dsh-mobile-plugin 0.5.20 → 0.5.22

package/lib/mobile/cli/acp.js

@@ -114,32 +114,46 @@ async function startAgent({ spec, cwd, env, onUpdate, onPermission, onStderr, on
   });
 
   let promptCapabilities = null;
-  const session = await Promise.race([
-    (async () => {
-      const initialized = await conn.agent.request(sdk.methods.agent.initialize, {
-        protocolVersion: sdk.PROTOCOL_VERSION,
-        // 不认领文件系统与终端能力：四家 CLI 都有自己的文件访问，我们替它读写反而要多做
-        // 一套实现，做漏了就是一条静默失败的路。
-        clientCapabilities: { terminal: false },
-        clientInfo: CLIENT_INFO,
-      });
-      // 这家认不认图片输入：握手时它自己说。不说就按「不支持」处理 —— 硬塞 image 块过去，
-      // 有的适配器会直接回一条参数错误，把整轮提问连正文一起废掉。
-      promptCapabilities = (initialized && initialized.agentCapabilities && initialized.agentCapabilities.promptCapabilities) || null;
-      const created = await conn.agent.request(sdk.methods.agent.session.new, {
-        cwd,
-        mcpServers: [],
-      });
-      return { sessionId: created.sessionId, created };
-    })(),
-    deadline,
-  ]);
 
+  /**
+   * 收掉这条连接与它的子进程。
+   *
+   * 必须定义在握手**之前**：握手失败或超时时这里直接抛错，而那时子进程已经起来了 —— 不在这
+   * 条路径上关掉，它就成了一个没人管的孤儿进程（卡在登录界面、还在等输入）。探配置那条路会
+   * 反复进来，漏一次就是攒一个进程。
+   */
   function kill() {
     try { conn.close(); } catch { /* 已经关了 */ }
     try { child.kill('SIGTERM'); } catch { /* 已经退出 */ }
   }
 
+  let session;
+  try {
+    session = await Promise.race([
+      (async () => {
+        const initialized = await conn.agent.request(sdk.methods.agent.initialize, {
+          protocolVersion: sdk.PROTOCOL_VERSION,
+          // 不认领文件系统与终端能力：四家 CLI 都有自己的文件访问，我们替它读写反而要多做
+          // 一套实现，做漏了就是一条静默失败的路。
+          clientCapabilities: { terminal: false },
+          clientInfo: CLIENT_INFO,
+        });
+        // 这家认不认图片输入：握手时它自己说。不说就按「不支持」处理 —— 硬塞 image 块过去，
+        // 有的适配器会直接回一条参数错误，把整轮提问连正文一起废掉。
+        promptCapabilities = (initialized && initialized.agentCapabilities && initialized.agentCapabilities.promptCapabilities) || null;
+        const created = await conn.agent.request(sdk.methods.agent.session.new, {
+          cwd,
+          mcpServers: [],
+        });
+        return { sessionId: created.sessionId, created };
+      })(),
+      deadline,
+    ]);
+  } catch (error) {
+    kill();
+    throw error;
+  }
+
   return {
     child,
     sessionId: session.sessionId,

package/lib/mobile/cli/mobile.js

@@ -46,6 +46,7 @@ const { createFrameSealer } = require('../stream.js')
 const { imageBlockOf, metaOf, openImage, saveImage, MAX_IMAGE_BYTES, MEDIA_EXT } = require('./images.js')
 const { resolveFinishedUpload } = require('../uploads.js')
 const { rememberModel } = require('./model-prefs.js')
+const { setValue } = require('./config-prefs.js')
 const { statsOf } = require('./usage.js')
 const { hiddenOf, setVisible } = require('./model-visibility.js')
 const { lookupModelMeta } = require('../model-meta.js')
@@ -1197,7 +1198,12 @@ function createCliMobile(deps) {
       const effort = textOf(body.reasoningEffort)
       if (effort) {
         const effortOption = thoughtOptionOf(options)
-        if (effortOption) await session.handle.setConfigOption(effortOption.id, effort)
+        if (effortOption) {
+          await session.handle.setConfigOption(effortOption.id, effort)
+          // 在对话里调过的档位也变成「以后新开的默认」—— 与配置页写的是同一本账
+          // （`config-prefs`），两条路不分家（见 A3-80）。
+          setValue(session.agentId, effortOption.id, effort)
+        }
       }
     } catch { /* 选不动就维持原样：下一次读 models 会回真实值 */ }
   }
