dsh-mini-remote 0.1.6 → 0.1.8

package/lib/pairing.js

@@ -140,8 +140,9 @@ async function qr(text) {
  * @param {string[]} [opts.bound] 真正绑定成功的地址；不传则用探测结果
  * @param {{enabled?: boolean, url?: string|null, starting?: boolean, error?: string|null}} [opts.tunnel] 公网隧道状态
  * @param {{installed?: boolean, url?: string|null, urlOfOtherPort?: string|null, error?: string|null}} [opts.serve] Tailscale HTTPS 状态
+ * @param {{enabled?: boolean, appId?: string, openIds?: string, chatIds?: string, hasSecret?: boolean, starting?: boolean, running?: boolean, connected?: boolean, rejected?: {reason: string, at: number}|null, error?: string|null}} [opts.feishu] 飞书那一块的现状（**不含 appSecret**）
  */
-export async function buildPairing({ port, token, bound, tunnel, serve }) {
+export async function buildPairing({ port, token, bound, tunnel, serve, feishu }) {
   const detected = reachableAddresses()
   const usable = bound ? detected.filter((a) => bound.includes(a.address)) : detected
 
@@ -200,6 +201,32 @@ export async function buildPairing({ port, token, bound, tunnel, serve }) {
     error: tunnel?.error ?? null,
   }
 
+  /**
+   * 飞书那一块的现状，**四种返回路径都要带上**（和 `serve` 同一个道理，见下面）。
+   *
+   * 这里**只回答「有没有凭据」**，绝不把 appSecret 本身送出去——这个字段会进浏览器。
+   * `openIds` / `chatIds` 是名单，可以回显：用户得看得见自己填的是什么。
+   */
+  const feishuStatus = {
+    enabled: Boolean(feishu?.enabled),
+    appId: feishu?.appId ?? '',
+    openIds: feishu?.openIds ?? '',
+    chatIds: feishu?.chatIds ?? '',
+    hasSecret: Boolean(feishu?.hasSecret),
+    starting: Boolean(feishu?.starting),
+    running: Boolean(feishu?.running),
+    connected: Boolean(feishu?.connected),
+    /**
+     * 上一次被白名单挡住的来源，原样交给界面。
+     *
+     * 这是**新用户唯一走得通的那条路**：名单默认空着（谁都不认），他不可能凭空知道
+     * 自己的 open_id 长什么样。第一次发消息被挡下时，把「来源是谁」当场显示出来，
+     * 抄进名单再发一次就通了——少了这一步，用户会卡死在「开了但没反应」。
+     */
+    rejected: feishu?.rejected ?? null,
+    error: feishu?.error ?? null,
+  }
+
   /**
    * Tailscale HTTPS 的现状，**四种返回路径都要带上**。
    *
@@ -243,7 +270,7 @@ export async function buildPairing({ port, token, bound, tunnel, serve }) {
     // 一条能用的都没有。三种成因要分开说，否则用户不知道该去改配置、去查网络，
     // 还是去查隧道——这三件事的下一步动作完全不同。
     if (status.enabled && status.error) {
-      return { ok: false, error: `公网访问没起来：${status.error}`, tunnel: status, tailscale, serve: httpsStatus }
+      return { ok: false, error: `公网访问没起来：${status.error}`, tunnel: status, tailscale, serve: httpsStatus, feishu: feishuStatus }
     }
     if (detected.length) {
       return {
@@ -253,6 +280,7 @@ export async function buildPairing({ port, token, bound, tunnel, serve }) {
         tunnel: status,
         tailscale,
         serve: httpsStatus,
+        feishu: feishuStatus,
       }
     }
     return {
@@ -261,8 +289,9 @@ export async function buildPairing({ port, token, bound, tunnel, serve }) {
       tunnel: status,
       tailscale,
       serve: httpsStatus,
+      feishu: feishuStatus,
     }
   }
 
-  return { ok: true, port, token, entries, tunnel: status, tailscale, serve: httpsStatus }
+  return { ok: true, port, token, entries, tunnel: status, tailscale, serve: httpsStatus, feishu: feishuStatus }
 }

package/lib/server.js

@@ -168,12 +168,45 @@ export const miniControl = {
  * @param {(line:string)=>Promise<{ok:boolean, error?:string}>} [opts.onCommand] 执行一条斜杠指令
  * @param {()=>Promise<{ok:boolean, error?:string, sessionId?:string}>|{ok:boolean, error?:string, sessionId?:string}} opts.onStop
  * @param {(id:string)=>{ok:boolean, error?:string, sessionId?:string}} opts.onUnqueue
+ * @param {() => (string|undefined)[]} [opts.imageRoots] 正文里相对路径图的额外候选根
+ *        （由插件递进「当前已注册工作区的目录」，见 extraImageRoots 那段）
  * @returns {Promise<{port:number, addresses:string[], failed:{address:string,message:string}[], close:()=>Promise<void>, broadcast:(event:string, data:unknown)=>void}>}
  */
-export async function createMiniServer({ store, config, token, bindAddresses, tunnelHost, onInstruction, onCommands, onCommand, onStop, onUnqueue, onUpload, onSessionOpened, log, tree, browse, build }) {
+export async function createMiniServer({ store, config, token, bindAddresses, tunnelHost, onInstruction, onCommands, onCommand, onStop, onUnqueue, onUpload, onSessionOpened, log, tree, browse, build, imageRoots }) {
   /** @type {Set<import('node:http').ServerResponse>} */
   const clients = new Set()
 
+  // 导航栏的数据比普通状态更适合做 stale-while-revalidate：工作区和会话不会因为
+  // 用户打开一次菜单就必须重新清点。第一次没有缓存时仍然等待真实结果；之后先回上次
+  // 整理好的列表，再在后台刷新。手动点刷新时由请求方显式 force，保持原来的语义。
+  const NAV_CACHE_TTL_MS = 30_000
+  let navWorkspaceCache = { value: null, at: 0, inflight: null }
+
+  async function loadWorkspaces(runningIds, force = false) {
+    const now = Date.now()
+    const fresh = navWorkspaceCache.value && now - navWorkspaceCache.at < NAV_CACHE_TTL_MS
+    if (!force && navWorkspaceCache.value) {
+      if (!fresh && !navWorkspaceCache.inflight) {
+        navWorkspaceCache.inflight = refreshWorkspaces(runningIds, false)
+          .finally(() => { navWorkspaceCache.inflight = null })
+      }
+      return navWorkspaceCache.value
+    }
+    if (navWorkspaceCache.inflight) return navWorkspaceCache.inflight
+    navWorkspaceCache.inflight = refreshWorkspaces(runningIds, force)
+      .finally(() => { navWorkspaceCache.inflight = null })
+    return navWorkspaceCache.inflight
+  }
+
+  async function refreshWorkspaces(runningIds, force) {
+    const started = performance.now()
+    const value = await nav.listWorkspaces(runningIds, force, true)
+    navWorkspaceCache = { value, at: Date.now(), inflight: null }
+    const elapsed = Math.round(performance.now() - started)
+    log?.info?.(`导航工作区读取 ${elapsed}ms（${value.length} 个）`)
+    return value
+  }
+
   // 没传 tree（测试里就是这样，headless 组合里也拿不到那两个服务）时给个空壳，
   // 导航栏显示「取不到」，遥控本身照常。
   // `createSession` 的空壳回 `no-controller`，跟真服务缺位时走同一条错误路径——
@@ -188,6 +221,11 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
     // 模型那两个的**空壳**：测试里没有真的 DSH，照上面的样式如实说"没这个能力"。
     modelCatalog: async () => ({ ok: false, reason: 'unavailable' }),
     selectModel: async () => ({ ok: false, reason: 'unavailable' }),
+    // 子智能体那四个的空壳，同样如实说"没这个能力"，不假装有一份空列表。
+    subagents: async () => ({ ok: false, error: '这台电脑上的 DSH 没提供子智能体。' }),
+    subagentTranscript: async () => ({ ok: false, error: '这台电脑上的 DSH 没提供子智能体。' }),
+    stopSubagent: async () => ({ ok: false, error: '这台电脑上的 DSH 没提供子智能体。' }),
+    askSubagent: async () => ({ ok: false, error: '这台电脑上的 DSH 没提供子智能体。' }),
   }
 
   // 目录浏览的空壳。它**只依赖 node:fs**，不像 tree 那样依赖 DSH 的服务，
@@ -198,6 +236,39 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
     makeDirectory: async () => ({ ok: false, reason: 'unavailable' }),
   }
 
+  /**
+   * 正文里写相对路径的图（`![](scratch/a.png)`）要多试的几个根：**当前已注册的工作区目录**。
+   *
+   * 为什么需要它（2026-09-28 实测确诊）：正文里的相对路径相对的是**那段对话的工作目录**，
+   * 而它可能是别的项目——那次是 `I:\DSH\dsh-jev-ultrafast`，正文写的是
+   * `scratch/preview-0.2.3-settings.png`。插件原先只按自己的两个根（仓库根、lib/art）找，
+   * 于是 404，手机上就是破图；图就在盘上，接口本身也没毛病。
+   *
+   * **只放宽「在哪找」。** 仍然要令牌、仍然只发图片扩展名、仍然卡体积、相对写法里的 `..`
+   * 仍然被拒（后两条在 page.js 的 readImage 里，这一版一个字没动）。
+   * 额外根拿不到（服务还没起来）时退回空列表，也就是原来的行为。
+   *
+   * 缓存 30 秒：列一遍注册表要遍历所有工作区，而这张表几乎不变；晚半分钟知道新建的工作区
+   * 没有影响——图的地址是用户在正文里写的，不会正好卡在那半分钟上。
+   */
+  const IMAGE_ROOTS_TTL_MS = 30_000
+  let imageRootsCache = { at: 0, list: [] }
+  function extraImageRoots() {
+    const now = Date.now()
+    if (now - imageRootsCache.at < IMAGE_ROOTS_TTL_MS) return imageRootsCache.list
+    let list = []
+    try {
+      const got = imageRoots?.()
+      // 去重：工作区里本来就可能包含插件根那个目录，重复只换来几次白跑的系统调用。
+      if (Array.isArray(got)) list = [...new Set(got.filter((r) => typeof r === 'string' && r))]
+    } catch {
+      // `workspaceRegistry.list()` 在服务还没就绪时会抛。少认几张图，不该拖垮整条取图的路。
+      list = []
+    }
+    imageRootsCache = { at: now, list }
+    return list
+  }
+
   function broadcast(event, data) {
     const frame = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`
     for (const res of clients) {
@@ -237,27 +308,81 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
     return clients.size > 0 || (phoneSeenAt > 0 && Date.now() - phoneSeenAt < PHONE_GRACE_MS)
   }
 
+  /**
+   * 「除了手机，还有别人在等这道题吗」——**收摊判据的第二个来源**。
+   *
+   * 手机全断开就立刻把问题还给电脑（上面那条，防的是永远卡住）；可飞书那条路
+   * （见 lib/lark.js）也能答同一道题，手机上没人不等于没人答。所以由调用方传一个
+   * `keepAlive()` 进来，它说「还挂着」就不收摊。
+   *
+   * **绝不因为这一句把题卡死**：没传、或者它抛了，一律当「没人在等」——宁可还给电脑，
+   * 也不能因为另一条路的内部错误让问题悬在半空。
+   */
+  function stillWaited(opts) {
+    try {
+      return opts?.keepAlive?.() === true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * 一道题/一条审批刚刚有结果了——**主动告诉手机页**。
+   *
+   * 为什么必须有这一条：手机和飞书可能同时看着同一道题（用户就在两个界面之间切）。
+   * 谁先答谁生效的语义本来就有（后到的那边拿到 `expired`），但那只在**后到的人自己动手**
+   * 时才说话。手机页那张卡片是推一次就留在屏幕上的，用户在飞书里答完，手机上那张还挂在
+   * 原地——他没法知道这道题已经有人答了，只能盯着它发愣（2026-10-02 真机就是这个现象）。
+   *
+   * 所以这里用**现成的 SSE 通道**补一条状态：手机页收到就把卡片收起来、换一行说明。
+   * 只说「哪一道、谁答的」，不重复推题目本身——两边都不重复打扰。
+   */
+  function notifySettled(kind, id, source) {
+    broadcast(`${kind}-done`, { id, source: source ?? '' })
+  }
+
+  /**
+   * 题挂上之后当场告诉调用方它的编号。
+   *
+   * **飞书那条路就靠这个号对号入座**（用户回的那句话是对哪一道题的答复），交出去的是
+   * 这一层内部用的编号（`q1`/`a1` 这种），不是界面上的顺序号。回调抛错只写一行日志，
+   * 不影响这道题本身——推不出去的只是「另一个界面也来问」这件事。
+   */
+  function notifyPending(opts, id) {
+    try {
+      opts?.onPending?.(id)
+    } catch (err) {
+      log?.warn?.(`遥控服务：通知另一条通路失败（${err?.message ?? err}）`)
+    }
+  }
+
   /**
    * 把这个提问推到手机上，等它答。
+   * @param {{keepAlive?: () => boolean, onPending?: (id: string) => void}} [opts]
+   *        见上面 stillWaited / notifyPending 两段说明。
    * @returns 答案对象；手机没了就返回 null，调用方据此**把问题还给电脑**。
    */
-  function askPhone(questions, agentId) {
+  function askPhone(questions, agentId, opts) {
     const id = 'q' + (++questionSeq)
     return new Promise((resolve) => {
       let watch = null
-      const settle = (value) => {
+      const settle = (value, from) => {
         if (!waitingQuestions.has(id)) return
         waitingQuestions.delete(id)
         if (watch) clearInterval(watch)
+        // 先通知、再落定：谁先答谁生效的语义一个字没动，这里只是**把结果说出去**，
+        // 让另一侧那张还挂着的卡片自己收起来（见 notifySettled）。
+        notifySettled('question', id, from ?? opts?.source)
         resolve(value)
       }
       // 题目本身也存进来（不只是 settle）：手机中途重连上来时要能补发给它，见 replayQuestions。
       waitingQuestions.set(id, { settle, agentId, questions })
+      notifyPending(opts, id)
       broadcast('question', { id, agentId, questions })
       // 用户选的是「一直等，不还回电脑」——但那不等于「手机都没了还等」。
       // 手机一旦全断开（锁屏、关了页面、网断），立刻收摊还给电脑，否则会永远卡住。
       watch = setInterval(() => {
-        if (!hasPhone()) settle(null)
+        if (!hasPhone() && !stillWaited(opts)) settle(null)
       }, 2000)
     })
   }
@@ -294,16 +419,20 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
 
   /**
    * 把一条命令确认推到手机上，等它拍板。
+   * @param {{keepAlive?: () => boolean, onPending?: (id: string) => void}} [opts]
+   *        和提问同一条：飞书那边也能拍这一板（见 lib/lark.js）。
    * @returns 'allowed-once' 或 'rejected'；手机没了返回 null，调用方据此还给电脑。
    */
-  function askApproval(req, agentId, command) {
+  function askApproval(req, agentId, command, opts) {
     const id = 'a' + (++approvalSeq)
     return new Promise((resolve) => {
       let watch = null
-      const settle = (value) => {
+      const settle = (value, from) => {
         if (!waitingApprovals.has(id)) return
         waitingApprovals.delete(id)
         if (watch) clearInterval(watch)
+        // 和提问那条同一句：通知另一侧那张卡片自己收起来（见 notifySettled）。
+        notifySettled('approval', id, from ?? opts?.source)
         resolve(value)
       }
       // 推给手机的就是这几样：工具名 + 为什么来问我。**不带命令正文**——
@@ -317,10 +446,12 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
         command: typeof command === 'string' ? command : '',
       }
       waitingApprovals.set(id, { settle, agentId, view })
+      notifyPending(opts, id)
       broadcast('approval', view)
-      // 和提问同一条判据：**不倒计时，看手机还在不在**。全断开了就立刻收摊还给电脑。
+      // 和提问同一条判据：**不倒计时，看手机还在不在**。全断开了就立刻收摊还给电脑
+      // （飞书那边还挂着就除外，见 stillWaited）。
       watch = setInterval(() => {
-        if (!hasPhone()) settle(null)
+        if (!hasPhone() && !stillWaited(opts)) settle(null)
       }, 2000)
     })
   }
@@ -335,11 +466,62 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
       }
     }
   }
+  /**
+   * 把一道题的答案交回去。**这是答题的唯一入口**，两个界面都走它：
+   *   手机页：POST /mini/api/answer
+   *   飞书：  miniControl.answerQuestion（见 lib/lark.js 的 onAnswer）
+   *
+   * 为什么收成一处：手机和飞书可能**同时**看着同一道题（用户就在两个人机界面之间切换），
+   * 「谁先答谁生效、另一个自动失效」不该写成两遍——这里只有一个 settle，第二个来的人
+   * 自然拿到 `expired`。这是现成的语义，不是为飞书新加的一套。
+   *
+   * @param {string} id 题号（waitingQuestions 里的那个）
+   * @param {{answers?: Array, cancel?: boolean}} input `cancel:true` = 不答：
+   *        按 settle(null) 处理，也就是和「手机全断了」**同一条路**——
+   *        调用方据此把问题还给电脑（见 lib/index.js 的 .then(answer => !answer → next())）。
+   * @param {'phone'|'feishu'} [from] 谁答的。**只用来通知另一侧**（见 notifySettled）：
+   *        「已在飞书答过」这句话要有出处，猜不得。
+   * @returns {{ok: boolean, error?: 'expired'|'bad'}}
+   */
+  function answerQuestion(id, input, from) {
+    const entry = waitingQuestions.get(id)
+    if (!entry) return { ok: false, error: 'expired' }
+    if (input?.cancel === true) {
+      entry.settle(null, from)
+      return { ok: true }
+    }
+    if (!Array.isArray(input?.answers)) return { ok: false, error: 'bad' }
+    entry.settle({ answers: input.answers }, from)
+    return { ok: true }
+  }
+
+  /**
+   * 把一条审批的结论交回去。形状、理由和 answerQuestion 一模一样（见上面那段）——
+   * 只是交回去的东西是结论，且**只认那两个值**：一个没见过的结论宁可说 bad，
+   * 也不能让电脑收到一个它看不懂的答复。
+   * @param {'phone'|'feishu'} [from] 谁拍的板。只用来通知另一侧（同 answerQuestion）。
+   */
+  function decideApproval(id, input, from) {
+    const entry = waitingApprovals.get(id)
+    if (!entry) return { ok: false, error: 'expired' }
+    if (input?.cancel === true) {
+      entry.settle(null, from)
+      return { ok: true }
+    }
+    if (input?.decision !== 'allowed-once' && input?.decision !== 'rejected') {
+      return { ok: false, error: 'bad' }
+    }
+    entry.settle(input.decision, from)
+    return { ok: true }
+  }
+
   // 把这两个能力放到插件够得着的固定位置（见文件上方 `miniControl` 的说明）。
   // 放在这里是因为它俩都已定义（函数声明本来也会提升），且不受下面那堆路由逻辑影响。
   miniControl.hasPhone = hasPhone
   miniControl.askPhone = askPhone
   miniControl.askApproval = askApproval
+  miniControl.answerQuestion = answerQuestion
+  miniControl.decideApproval = decideApproval
 
   /**
    * 把 UA 和来源地址压成一句人看的：设备类型 + 地址。
@@ -468,10 +650,11 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
       // 取图有两条路，都挂在这个前缀下：
       //   ① /mini/art/<名字>.webp —— 立绘。名字受白名单限制，地址里带构建指纹，可以长缓存。
       //   ② /mini/art/?p=<路径>   —— 正文里直接写了一张图在电脑上的位置（绝对路径，或相对
-      //      项目根）。只发图片类型，地址里没有指纹，所以不让浏览器缓存。
+      //      项目根／lib/art／已注册的工作区目录）。只发图片类型，地址里没有指纹，所以不
+      //      让浏览器缓存。
       const wanted = url.searchParams.get('p')
       if (wanted) {
-        const hit = readImage(wanted)
+        const hit = readImage(wanted, extraImageRoots())
         if (!hit) {
           sendJson(res, 404, { error: 'not found' })
           return
@@ -636,6 +819,24 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
       return
     }
 
+    // ---- 子智能体 ------------------------------------------------------
+    // 列表取**当前绑定会话**名下那一份（和 send / stop 同一套口径）。
+    // 失败一律 200 + ok:false：这是"这道能力现在没有"或"这台电脑没开这条路"，
+    // 不是请求本身有错——用 4xx 会让页面上的重试逻辑把它当网络故障。
+    if (req.method === 'GET' && path === '/mini/api/subagents') {
+      const result = await nav.subagents(store.snapshot().boundSessionId)
+      sendJson(res, 200, result)
+      return
+    }
+
+    // 某一道子智能体**自己的运行过程**（它自己的会话记录重放出来的聊天记录）。
+    if (req.method === 'GET' && path === '/mini/api/subagent') {
+      const childId = url.searchParams.get('id') ?? ''
+      const result = await nav.subagentTranscript(childId, store.snapshot().boundSessionId)
+      sendJson(res, 200, result)
+      return
+    }
+
     // ---- 斜杠指令列表 ----------------------------------------------------
     // 手机在输入框里打 `/` 时要显示的那一份。**名单来自 DSH 自己的指令账本**，
     // 所以电脑上新装一个带指令的插件，手机上刷新就有了，不用改这个插件。
@@ -661,8 +862,8 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
       )
       // includeEmpty：手机能自己新建工作区了，刚建好的那个本来就是空的。
       // 不列出来的话，建完它当场消失，用户只会以为没建成。
-      const workspaces = await nav.listWorkspaces(
-        runningIds, url.searchParams.get('refresh') === '1', true,
+      const workspaces = await loadWorkspaces(
+        runningIds, url.searchParams.get('refresh') === '1',
       )
       sendJson(res, 200, { ok: true, workspaces })
       return
@@ -672,11 +873,15 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
     if (req.method === 'GET' && wsSessions) {
       const asked = Number(url.searchParams.get('limit'))
       const limit = Number.isFinite(asked) && asked > 0 ? Math.min(asked, 100) : undefined
+      const workspaceId = decodeURIComponent(wsSessions[1])
+      const started = performance.now()
       const result = await nav.listSessionsOf(
-        decodeURIComponent(wsSessions[1]),
+        workspaceId,
         limit,
         url.searchParams.get('refresh') === '1',
+        (title) => broadcast('navigation-title', title),
       )
+      log?.info?.(`导航会话读取 ${Math.round(performance.now() - started)}ms（工作区 ${workspaceId}）`)
       if (!result) {
         sendJson(res, 404, { ok: false, error: '没有这个工作区。' })
         return
@@ -787,8 +992,9 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
 
     if (req.method === 'POST' && path === '/mini/api/answer') {
       const body = await readBody(req)
-      const waiting = waitingQuestions.get(body?.id)
-      if (!waiting) {
+      // 判据、错误文案都收在 answerQuestion 里——和飞书那条路共用同一处（见上面那段说明）。
+      const out = answerQuestion(body?.id, body, 'phone')
+      if (!out.ok && out.error === 'expired') {
         // 409 而不是 200：多半是这个提问早就结束了，如实说，别装作收下了。
         // 落一句痕：这是「手机答了、电脑没动静」唯一能查到的线索——手机那边原来
         // 把失败咽掉了，插件这边再不留痕，下次还是只能靠猜（2026-09-27）。
@@ -796,12 +1002,10 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
         sendJson(res, 409, { ok: false, error: '这个提问已经结束了。' })
         return
       }
-      const answers = Array.isArray(body?.answers) ? body.answers : null
-      if (!answers) {
+      if (!out.ok) {
         sendJson(res, 400, { ok: false, error: '答案格式不对。' })
         return
       }
-      waiting.settle({ answers })
       sendJson(res, 200, { ok: true })
       return
     }
@@ -811,20 +1015,20 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
     // 过期了如实说、格式不对就说格式不对，别装作收下了。
     if (req.method === 'POST' && path === '/mini/api/approval') {
       const body = await readBody(req)
-      const waiting = waitingApprovals.get(body?.id)
-      if (!waiting) {
+      // 手机页交上来的说法是 allow / deny，换成清单里的结论值；飞书那边直接交结论。
+      const decision = body?.decision === 'allow'
+        ? 'allowed-once'
+        : (body?.decision === 'deny' ? 'rejected' : body?.decision)
+      const out = decideApproval(body?.id, { ...body, decision }, 'phone')
+      if (!out.ok && out.error === 'expired') {
         console.log('[dsh-mini-remote] 手机上拍晚了：这条审批已经交回电脑（' + String(body?.id) + '），没接')
         sendJson(res, 409, { ok: false, error: '这条审批已经结束了。' })
         return
       }
-      const decision = body?.decision === 'allow'
-        ? 'allowed-once'
-        : (body?.decision === 'deny' ? 'rejected' : null)
-      if (!decision) {
+      if (!out.ok) {
         sendJson(res, 400, { ok: false, error: '审批的结论只有同意或拒绝两种。' })
         return
       }
-      waiting.settle(decision)
       sendJson(res, 200, { ok: true })
       return
     }
@@ -953,6 +1157,30 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
         return
       }
 
+      if (path === '/mini/api/subagent/stop') {
+        // 停一道子智能体**当前这一轮**。父会话 id 由服务端自己取，不信请求体里的——
+        // 权限凭据是「谁的父会话」，让手机随便填就等于谁都能停别人的。
+        const childId = typeof body.id === 'string' ? body.id : ''
+        const mode = typeof body.mode === 'string' ? body.mode : ''
+        const result = await nav.stopSubagent(childId, store.snapshot().boundSessionId, mode)
+        sendJson(res, result.ok ? 200 : 409, result)
+        return
+      }
+
+      if (path === '/mini/api/subagent/ask') {
+        // 跟一道子智能体接着说一句话。同样，父会话 id 服务端自己取。
+        const childId = typeof body.id === 'string' ? body.id : ''
+        const mode = typeof body.mode === 'string' ? body.mode : ''
+        const text = typeof body.text === 'string' ? body.text.trim() : ''
+        if (!text) {
+          sendJson(res, 400, { ok: false, error: '话是空的。' })
+          return
+        }
+        const result = await nav.askSubagent(childId, store.snapshot().boundSessionId, mode, text)
+        sendJson(res, result.ok ? 200 : 409, result)
+        return
+      }
+
       if (path === '/mini/api/unqueue') {
         // 撤掉一条还在排队的指令。撤的是「手机正在遥控的那个会话」队列里的那一条，
         // 和 send / stop 同一套口径。
@@ -987,6 +1215,8 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
           return
         }
         store.bind(created.sessionId)
+        // 新会话会改变工作区的数量；下次打开导航栏必须重新整理一次。
+        navWorkspaceCache = { value: null, at: 0, inflight: null }
         const snap = store.snapshot()
         broadcast('state', snap)
         sendJson(res, 200, {
@@ -1042,7 +1272,7 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
         }
         // 登记完立刻把最新的工作区列表带回去：手机拿到就能直接画出来，
         // 不用再补一趟请求，也就不会出现「建好了但列表里还没有」。
-        const workspaces = await nav.listWorkspaces(new Set(), true, true)
+        const workspaces = await loadWorkspaces(new Set(), true)
         sendJson(res, 200, {
           ok: true, created: made.created, workspace: made.workspace, workspaces,
         })

package/lib/store.js

@@ -348,6 +348,28 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
       persist()
     },
 
+    /**
+     * 子智能体完工的通知（`subagent-settled`）。
+     *
+     * 第三种东西，和指令行同类：既不是用户说的话，也不是模型的回答，而是**这个会话
+     * 派出去的一件事有结果了**。所以单独一个 role，界面上按一张可展开的卡片画——
+     * 混进用户气泡就变成「我说过这句话」，混进回答又会被读成模型的话，两种都是假的。
+     *
+     * 时间戳同样用事件自己的 `time`：硬盘重放出来那份（lib/history.js 里的 notice）
+     * 用的也是它，两边同一个钟才合成得成一条，而不是显示两遍。
+     */
+    pushNotice({ sessionId, text, summary, senderSessionId, timestamp }) {
+      pushHistory(sessionId, {
+        role: 'notice',
+        text,
+        summary: summary ?? '',
+        senderSessionId: senderSessionId ?? '',
+        timestamp: timestamp ?? Date.now(),
+        sessionId,
+      })
+      persist()
+    },
+
     /**
      * 一条斜杠指令开跑了（`command/run`）。
      *