dsh-mobile-plugin 0.5.1 → 0.5.3

package/lib/mobile/agent-presets.js

@@ -4,7 +4,8 @@
  * 移动端「Agent 预设管理」API：把桌面端设置页的预设管理分区补齐到手机上。
  *
  * 手机端只保留管理分区（app 的 PresetManager）：桌面那边设置里的一行与新建会话芯片已下线，
- * 手机一律吃宿主默认档。三条路由都只转发宿主的 agentPreset 域：read / copy / remove。
+ * 手机一律吃宿主默认档。四条路由：read / copy / remove 转发宿主的 agentPreset 域；default
+ * 写宿主 settings 里存「默认档」的那一格（见 handleAgentPresetDefault）。
  *
  * 语义按宿主原文透传：copy 是整份复制，标识符成为目录名且事后无法更改；remove 只对 user
  * 预设有效（随附预设回 agent-preset-read-only）。宿主的失败对象是 code + details，按 code
@@ -143,10 +144,73 @@ async function handleAgentPresetRemove(ctx, req, res) {
   sendJson(res, 200, { ok: true, agentPreset: id.value });
 }
 
+/** 宿主 settings 里存「默认预设」的那一格：桌面端「设为默认」写的就是它。 */
+const PRESET_SETTINGS_NS = 'agent-preset-registry';
+const PRESET_DEFAULT_FIELD = 'selectedDefault';
+
+/**
+ * POST /api/mobile/v1/agent-presets/default（token）{ agentPreset } → { ok, agentPreset }
+ *
+ * 「哪一档是新会话的默认档」不是预设自己的属性：宿主注册表从 settings 的
+ * `agent-preset-registry.selectedDefault` 读（没写过就退回部署时那个 default），桌面端那颗
+ * 「设为默认」写的就是这一格。手机此前没有这个入口，新会话只能吃部署时那一档。
+ *
+ * 先按名单确认这一档真在，再写：写一个不存在的 id 不会报错，但之后每次新建会话都会被宿主
+ * 拒（agent-preset-not-found），那时用户已经不知道是自己哪一步弄坏的。
+ */
+async function handleAgentPresetDefault(ctx, req, res) {
+  const body = await readJsonBody(req, PRESET_MAX_BODY);
+  const id = normalizeId(body && body.agentPreset);
+  if (!id.value) return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: id.problem } });
+
+  const listed = unwrap(await callAgentPresets(ctx, 'list', {}));
+  if (listed.error) return sendJson(res, statusOf(listed.error.code), { ok: false, error: failure(listed.error) });
+  const rows = listed.value && Array.isArray(listed.value.presets) ? listed.value.presets : [];
+  const row = rows.find((item) => item && item.id === id.value);
+  if (!row) {
+    return sendJson(res, 404, {
+      ok: false,
+      error: {
+        code: 'agent-preset-not-found',
+        message: presetMessage('agent-preset-not-found'),
+        details: { agentPreset: id.value, available: rows.map((item) => item && item.id).filter(Boolean) },
+      },
+    });
+  }
+  // 已经是默认档就不再写：settings.mutate 一次就推进一次 revision，白写等于让别处正在
+  // 改设置的人撞上冲突。
+  if (row.isDefault === true) return sendJson(res, 200, { ok: true, agentPreset: id.value });
+
+  const settings = ctx.apiProxy && ctx.apiProxy.settings;
+  if (!settings || typeof settings.mutate !== 'function') {
+    return sendJson(res, 400, {
+      ok: false,
+      error: { code: 'unsupported', message: '这台宿主没有设置写入接口，改不了默认预设' },
+    });
+  }
+  const { error } = unwrap(await settings.mutate({
+    rpcId: 'mobile',
+    method: 'settings.mutate',
+    payload: { ns: PRESET_SETTINGS_NS, ops: [{ op: 'set', path: [PRESET_DEFAULT_FIELD], value: id.value }] },
+  }));
+  if (error) {
+    const hostMessage = error && typeof error.message === 'string' ? error.message : '';
+    return sendJson(res, 400, {
+      ok: false,
+      error: {
+        code: error && typeof error.code === 'string' && error.code ? error.code : 'internal',
+        message: hostMessage ? `默认预设没写进去：${hostMessage}` : '默认预设没写进去',
+      },
+    });
+  }
+  sendJson(res, 200, { ok: true, agentPreset: id.value });
+}
+
 module.exports = {
   handleAgentPresetRead,
   handleAgentPresetCopy,
   handleAgentPresetRemove,
+  handleAgentPresetDefault,
   // 下面这些是给守卫测试直接驱动的纯函数（与 references.js 同做法）
   normalizeId,
   normalizeName,
@@ -159,4 +223,6 @@ module.exports = {
   PRESET_ID_MAX_CHARS,
   PRESET_NAME_MAX_CHARS,
   PRESET_BODY_MAX_CHARS,
+  PRESET_SETTINGS_NS,
+  PRESET_DEFAULT_FIELD,
 };

package/lib/mobile/debug-trace.js

@@ -0,0 +1,180 @@
+'use strict';
+
+/**
+ * 手机端调试轨迹的落盘口（`POST /api/mobile/v1/debug/trace`）。
+ *
+ * 为什么要有它：滑动手感出问题时，现场在手机上（偏移轨迹、每一行的实际高度、图片什么时候
+ * 才到），而能看这些东西的人在这台电脑上。让人把几万行日志抄进聊天不现实，所以 App 边录边把
+ * 一行行 JSONL 打到这里，插件落进 `<DSH_HOME>/mobile-debug/<capture>.jsonl`，维护者在这台
+ * 电脑上直接读文件。
+ *
+ * 三条边界，别放宽：
+ *  - **不是任意文件写入**：文件名只由 `capture` 生成，且只认 `[A-Za-z0-9._-]`。构造一个别的
+ *    capture 只会在这一个目录里多一份空文件，碰不到用户的任何东西；
+ *  - **只追加**：一次请求往 `<capture>.jsonl` 末尾续一段，从不覆盖、从不删别的文件；
+ *  - **封顶**：一份轨迹 8MB 之后停写（回 `capped: true`，App 收到就停手），目录里最多留 10 份，
+ *    第 11 份进来时删掉最旧那份。录音不会把盘写满。
+ *
+ * 与 `session/file`、`session/attachment` 那些读口方向相反：这条只写、写的位置固定，回给手机
+ * 的只有文件名与字节数，不回路径。
+ */
+
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+
+const { dshHome } = require('../shared/paths');
+const { sendJson, readJsonBody } = require('../shared/http-util');
+
+/** 一份轨迹的字节上限。真到这一步说明录得太久，该停了。 */
+const MAX_CAPTURE_BYTES = 8 * 1024 * 1024;
+/** 目录里最多留几份（按 mtime，新的来、旧的走）。 */
+const MAX_CAPTURES = 10;
+/** 一次请求最多带多少行；App 那边按 40KB 切批，正常远小于这个数。 */
+const MAX_LINES_PER_BATCH = 4000;
+/** 一次请求最多多少字节（`readJsonBody` 本身还有 344KB 的封顶，这里再收一道）。 */
+const MAX_BATCH_BYTES = 512 * 1024;
+/** 轨迹名（也就是文件名）：只认这几类字符，别的一律 400。 */
+const CAPTURE_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/;
+
+/** 轨迹目录。按调用时解析，测试可注入 `DSH_HOME`。 */
+function traceDir() {
+  return path.join(dshHome(), 'mobile-debug');
+}
+
+/** 某一份轨迹的落盘路径（`capture` 已经过白名单校验）。 */
+function capturePath(capture) {
+  return path.join(traceDir(), `${capture}.jsonl`);
+}
+
+/**
+ * 目录里留最近 `MAX_CAPTURES` 份。
+ *
+ * 按 mtime 而不是文件名：轨迹名由 App 带时间戳生成，但同一秒的两份、或者用户手改过的名字都
+ * 不该让清理算错。读不动 stat 的（正在被删）直接跳过，清理失败不该让这次上传失败。
+ */
+async function pruneCaptures() {
+  let names;
+  try {
+    names = await fsp.readdir(traceDir());
+  } catch {
+    return;
+  }
+  const files = [];
+  for (const name of names) {
+    if (!name.endsWith('.jsonl')) continue;
+    const full = path.join(traceDir(), name);
+    try {
+      const info = await fsp.stat(full);
+      if (info.isFile()) files.push({ name, full, mtime: info.mtimeMs });
+    } catch { /* 刚被删掉 / 读不动：跳过 */ }
+  }
+  if (files.length <= MAX_CAPTURES) return;
+  files.sort((a, b) => a.mtime - b.mtime);
+  for (const file of files.slice(0, files.length - MAX_CAPTURES)) {
+    try {
+      await fsp.unlink(file.full);
+    } catch { /* 删不掉就留着，下次再说 */ }
+  }
+}
+
+/**
+ * 续写一段轨迹。
+ *
+ * `lines` 是已经序列化好的 JSON 行（App 侧拼的），这里只做「拼成一段文本 + 追加」。一行都
+ * 不合法的批次按空处理：回 ok、写 0 字节，别让手机那头因为一次形状不对就整段录不上。
+ */
+async function handleDebugTrace(_ctx, req, res) {
+  const body = await readJsonBody(req);
+  const capture = body && typeof body.capture === 'string' ? body.capture : '';
+  if (!CAPTURE_RE.test(capture)) {
+    return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '需要 { capture }，且只认字母数字与 ._-' } });
+  }
+  const raw = body && Array.isArray(body.lines) ? body.lines : null;
+  if (!raw) {
+    return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '需要 { lines: string[] }' } });
+  }
+  if (raw.length > MAX_LINES_PER_BATCH) {
+    return sendJson(res, 413, { ok: false, error: { code: 'too-many-lines', message: `一次最多 ${MAX_LINES_PER_BATCH} 行` } });
+  }
+  const lines = raw.filter((line) => typeof line === 'string' && line.length > 0);
+  if (lines.length === 0) {
+    return sendJson(res, 200, { ok: true, file: `${capture}.jsonl`, bytes: 0, lines: 0, capped: false });
+  }
+  const text = `${lines.join('\n')}\n`;
+  const bytes = Buffer.byteLength(text, 'utf8');
+  if (bytes > MAX_BATCH_BYTES) {
+    return sendJson(res, 413, { ok: false, error: { code: 'too-large', message: `一次最多 ${MAX_BATCH_BYTES} 字节` } });
+  }
+
+  const file = capturePath(capture);
+  try {
+    await fsp.mkdir(traceDir(), { recursive: true });
+  } catch (error) {
+    return sendJson(res, 500, { ok: false, error: { code: 'io', message: `建目录失败：${error && error.message ? error.message : ''}` } });
+  }
+
+  let existing = 0;
+  let created = false;
+  try {
+    existing = (await fsp.stat(file)).size;
+  } catch {
+    created = true;
+  }
+
+  if (existing >= MAX_CAPTURE_BYTES) {
+    // 已经写满：回 capped 让 App 停手。文件留着，人要看的正是前面那一段。
+    return sendJson(res, 200, { ok: true, file: `${capture}.jsonl`, bytes: existing, lines: 0, capped: true });
+  }
+  // 快写满时**按整行留**：切在字节中间会让最后一行变成半截 JSON，读的人只会看到一行坏数据。
+  const room = MAX_CAPTURE_BYTES - existing;
+  let payload = text;
+  if (bytes > room) {
+    const kept = [];
+    let used = 0;
+    for (const line of lines) {
+      const size = Buffer.byteLength(line, 'utf8') + 1;
+      if (used + size > room) break;
+      kept.push(line);
+      used += size;
+    }
+    payload = kept.length > 0 ? `${kept.join('\n')}\n` : '';
+  }
+  try {
+    await fsp.appendFile(file, payload);
+  } catch (error) {
+    return sendJson(res, 500, { ok: false, error: { code: 'io', message: `写盘失败：${error && error.message ? error.message : ''}` } });
+  }
+  // 清理放在写完之后：这一份刚建出来的文件按 mtime 是最新的，留下来的正是它。
+  if (created) await pruneCaptures();
+  let total = existing;
+  try {
+    total = (await fsp.stat(file)).size;
+  } catch { /* 写成功但 stat 失败：回一个估计值，不影响 App */ }
+  sendJson(res, 200, {
+    ok: true,
+    file: `${capture}.jsonl`,
+    bytes: total,
+    lines: payload === text ? lines.length : (payload ? payload.split('\n').length - 1 : 0),
+    // 「这一段被切了」或「已经顶到上限」都算满：App 收到就停手，别继续往一条死路上发。
+    capped: payload !== text || total >= MAX_CAPTURE_BYTES,
+  });
+}
+
+/** 同步读一份轨迹（维护者在电脑上直接看文件；这里只给测试与将来的面板用）。 */
+function readCapture(capture) {
+  if (!CAPTURE_RE.test(capture)) return null;
+  try {
+    return fs.readFileSync(capturePath(capture), 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+module.exports = {
+  handleDebugTrace,
+  readCapture,
+  traceDir,
+  MAX_CAPTURE_BYTES,
+  MAX_CAPTURES,
+};

package/lib/mobile/deepseek-account.js

@@ -45,6 +45,9 @@ function normalizeProfile(result) {
     status: 'ready',
     name: textOrNull(profile.name),
     contact: textOrNull(profile.contact),
+    // 头像是资料的一部分（和名字、联系方式同级），手机拿去当 <Image> 的 uri 用；
+    // 账号 ID、token、attempt 仍然不出这一层。
+    avatarUrl: textOrNull(profile.avatarUrl),
   };
 }
 

package/lib/mobile/entry-window.js

@@ -15,9 +15,14 @@
  * 2000 不是随手取的上限：本机 1420 个真实回合量下来，最长一轮 576 条消息、超过 500 的
  * 有 3 个、超过 200 的有 18 个。它只是**上界**，宿主在跨过 `minTurns` 且遇到 turn/start
  * 时就会停，所以正常情况下读的仍是那几十条；只有碰上超长回合才会真往上读到 2000。
+ *
+ * `minTurns` 取 1，**不是 6**：进对话要的是「尾部这一屏」，不是「六轮上下文」。
+ * 取 6 的时候，一轮 40 步的会话会把窗口撑到一百多条，手机侧要铺十几屏才追得到底 ——
+ * 用户看到的是「进来之后内容一路往下滑」。窗口大小是这条链的总闸：窗口小，
+ * 「一屏就是终态」才成立；更早的内容由「加载更早」按需补。
  */
 const ENTRY_THIN_MAX_MESSAGES = 2000;
-const ENTRY_THIN_MIN_TURNS = 6;
+const ENTRY_THIN_MIN_TURNS = 1;
 
 /** 把入口窗口的取数参数写进宿主请求体（就地修改并返回，调用方只关心副作用）。 */
 function entryWindowPayload(payload, limit) {

package/lib/mobile/history-derive.js

@@ -12,6 +12,30 @@
  */
 
 const { cutAssistantBlock, cutToolResultEvent, createToolNameIndex } = require('./wire-cut.js');
+const { rememberToolResults, toolResultsFor } = require('./tool-result-cache.js');
+
+/** 每一轮出过的图（工具结果里的图片块），轮号 → 图。`lookback` 也扫：它才装得下更早那一页。 */
+function collectTurnImages(entries, lookbackEntries) {
+  const byTurn = new Map();
+  for (const list of [entries, lookbackEntries]) {
+    for (const entry of list || []) {
+      const e = entry && entry.event ? entry.event : entry;
+      if (!e || e.type !== 'tool/result' || !e.data || !e.data.message) continue;
+      const turn = typeof e.data.turn === 'number' ? e.data.turn : undefined;
+      if (turn === undefined) continue;
+      const { parts } = toolResultParts(cutToolResultEvent(e, '').data.message);
+      const images = toolResultImages(parts);
+      if (images.length === 0) continue;
+      const bucket = byTurn.get(turn) || [];
+      for (const image of images) {
+        if (bucket.some((kept) => kept.attachmentId && kept.attachmentId === image.attachmentId)) continue;
+        bucket.push(image);
+      }
+      byTurn.set(turn, bucket);
+    }
+  }
+  return byTurn;
+}
 const {
   reasoningStepSummary,
   toolStepSummary,
@@ -61,12 +85,14 @@ function toolResultParts(msg) {
  * 图片块 → 移动端图片条目（`ChatMessage.images[]` / 工具块的 `images[]` 同一个形状）。
  *
  * 两条互斥的出口：
- *  - 块上有 `attachmentId`：下发**引用** `{ mediaType, name?, attachmentId }`，**不带 data**。
- *    字节由手机端要画的时候按 attachmentId 单张去取（`/session/attachment`），
+ *  - 块上有 `attachmentId`：下发**引用** `{ mediaType, name?, width?, height?, attachmentId }`，
+ *    **不带 data**。字节由手机端要画的时候按 attachmentId 单张去取（`/session/attachment`），
  *    历史响应因此不再背着几十张截图的 base64。
- *  - 块里本来就只有内联 `data`、没有 attachmentId：照旧下发 `{ mediaType, data, name? }`。
+ *  - 块里本来就只有内联 `data`、没有 attachmentId：照旧下发 `{ mediaType, data, name?, width?, height? }`。
  *    这条兜底不能删——老日志、工具结果里存在这种直接带字节的图片块。
  *
+ * 宽高两格见 `imageDimsOf`：那是「手机能不能在挂载那一帧就占好位置」的前提。
+ *
  * 两条都要求 mediaType 可读（块上没有就退到 attachment 上的），否则 App 认不出来、
  * 也没有可显示的动作，返回 null 让调用方丢掉它。
  */
@@ -81,11 +107,28 @@ function imageEntryOf(block) {
   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 } : {}) };
+  const dims = imageDimsOf(block, attachment);
+  if (attachmentId) return { mediaType, ...(name !== undefined ? { name } : {}), ...dims, attachmentId };
+  if (typeof block.data === 'string' && block.data) return { mediaType, data: block.data, ...(name !== undefined ? { name } : {}), ...dims };
   return null;
 }
 
+/**
+ * 图片的原始宽高 —— 宿主的附件里本来就有（`attachment.width` / `attachment.height`）。
+ *
+ * **不许省掉这一格。** 手机侧要靠它把图片行的高度在**挂载那一帧就占好**：没有宽高，那一行
+ * 只能先按 240 方盒占位、等图解码完 onLoad 再改成真比例；而行高在挂载之后变高，正是对话页
+ * 「先落到底、再被顶回去」的来源（贴底列表上方一变高，屏幕上的内容就往下退一段）。
+ * 宽高非法（缺失 / 非正数）时整格不出现，调用方仍按旧兜底盒处理。
+ */
+function imageDimsOf(block, attachment) {
+  const pick = (value) => (typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : undefined);
+  const width = pick(block.width) ?? pick(attachment.width);
+  const height = pick(block.height) ?? pick(attachment.height);
+  if (width === undefined || height === undefined) return {};
+  return { width, height };
+}
+
 /** 把 tool/result 的图片块收成移动端图片条目（两种出口见 imageEntryOf）。 */
 function toolResultImages(parts) {
   const out = [];
@@ -324,10 +367,23 @@ function presentedPathsOf(events) {
  *  - command：command/run 发出行，command/done 原地升级。
  * 结构化项与消息按 seq 升序混排；旧载荷字段缺失时跳过对应项，绝不抛错。
  */
-function deriveMessages(events) {
+function deriveMessages(events, sessionId, lookbackEvents) {
   const out = [];
   // 预扫描 tool/result 事件（同批次事件内，结果可能在调用块之前/之后出现）。
-  const toolResults = buildToolResultMap(events);
+  // `lookbackEvents` 是这一页**再往前**的一小段：倒着分页时工具结果常常落在比消息更早的位置
+  // （一轮里先跑工具、最后才写正文），只看这一页就看不出这一轮出过哪些图。
+  const toolResults = buildToolResultMap(lookbackEvents && lookbackEvents.length ? events.concat(lookbackEvents) : events);
+  // 倒着分页时，一页的边界可能正好切在「工具调用」与「它的结果」之间：这一页只有调用，
+  // 结果在更新的一页（本机早就拿到过）。把那些记在进程里的结果并进来，图就跟着消息一起
+  // 下发，手机侧那一行在挂载那一帧就是终高（见 tool-result-cache.js）。
+  const remembered = toolResultsFor(sessionId);
+  if (remembered) {
+    for (const [callId, result] of remembered) {
+      if (!toolResults.has(callId)) toolResults.set(callId, result);
+    }
+  }
+  // 这一页看到的结果记下来，供更早的页用（同一进程里，后到的页是更早的那几页）。
+  rememberToolResults(sessionId, toolResults);
   // 预扫描 compaction/summary：检查点 user/message 与 summary 事件在日志里的先后不固定，
   // 用 compactionId → summary 数据把 counts 补全到同一压缩行上。
   const summaries = new Map();
@@ -505,12 +561,17 @@ function deriveMessages(events) {
     });
     const text = blocksToText(blocks);
     // 图片条目统一投影：引用模式带 attachmentId 不带 data，内联兜底带 data 不带 attachmentId。
+    //
+    // **宽高必须一起带上**（`imageDimsOf` 的口径）：手机侧靠它在挂载那一帧就把图片行的高度占好，
+    // 少这两格就只能先占 240 方盒、等解码完再改，而贴底列表上方一变高，屏幕上看到的内容就
+    // 往下退一段 —— 这正是「先落到底、再被顶回去」那一跳。
     const images = [
       ...blocks.filter((b) => b.type === 'image'),
       ...toolImages,
-    ].map(({ mediaType, data, name, attachmentId }) => ({
+    ].map(({ mediaType, data, name, attachmentId, width, height }) => ({
       mediaType,
       ...(typeof name === 'string' ? { name } : {}),
+      ...(Number.isFinite(width) && Number.isFinite(height) && width > 0 && height > 0 ? { width, height } : {}),
       ...(typeof attachmentId === 'string' && attachmentId ? { attachmentId } : {}),
       ...(typeof attachmentId === 'string' && attachmentId ? {} : { data }),
     }));
@@ -568,6 +629,16 @@ function deriveMessages(events) {
     if (item.role === 'user') lastOpener = item;
   };
 
+  /**
+   * 这次压缩由哪条 slash 命令触发（`compaction/*` 上的 `sourceCommandId`）。
+   *
+   * 手动 `/compact` 时压缩行与命令行是同一件事的两半（桌面 `CompactionCommandCard` 只画一个
+   * `CompactionItem`），靠这个 id 配对，见出循环后的「认领」。
+   */
+  const commandIdOf = (data) => (data && typeof data.sourceCommandId === 'string' && data.sourceCommandId !== ''
+    ? data.sourceCommandId
+    : null);
+
   // 放入一行 compaction：同一 compactionId 只保留一行，检查点行原地替换 start 行（最终按 seq 排序归位）。
   const placeCompaction = (item) => {
     let index = compactionAt.get(item.id);
@@ -611,6 +682,9 @@ function deriveMessages(events) {
           : (msg.id != null ? String(msg.id) : null);
         if (id === null) continue;
         const s = summaries.get(id);
+        // 触发命令的 id 在检查点自己的 source 上（桌面 `compactSource` 读的就是它）。只认
+        // `compaction/*` 的 data 时，检查点先到 / 那些事件在窗口外就配不上命令行。
+        const commandId = typeof src.sourceCommandId === 'string' && src.sourceCommandId !== '' ? src.sourceCommandId : null;
         placeCompaction({
           id,
           kind: 'compaction',
@@ -618,6 +692,7 @@ function deriveMessages(events) {
           summary: s ? compactionSummaryText(s.summary) : null,
           shadowedItemCount: s ? shadowedCount(s.shadowedSeqs) : null,
           shadowedTokenCount: s ? shadowedTokens(s.shadowedTokenCount) : null,
+          ...(commandId ? { compactionCommandId: commandId } : {}),
           seq,
           time,
         });
@@ -655,6 +730,7 @@ function deriveMessages(events) {
       // 行已由检查点发出（done）时跳过，避免重复行。同一轮里已有没落定的行就**原地顶替**
       // （换 id/状态，位置留在第一次尝试那一处）—— 否则一次跑几十步就是几十条行。
       const idx = pendingCompactionAt(e.data.turn, e.data.compactionId);
+      const commandId = commandIdOf(e.data);
       if (idx < 0) {
         placeCompaction({
           id: e.data.compactionId,
@@ -666,6 +742,7 @@ function deriveMessages(events) {
           seq,
           time,
           ...(typeof e.data.turn === 'number' ? { turn: e.data.turn } : {}),
+          ...(commandId ? { compactionCommandId: commandId } : {}),
         });
       } else {
         const existing = out[idx];
@@ -675,6 +752,7 @@ function deriveMessages(events) {
           state: 'running',
           error: null,
           ...(typeof e.data.turn === 'number' ? { turn: e.data.turn } : {}),
+          ...(commandId ? { compactionCommandId: commandId } : {}),
         };
         compactionAt.set(e.data.compactionId, idx);
       }
@@ -683,6 +761,7 @@ function deriveMessages(events) {
       // 带原因。这条以前整条丢掉，于是被拒绝的压缩永远停在「正在压缩…」，失败一次都看不见。
       const error = typeof e.data.error === 'string' && e.data.error !== '' ? e.data.error : null;
       const idx = pendingCompactionAt(e.data.turn, e.data.compactionId);
+      const commandId = commandIdOf(e.data);
       if (idx < 0) {
         placeCompaction({
           id: e.data.compactionId,
@@ -695,6 +774,7 @@ function deriveMessages(events) {
           seq,
           time,
           ...(typeof e.data.turn === 'number' ? { turn: e.data.turn } : {}),
+          ...(commandId ? { compactionCommandId: commandId } : {}),
         });
       } else {
         const existing = out[idx];
@@ -703,6 +783,7 @@ function deriveMessages(events) {
           id: e.data.compactionId,
           state: error ? 'failed' : 'done',
           error,
+          ...(commandId ? { compactionCommandId: commandId } : {}),
         };
         compactionAt.set(e.data.compactionId, idx);
       }
@@ -710,12 +791,14 @@ function deriveMessages(events) {
       // 已有同 compactionId 的行（start 或检查点发出）→ 升级为 done 并补 counts；否则新增 done 行。
       const id = e.data.compactionId;
       const existing = compactionAt.has(id) ? out[compactionAt.get(id)] : null;
+      const commandId = commandIdOf(e.data);
       if (existing) {
         existing.state = 'done';
         existing.error = null;
         existing.summary = compactionSummaryText(e.data.summary);
         existing.shadowedItemCount = shadowedCount(e.data.shadowedSeqs);
         existing.shadowedTokenCount = shadowedTokens(e.data.shadowedTokenCount);
+        if (commandId) existing.compactionCommandId = commandId;
       } else {
         placeCompaction({
           id,
@@ -726,6 +809,7 @@ function deriveMessages(events) {
           shadowedTokenCount: shadowedTokens(e.data.shadowedTokenCount),
           seq,
           time,
+          ...(commandId ? { compactionCommandId: commandId } : {}),
         });
       }
     } else if (e.type === 'llm/retry' && e.data && typeof e.data.retryId === 'string' && e.data.retryId !== '' && typeof e.data.retry === 'number') {
@@ -783,7 +867,9 @@ function deriveMessages(events) {
     } else if (e.type === 'command/done' && e.data && typeof e.data.commandId === 'string' && e.data.commandId !== '') {
       // 升级同 commandId 行（name 保 run 的）；done 先到（罕见）则按 done 内容建行。
       const id = e.data.commandId;
-      const done = { kind: 'command', status: 'done', seq, time };
+      // `id` 必须落在行上：done 先到（增量窗口从命令行尾巴开始时就是这种）时这条行是新建的，
+      // 没有 id 的话 App 按 id 合并就配不上那半截 run 行 —— 屏幕上会多出一行「命令 · …」。
+      const done = { id, kind: 'command', status: 'done', seq, time };
       if (e.data.kind === 'error' || e.data.kind === 'success') done.resultKind = e.data.kind;
       if (typeof e.data.text === 'string' && e.data.text !== '') done.text = e.data.text;
       const existing = commandAt.has(id) ? out[commandAt.get(id)] : null;
@@ -825,6 +911,24 @@ function deriveMessages(events) {
       };
     }
   }
+  /**
+   * 这一轮出过的图也按轮回填到**最后一条正文**上。
+   *
+   * 倒着翻页时，工具结果（图在这里）的 seq 往往比这条正文更早 —— 那一页后到，正文先上屏，
+   * 于是这一行先按「没图」的高度排好，等下一页把图带回来才长高；它在用户头顶上，一长高就把
+   * 正看的内容推走。`lookbackEvents` 里已经能看到这一轮的结果，就先挂到正文那条上（与 App
+   * `chatRenderRows` 的 settleImages 同口径），行在挂载那一帧就是终高。
+   */
+  if (producedItems.length > 0) {
+    const byTurn = collectTurnImages(events, lookbackEvents);
+    for (const [turn, images] of byTurn) {
+      // 这一轮已经有消息带图（工具调用那条就在这一页里）：别重复挂，App 那边也会去重。
+      if (producedItems.some((entry) => entry.turn === turn && (entry.item.images?.length ?? 0) > 0)) continue;
+      const carriers = producedItems.filter((entry) => entry.turn === turn && entry.item.role !== 'user' && entry.item.text);
+      const last = carriers[carriers.length - 1];
+      if (last) last.item.images = images;
+    }
+  }
   // 产出清单按轮回填：这一轮所有 write / edit 的并集，挂到这一轮每条 assistant 消息上。
   // 挂「整轮」而不是「从写那一刻起」，与桌面 `selectProducedFiles(owner)` 同口径；正文里
   // 提到这一轮写的文件就能解析成可点（App 侧按文件名或整条路径唯一命中才画，见
@@ -835,6 +939,41 @@ function deriveMessages(events) {
       if (bucket && bucket.size > 0) item.producedFiles = [...bucket];
     }
   }
+  // 手动 `/compact` 在桌面上是**一件事**：`CompactionCommandCard` 只画一个 `CompactionItem`
+  // （标题取命令名，摘要位放条数与 token 数，条数不齐时放命令结果原文），命令行那块根本不出现。
+  // 宿主的 command/run·done 与压缩检查点由 `sourceCommandId` 连在一起，所以这里让压缩行认领
+  // 命令行：压缩行继承命令名，命令行整条不发给手机 —— 否则屏幕上会多出一行「命令 ·
+  // Compacted N history items」（名字在增量窗口里丢了就掉成「命令」，摘要是宿主 en locale 的
+  // 英文原句，手机不本地化）。
+  const commandNames = new Map();
+  for (const item of out) {
+    if (!item || item.kind !== 'command') continue;
+    const entry = {};
+    if (typeof item.name === 'string' && item.name !== '') entry.name = item.name;
+    if (typeof item.text === 'string' && item.text !== '') entry.text = item.text;
+    if (entry.name !== undefined || entry.text !== undefined) commandNames.set(item.id, entry);
+  }
+  const claimedCommands = new Set();
+  for (const item of out) {
+    if (!item || item.kind !== 'compaction') continue;
+    const commandId = item.compactionCommandId;
+    if (typeof commandId !== 'string' || commandId === '') continue;
+    const paired = commandNames.get(commandId);
+    // 标题取命令名；命令行那半截不在窗口里也写 compact —— 只有 /compact 能触发压缩，桌面
+    // `fallbackState` 同样把名字兜成 'compact'，否则这一行会掉回「上下文已压缩」。
+    item.compactionTitle = paired && paired.name !== undefined ? paired.name : 'compact';
+    // 条数不齐时摘要位用命令结果原文顶上（桌面 `fallbackSummary: node.outcome?.text`）。
+    if (paired && paired.text !== undefined && (item.shadowedItemCount == null || item.shadowedTokenCount == null)) {
+      item.compactionFallbackSummary = paired.text;
+    }
+    claimedCommands.add(commandId);
+  }
+  if (claimedCommands.size > 0) {
+    for (let index = out.length - 1; index >= 0; index -= 1) {
+      const item = out[index];
+      if (item && item.kind === 'command' && claimedCommands.has(item.id)) out.splice(index, 1);
+    }
+  }
   // 压缩行带一个空正文：直播侧的同款行本来就带 `text: ''`（App 的 `structuralItems`
   // 一条不落），历史这边少这一格时，没跟上判空修复的旧安装包会在这条行上直接读正文、
   // 当场抛错、整页崩掉（2026-10-27 真机）。标题与摘要照旧按 kind 走，不读这个字段；