@@ -1213,6 +1219,7 @@ function createCliMobile(deps) {
       if (updated && Array.isArray(updated.configOptions)) session.configOptions = updated.configOptions
       const option = (session.configOptions || []).find((item) => item && item.id === optionId)
       if (option && option.category === 'model') rememberModel(session.agentId, optionId, textOf(body.value))
+      else if (option) setValue(session.agentId, optionId, textOf(body.value))
     } catch { /* 同上 */ }
   }
 

package/lib/mobile/cli/service.js

@@ -19,6 +19,7 @@
  *      带全量块重放，页面回到原样。
  */
 
+const { homedir } = require('node:os');
 const { WebSocketServer } = require('ws');
 
 const { readJsonBody, sendJson } = require('../../shared/http-util');
@@ -55,6 +56,14 @@ const FLUSH_MS = 60;
 /** 标题兜底截断长度（宿主没给 `session_info_update.title` 时用首条提问）。 */
 const TITLE_MAX = 40;
 
+/**
+ * 「探一次配置」的失败重试间隔。
+ *
+ * 探一次要起一个适配器（首次还可能要 npx 下载），不能每次进配置页都重来一遍；但也不该把
+ * 一次失败记一辈子 —— 用户多半是去装了 CLI / 登录了才回来的。
+ */
+const PROBE_RETRY_MS = 60 * 1000;
+
 class CliRequestError extends Error {
   constructor(code, message) {
     super(message);
@@ -93,6 +102,8 @@ function pendingPrefsOf(session) {
   for (const option of options) {
     if (option && option.category === 'model') skip.add(option.id);
   }
+  // 模型那一项记在 `model-prefs` 那本账里（`applyPreferredModel` 负责），这里一律跳过 ——
+  // 包括 id 不叫 `model` 的那些（claude 的 `agent` 子代理、opencode 的分组模型）。
   const out = [];
   for (const [configId, value] of Object.entries(recorded)) {
     if (skip.has(configId)) continue;
@@ -112,6 +123,38 @@ async function bodyJson(req) {
   return body;
 }
 
+/**
+ * 这一项是不是「模型」。
+ *
+ * 判据是 ACP 给的 `category`，不是 id 的字面值：codex/opencode 叫 `model`，claude 的模型
+ * 项也叫 `model`，但换一家可能就是别的名字 —— 按 id 猜就会漏掉一家，而漏掉的表现正是
+ * 「配置页勾上了、开新对话还是原来的模型」。认不出（配置页还没拿到选项表）就按 id 兜底。
+ */
+function isModelOption(options, configId) {
+  const list = Array.isArray(options) ? options : [];
+  const option = list.find((item) => item && item.id === configId);
+  if (option) return option.category === 'model';
+  return configId === 'model';
+}
+
+/**
+ * 配置页要画的「记着的那一套」。
+ *
+ * 两本账合到一处：模型记在 `model-prefs`（新会话开局由 `applyPreferredModel` 套），其余记在
+ * `config-prefs`。配置页只认一张表，所以在这里并起来 —— 不并的话，配置页里模型那一格永远
+ * 显示「跟 CLI 自己的一样」，用户选过的模型看不见。
+ */
+function valuesBodyOf(agentId, options) {
+  const values = { ...prefsOf(agentId).values };
+  const preferred = preferredModel(agentId);
+  if (preferred) values[preferred.configId] = preferred.value;
+  // 两本账里都不该有「模型」，但真出现过（旧版本写进去的）就别让它冒充生效值。
+  for (const key of Object.keys(values)) {
+    if (isModelOption(options, key) && !(preferred && preferred.configId === key)) delete values[key];
+  }
+  return values;
+}
+
 /** 会话表与它的所有出口。一个宿主进程一份（装配层建、装配层关）。 */
 function createCliService({ authorized, onLog } = {}) {
   /** sessionId → 会话。 */
@@ -142,6 +185,72 @@ function createCliService({ authorized, onLog } = {}) {
     return agentsPromise;
   }
 
+  /** agentId → `{ running, at, error, done }`：这一家探配置的状态（同时只允许一次）。 */
+  const probes = new Map();
+
+  function probeState(agentId) {
+    return probes.get(agentId) || null;
+  }
+
+  /**
+   * 现去问一次这个 CLI 有哪些可调项。
+   *
+   * 为什么要这一步：选项表是 CLI 自己在握手之后给的，缓存里只有「开过对话的那几家」。用户新
+   * 装一个 CLI、想先把权限档配好再去用，正是最需要配置页的时候，而那时缓存是空的 —— 配置页
+   * 就是一句「没有可调的项」，四个配置入口点下去长得一模一样。
+   *
+   * 代价是起一次适配器（首次还要 npx 下载），所以：同一个 CLI 同时只探一次；探到手就落缓存，
+   * 之后的配置页直接读；失败记一段时间（`PROBE_RETRY_MS`），别让用户每次进来都等一轮下载。
+   * 它不进 `sessions` 那张表 —— 这是一次性的探测进程，拿到表就关，侧栏里不该多出一行。
+   */
+  function startProbe(ctx, agentId) {
+    if (probes.has(agentId) && probes.get(agentId).running) return;
+    const entry = { running: true, at: Date.now(), error: '', done: false };
+    probes.set(agentId, entry);
+    void (async () => {
+      let handle = null;
+      try {
+        const agent = (await listAgents()).find((item) => item && item.id === agentId) || null;
+        if (!agent) throw new Error('这台电脑上没有这个 CLI');
+        const spec = resolveAgent(agent);
+        if (!spec.ok) throw new Error(spec.reason || '这个 CLI 起不来');
+        // 起在哪：配置项与目录无关，随便借一个已注册工作区（没有工作区就借家目录 —— 有些适配器
+        // 对 cwd 有要求，给个存在且可写的路径总比空串安全）。
+        const cwd = await pickProbeCwd(ctx);
+        handle = await startAgent({ spec, cwd, env: childEnv(spec.command) });
+        if (closed) return;
+        // 探到了就记下来（这家确实一项都不给时记的是空表，配置页据此说「没有可调的项」
+        // 而不是一直转圈）。
+        rememberOptions(agentId, handle.configOptions);
+        entry.error = '';
+        // 这一家**问过了**：哪怕它一项配置都不给，也不许再探第二次 —— 那等于每进一次配置页
+        // 就起一个适配器进程，而结果永远是同一张空表。
+        entry.done = true;
+      } catch (error) {
+        entry.error = error && error.message ? error.message : '问不到这个 CLI 的配置';
+        log(`cli 探配置失败（${agentId}）：${entry.error}`);
+      } finally {
+        entry.running = false;
+        entry.at = Date.now();
+        try { handle?.close(); } catch { /* 已经退了 */ }
+      }
+    })();
+  }
+
+  /** 探测进程的工作目录：优先借一个已注册工作区，取不到就用家目录。 */
+  async function pickProbeCwd(ctx) {
+    try {
+      const listed = await ctx.apiProxy.workspace.list({ rpcId: 'mobile', method: 'workspace.list', payload: {} });
+      const { value } = unwrap(listed);
+      const items = Array.isArray(value) ? value : (value && Array.isArray(value.items) ? value.items : []);
+      for (const item of items) {
+        const dir = text(item && item.path);
+        if (dir) return dir;
+      }
+    } catch { /* 取不到就退到家目录 */ }
+    return homedir();
+  }
+
   function send(ws, frame) {
     if (ws.readyState !== ws.OPEN) return;
     try { ws.send(JSON.stringify(frame)); } catch { /* 已经断了 */ }
@@ -664,11 +773,11 @@ function createCliService({ authorized, onLog } = {}) {
         const updated = await session.handle.setConfigOption(configId, body.value);
         if (updated && Array.isArray(updated.configOptions)) session.configOptions = updated.configOptions;
         // 选过的模型要记住：下一次在这个 CLI 上开新会话时自动套上（见 applyPreferredModel）。
-        // 只记模型那一项 —— 思考档 / 权限模式跟着模型走，单独记会把两边记岔。
+        // 模型只记在 `model-prefs` 那本账里；其余每一项记进 `config-prefs.js` —— 那是「下次
+        // 开局自动套上」的唯一来源，两本账各记一份的话生效的那本必须是被写的那本。
         const option = (session.configOptions || []).find((item) => item && item.id === configId);
         if (option && option.category === 'model') rememberModel(session.agentId, configId, body.value);
-        // 每一项都记：这是「下次开局自动套上」的唯一来源（见 `cli/config-prefs.js`）。
-        if (option) setValue(session.agentId, configId, text(body.value));
+        else if (option) setValue(session.agentId, configId, text(body.value));
       } else throw fail('BAD_REQUEST', '需要 configId 或 modeId');
     } catch (error) {
       if (error && error.code && STATUS_BY_CODE[error.code]) throw error;
@@ -680,11 +789,15 @@ function createCliService({ authorized, onLog } = {}) {
   /**
    * GET /cli/prefs?agent=：一个 CLI 的配置全貌（配置页读它）。
    *
-   * 配置页在**没有开会话**的时候就要能画：所以这里回的是「上次记下的选项表 + 记着的值」，
-   * 一个进程都不用起。`live` 说的是这份表是从正在跑的那条会话读的（更新），还是缓存（CLI 那之后
-   * 可能升级过）。
+   * 优先顺序：正开着的那条会话手上的表（最新）→ 记忆里那份（CLI 握过手就记下）→ **现去问一次**。
+   * 最后一档是必须的：选项表是 CLI 自己给的，一家从没在这台电脑上开过对话的 CLI（全新装的
+   * Gemini CLI 之类）记忆里一条都没有，配置页就成了一句「没有可调的项」—— 而「提前把权限配
+   * 好」正是最需要它的时候。问的那一次在后台跑（起一个适配器、拿到 `configOptions` 就关掉），
+   * 回来之前回 `pending`，App 按退避重问。
+   *
+   * `live` 说的是这份表是从跑着的会话读的；`pending` 说的是正在问。
    */
-  function handlePrefs(_ctx, req, res) {
+  async function handlePrefs(ctx, req, res) {
     const agentId = text(query(req).get('agent'));
     if (!agentId) throw fail('BAD_REQUEST', '需要 agent');
     const recorded = prefsOf(agentId);
@@ -700,12 +813,29 @@ function createCliService({ authorized, onLog } = {}) {
       live = true;
       break;
     }
+    let pending = false;
+    let probeError = '';
+    // `force` 是配置页那行「重试」：探测失败之后，用户去装了 CLI / 登了录才回来，等
+    // `PROBE_RETRY_MS` 到点是不对的 —— 他这一下就是要现在再问一次。
+    const force = query(req).get('probe') === '1';
+    if (options.length === 0 && !live) {
+      const state = probeState(agentId);
+      if (state && state.running) pending = true;
+      else if (!state || force || (!state.done && (!state.error || Date.now() - state.at > PROBE_RETRY_MS))) {
+        startProbe(ctx, agentId);
+        pending = true;
+      } else if (!state.done && state.error) {
+        probeError = state.error;
+      }
+    }
     sendJson(res, 200, {
       ok: true,
       agent: agentId,
       options,
-      values: recorded.values,
+      values: valuesBodyOf(agentId, options),
       live,
+      pending,
+      ...(probeError ? { probeError } : {}),
     });
   }
 
@@ -724,14 +854,21 @@ function createCliService({ authorized, onLog } = {}) {
    * 那几条」。配置页在没有会话时用它，所以它也不启动任何进程。
    *
    * `value` 空 = 撤掉这一项，回到 CLI 自己的默认。
+   *
+   * **模型那一项记在 `model-prefs` 那本账上**：新会话开局是 `applyPreferredModel` 在读它，
+   * 记进 `config-prefs` 只会出现「配置页勾上了、开新对话却是别的」—— 两本账各记一份时，
+   * 生效的那本必须是被写的那本。
    */
   async function handleSetPref(_ctx, req, res) {
     const body = await bodyJson(req);
     const agentId = text(body.agent);
     const configId = text(body.configId);
     if (!agentId || !configId) throw fail('BAD_REQUEST', '需要 agent 与 configId');
-    setValue(agentId, configId, text(body.value));
-    sendJson(res, 200, { ok: true, agent: agentId, values: prefsOf(agentId).values });
+    const value = text(body.value);
+    const options = prefsOf(agentId).options;
+    if (isModelOption(options, configId)) rememberModel(agentId, configId, value);
+    else setValue(agentId, configId, value);
+    sendJson(res, 200, { ok: true, agent: agentId, values: valuesBodyOf(agentId, options) });
   }
 
   /** POST cli/close { sessionId }：主动收掉一个会话（用户点「结束」）。 */
@@ -897,5 +1034,9 @@ module.exports = {
   mountCli,
   createCliService,
   pendingPrefsOf,
+  // 配置页要画的那张表与「哪一项是模型」的判据：两条都在这里，测试直接钉这两份真函数
+  // （照抄一份等价实现的话，实现写错测试照样绿）。
+  isModelOption,
+  valuesBodyOf,
   MAX_SESSIONS,
 };

package/lib/mobile/extension-catalog.js

@@ -0,0 +1,244 @@
+'use strict';
+
+/**
+ * 已审核扩展清单：随 dsh-mobile-plugin 的 npm 包一起发布的第三方扩展（包内 `extensions/`）。
+ *
+ * 与开发包那条路的分界：开发包读作者电脑上的 `$DSH_HOME/extension-dev`（边写边看），这条读
+ * 插件包自带的只读目录 —— 只有审过、登记进 `extensions/catalog.json` 的包才下发，目录里有但
+ * 没登记的一律当不存在。审核闸门在清单，不在目录。
+ *
+ * 能力面只多「读这一个固定目录」：根由 `__dirname` 定位，不依赖进程 cwd，也不建目录；每个
+ * 文件的 size 与 sha256 由宿主扫目录现算，不信清单里写的数字。取文件先挡绝对路径与 `..` 段，
+ * 再 resolve 之后判前缀（带分隔符），不接受任意路径。仍然不暴露 shell、系统设置、任意文件读写。
+ *
+ * 坏包一律静默跳过：没登记、目录不在、manifest 读不出、超限（20MB / 200 个文件）都不该让整张
+ * 列表变红；catalog.json 不在或坏了就是一份空清单，不抛。取文件那条才逐个回错误码。
+ */
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { sendJson } = require('../shared/http-util');
+
+/** 审核清单文件名。只有列进来的 slug 才下发。 */
+const CATALOG_FILE = 'catalog.json';
+/** slug 直接当包目录名，所以只认这套字符；别的名字连读都不读。 */
+const SLUG_PATTERN = /^[A-Za-z0-9._-]{1,64}$/;
+/** 整包上限：与开发包同一档，太重的包手机也不该整份拉。 */
+const MAX_PACKAGE_BYTES = 20 * 1024 * 1024;
+const MAX_PACKAGE_FILES = 200;
+/** 单个文件上限：一条 base64 响应要塞进手机内存，再大就不该走这条路。 */
+const MAX_FILE_BYTES = 8 * 1024 * 1024;
+
+/** 包内固定目录：从 lib/mobile/ 往上两级就是包根。不依赖 cwd、不建目录（随 npm 包发布）。 */
+function catalogRoot() {
+  return path.join(__dirname, '..', '..', 'extensions');
+}
+
+/** 400 信封：与其余移动端接口同形，App 按 code 翻人话。 */
+function fail(res, status, code, message) {
+  return sendJson(res, status, { ok: false, error: { code, message } });
+}
+
+/** manifest 里取一个非空字符串，缺了 / 类型不对 / 空串都退回默认值。 */
+function textField(value, fallback) {
+  return typeof value === 'string' && value ? value : fallback;
+}
+
+/** 清单里的可选文案：非空字符串才收，其余一律 null。 */
+function textOrNull(value) {
+  return typeof value === 'string' && value.trim() ? value : null;
+}
+
+/** 能力声明收窄成字符串数组：表外的类型与空串丢掉，重复的不给第二份。 */
+function capabilitiesOf(value) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  const seen = new Set();
+  for (const item of value) {
+    if (typeof item !== 'string' || !item.trim() || seen.has(item)) continue;
+    seen.add(item);
+    out.push(item);
+  }
+  return out;
+}
+
+function sha256Hex(raw) {
+  return crypto.createHash('sha256').update(raw).digest('hex');
+}
+
+/**
+ * 读审核清单。文件不在、读坏、形状不对都当空清单 —— 空的插件包本来就没有第三方扩展。
+ * 只收 slug / description / author / releaseNotes 四样，其余字段（包括任何 size / sha256）
+ * 一概不认：清单只负责「谁审过了」，文件事实由扫目录算。
+ */
+function readCatalog(root) {
+  let text;
+  try { text = fs.readFileSync(path.join(root, CATALOG_FILE), 'utf8'); } catch { return []; }
+  let parsed;
+  try { parsed = JSON.parse(text); } catch { return []; }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed) || !Array.isArray(parsed.packages)) return [];
+  const rows = [];
+  const seen = new Set();
+  for (const raw of parsed.packages) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) continue;
+    const slug = typeof raw.slug === 'string' ? raw.slug.trim() : '';
+    if (!SLUG_PATTERN.test(slug) || seen.has(slug)) continue;
+    seen.add(slug);
+    rows.push({
+      slug,
+      description: textOrNull(raw.description),
+      author: textOrNull(raw.author),
+      releaseNotes: textOrNull(raw.releaseNotes),
+    });
+  }
+  return rows;
+}
+
+/**
+ * 递归收集包内的普通文件，`path` 是相对包目录的 POSIX 路径。与 extension-dev.js 同一套口径：
+ * 点开头的文件与目录不看，符号链接不是普通文件，超限当场收手返回 false（先收完再判等于把
+ * 500MB 的目录整个哈希一遍）。
+ */
+function collectFiles(directory, acc) {
+  let entries;
+  try { entries = fs.readdirSync(directory, { withFileTypes: true }); } catch { return false; }
+  for (const entry of entries) {
+    if (entry.name.startsWith('.')) continue;
+    const full = path.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      if (!collectFiles(full, acc)) return false;
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    let raw;
+    try { raw = fs.readFileSync(full); } catch { continue; }
+    acc.bytes += raw.length;
+    acc.files.push({
+      path: path.relative(acc.root, full).split(path.sep).join('/'),
+      size: raw.length,
+      sha256: sha256Hex(raw),
+    });
+    if (acc.bytes > MAX_PACKAGE_BYTES || acc.files.length > MAX_PACKAGE_FILES) return false;
+  }
+  return true;
+}
+
+/**
+ * 扫审核清单，把每个登记过、且目录与 manifest 都在的包读成一份 Package。
+ *
+ * 入口页固定是包目录下那层 `index.html`：App 侧 `extensionEntryPath` 找的就是这个名字，
+ * `manifest.json` 里写 `main` 不生效。所以这里在列包时先确认 `index.html` 真的在文件清单里，
+ * 缺了就把整包跳过 —— 装到手机上再报「需要重新安装」，比根本不出现在清单里难查得多。
+ *
+ * 纯函数、root 由调用方给：守卫拿假目录跑，线上 handler 给包内那个固定目录。
+ */
+function listPackages(root) {
+  const packages = [];
+  for (const entry of readCatalog(root)) {
+    const directory = path.join(root, entry.slug);
+    let stats;
+    try { stats = fs.statSync(directory); } catch { continue; }
+    if (!stats.isDirectory()) continue;
+    let manifest;
+    try {
+      manifest = JSON.parse(fs.readFileSync(path.join(directory, 'manifest.json'), 'utf8'));
+    } catch { continue; }
+    if (!manifest || typeof manifest !== 'object' || Array.isArray(manifest)) continue;
+    const acc = { root: directory, files: [], bytes: 0 };
+    if (!collectFiles(directory, acc) || acc.files.length === 0) continue;
+    if (!acc.files.some((file) => file.path === 'index.html')) continue;
+    packages.push({
+      slug: entry.slug,
+      name: textField(manifest.name, entry.slug),
+      description: entry.description,
+      author: entry.author,
+      versionName: textField(manifest.versionName, textField(manifest.version, '0.0.0')),
+      apiVersion: textField(manifest.apiVersion, textField(manifest.api_version, '1')),
+      releaseNotes: entry.releaseNotes,
+      capabilities: capabilitiesOf(manifest.capabilities),
+      size: acc.bytes,
+      fileCount: acc.files.length,
+      files: acc.files,
+    });
+  }
+  return packages;
+}
+
+/**
+ * GET /api/mobile/v1/extension/catalog（token）
+ *
+ * 回审核过的第三方扩展清单。`root` 只是给守卫传假目录的可选参数，线上由 route() 调用时
+ * 不传，永远走包内那个固定目录。
+ */
+async function handleCatalog(_ctx, _req, res, root = catalogRoot()) {
+  sendJson(res, 200, { ok: true, packages: listPackages(root) });
+}
+
+/**
+ * GET /api/mobile/v1/extension/catalog/file?slug=…&path=…（token）
+ *
+ * 取一个已审核包里的一个文件，回 base64 与 sha256（与列表里那条同一份算法）。审核闸门对取文件
+ * 同样生效：没登记进 catalog.json 的 slug 一律 404，免得绕过清单直接把目录里的字节读走。
+ *
+ * 路径检查两道：先挡明显不该出现的（绝对路径、`..` 段），再 resolve 之后判前缀 —— 后者才是
+ * 判据，前缀比较必须带分隔符，否则 `/x/extensions/foobar` 会被 `/x/extensions/foo` 认成子路径。
+ */
+async function handleCatalogFile(_ctx, req, res, root = catalogRoot()) {
+  const url = new URL(req.url || '/', 'http://x');
+  const slug = (url.searchParams.get('slug') || '').trim();
+  const requested = (url.searchParams.get('path') || '').trim();
+  if (!slug || !requested || !SLUG_PATTERN.test(slug)) {
+    return fail(res, 400, 'bad-request', '需要合法的 slug 与 path（path 是相对包目录的路径）');
+  }
+
+  if (!readCatalog(root).some((entry) => entry.slug === slug)) {
+    return fail(res, 404, 'package-missing', `审核清单里没有 ${slug} 这个包`);
+  }
+  const directory = path.join(root, slug);
+  if (!fs.existsSync(path.join(directory, 'manifest.json'))) {
+    return fail(res, 404, 'package-missing', `${slug} 没有可下发的包（缺 manifest.json）`);
+  }
+
+  if (path.isAbsolute(requested) || requested.split(/[\\/]/).includes('..')) {
+    return fail(res, 400, 'bad-request', 'path 必须是包目录内的相对路径');
+  }
+  const target = path.resolve(directory, requested);
+  if (!target.startsWith(`${directory}${path.sep}`)) {
+    return fail(res, 400, 'bad-request', 'path 必须是包目录内的相对路径');
+  }
+
+  let stats;
+  try { stats = fs.statSync(target); } catch { stats = null; }
+  if (!stats || !stats.isFile()) {
+    return fail(res, 404, 'file-missing', `这个包里没有 ${requested}`);
+  }
+  if (stats.size > MAX_FILE_BYTES) {
+    return fail(res, 413, 'file-too-large', `单个文件上限 ${MAX_FILE_BYTES} 字节，这个超了`);
+  }
+
+  let raw;
+  try { raw = fs.readFileSync(target); } catch {
+    return fail(res, 404, 'file-missing', `这个包里没有 ${requested}`);
+  }
+
+  const relative = path.relative(directory, target).split(path.sep).join('/');
+  sendJson(res, 200, {
+    ok: true,
+    path: relative,
+    size: raw.length,
+    sha256: sha256Hex(raw),
+    content: raw.toString('base64'),
+  });
+}
+
+module.exports = {
+  catalogRoot,
+  listPackages,
+  handleCatalog,
+  handleCatalogFile,
+  MAX_PACKAGE_BYTES,
+  MAX_PACKAGE_FILES,
+  MAX_FILE_BYTES,
+};

package/lib/mobile/local-images.js

@@ -44,7 +44,7 @@ const MEDIA_TYPES = {
   '.gif': 'image/gif',
 };
 
-/** 单张图上限：再大的东西不该整包回给手机（超出如实保持字面 markdown）。 */
+/** 单张图上限：再大的东西不该整包回给手机。 */
 const MAX_IMAGE_BYTES = 2.5 * 1024 * 1024;
 /** 读宽高只需要文件头：JPEG 的 SOF 段可能在几百字节之后，64KB 足够覆盖绝大多实拍图。 */
 const HEAD_BYTES = 64 * 1024;
@@ -246,6 +246,10 @@ async function readHead(filePath, size) {
  *
  * 编号取「路径 + 大小 + 修改时间」的短哈希：同一张图在同一轮历史里会被反复解析，
  * 这个组合稳定，且改过之后自然换号（图片内容变了本来就该换）。
+ *
+ * **超过单张上限的图也登记，只是标一句 `tooLarge`**：不登记的话正文里那一段就退回字面
+ * markdown，用户在手机上看到的是一串 `![](路径)` 源码 —— 既不知道发生过什么，也没有任何
+ * 入口。标了之后取图口如实回 413，App 画成「图片太大」的占位块，这才是用户能读懂的一句话。
  */
 async function registerLocalImage(filePath) {
   let stat;
@@ -254,7 +258,7 @@ async function registerLocalImage(filePath) {
   } catch {
     return null;
   }
-  if (!stat.isFile() || stat.size <= 0 || stat.size > MAX_IMAGE_BYTES) return null;
+  if (!stat.isFile() || stat.size <= 0) return null;
   const id = crypto.createHash('sha1').update(`${filePath}:${stat.size}:${stat.mtimeMs}`).digest('hex').slice(0, 16);
   const known = registry.get(id);
   if (known) return { id, ...known };
@@ -262,11 +266,12 @@ async function registerLocalImage(filePath) {
   if (!head) return null;
   const mediaType = sniffMediaType(head);
   if (!mediaType) return null;
-  const parsed = imageSizeOf(head);
+  const over = stat.size > MAX_IMAGE_BYTES;
+  const parsed = over ? null : imageSizeOf(head);
   const sane = parsed && parsed.width > 0 && parsed.height > 0
     && parsed.width <= 30000 && parsed.height <= 30000;
   const size = sane ? parsed : {};
-  const entry = { filePath, mediaType, ...size };
+  const entry = { filePath, mediaType, ...size, ...(over ? { tooLarge: true } : {}) };
   registry.set(id, entry);
   while (registry.size > MAX_REGISTRY_ENTRIES) registry.delete(registry.keys().next().value);
   return { id, ...entry };
@@ -467,4 +472,4 @@ function inRanges(index, ranges) {
   return false;
 }
 
-module.exports = { inlineTextImages, createTextImageBudget, localImagePathOf, hasRelativeImage, localImageOf, registerLocalImage, imageSizeOf, sniffMediaType, clearLocalImages };
+module.exports = { inlineTextImages, createTextImageBudget, localImagePathOf, hasRelativeImage, localImageOf, registerLocalImage, imageSizeOf, sniffMediaType, clearLocalImages, MAX_IMAGE_BYTES };

package/lib/mobile/monitor.js

@@ -26,7 +26,7 @@ const {
 const { updateCompletionStates, confirmCompletionFromHistory } = require('./completion.js');
 const { lastTurnOf } = require('./session-last-turn.js');
 const { sessionPreviewFor } = require('./session-preview.js');
-const { workspaceSessionFlags, pendingInteractionOf, pendingCardOf } = require('./session-flags.js');
+const { archivedSessionIdsForMonitor, pendingInteractionOf, pendingCardOf } = require('./session-flags.js');
 
 /**
  * 一条会话在监控视图里的那几格。
@@ -114,7 +114,10 @@ async function buildMonitorState(ctx, deviceKey, extraItems = null) {
 
   const generation = completionGenerationOf(ctx, deviceKey);
   const deleted = deletedSessionIdsOf(ctx);
-  const { archived } = await workspaceSessionFlags(ctx);
+  // 归档集合用「记住上一次真读到的那份」那个口径，不用列表那条 fail-open：
+  // 这一条决定要不要在后台叫醒人，一次读不到就按「没归档」画会让已归档的会话重新进清单、
+  // 被当成刚跑完再响一遍（见 session-flags.js 的 archivedSessionIdsForMonitor）。
+  const archived = await archivedSessionIdsForMonitor(ctx);
   // 子代理会话不参与后台提醒：它们是主轮内部的执行单元，App 侧栏也不列；把它们算进来
   // 会在后台弹一堆「子代理跑完了」。
   const live = summaries.filter((s) => s && typeof s.sessionId === 'string' && s.sessionId