dsh-mobile-plugin 0.1.92 → 0.1.94

package/README.md

@@ -7,6 +7,7 @@ AI-HUB 手机端插件，为 DSH 提供移动 API、远程连接和局域网代
 ## 下载 AI-HUB 手机 App
 
 - [Android APK](https://app.wnluo.com/public/apps/14)
+- [Android APK（GitHub 渠道）](https://github.com/WNLUO/dsh-mobile-plugin/releases/latest/download/ai-hub-android.apk)；[历史版本](https://github.com/WNLUO/dsh-mobile-plugin/releases)
 - [App Store](https://apps.apple.com/us/app/ai-hub/id6821681438)（若暂时无法打开，可能是 App 仍在等待苹果审核通过。）
 - [TestFlight 测试版](https://testflight.apple.com/join/4fn5PCMD)
 
@@ -55,7 +56,7 @@ curl http://127.0.0.1:3080/api/relay/pairing
 
 移动 API 需要 Bearer token。设备事件流 `GET /api/mobile/v1/events/stream` 使用 SSE 转发宿主事件。创建会话时可传 `workspaceId` 或 `cwd`；前者优先，并将会话归入指定工作区。移动端排序也会同步到宿主工作区。
 
-配对策略默认为 `code`（凭配对码放行）；设为 `deny` 时拒绝所有新配对。自动归档只隐藏符合条件的闲置会话，不删除日志。`session_cleanup` 工具可归档会话，也可永久删除已归档会话；删除不可恢复，需要显式确认。
+配对策略默认为 `code`（凭配对码放行）；设为 `deny` 时拒绝所有新配对。自动归档只隐藏符合条件的闲置会话，不删除日志。`session_cleanup` 工具可归档会话，也可永久删除已归档会话；删除不可恢复，需要显式确认。删除是「排进待删队列」：会话立刻从列表里消失，日志与投影缓存等宿主下次启动时才从磁盘上删掉 —— 宿主没有「删除会话」的接口，进程活着的时候从它脚底下删文件会让它读到不存在的日志，那是未捕获异常，会带走整个宿主进程。
 
 ## 无头部署
 
@@ -104,6 +105,7 @@ npm test
 - npm 包的 `repository` 字段用于关联插件列表条目；修改后需再次发布，注册表信息才会更新。
 - 插件列表收录通过向 awesome-dsh-plugin 提交 `data/plugins/<owner>__<repo>.yml` 完成。描述中的数字和 API 名称应能由代码核实；列表要求 `description.en`、`category: remote`，包需声明 `dsh.bundle`，仓库需有 `dsh-plugin` topic。
 - 仓库创建满一天的检查会自动重跑；截图可通过 `screenshots.json` 提供，也可由市场从 README 查找。
+- GitHub 的 release 页放手机 App 的 APK（下载入口见开头那一节）：资产名固定用 `ai-hub-android.apk`，并且发成正式版 —— 草稿与预发布都不会成为「最新」，README 里那条直连会随之断掉。插件自身走 npm 发布，不在本仓库发 release。
 - 隐私政策：[PRIVACY.md](PRIVACY.md)。技术支持与常见问题：[SUPPORT.md](SUPPORT.md)。
 
 ### 发布新版本

package/config/agent-presets/standard/agent.cordis.yml

@@ -162,9 +162,12 @@
       searchTimeoutMs: 60000
   # Without this row the mobile host's tool catalog has no `ask_user_question`,
   # so the App's question dock could never appear: the model simply reports that
-  # the tool is unavailable. `@deepseek-ai/dsh-host-apiproxy` already registers
-  # the `ctx.userQuestions` provider that bridges `ask()` to the mux
-  # `question/requested` frame, and the plugin's `lib/mobile/questions.js`
-  # answers it — only the tool row was missing.
+  # the tool is unavailable. The plugin's `lib/mobile/questions.js` listens on
+  # the `user-questions/request` hook (0.2.x shape) and answers it — only the
+  # tool row was missing.
+  #
+  # The package must be pinned to the runtime's own generation (0.2.0-rc.2):
+  # its peerDependencies track the runtime release exactly, and the loader
+  # disables the whole row — rather than degrade — when one does not match.
   - id: tool-ask-user
     name: '@deepseek-ai/dsh-tool-ask-user'

package/lib/desktop-view.cjs

@@ -19,6 +19,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const paths = require('./shared/paths');
+const { desktopViewSignal } = require('./shared/desktop-view-signal.js');
 
 /** 单个键（workspaceId）长度上限；超长的一律丢弃（真实 id 只有十几字节）。 */
 const MAX_KEY_LENGTH = 200;
@@ -36,6 +37,17 @@ function stateFile() {
 let cached = null;
 let loaded = false;
 
+/**
+ * 折叠态内容指纹（键排序后序列化）。
+ *
+ * 只用来回答「这次上报真的改了折叠态吗」：两次 JSON.stringify 的键序不保证一致，
+ * 直接比会让同一份状态被认成两次变更。内容没变就既不重写文件、也不给手机推帧。
+ */
+function expansionFingerprint(groupExpansion) {
+  const keys = Object.keys(groupExpansion).sort();
+  return JSON.stringify(keys.map((key) => [key, groupExpansion[key]]));
+}
+
 /** 归一化上报的 groupExpansion：只保留布尔值、限长限量；形状不对返回 null。 */
 function normalizeGroupExpansion(input) {
   if (!input || typeof input !== 'object' || Array.isArray(input)) return null;
@@ -91,11 +103,16 @@ function update(input, now = Date.now()) {
   const groupExpansion = normalizeGroupExpansion(input && input.groupExpansion);
   if (!groupExpansion) throw new Error('groupExpansion 必须是对象');
   const rawSource = input && (typeof input.source === 'string' ? input.source : input.storageKey);
+  const previous = load();
   const next = {
     groupExpansion,
     receivedAt: now,
     source: typeof rawSource === 'string' ? rawSource.slice(0, MAX_SOURCE_LENGTH) : '',
   };
+  // 折叠态没变就不落盘、不广播：客户端半边在页面重载 / 切窗口时会重发同一份。
+  // 什么都没变却写一次文件、给每台手机推一帧，等于把白问的轮询换成白推的帧。
+  const changed = !previous || expansionFingerprint(previous.groupExpansion) !== expansionFingerprint(groupExpansion);
+  if (!changed) return snapshot();
   const file = stateFile();
   fs.mkdirSync(path.dirname(file), { recursive: true });
   const tmp = `${file}.tmp`;
@@ -103,6 +120,9 @@ function update(input, now = Date.now()) {
   fs.renameSync(tmp, file);
   cached = next;
   loaded = true;
+  // 落盘之后再广播：订阅方收到帧会立刻回来读这条路（GET /desktop-view 读的是这份
+  // cached），先通知后落盘会把它引到上一份内容上。
+  desktopViewSignal.bump(next.receivedAt);
   return snapshot();
 }
 

package/lib/impl.js

@@ -24,7 +24,7 @@ const { authorized } = require('./mobile/auth.js')
 const { createSidecarLifecycle } = require('./sidecar-lifecycle.cjs')
 const { createMirrorPusher } = require('./mirror/pusher.cjs')
 const { randomBytes } = require('node:crypto')
-const { lanUrls, advertisedCandidates, orderCandidates } = require('./relay/lan-network.cjs')
+const { lanUrls, advertisedCandidates, orderCandidates, ipv6Candidates } = require('./relay/lan-network.cjs')
 const { resolvePort } = require('./relay/port-allocator.cjs')
 const { createPreviewService } = require('./relay/preview.js')
 // 本机设备凭据库：/api/relay/revoke-all 必须同时吊销局域网直连的 dshc_ 凭据，
@@ -177,6 +177,9 @@ function pairingPayload(state, lanPort) {
     // 候选列表随二维码一起带走：App 配对后即使换了网段，也能按这份列表
     // 依次重试而不用先回到公网中转去问。
     lanCandidates: candidates.map(candidate => candidate.url).filter(Boolean),
+    // IPv6 直连候选（理想情况下是手机**不在同一个 Wi-Fi 里**时唯一能拨到的地址）：不参与上面
+    // 那份的排序，顺序由 App 侧拿它和公网中转实测比出来；直连监听没开就没有这条通道。
+    ipv6Candidates: state.lanEnabled ? ipv6Candidates(port).map(candidate => candidate.url).filter(Boolean) : [],
   }
   return {
     payload,
@@ -292,7 +295,7 @@ function apply(ctx) {
   const { sidecarToken, syncSidecar, restartSidecar, tunnelConnected } = sidecarLifecycle
 
   // 镜像推送调度器：会话事件立即推，后台循环每个 tick 补推一个冷会话。
-  const mirror = createMirrorPusher({ ctx, tunnelConnected, getSidecar: sidecarLifecycle.getSidecar })
+  const mirror = createMirrorPusher({ ctx, tunnelConnected, getSidecar: sidecarLifecycle.getSidecar, lastMobileAt: activity.snapshot })
   // 隧道刚连上时补推一次全量：未连通期间每轮推送都被 worker 以 503 拒绝。
   sidecarLifecycle.onTunnelUp(() => { void mirror.pushMirror(); })
 
@@ -413,6 +416,8 @@ function apply(ctx) {
     getSidecarSnapshot: sidecarLifecycle.getSnapshot,
     // 移动端路由表那边叫它「局域网候选」，取的是同一份私网优先的清单。
     safeLanCandidates: advertisedCandidates,
+    // IPv6 直连候选单独一份：App 拿它单开一条通道、和公网中转比速度，不掺进上面那份的排序。
+    safeIpv6Candidates: ipv6Candidates,
     lanPortInUse: advertisedLanPort, // LAN 候选用实绑端口
     // 配对那条路由自己要签凭据：core 是签 token 的实现，pairingApproval 决定这台机器
     // 收不收新设备（'deny' 时一律拒）。两者本文件都已有，透传给移动端路由。

package/lib/mirror/pusher.cjs

@@ -39,6 +39,25 @@ const { observeCompletionEvent } = require('../mobile/completion.js');
 /** 后台循环每个 tick 补推一个冷会话，保证没人动的会话镜像也不长期不更新。 */
 const HIGH_PRIORITY_WINDOW_MS = 5 * 60 * 1000;
 const BG_TICK_INTERVAL_MS = 500;
+/**
+ * 没人看的时候，后台 tick 降到这个节拍。
+ *
+ * 500ms 那条节奏是给「手机正在用」准备的：清单或工作区一变，手机半秒内就该看到。
+ * 但宿主一天里大部分时间没人看 —— 那时每 500ms 整轮重建一次清单/工作区，走中转的
+ * 还要把快照推过一条隧道，纯属空转。
+ *
+ * 上限由 sidecar 的快照 TTL 卡着：镜像快照 15s 过期，降频必须明显小于它，
+ * 取 5s（= TTL/3，`test/mirror-tick-budget.test.cjs` 钉着这条比例）。
+ */
+const IDLE_TICK_INTERVAL_MS = 5_000;
+/**
+ * 多久没有手机请求就算「没人看」。
+ *
+ * 走中转的手机每个请求都会记一次 `mobile/activity.cjs` 的 `note()`；局域网直连的手机
+ * 不走那道守卫所以记不到，那种情况另有 `listSignal.watching()` 兜着（有人订阅清单变化时
+ * 它为真）。两个判据都不成立时才降频。
+ */
+const AUDIENCE_IDLE_MS = 30_000;
 /**
  * 冷会话轮转的最小间隔（清单/工作区都没变时才生效）。
  *
@@ -64,6 +83,19 @@ const MAX_CONSECUTIVE_EVENT_BUILDS = 3;
 
 function createMirrorPusher(deps) {
   const { ctx, tunnelConnected, getSidecar, listSignal = sharedListSignal, sessionSignal = sharedSessionSignal } = deps;
+  /**
+   * 「手机最近来过没有」的取值器（`mobile/activity.cjs` 的 `snapshot` 形态）。
+   *
+   * 不传就按「有人在看」处理、维持原来 500ms 的节拍：降频是个优化，不是契约，
+   * 别让一处漏接线的装配把镜像悄悄降成 5s 一份。
+   */
+  const lastMobileAt = typeof deps.lastMobileAt === 'function' ? deps.lastMobileAt : null;
+  const hasAudience = () => {
+    if (listSignal.watching()) return true;
+    if (!lastMobileAt) return true;
+    const at = Number(lastMobileAt()?.lastMobileAt) || 0;
+    return at > 0 && Date.now() - at <= AUDIENCE_IDLE_MS;
+  };
 
   // 移动镜像推送状态（供诊断/状态面板观测：最近推送时间 + 结果）
   let mirrorPushAt = 0
@@ -565,9 +597,17 @@ function createMirrorPusher(deps) {
   let bgQueueBusy = false;
   // 上一次真的跑过冷会话轮转的时刻（见 BG_COLD_ROTATE_MIN_INTERVAL_MS）。
   let lastColdRotateAt = 0;
+  // 上一轮后台扫描真正跑起来的时刻（见 IDLE_TICK_INTERVAL_MS 的降频）。
+  let lastBgScanAt = 0;
 
   const processBgQueue = async () => {
     if (bgQueueBusy) return;
+    // 降频：没人看的时候不必每 500ms 重建一轮清单。判据用「手机最近有没有请求」，
+    // 而不是「隧道连没连上」—— 隧道连着但人没在用，一样是空转。
+    // 有人在看时不加额外下限，节奏仍由 500ms 的定时器自己决定。
+    // 事件驱动那条路径（pushSessionImmediately）不受这里影响，会话真的变了仍是立即推。
+    if (!hasAudience() && lastBgScanAt && Date.now() - lastBgScanAt < IDLE_TICK_INTERVAL_MS) return;
+    lastBgScanAt = Date.now();
     const online = tunnelConnected();
     // 隧道未连接时这个 500ms 的 tick 只在**有人听**的时候才有意义：构建出来的快照没有
     // 任何去处（pushMirrorPayload 会短路），但「清单变了」这件事仍然要说给手机听 ——

package/lib/mobile/archive-clean.js

@@ -1,30 +1,33 @@
 'use strict';
 
 /**
- * 移动端「清理所有已归档的对话」：按宿主归档集合确定清理范围，并删掉它们的日志。
+ * 移动端「清理所有已归档的对话」：按宿主归档集合确定清理范围，把它们排进待删队列。
  *
  * 以 workspace.list 的 archivedSessionIds 为清理范围，不用可能过时的列表状态缩小范围；
  * 请求必须显式带 confirm: true —— 磁盘删除不可恢复，手机端「少点一次」不值得把它变成滑一下就没了的动作。
  *
- * 删除动作不重写：读日志 header.id → 删会话目录 + 投影缓存只在 session-cleanup.cjs 里存在
- * （见地图 A3-17），这里只是把它的触发面从 agent 工具扩到移动端路由。
+ * **这里不删磁盘**：只把 id 排进 session-cleanup.cjs 的待删队列，日志留到宿主下次启动时删
+ * （见那个文件的 deleteQueuedArchivedSessions）。宿主没有「删除会话」接口，进程活着的时候
+ * 它随时可能去打开那些文件 —— 文件不在就是一次未捕获的 ENOENT，宿主整个退出、桌面端闪退
+ * （2026-10-20 真机现场）。本进程只把 id 压进删除集，让手机列表立刻看不到它们。
  *
- * **这里不擦宿主的归档集合**（只把删掉的 id 记进本进程的删除集，挡住手机端列表里可能
- * 还没失效的旧快照）。进程里擦集合会把桌面端那份会话列表快照里、其实已经删掉的行放回
- * 正常列表——桌面端用户看到的就是「清理完它们又回来了，重启 DSH 才真的消失」。归档集合
- * 的收尾放在宿主启动时做，见 session-cleanup.cjs 的 pruneOrphanedArchivedSessionsOnce。
+ * 也**不擦宿主的归档集合**：进程里擦会把桌面端快照里那些其实已经没有日志的行放回正常列表。
+ * 归档集合的收尾同样在宿主启动时做，见 pruneOrphanedArchivedSessionsOnce。
  */
 
 const { sendJson, readJsonBody } = require('../shared/http-util');
 const { withIdempotency, requestIdOf } = require('./idempotency.js');
-const { canonicalDeviceKey, rememberDeletedSessionIds, deletedSessionIdsOf } = require('./session-cache.js');
+const { canonicalDeviceKey, rememberDeletedSessionIds } = require('./session-cache.js');
 const { invalidateSessionList } = require('./sessions.js');
 const { unwrap } = require('./envelope.js');
-const { deleteSessionData, sessionIdsWithoutAnyData } = require('../session-cleanup.cjs');
+const { queueArchivedClearIds } = require('../session-cleanup.cjs');
 
 /**
  * POST /api/mobile/v1/workspace/clear-archived（token）
  * body: { confirm: true } → { ok: true, deleted: N }。confirm 不为 true 一律 400。
+ *
+ * deleted = 这次被排进队列、手机上立刻消失的条数（含盘上早就没有数据的那些）；日志要到
+ * 宿主下次启动才真正从磁盘上消失。
  */
 async function handleClearArchived(ctx, req, res) {
   const body = await readJsonBody(req, 64 * 1024);
@@ -41,17 +44,13 @@ async function handleClearArchived(ctx, req, res) {
     const archivedIds = Array.isArray(workspaceResponse.value?.archivedSessionIds) ? workspaceResponse.value.archivedSessionIds : [];
     const selected = archivedIds.filter((id) => typeof id === 'string' && id);
     if (selected.length === 0) return { status: 200, body: { ok: true, deleted: 0 } };
-    const removed = await deleteSessionData(selected);
-    // 删的是列表里可见的行：手机端正开着列表，宿主那份快照可能还带着它们，先在本进程压住。
-    // 盘上已经没有数据的归档 id 一并压住：上一次删到一半抛错时，已删的那批没记进删除集，
-    // 宿主的进程内清单却还挂着它们 —— 不补记的话再点清理只回 0，手机上永远清不掉。
-    const already = deletedSessionIdsOf(ctx);
-    const cleared = new Set(removed);
-    for (const id of sessionIdsWithoutAnyData(selected)) if (!already.has(id)) cleared.add(id);
-    rememberDeletedSessionIds(ctx, cleared);
+    // 排不进队列就整次失败（路由回 500）：回「已清理」却没排上，重启之后它们原样回来。
+    queueArchivedClearIds(selected);
+    // 宿主那份快照可能还带着它们，先在本进程压住：手机列表与归档列表立刻看不到。
+    rememberDeletedSessionIds(ctx, selected);
     // 不立刻失效的话，最长 10 秒还能点到已删的行。
     invalidateSessionList(ctx);
-    return { status: 200, body: { ok: true, deleted: cleared.size } };
+    return { status: 200, body: { ok: true, deleted: selected.length } };
   });
   sendJson(res, outcome.status, outcome.body);
 }

package/lib/mobile/attachments.js

@@ -1,16 +1,24 @@
 'use strict';
 
 /**
- * 图片归一：会话历史存的是 `{type:'image', attachment}` 而不是内联字节，
- * 手机端拿到后要经 session attachment RPC 把图片取回来。
+ * 图片归一：会话历史存的是 `{type:'image', attachment}` 而不是内联字节。
  *
  * 宿主事件里图片可能出现在四处：message/content、inserted 上下文项、
  * assistant chunk 的 block，以及更深的嵌套 content。全部在这里归一，
- * 这样历史与 SSE 暴露给手机端的内联图片形状是同一个。
+ * 这样历史与 SSE 暴露给手机端的图片形状是同一个。
+ *
+ * **默认（引用模式 `opts.referencesOnly`）不取字节**：图片块原样留着 `attachment`
+ * 引用，由 history-derive 投影成 `{mediaType, name?, attachmentId}`，手机端要画的时候
+ * 按 attachmentId 单张去取（`/session/attachment`）。此前这里把每张图都换成内联 base64，
+ * 一页 200 条带十几张截图的响应接近 10MB，每次进会话都要重传一遍。
+ *
+ * 只有显式传 `referencesOnly: false` 时才回到「经 session attachment RPC 取回字节」的
+ * 老行为；取不回字节的块打 `dataUnavailable` 标（语义不变，见 dataUnavailableBlock）。
  *
  * 另外一类图片在正文里：`![](/abs/path.png)` 这种指向**宿主本机文件**的写法
  * （本机绝对路径、file://、~）在手机上取不到字节，也会被 App 当成非 http 图片降级成字面
  * markdown。这里顺手按同一形状内联成 data URI（实现与预算见 local-images.js）。
+ * 这条与附件引用是两件事：它走的是正文里的路径、没有 attachmentId，预算与行为保持原样。
  */
 
 const { unwrap } = require('./envelope.js');
@@ -19,12 +27,16 @@ const { inlineTextImages, createTextImageBudget } = require('./local-images.js')
 
 /**
  * Resolve durable image references before exposing messages to mobile clients.
- * Session history stores `{type:'image', attachment}` rather than inline bytes;
- * the mobile client resolves these through the session attachment RPC.
+ *
+ * Session history stores `{type:'image', attachment}` rather than inline bytes.
+ * By default (`referencesOnly`) the block is left as a reference and the mobile
+ * client fetches the bytes per attachment (`/session/attachment`); no host RPC
+ * happens on this path at all. Pass `referencesOnly: false` for the legacy
+ * inline-bytes shape.
  *
  * Host events can carry content in several places: message/content, inserted
  * context items, or an assistant/chunk block. Keep this normalization here so
- * history and SSE expose the same inline-image shape to mobile clients.
+ * history and SSE expose the same image shape to mobile clients.
  *
  * Text blocks additionally get local-file image syntax inlined as data URIs
  * (see local-images.js); `opts.budget` is a shared per-response budget so one
@@ -47,6 +59,9 @@ async function resolveEventAttachments(ctx, sessionId, event, opts = {}) {
   if (!event || !event.data || typeof event.data !== 'object') return event;
   const data = event.data;
   const budget = opts.budget || createTextImageBudget();
+  // 引用模式（默认）：图片块只留 attachment 引用，**一次宿主 RPC 都不发**。
+  // 只有显式 referencesOnly:false 才走下面那条把字节取回来的老路。
+  const referencesOnly = opts.referencesOnly !== false;
   let nextData = data;
   let eventChanged = false;
 
@@ -59,6 +74,8 @@ async function resolveEventAttachments(ctx, sessionId, event, opts = {}) {
     if (block.type === 'image' && !block.data && block.attachment) {
       const attachmentId = block.attachment.attachmentId;
       if (typeof attachmentId !== 'string' || !attachmentId) return block;
+      // 引用模式到此为止：块原样返回，字节由手机端按 attachmentId 单张去取。
+      if (referencesOnly) return block;
       let result;
       try {
         result = unwrap(await callSessions(ctx, 'attachment', { sessionId, attachmentId }));

package/lib/mobile/events.js

@@ -6,9 +6,10 @@
  * 但宿主在 DSH 0.2.0 兼容桥下只会订阅 workspace/follow + session/control，会话状态变化
  * 走的是 session/projection（被白名单丢掉），于是这条流连着却可能长时间一帧都不发；
  * 插件自己补了 device/list-changed（来自 lib/shared/list-signal.js，清单变了）、
- * device/session-activity（来自 lib/shared/session-signal.js，某个会话的正文水位涨了）
- * 与 device/heartbeat（心跳）三类自产帧，App 侧靠它们判断「这条流还活着」「该重拉列表」
- * 「该给某个会话补正文」并据此决定要不要把兜底轮询降频。
+ * device/session-activity（来自 lib/shared/session-signal.js，某个会话的正文水位涨了）、
+ * device/desktop-view-changed（来自 lib/shared/desktop-view-signal.js，桌面侧栏折叠态
+ * 变了）与 device/heartbeat（心跳）四类自产帧，App 侧靠它们判断「这条流还活着」
+ * 「该重拉列表」「该给某个会话补正文」「该重取折叠态」并据此决定要不要把兜底轮询降频。
  *
  * 断流补偿：这条流不做 Last-Event-ID 续传（App 只把它当信号，不当数据源），所以**连上时**
  * 会立刻补发「当前状态」——一帧最近已知 revision 的 device/list-changed + 每个已跟踪会话
@@ -19,6 +20,7 @@
 
 const { listSignal: sharedListSignal } = require('../shared/list-signal.js');
 const { sessionSignal: sharedSessionSignal } = require('../shared/session-signal.js');
+const { desktopViewSignal: sharedDesktopViewSignal } = require('../shared/desktop-view-signal.js');
 const { writeSse: sharedWriteSse, stableEventId: sharedEventId } = require('../shared/sse-write.js');
 
 const DEDUP_WINDOW = 2048;
@@ -194,6 +196,22 @@ async function handleDeviceStream(ctx, req, res) {
     if (ac.signal.aborted) return;
     if (!writeFrame({ type: 'device/session-activity', sessionId: event.sessionId, seq: event.seq, at: event.at })) ac.abort();
   });
+  /**
+   * 自产的「桌面侧栏折叠态变了」帧。
+   *
+   * 桌面端那份 groupExpansion 只活在浏览器 localStorage，插件靠客户端半边轮询上报，
+   * 落在 lib/desktop-view.cjs；手机要拿到它只能问 GET /desktop-view。过去 App 用
+   * 「跟列表刷新走 + 5 分钟最短间隔」去猜它有没有变，稳态下一天白问几百次 —— 而插件
+   * 早就知道它哪一刻变了（desktop-view.cjs 的 update()）。这里补上那个出口。
+   *
+   * 只发 updatedAt、不发内容：手机据此重拉那一发，拿到的是与列表同一口径的完整镜像，
+   * 也不必让这条「信号流」承担数据同步（它的帧一律可丢、可重放）。
+   * 同样必须直订 + 收尾注销，理由与上面两条一致。
+   */
+  const unsubscribeDesktopView = sharedDesktopViewSignal.onBump((event) => {
+    if (ac.signal.aborted) return;
+    if (!writeFrame({ type: 'device/desktop-view-changed', updatedAt: event.updatedAt, at: event.at })) ac.abort();
+  });
   /**
    * 连上就先补一帧「当前状态」。
    *
@@ -213,6 +231,12 @@ async function handleDeviceStream(ctx, req, res) {
     if (list && list.revision) {
       if (!writeFrame({ type: 'device/list-changed', revision: list.revision, at: list.at || Date.now() })) return false;
     }
+    // 桌面侧栏折叠态：手机从此只在变化时拉一次。老 App 不认识这一帧（走默认分支忽略），
+    // 所以补发它不会改变老客户端的任何行为。
+    const view = sharedDesktopViewSignal.snapshot();
+    if (view && view.updatedAt > 0) {
+      if (!writeFrame({ type: 'device/desktop-view-changed', updatedAt: view.updatedAt, at: view.at || Date.now() })) return false;
+    }
     for (const [sessionId, seq] of Object.entries(sharedSessionSignal.snapshot())) {
       if (!(seq > 0)) continue;
       if (!writeFrame({ type: 'device/session-activity', sessionId, seq, at: Date.now() })) return false;
@@ -279,6 +303,7 @@ async function handleDeviceStream(ctx, req, res) {
   clearInterval(keepAlive);
   unsubscribeSignal();
   unsubscribeActivity();
+  unsubscribeDesktopView();
   releaseSignal();
   try {
     if (!res.writableEnded) {

package/lib/mobile/history-derive.js

@@ -99,6 +99,46 @@ function toolResultParts(msg) {
   };
 }
 
+/**
+ * 图片块 → 移动端图片条目（`ChatMessage.images[]` / 工具块的 `images[]` 同一个形状）。
+ *
+ * 两条互斥的出口：
+ *  - 块上有 `attachmentId`：下发**引用** `{ mediaType, name?, attachmentId }`，**不带 data**。
+ *    字节由手机端要画的时候按 attachmentId 单张去取（`/session/attachment`），
+ *    历史响应因此不再背着几十张截图的 base64。
+ *  - 块里本来就只有内联 `data`、没有 attachmentId：照旧下发 `{ mediaType, data, name? }`。
+ *    这条兜底不能删——老日志、工具结果里存在这种直接带字节的图片块。
+ *
+ * 两条都要求 mediaType 可读（块上没有就退到 attachment 上的），否则 App 认不出来、
+ * 也没有可显示的动作，返回 null 让调用方丢掉它。
+ */
+function imageEntryOf(block) {
+  if (!block || typeof block !== 'object') return null;
+  const attachment = block.attachment && typeof block.attachment === 'object' ? block.attachment : {};
+  const attachmentId = typeof attachment.attachmentId === 'string' ? attachment.attachmentId : '';
+  const mediaType = typeof block.mediaType === 'string' && block.mediaType
+    ? block.mediaType
+    : (typeof attachment.mediaType === 'string' ? attachment.mediaType : '');
+  if (!mediaType) return null;
+  const name = typeof block.name === 'string'
+    ? block.name
+    : (typeof attachment.name === 'string' ? attachment.name : undefined);
+  if (attachmentId) return { mediaType, ...(name !== undefined ? { name } : {}), attachmentId };
+  if (typeof block.data === 'string' && block.data) return { mediaType, data: block.data, ...(name !== undefined ? { name } : {}) };
+  return null;
+}
+
+/** 把 tool/result 的图片块收成移动端图片条目（两种出口见 imageEntryOf）。 */
+function toolResultImages(parts) {
+  const out = [];
+  for (const part of parts) {
+    if (!part || typeof part !== 'object' || part.type !== 'image') continue;
+    const entry = imageEntryOf(part);
+    if (entry) out.push(entry);
+  }
+  return out;
+}
+
 /** 预扫描 tool/result 事件，构建 callId → {isError, code} 映射（对接桌面 toolRowModel 状态派生）。 */
 function buildToolResultMap(events) {
   const map = new Map();
@@ -115,10 +155,7 @@ function buildToolResultMap(events) {
        if (part && typeof part === 'object' && part.type === 'image') return '';
         try { return JSON.stringify(part); } catch { return ''; }
      }).filter(Boolean).join('');
-     const images = parts
-        .filter((part) => part && typeof part === 'object' && part.type === 'image'
-          && typeof part.data === 'string' && typeof part.mediaType === 'string')
-        .map((part) => ({ mediaType: part.mediaType, data: part.data, ...(typeof part.name === 'string' ? { name: part.name } : {}) }));
+     const images = toolResultImages(parts);
       const diffs = normalizeResultDiffs(e.data.meta);
       map.set(src.callId, { isError, code, ...(output ? { output } : {}), ...(images.length ? { images } : {}), ...(diffs ? { diffs } : {}) });
   }
@@ -142,8 +179,11 @@ function parseBlocks(blocks, toolResults) {
       // The image attachment resolver marked this block as unavailable. Keep it out of
       // visible text; pushMessage projects its retry metadata onto unavailableImages.
       continue;
-    } else if (b.type === 'image' && typeof b.data === 'string' && typeof b.mediaType === 'string') {
-      out.push({ type: 'image', mediaType: b.mediaType, data: b.data, name: typeof b.name === 'string' ? b.name : undefined });
+    } else if (b.type === 'image') {
+      // 有 attachmentId 走引用、只有内联 data 的走兜底（见 imageEntryOf）。两者都认不出
+      // 就整块丢掉——与旧行为一致，绝不能把它兜底成一段 JSON 文本。
+      const entry = imageEntryOf(b);
+      if (entry) out.push({ type: 'image', ...entry });
     } else if (b.type === 'tool-call') {
       // tool-call 块字段为 id/name/arguments（与 harness toAssistantBlock 同口径）。
       const callId = b.id != null ? String(b.id) : undefined;
@@ -336,10 +376,16 @@ function deriveMessages(events) {
       return rest;
     });
     const text = blocksToText(blocks);
+    // 图片条目统一投影：引用模式带 attachmentId 不带 data，内联兜底带 data 不带 attachmentId。
     const images = [
       ...blocks.filter((b) => b.type === 'image'),
       ...toolImages,
-    ].map(({ mediaType, data, name }) => ({ mediaType, data, name }));
+    ].map(({ mediaType, data, name, attachmentId }) => ({
+      mediaType,
+      ...(typeof name === 'string' ? { name } : {}),
+      ...(typeof attachmentId === 'string' && attachmentId ? { attachmentId } : {}),
+      ...(typeof attachmentId === 'string' && attachmentId ? {} : { data }),
+    }));
     const unavailableImages = (Array.isArray(msg.content) ? msg.content : [])
       .filter((block) => block && block.type === 'image' && block.dataUnavailable === true)
       .map((block) => {

package/lib/mobile/host-bridge/endpoints.js

@@ -110,7 +110,6 @@ const ENDPOINTS = {
 
   // skills / subagents
   'skills.list': inv('skills', 'list'),
-  'subagents.history': inv('subagents', 'history'),
   'subagents.prompt': inv('subagents', 'prompt', (p) => ({
     request: {
       ...pick(p, ['parentSessionId', 'childSessionId', 'mode', 'content', 'clientTimeZone']),

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

@@ -21,6 +21,28 @@ function sessionHint(request) {
   return typeof sessionId === 'string' && sessionId ? sessionId : null;
 }
 
+/**
+ * 这条单会话流该按哪种地址订阅。
+ *
+ * 子会话必须换成 `{kind:'subagent'}` 的 durable 地址：宿主 `validateAddress` 对
+ * `origin === 'subagent'` 的会话拿普通地址一律回 agent-busy，subscribe 直接失败 ——
+ * 表现就是「子代理页面打得开，但内容永远不自己更新」。请求体里带上 `parentSessionId`
+ * 就是「这是个子会话」的信号（与历史那条同源，见 stream.js 的 handleStream）。
+ */
+function sessionAddress(payload) {
+  const sessionId = payload && payload.sessionId;
+  const parentSessionId = payload && payload.parentSessionId;
+  if (typeof parentSessionId === 'string' && parentSessionId) {
+    return {
+      kind: 'subagent',
+      parentSessionId,
+      childSessionId: sessionId,
+      mode: (payload && payload.mode) || 'continuable',
+    };
+  }
+  return { kind: 'session', sessionId };
+}
+
 /** 一条流跑不通不该拖垮其余流：这里把异常吃掉，只丢这一条源的帧。 */
 async function* tolerate(frames, what, ctx) {
   try {
@@ -207,20 +229,28 @@ async function* deviceFrames(ctx, signal) {
 /** 旧 `events.mux`：设备级帧流，带 sessionId 时收窄成单会话视角。 */
 function muxFrames(ctx, request, signal) {
   const sessionId = sessionHint(request);
+  const payload = request && request.payload;
   return (async function* run() {
     if (!sessionId) {
       yield* deviceFrames(ctx, signal);
       return;
     }
+    const address = sessionAddress(payload);
+    // 子会话没有 job 面板（任务归属父会话），也就不订阅那一条：拿子会话 id 去问 job.list
+    // 只会白打一发，而且它的失败会被 tolerate 吞成一条警告。
     const control = openStream(ctx, 'session', 'control', {}, signal).then((frames) => tolerate(frames, 'session/control', ctx));
-    const jobs = openStream(ctx, 'job', 'list', { request: { sessionId } }, signal).then((frames) => tolerate(frames, `job/${sessionId}`, ctx));
+    const jobs = address.kind === 'session'
+      ? openStream(ctx, 'job', 'list', { request: { sessionId } }, signal).then((frames) => tolerate(frames, `job/${sessionId}`, ctx))
+      : null;
     // assistantStream: 逐块增量只走这条流的 assistant-stream 通知（见 followFramePayloads）。
     const follow = openStream(ctx, 'session', 'follow', {
-      request: { address: { kind: 'session', sessionId }, maxMessages: 1, assistantStream: true },
+      request: { address, maxMessages: 1, assistantStream: true },
     }, signal).then((frames) => tolerate(frames, `session/${sessionId}`, ctx));
     const projections = projectionState();
     const followState = { turn: null, step: null, streaming: false };
-    const sources = await Promise.all([['control', control], ['jobs', jobs], ['follow', follow]].map(([source, promise]) => promise.then(async function* wrap(iterable) {
+    const opening = [['control', control], ['follow', follow]];
+    if (jobs !== null) opening.push(['jobs', jobs]);
+    const sources = await Promise.all(opening.map(([source, promise]) => promise.then(async function* wrap(iterable) {
       for await (const frame of iterable) {
         if (source === 'follow') {
           // follow 一帧可能产出 0..n 个 mux 帧（事件原样 + 增量通知合成 chunk 事件）。

package/lib/mobile/host-bridge/shims.js

@@ -13,13 +13,36 @@ const { invoke, invokeEnvelope, ok, fail, pick, warn, deadline, openStream, SYNT
  * follow 拿游标（读完首帧立刻 break，网关会取消这条流），再翻一页历史。
  * 返回值把 records 拆回旧形状的 events（history-derive.js 只认 events/hasMore）。
  */
+/**
+ * 这次 history 要读的是「谁」的地址。
+ *
+ * 普通会话是 `{kind:'session'}`；子会话必须换成**带父会话的 durable 地址**
+ * `{kind:'subagent'}` —— 宿主对 `origin === 'subagent'` 的会话拿普通地址一律回
+ * agent-busy（见 dsh-api-session-controller 的 validateAddress），这跟续话那条
+ * 是同一个门。`mode` 也要带：宿主会拿它跟子会话自己的 descriptor 对一遍。
+ */
+function historyAddress(payload) {
+  const sessionId = payload && payload.sessionId;
+  const parentSessionId = payload && payload.parentSessionId;
+  if (typeof parentSessionId === 'string' && parentSessionId) {
+    return {
+      kind: 'subagent',
+      parentSessionId,
+      childSessionId: sessionId,
+      mode: (payload && payload.mode) || 'continuable',
+    };
+  }
+  return { kind: 'session', sessionId };
+}
+
 async function historyViaPage(ctx, payload, signal) {
   const sessionId = payload && payload.sessionId;
   if (typeof sessionId !== 'string' || !sessionId) return fail({ code: 'bad-request', message: '缺少 sessionId' }, 'bad-request');
+  const address = historyAddress(payload);
   let throughSeq = -1;
   try {
     const frames = await openStream(ctx, 'session', 'follow', {
-      request: { address: { kind: 'session', sessionId }, maxMessages: 1 },
+      request: { address, maxMessages: 1 },
     }, deadline(signal, SYNTHETIC_DEADLINE_MS));
     for await (const frame of frames) {
       if (frame && frame.type === 'snapshot' && Number.isSafeInteger(frame.cursor)) {
@@ -31,7 +54,7 @@ async function historyViaPage(ctx, payload, signal) {
     return fail(error);
   }
   const request = {
-    address: { kind: 'session', sessionId },
+    address,
     throughSeq,
     ...pick(payload, ['maxMessages', 'beforeSeq', 'turnWindow']),
   };
@@ -86,10 +109,11 @@ async function modelCatalog(ctx, payload, signal) {
         : null)
     : null;
   const effective = sessionSelection && sessionSelection.provider && sessionSelection.model ? sessionSelection : current;
-  const routable = Array.isArray(catalog.routableProviders) ? catalog.routableProviders : [];
+  const routableProviders = Array.isArray(catalog.routableProviders) ? catalog.routableProviders : [];
   return ok({
     ...(effective ? { current: effective } : {}),
-    routable: Boolean(effective && routable.includes(effective.provider)),
+    routable: Boolean(effective && routableProviders.includes(effective.provider)),
+    routableProviders,
     groups: Array.isArray(catalog.groups) ? catalog.groups : [],
   });
 }