dsh-mini-remote 0.1.7 → 0.1.9

package/lib/page.html

@@ -21,13 +21,15 @@
          需要"显眼一点"的地方一律用鲸鱼娘的冰蓝 --ice，别动这两个。
        · --ok/--run/--err 是状态点的语义色，占的是 8px 一个小点，不算强调色。
        · 配色以鲸鱼娘为准心：深海墨蓝打底，她的冰蓝作次级色。
-       · 两套主题：这套（默认，深色）和 [data-theme="light"]，色调跟宣传图
+       · 两套主题：[data-theme="light"]（默认，浅色）和深色，色调跟宣传图
          （docs/promo.png）统一。**颜色令牌两边必须一一对应**——缺一个，就有元素
          在某个主题下"隐身"，而且只在那个主题下才看得出来。守卫在 test/ui.test.mjs。 */
   :root {
     color-scheme: dark;
     --bg: #0a0f16;
     --bg-top: #101a27;
+    /* 基准字号：设置页「字体大小」三档控制，默认 15.5px */
+    --font-base: 15.5px;
     --bg-deep: #070b11;
     --panel: #121a25;
     --panel-2: #18222f;
@@ -40,6 +42,7 @@
     --act: #c9a55c;       /* 强调色当**底**用：一屏一个的主按钮 */
     --ok: #4fb477;
     --run: #a9c8e8;
+    --shimmer: #eaf4ff;   /* 跑着的行那道扫光的亮色（照 PC 的 label-shimmer，2026-10-04） */
     --err: #d4614f;
     --r: 2px;
     --sh-1: 0 1px 2px rgba(0, 0, 0, .28);
@@ -71,6 +74,7 @@
     --act: #3b6fc4;       /* 主按钮底：用宣传图那个宝蓝（用户 2026-09-27 裁决） */
     --ok: #2e9a5f;
     --run: #3b6fc4;
+    --shimmer: #7ea6e6;   /* 浅色下的扫光要比 --run 亮、又不能白到看不见 */
     --err: #c0392b;
     --sh-1: 0 1px 2px rgba(28, 60, 110, .07);
     --sh-2: 0 2px 8px rgba(28, 60, 110, .12);
@@ -124,6 +128,146 @@
     font-size: 16px; display: grid; place-items: center; cursor: pointer;
   }
   .icon-btn:active { transform: scale(.94); }
+  #btnSubagents.subagent-running svg { animation: subagent-spin 1.6s linear infinite; }
+  #btnSubagents.subagent-running { border-color: var(--run); color: var(--run); }
+  @keyframes subagent-spin { to { transform: rotate(360deg); } }
+  @media (prefers-reduced-motion: reduce) {
+    #btnSubagents.subagent-running svg { animation: none; }
+  }
+
+  /* ---------- 子智能体（2026-10-03） ----------
+     整块**只新增两条外观**：列表里的一行、聊天记录里那张完工卡片。其余全部复用：
+     抽屉外壳用设置那一套（#subagents 的骨架和 .sheet 完全一样），状态点用既有 .dot，
+     主按钮用既有 .btn.primary，气泡用既有 .bubble / .said。
+
+     **一个颜色令牌都没新加**：全用主屏已有的那几个，浅色主题下跟着变就行——
+     令牌是两套主题各写一份的，新造一个就等于在浅色下多挖一个坑。
+
+     也没有新的关键帧：卡片能不能展开交给原生 <details>，不写一行脚本去演它。 */
+  #subagents {
+    position: fixed; inset: 0; background: var(--scrim);
+    display: none; align-items: flex-end; z-index: 50;
+  }
+  #subagents.open { display: flex; }
+  .sa-head { display: flex; align-items: center; gap: 10px; margin: 0 0 14px; }
+  .sa-head h2 { margin: 0; font-size: 16px; flex: 1 1 auto; }
+  .sa-back {
+    flex: 0 0 auto; border: none; background: transparent; color: var(--muted);
+    font: inherit; font-size: 14px; cursor: pointer; padding: 0;
+  }
+  .sa-none { color: var(--muted); font-size: 14px; padding: 6px 0 2px; }
+
+  /* ---------- 插件页面（2026-10-04） ----------
+     外壳和设置抽屉 / 子智能体**同一套**（#xxx.open + .sheet），不新建样式体系。
+     层级比设置抽屉高一档（60 > 50）：它从设置里点开，得盖在设置**上面**，
+     而不是掉到输入框下面去（2026-10-04 用户真机报的正是这一条）。 */
+  #plugins {
+    position: fixed; inset: 0; background: var(--scrim);
+    display: none; align-items: flex-end; z-index: 60;
+  }
+  #plugins.open { display: flex; }
+  /* .sa-list 把两边拽到贴屏边（负 16px，让分隔线横贯），所以这里的左右缩进
+     得自己补回同一个 16px——少这一笔，文字就贴着屏幕边（用户报的「两侧没有留白」）。
+
+     ---------- 分组可折可展（2026-10-05 用户要「分组做成可以折叠展开，默认折叠」）----------
+     用浏览器原生的 <details>/<summary>：不写一行脚本去演它、不加关键帧，键盘和读屏
+     也都认（和子智能体那张完工卡片同一个做法，见 .sa-card）。默认收起：HTML 里
+     不写 open 属性就自然是收着的，所以「默认折叠」不需要额外的代码去保证。
+
+     小三角**用 CSS 画**（两条边框拼一个实心三角），不写字形——字形依赖字体，
+     换个机型就可能变成豆腐块；颜色用 currentColor，深浅两套主题自动都对。 */
+  .plugin-fold { margin: 16px 0 0; }
+  .plugin-fold > summary {
+    display: flex; align-items: center; gap: 8px; list-style: none;
+    margin: 0 16px 6px; padding: 4px 0;
+    font-size: 13px; color: var(--muted); cursor: pointer;
+  }
+  .plugin-fold > summary::-webkit-details-marker { display: none; }
+  /* 收起时朝右，展开时朝下——和 PC 那页的分组箭头一个意思。 */
+  .plugin-fold > summary::before {
+    content: ""; flex: 0 0 auto; width: 0; height: 0;
+    border-left: 5px solid currentColor;
+    border-top: 4px solid transparent;
+    border-bottom: 4px solid transparent;
+  }
+  .plugin-fold[open] > summary::before {
+    border-left: 5px solid transparent;
+    border-top: 5px solid currentColor;
+    border-right: 5px solid transparent;
+  }
+  /* 展开的那一组，标题点亮一点，免得收/开两态看着一样。 */
+  .plugin-fold[open] > summary { color: var(--fg); }
+  /* 一级分组（官方 / 已安装）比二级（全局插件 / 会话插件 / 预设名）重一点。 */
+  .plugin-fold.depth-1 > summary { font-size: 14px; margin-top: 4px; }
+  .plugin-fold.depth-2 { margin-top: 10px; }
+  .plugin-fold.depth-2 > summary { font-size: 12px; color: var(--dim); }
+  .plugin-fold.depth-2[open] > summary { color: var(--muted); }
+  .plugin-note { font-size: 12px; color: var(--err); margin: 6px 16px; }
+  .plugin-row {
+    display: flex; align-items: center; gap: 10px;
+    padding: 12px 16px; border-bottom: 1px solid var(--line);
+  }
+  .plugin-row:last-child { border-bottom: none; }
+  .plugin-info { flex: 1 1 auto; min-width: 0; }
+  .plugin-name { display: block; font-size: 15px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  .plugin-desc { display: block; font-size: 12px; color: var(--muted); margin-top: 3px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  /* 插件报错/装不上：那一行说人话，颜色用状态语义色 --err（不是强调色）。 */
+  .plugin-problem { color: var(--err); }
+  .plugin-badge { flex: 0 0 auto; font-size: 10px; padding: 2px 6px; border-radius: var(--r); }
+  .plugin-badge.on { color: var(--ok); border: 1px solid var(--ok); }
+  .plugin-badge.off { color: var(--dim); border: 1px solid var(--line); }
+  .plugin-badge.err { color: var(--err); border: 1px solid var(--err); }
+  /* 行负着左右两边的 16px：让分隔线横贯整个抽屉，而不是在里面缩一截。 */
+  .sa-list { margin: 0 -16px; }
+  .sa-row {
+    display: flex; align-items: center; gap: 10px; width: 100%;
+    padding: 12px 16px; border: none; border-bottom: 1px solid var(--line);
+    background: transparent; color: var(--fg); font: inherit; text-align: left; cursor: pointer;
+  }
+  .sa-row:last-child { border-bottom: none; }
+  /* 清单还在读时那一行也在 .sa-list 里，会被那 -16px 拽到贴屏边，
+     和行的文字差着一档。补回 .sa-row 同一个 16px 才对齐。 */
+  .sa-none.sa-none-indent { padding-left: 16px; }
+  /* 读不动的那一支只有说明、点不动，所以没有手指光标。 */
+  .sa-plain { cursor: default; }
+  .sa-main { flex: 1 1 auto; min-width: 0; }
+  .sa-name { display: block; font-size: 15px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  .sa-sub { display: block; font-size: 12px; color: var(--muted); margin-top: 3px; }
+  /* 数字用等宽数位：几行并排时小数点对齐，扫一眼就能比大小。 */
+  .sa-num {
+    flex: 0 0 auto; text-align: right; font-size: 12px; color: var(--muted);
+    font-variant-numeric: tabular-nums; line-height: 1.5;
+  }
+  .sa-acts { display: flex; gap: 10px; margin-top: 16px; }
+  .sa-acts .btn { flex: 1 1 0; text-align: center; }
+  .sa-ask { display: flex; gap: 10px; margin-top: 16px; align-items: flex-end; }
+  .sa-ask input {
+    flex: 1 1 auto; min-width: 0; padding: 10px 12px; border-radius: var(--r);
+    border: 1px solid var(--line); background: var(--panel-2); color: var(--fg);
+    font: inherit; font-size: 16px; line-height: 1.5; outline: none;
+  }
+  .sa-ask input:focus { border-color: var(--ice); }
+  .sa-ask .btn { flex: 0 0 auto; }
+  .sa-doc { max-height: 52vh; overflow-y: auto; margin: 0 -16px; padding: 0 16px; }
+  .sa-doc .bubble, .sa-doc .said { max-width: 100%; }
+
+  /* 完工卡片。展开/收起用原生 <details>：不写脚本、不加关键帧，键盘和读屏也都认。
+     样子和主会话里那张卡片同一个思路——单薄一层边框，不抢回答的气泡感。 */
+  .sa-card {
+    margin: 10px 0; border: 1px solid var(--line); border-radius: var(--r);
+    background: var(--panel-2); overflow: hidden;
+  }
+  .sa-card > summary {
+    display: flex; align-items: center; gap: 8px; list-style: none;
+    padding: 10px 12px; font-size: 13px; color: var(--muted); cursor: pointer;
+  }
+  .sa-card > summary::-webkit-details-marker { display: none; }
+  .sa-card > summary b { color: var(--fg); font-weight: 600; }
+  .sa-card[open] > summary { border-bottom: 1px solid var(--line); }
+  .sa-card .sa-body {
+    padding: 10px 12px; font-size: 14px; white-space: pre-wrap;
+    word-break: break-word; max-height: 240px; overflow: auto;
+  }
 
   /* ---------- 显示区 ---------- */
   main { flex: 1 1 auto; overflow-y: auto; -webkit-overflow-scrolling: touch; padding: 16px 14px; }
@@ -153,7 +297,7 @@
        回答正文第一行之间贴得太紧」——10px 是「同一条消息内部」的距离，
        而这里跨的是「我说的话」和「它答的话」，是更大的一个断点，该给更多。 */
     margin-bottom: 18px; white-space: pre-wrap; word-break: break-word;
-    font-size: 15.5px; line-height: 1.7;
+    font-size: var(--font-base); line-height: 1.7;
   }
   .bubble.user { margin-left: auto; background: var(--panel-2); border: 1px solid var(--line); }
   .bubble.assistant { margin-right: auto; background: var(--panel); border: 1px solid var(--line); }
@@ -169,7 +313,7 @@
   /* ---------- Markdown 正文 ---------- */
   /* 外层是 pre-wrap（用户消息和旧内容靠它），markdown 输出的是真块级元素，
      所以要在这里把 pre-wrap 收掉，否则段落之间会多出一堆空行。 */
-  .md { white-space: normal; }
+  .md { white-space: normal; font-size: var(--font-base); line-height: 1.7; }
   /* 回复里的图。地址有两种写法，见下面 mdInline() 里那段注释。
      宽度只封顶不写死：窄屏上占满可用宽度、按比例缩，圆角沿用全站那 2 像素。 */
   /* 图片没加载出来时的那一圈虚线。用中性灰，不动暖金——那是唯一的强调色，一屏最多两次。 */
@@ -261,13 +405,25 @@
     border-left: 2px solid var(--line); border-radius: 0 var(--r) var(--r) 0;
     background: var(--panel-2); font-size: 13px; line-height: 1.5;
   }
-  /* 名字加参数排一行，太长就省略——它是「做了哪件事」的标签，不是正文。 */
+  /* 名字加参数排一行，太长就省略——它是「做了哪件事」的标签，不是正文。
+     收缩权重给到 10：位置要让给下面那条结果。挪不开的时候它先让到 0
+     （2026-09-30 之前就是这样：长结果把标签挤没了），这个观感这次不动它。 */
   .cmd .cmd-line {
+    flex: 0 10 auto;
     min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
     font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
     color: var(--fg);
   }
-  .cmd .cmd-res { flex: 0 0 auto; color: var(--muted); }
+  /* 结果是**正文**，得能整段读全。原来是 `flex: 0 0 auto`——那等于「这一格不许缩，
+     一行放完」，于是长结果（2026-09-30 用户报的 /doctor 那条）直接顶出 .cmd 的框，
+     顶出去的半截连底色都没有；.cmd 不裁剪，溢出再顶到 main，而 main 的 overflow-y:auto
+     会把横向一起算成滚动区，整页于是能左右拉、右边那截得滑一下才看得见。
+     改成可以缩（min-width:0 拿掉「不许窄于内容」的下限）+ 允许从任意处断开，
+     长结果就在框里正常折行。不做横向滚动、也不做省略号截断：用户要的是读全。 */
+  .cmd .cmd-res {
+    flex: 1 1 auto; min-width: 0; overflow-wrap: anywhere;
+    color: var(--muted);
+  }
   .cmd.success { border-left-color: var(--ok); }
   .cmd.success .cmd-res { color: var(--ok); }
   /* 出错的那一种必须是红的：整串历史里只有它需要用户抬眼看一下。 */
@@ -450,6 +606,11 @@
   }
   .stop:disabled { opacity: .5; }
 
+  /* 「完整」模式不放装饰（2026-10-03 用户点名）：立绘、气泡、光流进度条都不出现——
+     那一屏的过程由轨迹自己在逐条冒，再挂一只跑动的鲸鱼娘就是重复。只留
+     「已 N 秒 / 停止」那一行：去掉它就中止不了任务了。 */
+  .work.bare .work-top, .work.bare .work-progress { display: none; }
+
   /* 排队中的指令。跑着任务时接着发的那几条排在这儿，等这一轮跑完再跑。
      单帧模式下你发出去的那句话在别处一个字都看不见（那一模式只显示回复），
      所以这块是唯一的反馈，不能省。 */
@@ -517,6 +678,8 @@
     .work-stage { animation: none; }
     .pose { animation: none; transition: none; }
     .work-progress i { width: 100%; opacity: .45; animation: none; }
+    /* 扫光是状态指示、不是装饰，但用户要「减少动效」时整条关掉——底色照旧。 */
+    .traj-shimmer { animation: none; background-image: none; color: var(--run); }
     .queue .q-node i { transition: none; }
     .dot { transition: none; }
   }
@@ -551,11 +714,40 @@
     border: 1px solid var(--line); background: var(--panel-2); color: var(--muted);
     display: inline-flex; align-items: center; justify-content: center; cursor: pointer;
   }
-  .attach svg { width: 19px; height: 19px; fill: none; stroke: currentColor; stroke-width: 1.8; stroke-linecap: round; stroke-linejoin: round; }
+  /* 图标是 DSH 桌面端那个鲸鱼（见 HTML 里那段注释）。
+     和原来的回形针有两点不一样，两条都得改：
+       · 它是**实心**路径（fill），不是描边的——留着 stroke 会把整个轮廓再描一圈；
+       · 它是横长条（23.16 : 17.04），不是正方形——照原来 19×19 会被拉扁。
+     颜色走 currentColor（跟着按钮的 var(--muted)），所以深浅两套主题各自适配。 */
+  .attach svg { width: 22px; height: 16.2px; fill: currentColor; stroke: none; }
   .attach:disabled { opacity: .4; }
-  /* 上传中：图标转起来。这条路上没有进度条，至少要让人看出「它在动」。 */
-  .attach.busy svg { animation: spin 1s linear infinite; }
-  @keyframes spin { to { transform: rotate(360deg); } }
+  /* 上传中：鲸鱼**原地游动**（2026-10-05 用户要求换掉转圈）。
+     为什么不用转圈：转圈是「物件在转」的语汇（齿轮、加载器），用在活物身上
+     读起来像标本被转着看。鲸鱼该有的动作是**游**。
+
+     这一组值改过两轮：用户先审了 1.5px / ±4 度，看过之后说「幅度可以再大一些」，
+     于是放到 **2.5px / ±7 度**（上下各大了 67%、俯仰大了 75%）。
+     一个来回仍是 1.8 秒（用户只提了幅度，速度没动）。
+     幅度占图标高度的 15%（16.2px 里的 2.5px）；连同俯仰撑开的量，
+     离 42px 按钮的边还有 8px 以上余量，跑不出去。
+
+     **俯仰的方向别写反**（第一版就写反了，靠放大渲染才发现）：
+     鲸鱼是**朝左**的（鼻头在左、尾巴在右上），而 CSS 里正角度是顺时针
+     ——顺时针会把**左边**抬起来（拿 rotate(90deg) 想：左边的点会转到上方）。
+     所以「鼻尖抬起」是**正角度**。要的效果是「朝着前进的方向点头」：
+     上浮时鼻尖朝上、下潜时鼻尖朝下。于是 0%/100%（最高点）用 +7deg，
+     50%（最低点）用 -7deg。写反了看起来就像它在倒着游。 */
+  .attach.busy svg { animation: whaleSwim 1.8s ease-in-out infinite; }
+  @keyframes whaleSwim {
+    0%, 100% { transform: translateY(-2.5px) rotate(7deg); }
+    50%      { transform: translateY(2.5px) rotate(-7deg); }
+  }
+  /* 用户要「减少动效」时它就不动——但**忙碌的表示没丢**：
+     按钮此时是禁用态（opacity .4），本来就是「正在进行」的样子。
+     （这一条同时补掉一个遗留缺口：原来那个转圈压根没管减少动效。） */
+  @media (prefers-reduced-motion: reduce) {
+    .attach.busy svg { animation: none; }
+  }
 
   /* 附件小条：排在输入框上面，让你发之前看得见自己带了什么。 */
   .attach-bar {
@@ -591,24 +783,35 @@
     backdrop-filter: blur(14px) saturate(1.1);
   }
   .cmd-menu[hidden] { display: none; }
-  .cmd-menu .cmd-row {
+  /* 面板里的指令列表（#opsCmds）和这只菜单**长得一样、也共用这份规则**：
+     同一份数据、同一种行，没有第二套样式。 */
+  .cmd-menu .cmd-row,
+  .ops-cmds .cmd-row {
     display: flex; align-items: baseline; gap: 10px; width: 100%;
     padding: 9px 8px; border: none; border-radius: var(--r); background: none;
     color: var(--fg); font: inherit; font-size: 14.5px; text-align: left; cursor: pointer;
   }
-  .cmd-menu .cmd-row:active { background: var(--panel-2); }
-  .cmd-menu .cmd-name {
+  .cmd-menu .cmd-row:active,
+  .ops-cmds .cmd-row:active { background: var(--panel-2); }
+  .cmd-menu .cmd-name,
+  .ops-cmds .cmd-name {
     flex: 0 0 auto; color: var(--ice);
     font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
   }
   /* 说明收成一行：这一屏是「扫一眼挑一个」，不是读文档的地方。 */
-  .cmd-menu .cmd-desc {
+  .cmd-menu .cmd-desc,
+  .ops-cmds .cmd-desc {
     flex: 1 1 auto; min-width: 0; color: var(--muted); font-size: 12.5px;
     overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
   }
   /* 取不到指令时说清原因，**不显示空列表**：空列表看着就像「这个会话没有指令」，
      而真实原因多半是「这个会话现在没在跑」——两件事，用户能做的事也不一样。 */
-  .cmd-menu .cmd-note { padding: 10px 8px; color: var(--muted); font-size: 13px; }
+  .cmd-menu .cmd-note,
+  .ops-cmds .cmd-note { padding: 10px 8px; color: var(--muted); font-size: 13px; }
+  /* 面板那一行多两样：一层包住名字和说明（好让右边那面小旗挨着它排），以及那面小旗本身
+     （声明了收附件的指令，手机这一版带不了）。名字和说明的省略规则照旧用上面那一套。 */
+  .ops-cmds .cmd-top { display: flex; align-items: baseline; gap: 10px; flex: 1 1 auto; min-width: 0; }
+  .ops-cmds .cmd-flag { flex: none; color: var(--muted); font-size: 12px; white-space: nowrap; }
 
   /* ---------- 左侧导航栏 ---------- */
   #nav {
@@ -679,6 +882,22 @@
   .ws-new:active { background: var(--panel-2); }
   .ws-new[disabled] { color: var(--muted); cursor: default; }
 
+  /* 「新建会话」下展开的模式清单（2026-10-04）。行内展开、点谁建谁——照
+     「新建文件夹」的先例不弹窗；左侧一条细线表明它是那一行展开的内容；
+     坏档灰字不可点。 */
+  .ws-modes { margin: 2px 0 8px; padding-left: 10px; border-left: 1px solid var(--line); }
+  .ws-mode {
+    display: block; width: 100%; text-align: left; cursor: pointer;
+    font: inherit; font-size: 12.5px; line-height: 1.5;
+    padding: 7px 8px; color: var(--fg);
+    background: none; border: none;
+  }
+  .ws-mode:active { background: var(--panel-2); }
+  .ws-mode b { font-weight: 650; }
+  .ws-mode-desc { display: block; color: var(--muted); font-size: 11.5px; }
+  .ws-mode-def { margin-left: 8px; color: var(--dim); font-size: 11px; }
+  .ws-mode-broken { color: var(--muted); cursor: default; }
+
   /* 导航栏最上面那条「新建工作区」。跟工作区条目之间用一条线隔开：
      它是这一屏的入口，不是一个工作区。 */
   .nav-cta {
@@ -752,6 +971,94 @@
      露和收之间就不会把下面的消息顶来顶去（那会是一次小跳）。 */
   .more-note.hide { visibility: hidden; }
 
+  /* 「完整」模式：过程组穿插在对话原位，长相对齐 PC 的 turn-process（tasks/todo.md 11）：
+     行首一枚细线小图标 + 灰色状态词/标题（叫法照抄 DSH，一个字不自创），点开才见原文。
+     只用现成令牌、不加动效不加新颜色：它是补充信息，不是这一屏的主角。 */
+  .traj-group { margin-bottom: 10px; }
+  .traj-head {
+    display: flex; align-items: baseline; gap: 6px; width: 100%; text-align: left; cursor: pointer;
+    font: inherit; font-size: 12.5px; line-height: 1.6;
+    padding: 6px 4px; color: var(--muted);
+    background: none; border: none; border-top: 1px dashed var(--line);
+  }
+  .traj-entries { margin: 2px 0 0 4px; padding-left: 10px; border-left: 1px solid var(--line); }
+  .traj-row {
+    display: flex; align-items: baseline; gap: 6px; width: 100%; text-align: left; cursor: pointer;
+    font: inherit; font-size: 13px; line-height: 1.6;
+    padding: 5px 4px; color: var(--fg);
+    background: none; border: none;
+  }
+  .traj-row:active { background: var(--panel-2); }
+  .traj-ico { flex: none; width: 14px; height: 14px; color: var(--muted); }
+  .traj-ico svg { display: block; width: 14px; height: 14px; }
+  .traj-name { flex: none; color: var(--muted); }
+  /* 折叠行右侧的内容一行截断（照 PC）：折叠行是给人扫的，不是给人读的——
+     具体东西在展开里。组头标题同款处理（活片段再长也不许换行刷屏）。 */
+  .traj-detail {
+    flex: 1 1 auto; min-width: 0;
+    white-space: nowrap; overflow: hidden; text-overflow: ellipsis;
+    color: var(--fg);
+  }
+  .traj-head .traj-title, .traj-head .traj-run {
+    flex: 1 1 auto; min-width: 0;
+    white-space: nowrap; overflow: hidden; text-overflow: ellipsis;
+  }
+  .traj-say {
+    margin: 4px 0 8px; padding: 0 2px;
+    word-break: break-word;
+    color: var(--fg); font-size: 13px; line-height: 1.7;
+  }
+  .traj-say p { margin: 0 0 6px; }
+  .traj-say p:last-child { margin-bottom: 0; }
+  /* 思考正文（照 PC 的 compact Markdown）：普通段落、三级灰、左缩进 22px，不套框。 */
+  .traj-think {
+    margin: 2px 0 8px; padding: 4px 0 4px 22px;
+    color: var(--muted); font-size: 13px; line-height: 20px;
+    word-break: break-word;
+  }
+  .traj-think p { margin: 0 0 6px; }
+  .traj-think p:last-child { margin-bottom: 0; }
+  /* 工具展开卡（照 PC 的通用 IN/OUT 卡）：标签小字灰、正文等宽、细线分隔、出错整段红。 */
+  .traj-io {
+    margin: 2px 0 8px;
+    background: var(--panel-2); border: 1px solid var(--line); border-radius: var(--r);
+  }
+  .traj-io-row { display: flex; gap: 10px; padding: 8px 10px; }
+  .traj-io-row + .traj-io-row { border-top: 1px solid var(--line); }
+  .traj-io-label { flex: none; width: 34px; color: var(--muted); font-size: 11px; line-height: 1.7; }
+  .traj-io-body { flex: 1 1 auto; min-width: 0; color: var(--muted); font-size: 12.5px; line-height: 1.6; }
+  .traj-io-body pre {
+    margin: 0; white-space: pre-wrap; word-break: break-word;
+    font-family: ui-monospace, Menlo, Consolas, monospace; font-size: 12px;
+  }
+  .traj-io-err pre { color: var(--err); }
+  .traj-io-note { margin-top: 4px; color: var(--dim); font-size: 11px; }
+  /* 四类状态的字样：只上色、零动效（动效守卫只认那五种关键帧），颜色全取现成令牌。 */
+  .traj-err { color: var(--err); }   /* 失败首行：折叠处一眼可见 */
+  .traj-run { color: var(--run); }   /* 进行中：有标识；2026-10-04 起再加一道扫光（用户点名） */
+  /* 跑着的行有一道渐变光扫过去（照 DSH 的 TextShimmer，2026-10-04 用户点名复现，
+     要适配主题）。机制照 PC：底色还是语义色（--run），一道亮色（--shimmer）扫过；
+     每秒 48 格、1.5 秒一轮、走前 2/3 停后 1/3，与 PC 同参。颜色全走现成令牌，
+     深浅两套主题各看各的。行上带一个负 delay（trajShimStyle）：页面整块重画会把
+     动画打回开头，接上全局时钟的相位才不会变成频闪。 */
+  .traj-shimmer {
+    background-image: linear-gradient(105deg,
+      var(--run) 38%, var(--shimmer) 50%, var(--run) 62%);
+    background-size: 260% 100%;
+    -webkit-background-clip: text; background-clip: text;
+    color: transparent;
+    animation: shimSweep 1.5s steps(48, end) infinite;
+  }
+  @keyframes shimSweep {
+    0% { background-position: 150% 0; }
+    66.6667%, 100% { background-position: -50% 0; }
+  }
+  .traj-note {
+    margin: 0 0 10px; padding: 6px 8px;
+    background: var(--panel-2); border: 1px solid var(--line); border-radius: var(--r);
+    color: var(--muted); font-size: 12.5px; line-height: 1.6;
+  }
+
   /* ---------- 设置抽屉 ---------- */
   #settings {
     position: fixed; inset: 0; background: var(--scrim);
@@ -767,11 +1074,77 @@
     backdrop-filter: blur(14px) saturate(1.1);
   }
   .sheet h2 { margin: 0 0 14px; font-size: 16px; }
+
+  /* ---------- 设置页：整屏（2026-10-05 用户要求） ----------
+     内容越来越多，贴底那张最高 86vh 的抽屉不够用了。
+
+     **只改设置这一处**，不动 .sheet 本身——设置 / 统一操作面板 / 子智能体 / 插件页
+     共用那一套（✓ 毛玻璃底色照旧，一个字没改），另外三处本来就短，照旧贴底。
+
+     布局改成一列：页眉（.sheet-head）待在**滚动区外面**，内容（.sheet-body）自己滚。
+     为什么要这样而不是把页眉做成吸顶的：吸顶的页眉得自己铺一层底色去挡滚上来的内容，
+     而它铺在抽屉的毛玻璃之上会**再叠一层**、叠出更深的色，顶上就一道色差。
+     页眉不进滚动区，底下就还是抽屉本来的那层毛玻璃，什么都不用铺。
+
+     圆角和上边框去掉：它们本来是「贴着底边只露一截」才需要的，整屏之后那两条边
+     就是屏幕边。 */
+  #settings .sheet {
+    display: flex; flex-direction: column;
+    overflow: hidden;
+    max-height: none; height: 100%;
+    border-radius: 0; border-top: none;
+    padding: 0;
+  }
+  /* 页眉。**整屏之后必须有一个一直看得见的关闭口**：原来「点抽屉外面」那条路没了
+     （没有露在外面的遮罩可点），光靠底部那个「完成」得先滚到底才行。
+
+     高度是省出来的（2026-10-05 用户说太高）：原来上下留 16/10px，而真正把这条页眉
+     顶高的是右边那个按钮——.btn 默认上下各 8px 内边距、14px 字，光它就 39px，
+     加起来 65px，比页面自己那条顶栏还高。
+       · 上内边距收到 10px，和页面顶栏（header）**同一条竖向节奏**；
+       · 页眉里这一个按钮单独紧凑一档（见下），别处照旧。
+     两处合起来约 50px。 */
+  .sheet-head {
+    flex: 0 0 auto;
+    display: flex; align-items: center; justify-content: space-between; gap: 12px;
+    padding: calc(env(safe-area-inset-top) + 10px) 16px 10px;
+    border-bottom: 1px solid var(--line);
+  }
+  .sheet-head h2 { margin: 0; }
+  /* 设置页真正滚的那一块。左右 16px 和底部安全区都是从 .sheet 挪过来的
+     （那边 padding 已归零，账不能丢）。 */
+  #settings .sheet-body {
+    flex: 1 1 auto; overflow-y: auto;
+    padding: 14px 16px calc(env(safe-area-inset-bottom) + 18px);
+  }
   .row {
     display: flex; align-items: center; justify-content: space-between;
     gap: 12px; padding: 12px 0; border-bottom: 1px solid var(--line);
   }
   .row:last-of-type { border-bottom: none; }
+  /* 权限档位那一块外面套了一层（#permBlock，服务拿不到时整块要藏起来）。
+     它下面**没有分割线**，而别的板块之间都有——2026-10-05 用户截图点名。
+     原因：别的板块的分割线都是「那一行自己的下边线」（.row 的 border-bottom），
+     而权限档位那层的最后一个元素是**那排按钮**（.seg，它自带边框），
+     那层自己没有下边线，所以两块之间是空的。
+
+     修法就照其他线的做法，一模一样：**让这一块自己带一条下边线，
+     并且先留出 12px**——线因此落在「按钮 + 12px」处，
+     和别处的线一样居中在留白里（下一行也有 12px 上边距）。
+     为什么不给「繁忙」那行加 border-top：那会让线紧贴着按钮的边框，
+     看起来只是按钮框变粗，不像一条分割线。
+     藏起来时（hidden = display:none）这条线自然不画，
+     上面「字体大小」那条线正好接上，不会两条挤在一起。 */
+  #permBlock { padding-bottom: 12px; border-bottom: 1px solid var(--line); }
+  /* 权限档位里面那行标签**不要自己的下边线**（2026-10-05 用户截图点名：
+     「权限档位格子的上缘有一条粗线」）。
+     原因：那行标签按 .row 的规矩带着一条下边线，而它下面紧挨着的就是**按钮框**
+     （.seg 自带整圈边框）——两条 1px 的线贴在一起，看起来就是一条粗线。
+     实测：上缘 2 个 CSS 像素、下缘 1 个，粗细不一样。
+     为什么那行没被「最后一个不画下边线」那条规则管到：权限档位这一层里，
+     按钮框排在标签**后面**，所以标签那行不算「最后一个」。
+     它本来也不该有线——它是下面那排按钮的标签，中间画一条分割线没有道理。 */
+  #permBlock .row { border-bottom: none; }
   .row .label { font-size: 15px; }
   .row .hint { font-size: 12px; color: var(--muted); margin-top: 2px; }
   /* flex-shrink: 0 不能省。它是弹性项，左边的说明文字一长就会被压缩；
@@ -783,15 +1156,89 @@
     font-size: 13px; cursor: pointer;
   }
   .seg button.active { background: var(--ice); color: var(--on-act); }
+  /* 权限档位那排按钮要**撑满**它的框（2026-10-05 用户截图点名：「自动审查那一格
+     背景颜色没填满」）。
+     根因：别的 .seg 都套在 .row 里（那是弹性容器），所以框会缩到内容那么宽，
+     按钮正好填满；而权限档位这一排是 #permBlock 的直接子元素，**在块级上下文里**
+     → 框被拉成整行宽，而四个按钮只占自己文字那么宽，右边就空出一条
+     （实测约 10 个 CSS 像素），露出来的是框自己的底色，看着像那一格没填满。
+     修法：让它们按内容分配、再把多出来的空间摊平（1 1 auto）。
+     不用 flex: 1 1 0（四等分）——「工作区内修改」六个字比别的宽，
+     强行等分会把它挤到换行。 */
+  #segPerm button { flex: 1 1 auto; }
   select, .btn {
     padding: 8px 12px; border-radius: var(--r); border: 1px solid var(--line);
     background: var(--panel-2); color: var(--fg); font: inherit; font-size: 14px;
   }
   .btn { cursor: pointer; }
   .btn.primary { background: var(--act); border-color: var(--act); color: var(--on-act); font-weight: 600; }
+  /* 页眉里那个动作按钮（关闭）比通用 .btn 紧凑一档。
+
+     通用 .btn 是给面板正身用的：上下各 8px 内边距 + 14px 字，约 39px 高。
+     摆进页眉就比标题高出一大截——**整条页眉的高度其实是它顶出来的**，而且那个
+     方框比标题那行字高出一圈，看着又大又不像跟标题对齐。
+     2026-10-05 用户两次报到这里：先说设置页「页眉高度太大」，又说插件页
+     「关闭按钮太大了，没跟插件两个字对齐」。
+
+     **四个面板页眉共用这一档**（统一操作面板 / 子智能体 / 插件页 / 设置页），
+     免得一处收了一处没收、几个面板长得不一样。
+     通用 .btn 的内边距一个字没动——它别处到处在用，动它等于整页跟着变。 */
+  .ops-head .btn, .sa-head .btn, .sheet-head .btn {
+    padding: 5px 11px; font-size: 13px;
+  }
   .sheet .foot { margin-top: 18px; display: flex; gap: 10px; }
+  /* 设置抽屉最底下那行 DSH 版本：做成一条**收尾的分隔线**——两侧各一条细线、
+     版本号居中，把这一屏收住，免得孤零零一行小字吊在最后（2026-10-05 用户要的
+     「加一点设计感，比如两侧加横线」）。
+     线用现成的 --line（细线色），不新造令牌、不加关键帧、不碰圆角——这一屏的
+     层次本来就靠这条 1px 细线建立，别为了一行版本号另起一套。
+
+     `[hidden]` 那一句**不能省**：下面写了 display: flex，而作者样式表里的
+     display 会盖掉 HTML `hidden` 自带的 display: none——少了它，问不到版本时
+     这一行照样显示，变成一条空的分隔条。 */
+  .sheet .version {
+    display: flex; align-items: center; gap: 10px;
+    padding: 18px 0 6px; font-size: 12px; color: var(--muted);
+    letter-spacing: 0.04em;
+  }
+  .sheet .version[hidden] { display: none; }
+  .sheet .version::before,
+  .sheet .version::after {
+    content: ""; flex: 1 1 0; height: 1px; background: var(--line);
+  }
   .sheet .foot .btn { flex: 1 1 0; text-align: center; }
 
+  /* ---------- 统一操作面板（输入框旁边那一个入口点开的东西） ----------
+     骨架和设置抽屉**是同一套**：同一个 `#xxx.open` 即时显隐、同一个贴底的 `.sheet`
+     （它自带 max-height / overflow-y / safe-area 那三样，窄屏顶不出去），不新建样式体系。
+     这里独有的只有上面两段小节头和那个筛选框；指令行沿用 .cmd-menu 那一套。 */
+  #ops {
+    position: fixed; inset: 0; background: var(--scrim);
+    display: none; align-items: flex-end; z-index: 50;
+  }
+  #ops.open { display: flex; }
+  .ops-head { display: flex; align-items: center; gap: 10px; margin-bottom: 12px; }
+  .ops-head h2 { flex: 1 1 auto; margin: 0; }
+  /* 两个动作平分一行。都是既有 .btn（细边框 + --r 圆角 + --panel-2 底），
+     没有主按钮——这一屏不放强调色（#settings 那一屏已经有一处「完成」）。 */
+  .ops-acts { display: flex; gap: 10px; }
+  .ops-acts .btn { flex: 1 1 0; text-align: center; }
+  .ops-files { display: flex; flex-wrap: wrap; gap: 6px; margin-top: 12px; }
+  .ops-files[hidden] { display: none; }
+  /* 「调用指令」这个小标题**要带上前面的类**，不能只写 .ops-sub。
+     2026-10-05 用户截图点名：「调用指令和上方选文件拍照那一行要有点留白」。
+     根因：这里本来写着 margin: 20px 0 10px，但上面有条 `.sheet h2 { margin: 0 0 14px }`
+     ——它是「一个类 + 一个元素」(0,1,1)，比只有「一个类」的 .ops-sub (0,1,0) 优先级高，
+     于是 margin-top 被盖成 0，那 20px 从来没生效过，标题就贴着按钮。
+     写成 .sheet .ops-sub (0,2,0) 才压得住那条规则。 */
+  .sheet .ops-sub { margin: 20px 0 10px; font-size: 16px; }
+  .ops-filter {
+    width: 100%; padding: 9px 12px; border-radius: var(--r); border: 1px solid var(--line);
+    background: var(--panel-2); color: var(--fg); font: inherit; font-size: 16px;
+  }
+  /* 列表自己滚，别把整张抽屉撑出屏幕。 */
+  .ops-cmds { margin-top: 8px; max-height: 40vh; overflow-y: auto; -webkit-overflow-scrolling: touch; }
+
   /* ---------- token 输入 ---------- */
   #gate { position: fixed; inset: 0; background: var(--bg); z-index: 100;
           display: none; flex-direction: column; justify-content: center;
@@ -876,11 +1323,14 @@
   // 所以这一段留在 <head> 里、样式表后面，**别挪到页面底部那段脚本区去**。
   (function () {
     try {
-      var pick = localStorage.getItem('dshMiniTheme') || 'dark';
+      var pick = localStorage.getItem('dshMiniTheme') || 'light';
       var dark = !window.matchMedia || window.matchMedia('(prefers-color-scheme: dark)').matches;
-      document.documentElement.setAttribute('data-theme',
-        pick === 'auto' ? (dark ? 'dark' : 'light') : pick);
-    } catch (e) { /* 无痕模式下 localStorage 会抛；按默认深色走，不影响页面 */ }
+      var use = pick === 'auto' ? (dark ? 'dark' : 'light') : pick;
+      document.documentElement.setAttribute('data-theme', use);
+      // 首屏时也更新状态栏颜色，否则浅色页配深色状态栏会闪一下
+      var meta = document.querySelector('meta[name="theme-color"]');
+      if (meta) meta.setAttribute('content', use === 'light' ? '#eaf3fc' : '#0a0f16');
+    } catch (e) { /* 无痕模式下 localStorage 会抛；按默认浅色走，不影响页面 */ }
   })();
 </script>
 </head>
@@ -920,6 +1370,7 @@
   <span class="dot" id="dot"></span>
   <span class="brand">极简遥控器</span>
   <span class="status" id="status">连接中…</span>
+  <button class="icon-btn" id="btnSubagents" aria-label="子智能体"><svg viewBox="0 0 24 24" aria-hidden="true"><path d="M8.2 12H11M11 6v12M11 6h4.8M11 18h4.8"/><circle cx="6" cy="12" r="2.2"/><circle cx="18" cy="6" r="2.2"/><circle cx="18" cy="18" r="2.2"/></svg></button>
   <button class="icon-btn" id="btnSettings" aria-label="设置"><svg viewBox="0 0 24 24" aria-hidden="true"><path d="M4 7h8M16 7h4M4 17h4M12 17h8"/><circle cx="14" cy="7" r="2.2"/><circle cx="10" cy="17" r="2.2"/></svg></button>
 </header>
 
@@ -971,9 +1422,14 @@
 <div class="cmd-menu" id="cmdMenu" hidden></div>
 
 <footer>
-  <!-- 回形针。input 藏起来，按钮点它——iOS 上直接放一个 file input 样式很难统一。 -->
-  <button class="attach" id="btnAttach" type="button" aria-label="上传文件" title="上传文件">
-    <svg viewBox="0 0 24 24" aria-hidden="true"><path d="M21.44 11.05l-9.19 9.19a6 6 0 0 1-8.49-8.49l9.19-9.19a4 4 0 0 1 5.66 5.66l-9.2 9.19a2 2 0 0 1-2.83-2.83l8.49-8.48"/></svg>
+  <!-- 统一入口。位置和尺寸一个像素都没动（还是原来回形针那个 42×42），改的只是点了之后
+       干什么：原来直接开文件选择器，现在开下面那张统一操作面板（文件 + 指令都在里面）。
+       input 藏起来，按钮点它——iOS 上直接放一个 file input 样式很难统一。 -->
+  <button class="attach" id="btnAttach" type="button" aria-label="添加文件或调用指令" title="添加文件或调用指令">
+    <!-- 图标是 DSH 桌面端那个鲸鱼（dsh-client-ui-primitives 的 FishLogo，
+           viewBox 0 0 23.16 17.04）。路径**原样抄自桌面端**，没有自己重画。
+           填色走 currentColor，所以跟着按钮的 var(--muted) 走，深浅两套主题各自适配。 -->
+      <svg viewBox="0 0 23.16 17.04" aria-hidden="true"><path d="M22.9168 1.43018C22.6713 1.31018 22.5658 1.53918 22.4223 1.65519C22.3733 1.69269 22.3318 1.74169 22.2903 1.78669C21.9317 2.1697 21.5127 2.42121 20.9657 2.39121C20.1657 2.34621 19.4827 2.59771 18.8787 3.20973C18.7502 2.45521 18.3236 2.0047 17.6746 1.71569C17.3351 1.56568 16.9916 1.41518 16.7536 1.08867C16.5876 0.856163 16.5421 0.597155 16.4591 0.341647C16.4061 0.187643 16.3536 0.0301382 16.1761 0.00363739C15.9836 -0.0263635 15.9081 0.135141 15.8326 0.270145C15.5306 0.822162 15.4136 1.43018 15.4251 2.0462C15.4516 3.43174 16.0366 4.53527 17.1991 5.3203C17.3311 5.4103 17.3651 5.5003 17.3236 5.63181C17.2441 5.90231 17.1501 6.16482 17.0671 6.43533C17.0141 6.60784 16.9351 6.64584 16.7501 6.57033C16.1121 6.30383 15.5611 5.90931 15.074 5.4328C14.2475 4.63328 13.5 3.75075 12.568 3.05973C12.349 2.89822 12.13 2.74822 11.9034 2.60522C10.9524 1.68169 12.028 0.923165 12.277 0.833162C12.5375 0.739159 12.3675 0.41615 11.5259 0.42015C10.6844 0.42365 9.91439 0.705658 8.93286 1.08117C8.78935 1.13767 8.63835 1.17867 8.48384 1.21267C7.59332 1.04367 6.66829 1.00617 5.70226 1.11517C3.88321 1.31768 2.43016 2.1777 1.36213 3.64575C0.0790928 5.4103 -0.222916 7.41536 0.146595 9.50642C0.535106 11.7105 1.66014 13.535 3.38869 14.9616C5.18125 16.4406 7.24581 17.1657 9.60138 17.0266C11.0319 16.9441 12.6245 16.7526 14.421 15.2321C14.874 15.4576 15.3496 15.5476 16.1381 15.6151C16.7456 15.6716 17.3306 15.5851 17.7836 15.4911C18.4931 15.3411 18.4441 14.6841 18.1876 14.5636C16.1081 13.595 16.5646 13.9891 16.1496 13.67C17.2061 12.42 18.8202 10.1979 19.3182 7.17235C19.3672 6.83834 19.4297 6.36783 19.4222 6.09732C19.4182 5.93231 19.4562 5.86831 19.6447 5.84931C20.1657 5.78931 20.6712 5.64681 21.1357 5.3913C22.4833 4.65528 23.0268 3.44624 23.1548 1.9972C23.1738 1.77569 23.1508 1.54668 22.9168 1.43018ZM11.1749 14.4736C9.15936 12.889 8.18184 12.3675 7.77832 12.39C7.40081 12.4125 7.46881 12.8445 7.55182 13.126C7.63882 13.404 7.75182 13.5955 7.91033 13.8396C8.01983 14.0011 8.09533 14.2411 7.80083 14.4216C7.15181 14.8231 6.02327 14.2866 5.97027 14.2601C4.65673 13.4865 3.5587 12.4655 2.78467 11.069C2.03715 9.72493 1.60314 8.28289 1.53164 6.74384C1.51264 6.37233 1.62214 6.24082 1.99215 6.17332C2.47916 6.08332 2.98118 6.06432 3.46769 6.13582C5.52476 6.43633 7.27581 7.35586 8.74385 8.8129C9.58188 9.64243 10.2159 10.634 10.8689 11.6025C11.5634 12.631 12.3105 13.611 13.262 14.4146C13.598 14.6961 13.866 14.9101 14.1225 15.0681C13.349 15.1546 12.058 15.1731 11.1749 14.4746L11.1749 14.4736ZM12.141 8.25988C12.141 8.09488 12.273 7.96338 12.439 7.96338C12.4765 7.96338 12.5105 7.97088 12.541 7.98188C12.5825 7.99688 12.6205 8.01938 12.6505 8.05338C12.7035 8.10588 12.7335 8.18088 12.7335 8.25988C12.7335 8.42489 12.6015 8.55639 12.4355 8.55639C12.2695 8.55639 12.141 8.42489 12.141 8.25988ZM15.1415 9.79893C14.949 9.87793 14.7565 9.94544 14.5715 9.95294C14.2845 9.96794 13.9715 9.85143 13.8015 9.70893C13.5375 9.48742 13.3485 9.36342 13.2695 8.97691C13.2355 8.8119 13.2545 8.55639 13.2845 8.40989C13.3525 8.09438 13.277 7.89187 13.0545 7.70787C12.8735 7.55786 12.643 7.51636 12.39 7.51636C12.2955 7.51636 12.209 7.47486 12.1445 7.44136C12.039 7.38886 11.9519 7.25735 12.035 7.09585C12.0615 7.04335 12.19 6.91584 12.22 6.89334C12.5635 6.69784 12.9595 6.76184 13.326 6.90834C13.6655 7.04735 13.9225 7.30236 14.292 7.66287C14.6695 8.09838 14.7375 8.21838 14.9525 8.54539C15.1225 8.8009 15.277 9.06341 15.3831 9.36392C15.4471 9.55142 15.3641 9.70493 15.1415 9.79893Z" fill="currentColor"/></svg>
   </button>
   <input type="file" id="filePick" hidden>
   <textarea id="input" rows="1" placeholder="说点什么…" enterkeyhint="send"></textarea>
@@ -993,7 +1449,16 @@
 
 <div id="settings">
   <div class="sheet">
-    <h2>设置</h2>
+    <!-- 页眉。整屏之后「点外面关掉」没了，所以这里必须有一个一直看得见的关闭口
+         （滚到哪儿都在）；底部那个「完成」照样留着。
+
+         它在**滚动区外面**（里面那个 .sheet-body 才是滚动区）：这样页眉底下就是抽屉
+         本来那层毛玻璃，不用为它另铺一层底色——铺了会叠出更深的色，顶部一道色差。 -->
+    <div class="sheet-head">
+      <h2>设置</h2>
+      <button class="btn" id="btnSettingsClose">关闭</button>
+    </div>
+    <div class="sheet-body">
 
     <div class="row">
       <div>
@@ -1003,6 +1468,7 @@
       <div class="seg" id="segMode">
         <button data-mode="minimal">单帧</button>
         <button data-mode="chat">聊天</button>
+        <button data-mode="full">完整</button>
       </div>
     </div>
 
@@ -1019,6 +1485,18 @@
       </div>
     </div>
 
+    <!-- 字体大小：三档，存 localStorage，改 CSS 变量 --font-base -->
+    <div class="row">
+      <div>
+        <div class="label">字体大小</div>
+      </div>
+      <div class="seg" id="segFont">
+        <button data-font="small">小</button>
+        <button data-font="normal">标准</button>
+        <button data-font="large">大</button>
+      </div>
+    </div>
+
     <!-- 权限档位。整块由脚本填：这台电脑有哪些档位是**运行时读**的，一个都不写死。
          服务拿不到时整块不显示——它是附加能力，缺了遥控本身照常。 -->
     <div id="permBlock" hidden>
@@ -1031,6 +1509,23 @@
       <div class="seg" id="segPerm"></div>
     </div>
 
+    <!-- 繁忙时的发送行为（2026-10-05 用户要求搬进手机设置）。
+         PC 上「设置 → 通用 → 繁忙时的发送行为」就是它：智能体跑着的时候，
+         你发的那句话是排队等这一轮跑完，还是当场插进去让它调整方向。
+         **两端共用宿主那一份设置**——手机上改，电脑上也是这个值。
+         文案照抄 PC 词条表（settings.enter.*），一个字不自创。
+         读不到时整条藏起来（见 loadBusyEnter），不摆一个点了没用的开关。 -->
+    <div class="row" id="rowBusyEnter" hidden>
+      <div>
+        <div class="label">繁忙时的发送行为</div>
+        <div class="hint">智能体运行时发送按钮的行为</div>
+      </div>
+      <div class="seg" id="segBusyEnter">
+        <button data-busy="queue">排队发送</button>
+        <button data-busy="steer">插话发送</button>
+      </div>
+    </div>
+
     <!--
       这里原来有两行：「完成后提醒」和「语音输入」。
 
@@ -1095,10 +1590,87 @@
       <button class="btn" id="btnReconnect">重连</button>
     </div>
 
+    <div class="row">
+      <div>
+        <div class="label">插件</div>
+        <div class="hint">查看官方插件和已安装插件</div>
+      </div>
+      <button class="btn" id="btnPlugins">查看</button>
+    </div>
+
     <div class="foot">
       <button class="btn" id="btnForget">清除 token</button>
       <button class="btn primary" id="btnClose">完成</button>
     </div>
+
+    <div class="version" id="dshVersion" hidden></div>
+    </div>
+  </div>
+</div>
+
+<!-- 统一操作面板：输入框旁边那一个入口点开的就是它，上面「添加文件」、下面「调用指令」。
+     原来这两件事各有各的门（回形针直接开文件选择器、打 `/` 才弹指令菜单），手机上没人
+     知道打一个斜杠还能调指令。
+
+     外壳是设置抽屉那一套**一模一样**的写法（`#xxx.open` 即时显隐 + `.sheet` 贴底），
+     不新建样式体系；令牌、圆角、细边框也全是现成的。
+
+     它盖住整屏、贴着底边（和设置抽屉同一层），所以不和底栏抢位置；打开时先把键盘收起来，
+     不然手机键盘会把这张抽屉顶到看不见的地方。 -->
+<div id="ops">
+  <div class="sheet">
+    <div class="ops-head">
+      <h2>添加文件</h2>
+      <button class="btn" id="opsClose">关闭</button>
+    </div>
+    <div class="ops-acts">
+      <button class="btn" id="opsPick" type="button">选文件</button>
+      <button class="btn" id="opsShot" type="button">拍照</button>
+    </div>
+    <!-- 已选文件的去处和附件小条**是同一份数据**（state.uploads，同一个 renderAttach）。
+         这里画一遍是为了让用户在面板里就看得到自己带了什么，不必先关掉面板。 -->
+    <div class="ops-files" id="opsFiles" hidden></div>
+
+    <h2 class="ops-sub">调用指令</h2>
+    <input class="ops-filter" id="opsFilter" type="text" placeholder="筛选指令…"
+           autocomplete="off" autocapitalize="off" autocorrect="off" spellcheck="false">
+    <div class="ops-cmds" id="opsCmds"></div>
+  </div>
+</div>
+
+<!-- 子智能体（2026-10-03 用户要求：把电脑端「子智能体」搬到手机）。
+
+     入口在顶栏，紧挨着设置齿轮的左边。面板外壳和设置抽屉**是同一套**（#subagents
+     的骨架和 .sheet 一个样），不新建样式体系；这一块独有的外观只有两条——列表里的
+     一行，和聊天记录里那张完工卡片（见 CSS 那段注释）。
+
+     **列表取的是手机当前绑定的那个会话**名下的子智能体，和 send / stop 同一套口径：
+     手机上遥控的是你正看着的那个会话，不该牵动你在电脑上另开的那个。
+
+     一个面板两种视图：清单；点某一行换成它**自己的运行记录**（返回键换回来）。 -->
+<div id="subagents">
+  <div class="sheet">
+    <div class="sa-head">
+      <button class="sa-back" id="subagentsBack" hidden>‹ 返回</button>
+      <h2 id="subagentsTitle">子智能体</h2>
+      <button class="btn" id="subagentsClose">关闭</button>
+    </div>
+    <div class="sa-list" id="subagentsList"></div>
+    <div class="sa-doc" id="subagentsDoc" hidden></div>
+  </div>
+</div>
+
+<!-- 插件页面（2026-10-04 用户要求：移动端设置里加插件入口）。
+     外壳和子智能体面板同一套（.sheet），显示官方插件和已安装插件（内置+第三方）。 -->
+<div id="plugins">
+  <div class="sheet">
+    <div class="sa-head">
+      <h2>插件</h2>
+      <button class="btn" id="pluginsClose">关闭</button>
+    </div>
+    <div class="sa-list" id="pluginsList">
+      <div class="sa-none sa-none-indent">正在读取插件列表…</div>
+    </div>
   </div>
 </div>
 
@@ -1133,12 +1705,15 @@
     mode: localStorage.getItem('dshMiniMode') || DEFAULT_MODE || 'minimal',
     // 外观：'dark' | 'light' | 'auto'。默认深色——不给老用户换掉现在的样子；
     // 要浅色或跟着系统走，去设置页「外观」点一下。
-    theme: localStorage.getItem('dshMiniTheme') || 'dark',
+    theme: localStorage.getItem('dshMiniTheme') || 'light',
+    // 字体大小：'small' | 'normal' | 'large'。默认标准。
+    fontSize: localStorage.getItem('dshMiniFont') || 'normal',
     sound: localStorage.getItem('dshMiniSound') !== 'off',
     // 锁屏也能提醒（系统通知）。默认关着——它要用户主动点一下才会申请权限，
     // 不能替他决定。明文连接下这一项永远是空转的，见下面「锁屏也能提醒」那一段。
     notify: localStorage.getItem('dshMiniNotify') === 'on',
     running: false,
+    subagentsRunning: false,
     sessions: [],
     // 排队中的指令（[{ id, text, placement }]）。跑着任务时接着发的那几条排在这儿，
     // 由服务端每次取快照时从 agent 的收件箱现读，手机不自己记。
@@ -1164,6 +1739,24 @@
     // 「这份历史只到最近一段」（服务端读历史有上限时会给这一句）。
     historyTruncated: false,
     historyNote: '',
+    /**
+     * 执行轨迹（「完整」模式里的过程）：一组一轮，形状与服务端
+     * `GET /mini/api/trajectory` 的 `turns` 一字不差
+     * （`[{ turn, state, reason, entries:[…] }]`）。
+     *
+     * **它和 latest / history 是两回事**：思考正文只活在 `entries[].output` 里，
+     * 回答气泡那两条路（`state.latest` / `state.history`）一个字都不碰它——
+     * 这是 2026-09-27 用户定的边界（思维链一个字都不上气泡）。
+     *
+     * 只在「完整」模式订阅、只在那里画；切回单帧/聊天就退订，不再收也不再画。
+     */
+    trajectory: [],
+    trajectoryNote: '',        // 「这份轨迹不是全部」时服务端给的那句话（展示下一棒接手）
+    trajectoryTruncated: false,
+    trajectoryLoading: false,  // 服务端还在读会话记录（**不等于「没有过程」**）
+    trajectoryEpoch: '',       // 服务换了一代（重启）就不能再往旧的那份上面接
+    trajectorySeq: 0,          // 收到第几帧，用来认出「我漏了几帧」（只进不退）
+    trajectoryLive: '',        // 活片段：正在想的那一句（只有完整模式有值，落盘即清）
     // 斜杠指令的列表（在输入框里打 / 时弹出来的那个菜单）。
     // **按绑定的会话缓存**：指令表是每个会话一份的，而这个会话没在跑时服务端一条都
     // 读不到（回 ok:false + 一句话）。所以换了会话必须重取——否则用户点到的是上一个
@@ -1171,7 +1764,15 @@
     commands: null,        // null = 还没取到
     commandsError: '',     // 取不到时服务端给的那句话，原样显示给用户
     commandsFor: null,     // 上面这份数据是哪个会话的
-    commandsLoading: false // 正在取（挡住重复请求，见 loadCommands）
+    commandsLoading: false, // 正在取（挡住重复请求，见 loadCommands）
+    /**
+     * 「输入框里这一行曾经是一条指令」——点过面板/菜单里某一条之后，这里记着它的名字。
+     *
+     * 用来堵一个真缺口：点了一条要参数的指令，用户把 `/名字 ` 里的名字删掉、只留参数，
+     * 那一行就不再以 `/` 开头，会被当成普通提问发给模型，白花一次额度。
+     * 有这枚标记时，send() 会把这一行拦下来，让他补回名字或**清空输入框**（= 明确取消）。
+     */
+    pendingCommand: null
   };
   if (params.get('token')) {
     localStorage.setItem('dshMiniToken', params.get('token'));
@@ -1179,6 +1780,232 @@
     history.replaceState(null, '', location.pathname);
   }
 
+  /**
+   * ---------------- 执行轨迹：订阅与收帧（数据层） ----------------
+   *
+   * 轨迹**不走全量快照**：实测它的正文是回答正文的 90.7 倍（单轮最高约 946KB），
+   * 而 `event: state` 是「每条广播都发整份」。所以它走单独的增量帧
+   * （`event: trajectory`，每帧只带新加的几条和改了的几笔），且**只有「完整」模式的
+   * 连接才订**——不看这块的人一个字节都不付。
+   *
+   * 三件事一起看才完整：切到「完整」时订上并 GET 一次当前状态；切回单帧/聊天就退订；
+   * 断线重连把 clientId 和 `?full=1` 带在流地址上（服务端自动重新订上），重连后再
+   * GET 一次对齐——帧里的 epoch 变了就整个重拉。
+   *
+   * 本片到「收进 state.trajectory」为止；画法（三层折叠）在 renderFull 后面那一片。
+   * clientId / subscribedClientId 两个连接身份变量声明在下面 SSE 一节里——
+   * 那一节被测试整段抠出来跑，身份必须跟流地址待在一起才找得到。
+   */
+
+  /**
+   * 这一帧该不该接、接到哪一组。三道门：
+   * 不是「完整」模式不接（退订之后可能还有在路上的旧帧）；
+   * 不是当前这个会话不接（切会话了，旧会话的过程与新会话无关）。
+   * 没有这一组就立一个（turn 号是帧给的，组里 entries 往后只增不减）。
+   */
+  function trajectoryKeyOf(frame) {
+    if (state.mode !== 'full') return null;
+    if (frame.sessionId && state.boundSessionId && frame.sessionId !== state.boundSessionId) return null;
+    var turn = typeof frame.turn === 'number' ? frame.turn : null;
+    for (var i = 0; i < state.trajectory.length; i++) {
+      if (state.trajectory[i].turn === turn) return state.trajectory[i];
+    }
+    var group = { turn: turn, state: 'running', reason: null, entries: [] };
+    state.trajectory.push(group);
+    return group;
+  }
+
+  /**
+   * 把一条增量补丁贴到已有条目上。**只改补丁里真有的字段**——「停了」那种补丁不该
+   * 顺手把输出清空；截断信息是合并而不是替换（一条工具步可能参数超长、结果也超长）。
+   * 写法和 lib/trajectory.js 的 applyTrajectoryPatch 一致：两端对同一笔补丁的理解
+   * 必须一样，否则手机上会出现「明明有结果却还写着正在跑」。
+   */
+  function patchTrajectoryEntry(entry, patch) {
+    if (!entry || !patch) return;
+    if (typeof patch.state === 'string') entry.state = patch.state;
+    if (Object.prototype.hasOwnProperty.call(patch, 'output')) entry.output = patch.output;
+    if (Object.prototype.hasOwnProperty.call(patch, 'error')) entry.error = patch.error;
+    if (patch.truncated) {
+      entry.truncated = Object.assign({}, entry.truncated || {}, patch.truncated);
+    }
+  }
+
+  /**
+   * 一帧的落法，四步按顺序走：
+   *
+   * 1. **换代认新**：帧里 epoch 和手里记的不一样（服务重启过），旧的那份整份作废，
+   *    用 GET 重拉——旧代的 seq 在新代里毫无意义，硬拼会出现「凭空多出半截过程」。
+   * 2. **缺帧认补**：帧的 seq 比预期大出不止一格，中间丢过帧，GET 重拉；
+   *    seq 只进不退（重连后服务端可能从头再发一轮）。
+   * 3. **add 幂等**：同一条目按 id 认——收过就改成补丁，没收过才追加。
+   *    同一帧送两遍（重连重放）不会长出两份，这是「帧重复」的硬要求。
+   * 4. **组态只进结论**：一组的 running 是过程中的默认值，收下任何结论态就不再
+   *    被后面的 running 盖回去（结论到了之后又来一条旧的 running 帧，不算输）。
+   */
+  function applyTrajectoryFrame(frame) {
+    if (!frame || typeof frame !== 'object') return false;
+    var epoch = typeof frame.epoch === 'string' ? frame.epoch : '';
+    if (state.trajectoryEpoch && epoch && epoch !== state.trajectoryEpoch) {
+      state.trajectoryEpoch = epoch;
+      state.trajectorySeq = 0;
+      state.trajectory = [];
+      if (state.mode === 'full') requestTrajectory();
+      return false;
+    }
+    if (!state.trajectoryEpoch && epoch) state.trajectoryEpoch = epoch;
+    var seq = typeof frame.seq === 'number' ? frame.seq : 0;
+    if (seq > 0 && state.trajectorySeq > 0 && seq > state.trajectorySeq + 1) {
+      state.trajectorySeq = seq;
+      if (state.mode === 'full') requestTrajectory();
+      return false;
+    }
+    if (seq > state.trajectorySeq) state.trajectorySeq = seq;
+
+    var group = trajectoryKeyOf(frame);
+    if (!group) return false;
+
+    var add = Array.isArray(frame.add) ? frame.add : [];
+    for (var i = 0; i < add.length; i++) {
+      var raw = add[i];
+      if (!raw || typeof raw.id !== 'string' || !raw.id) continue;
+      var hit = null;
+      for (var j = 0; j < group.entries.length; j++) {
+        if (group.entries[j].id === raw.id) { hit = group.entries[j]; break; }
+      }
+      if (hit) {
+        patchTrajectoryEntry(hit, raw);
+      } else {
+        group.entries.push({
+          id: raw.id,
+          turn: typeof raw.turn === 'number' ? raw.turn : group.turn,
+          step: raw.step,
+          // 三种条目照单全收（think / say / tool）——旁白（say）是 2026-10-04 加的，
+          // 这里原来写死成两种，实时帧里的旁白会被画成「工具调用」空壳行，
+          // 等下一次整份对齐才变回正文段落（真机上就是「展现不对」）。
+          kind: raw.kind === 'think' || raw.kind === 'say' ? raw.kind : 'tool',
+          name: raw.name,
+          args: raw.args,
+          summary: raw.summary,
+          output: raw.output,
+          state: typeof raw.state === 'string' ? raw.state : 'running',
+          error: raw.error || null,
+          truncated: raw.truncated || null,
+          timestamp: raw.timestamp,
+        });
+      }
+    }
+    // 真条目进来了：活片段让位（服务端也会喊清，这里兜一道——影子不许盖住落定的字）。
+    if (add.length) state.trajectoryLive = '';
+    var upd = Array.isArray(frame.update) ? frame.update : [];
+    for (var k = 0; k < upd.length; k++) {
+      var patch = upd[k];
+      if (!patch || typeof patch.id !== 'string') continue;
+      for (var m = 0; m < group.entries.length; m++) {
+        if (group.entries[m].id === patch.id) { patchTrajectoryEntry(group.entries[m], patch); break; }
+      }
+    }
+    if (typeof frame.state === 'string' && frame.state !== 'running') {
+      group.state = frame.state;
+      group.reason = frame.reason || null;
+    } else if (group.state === 'running') {
+      if (frame.reason) group.reason = frame.reason;
+    }
+    return true;
+  }
+
+  /** 一帧到了：落进手里那份，只在「完整」模式下重画。 */
+  function receiveTrajectoryFrame(frame) {
+    if (!applyTrajectoryFrame(frame)) return;
+    render();
+  }
+
+  /**
+   * 用一份 GET 结果把手里那份**整个换掉**（不是往里合）：GET 是服务端按当前记录
+   * 重新汇总的全量视图，比任何增量拼接都新，换掉就不会「补丁叠在过期底稿上」。
+   * `loading` 如实收下——它说的是「还在读会话记录」，不是「没有过程」。
+   */
+  function setTrajectoryFromGet(view) {
+    if (!view || view.ok !== true) return;
+    state.trajectoryEpoch = typeof view.epoch === 'string' ? view.epoch : state.trajectoryEpoch;
+    state.trajectorySeq = typeof view.seq === 'number' ? view.seq : 0;
+    state.trajectory = Array.isArray(view.turns) ? view.turns : [];
+    state.trajectoryTruncated = view.truncated === true;
+    state.trajectoryNote = typeof view.note === 'string' && view.note ? view.note : '';
+    state.trajectoryLoading = view.loading === true;
+    render();
+  }
+
+  /**
+   * 拉一次当前过程。只在「完整」模式发；不是完整模式宁可什么都不说——去要一份
+   * 自己没订的数据，等于给服务端添一次白跑。读完只有两种岔路：是完整模式且还是
+   * 同一个会话才收下（发请求后切了会话/切了模式，这份就是旧账，直接丢），
+   * 读不到就把原因写出来，不说「没有过程」。
+   */
+  function requestTrajectory() {
+    if (state.mode !== 'full' || !state.token) return;
+    var sessionId = state.boundSessionId;
+    if (!sessionId) {
+      state.trajectory = [];
+      state.trajectorySeq = 0;
+      state.trajectoryLoading = false;
+      return;
+    }
+    state.trajectoryLoading = true;
+    api('/mini/api/trajectory?sessionId=' + encodeURIComponent(sessionId))
+      .then(function (view) {
+        if (state.mode !== 'full' || state.boundSessionId !== sessionId) return;
+        setTrajectoryFromGet(view);
+      })
+      .catch(function () {
+        if (state.mode !== 'full' || state.boundSessionId !== sessionId) return;
+        state.trajectoryLoading = false;
+        state.trajectoryNote = '读不到这个会话的过程。';
+        render();
+      });
+  }
+
+  /**
+   * 模式开关的订阅侧动作，跟着「显示模式」按钮走：
+   *
+   * - 切到「完整」：连流时没带 `?full=1`（连流那一刻不是完整模式）就得补一次
+   *   POST 订上，然后 GET 一次把手里的换成当前状态；已经订过就只 GET 对齐。
+   * - 切走：POST 退订，同时把身份清掉——服务端那条连接已经不再推了，
+   *   手里这个「已订」的记号必须同步作废，否则下次切回来会误以为还订着。
+   * - POST 回 404：这条流已经不在了（服务重启或断流没重连），立刻重连一次；
+   *   重连的地址自带 `?full=1`（当前就是完整模式），服务端会重新把这条连接订上。
+   *   重连成功与否都不用在这里补救——`open` 里那一套会再走一遍。
+   */
+  function syncTrajectorySubscription() {
+    if (!state.token) return;
+    var want = state.mode === 'full';
+    if (!want) {
+      if (subscribedClientId) {
+        var was = subscribedClientId;
+        subscribedClientId = '';
+        api('/mini/api/trajectory/subscribe', {
+          method: 'POST',
+          body: JSON.stringify({ clientId: was, on: false }),
+        }).catch(function () { /* 断了就断了：服务端本来就会随连接清理 */ });
+      }
+      return;
+    }
+    if (subscribedClientId) {
+      requestTrajectory();
+      return;
+    }
+    api('/mini/api/trajectory/subscribe', {
+      method: 'POST',
+      body: JSON.stringify({ clientId: clientId, on: true }),
+    }).then(function () {
+      if (state.mode !== 'full') return; // 刚要订又切走了，回包当没看见
+      subscribedClientId = clientId;
+      requestTrajectory();
+    }).catch(function (err) {
+      if (err && err.status === 404) connect();
+    });
+  }
+
   var $ = function (id) { return document.getElementById(id); };
   var mainEl = $('main'), replyEl = $('reply'), inputEl = $('input');
   var dotEl = $('dot'), statusEl = $('status');
@@ -2043,6 +2870,11 @@
     // 「正在执行」那块照旧：它是常驻的 #work，跟这里没关系。
     var tail = commandTail();
     if (tail) parts.push(commandBlock(tail));
+    // 子智能体刚完工的那条通知同理（判据见 noticeTail）。它出现在这里的时机很窄——
+    // 通知一到，父级通常会被唤醒作答，那条回答很快就会把它顶掉——但那一段空窗里
+    // 屏幕上什么都不变的话，用户会以为子智能体那边没消息。
+    var note = noticeTail();
+    if (note) parts.push(noticeBlock(note));
     if (live) parts.push(liveBlock(live));
     if (parts.length) {
       var stick = atBottom();
@@ -2150,6 +2982,61 @@
     return last;
   }
 
+  /**
+   * 一个会话 id 的「能区分人的那一段」。
+   *
+   * **不能直接取 id 的开头几位**：本机的会话 id 长这样 `session-80fd8f3c-…`，
+   * 开头八位永远是 `session-`，一排子智能体就会全叫同一个名字。导航栏那边踩过
+   * 同一个坑，page.test.mjs 里有一条守卫专门钉着它。所以先把 `session-` 这段
+   * 人人相同的前缀去掉，再取一段开头——留下的才是真能区分它们的字符。
+   */
+  function shortSessionId(id) {
+    var s = String(id || '');
+    if (s.slice(0, 8) === 'session-') s = s.slice(8);
+    if (!s) s = String(id || '');
+    return s.slice(0, 8);
+  }
+
+  /**
+   * 子智能体完工的那张卡片（聊天记录里的一种条目）。
+   *
+   * 它是**第三样东西**：不是用户说的话，也不是模型的回答，而是「这个会话派出去的
+   * 一件事有结果了」。所以既不套用户气泡、也不画成回答正文——套上气泡就变成
+   * 「我说过这句话」，混进正文又会被读成模型的话，两种都是假的。
+   *
+   * 展开/收起交给原生 `<details>`：不写一行脚本、不加一个关键帧，键盘和读屏也都认。
+   *
+   * 正文**原样贴出来**（`white-space: pre-wrap`，见 .sa-card .sa-body），不再解析：
+   * 这段话是 DSH 生成的——它先说清「谁、为什么结束」，再把子智能体最后的原话接上。
+   * 那是**转述**，不该由我们这边的渲染器再加工一遍。
+   */
+  function noticeBlock(m) {
+    var who = m.senderSessionId ? shortSessionId(m.senderSessionId) : '';
+    var when = m.timestamp ? timeLabel(m.timestamp) : '';
+    return '<details class="sa-card"><summary><b>子智能体完工</b>'
+      + (who ? '<span>' + escapeHtml(who) + '</span>' : '')
+      + (when ? '<span>' + escapeHtml(when) + '</span>' : '')
+      + '</summary><div class="sa-body">' + escapeHtml(m.text || '') + '</div></details>';
+  }
+
+  /**
+   * 单帧模式要跟着显示的那条通知：**历史里最后一条**，而且得真的是一条通知。
+   *
+   * 判据和 commandTail 完全一样，连那道时间判断都照抄，理由也一样：
+   *   - 用「最后一条」而不是「最近一条」：中间要是夹了别的消息（父级被唤醒后又答了
+   *     一句），那条通知已经不是最新的事了，再贴在最下面就成了过期通知；
+   *   - 单帧模式的回答走 SSE 的 reply 那条路，**不往 history 里塞**，所以 history
+   *     的尾巴会一直停在那条通知上——不挡一下，新回答到了之后底下还挂着它。
+   */
+  function noticeTail() {
+    var h = state.history || [];
+    var last = h.length ? h[h.length - 1] : null;
+    if (!last || last.role !== 'notice') return null;
+    var lt = (state.latest && state.latest.timestamp) || 0;
+    if (lt && last.timestamp && last.timestamp < lt) return null;
+    return last;
+  }
+
   /**
    * 该不该自动滚到底。
    *
@@ -2240,8 +3127,50 @@
     el.classList.toggle('hide', !chatNoteVisible());
   }
 
-  function renderChat() {
-    mainEl.classList.remove('center');
+  /**
+   * 一条消息的 HTML。从 renderChat 的逐条循环里提出来：完整模式要把每轮的过程组
+   * **穿插进这串消息的原位**（renderFull → trajInterleave），聊天模式直接按顺序拼——
+   * 两边画同一条消息必须是同一段代码，两处各写一遍迟早走样。
+   */
+  function chatMsgHtml(m) {
+    // 指令行：这是会话做的一个动作，不是谁说的话，单独一种长相——
+    // 不套气泡、不给复制按钮（见 commandBlock 的说明）。
+    if (m.role === 'command') return commandBlock(m);
+    // 子智能体完工的通知：同一类「会话做的事」，画成一张可展开的卡片
+    // （见 noticeBlock 的说明）。它没有复制按钮，也没有气泡。
+    if (m.role === 'notice') return noticeBlock(m);
+    // 被按停的那一轮：标一句，别让人以为模型答到一半断了。
+    var stopped = m.interrupted ? '<span class="stopped">已停止</span>' : '';
+    // 两种消息都给复制按钮。自己敲的指令也常有「再发一遍」「拿去别处用」的时候，
+    // 原来只给 AI 气泡，用户反馈自己的话复制不了。
+    var copyBtn = '<button class="copy" type="button" aria-label="复制" title="复制"'
+      + ' data-copy="' + escapeHtml(m.text) + '">' + ICON_COPY + '</button>';
+    if (m.role === 'user') {
+      // 自己的指令：仍然是气泡，靠右。自己敲的是纯文本，不走 markdown——
+      // 不然打几个星号就变样了。
+      return '<div class="bubble user">' + linkify(m.text)
+        + '<span class="meta">' + stopped + timeLabel(m.timestamp) + copyBtn + '</span></div>';
+    }
+    // AI 的回答：**不套气泡**（用户要求「参考单帧模式那样」）。
+    // 于是一左一右、一个有框一个没框，正好分得清谁说的。
+    return '<div class="said">'
+      + (stopped ? '<div class="reply-bar">' + stopped + '</div>' : '')
+      + '<div class="md">' + mdToHtml(m.text) + '</div>'
+      + '<div class="reply-foot">' + copyBtn
+      + '<span class="time">' + timeLabel(m.timestamp) + '</span></div></div>';
+  }
+
+  /**
+   * 聊天那一串的「料」：滤掉排队那条、按窗口裁好、逐条变行。
+   *
+   * 返回的是**结构**（行数组 + 对应消息 + 滤后全量），不是拼好的字符串——
+   * renderChat 直接按顺序拼；renderFull 拼之前要把每轮的过程组插进 rows 的
+   * 原位（见 trajInterleave），只有结构在手才插得动。
+   *
+   * searchTurns 是「搜索命中的轮号」（只在完整模式搜索时给）：命中轮的消息
+   * 哪怕在窗口外也要露出来（10.3-3，「命中组在原位强开」的原位得先在场）。
+   */
+  function buildChat(searchTurns) {
     // 换了会话就把窗口收回首屏：上一个会话铺到多少条都不该跟过来——那正是这次要修的慢。
     // 判据用会话 id 而不是 history 的引用：服务端每次推的都是整份新数组，比引用永远「变了」。
     if (chatWindowFor !== state.boundSessionId) {
@@ -2272,58 +3201,47 @@
       // 「正在读」和「确实没有」是两件事，分开说。点开一个插件没看过的会话时，
       // 服务端要去 DSH 的会话记录里读它那一段（最大的那条 20 MB、约半秒），
       // 这期间说「还没有对话记录」会让人以为这个会话本来就是空的。
-      replyEl.innerHTML = state.historyLoading
-        ? '<div class="placeholder">正在读取这个会话的记录…</div>'
-        : '<div class="placeholder">还没有对话记录。</div>';
-      return;
+      return {
+        empty: state.historyLoading
+          ? '<div class="placeholder">正在读取这个会话的记录…</div>'
+          : '<div class="placeholder">还没有对话记录。</div>',
+        moreNote: '', rows: [], list: [], all: [],
+      };
     }
     // **只铺最近那几十条**，剩下的留在手里等用户往上滑（来由见 CHAT_PAGE 那段）。
     // 切在**滤掉排队那条之后**：不然被滤掉的那条会白占一个名额。
     var older = Math.max(0, chatLoaded - chatWindow);
-    if (older) list = list.slice(older);
-    var html = list.map(function (m) {
-      // 指令行：这是会话做的一个动作，不是谁说的话，单独一种长相——
-      // 不套气泡、不给复制按钮（见 commandBlock 的说明）。
-      if (m.role === 'command') return commandBlock(m);
-      // 被按停的那一轮：标一句，别让人以为模型答到一半断了。
-      var stopped = m.interrupted ? '<span class="stopped">已停止</span>' : '';
-      // 两种消息都给复制按钮。自己敲的指令也常有「再发一遍」「拿去别处用」的时候，
-      // 原来只给 AI 气泡，用户反馈自己的话复制不了。
-      var copyBtn = '<button class="copy" type="button" aria-label="复制" title="复制"'
-        + ' data-copy="' + escapeHtml(m.text) + '">' + ICON_COPY + '</button>';
-      if (m.role === 'user') {
-        // 自己的指令：仍然是气泡，靠右。自己敲的是纯文本，不走 markdown——
-        // 不然打几个星号就变样了。
-        return '<div class="bubble user">' + linkify(m.text)
-          + '<span class="meta">' + stopped + timeLabel(m.timestamp) + copyBtn + '</span></div>';
+    // 搜索命中轮把窗口上沿抬到自己（10.3-3）：不然命中的过程组按「组跟消息走」
+    // 的规矩被裁在窗口外，搜得到、看不见。
+    if (searchTurns && searchTurns.length) {
+      for (var t = 0; t < list.length; t++) {
+        if (list[t] && searchTurns.indexOf(String(list[t].turn)) >= 0 && t < older) {
+          older = t;
+          break;
+        }
       }
-      // AI 的回答：**不套气泡**（用户要求「参考单帧模式那样」）。
-      // 于是一左一右、一个有框一个没框，正好分得清谁说的。
-      return '<div class="said">'
-        + (stopped ? '<div class="reply-bar">' + stopped + '</div>' : '')
-        + '<div class="md">' + mdToHtml(m.text) + '</div>'
-        + '<div class="reply-foot">' + copyBtn
-        + '<span class="time">' + timeLabel(m.timestamp) + '</span></div></div>';
-    }).join('');
+    }
+    var all = list;
+    if (older) list = list.slice(older);
     // 「上面还有，往上滑」要贴在**看得到的顶上**，而且**离顶远了就收起来**——
     // 两处讲究见 .more-note 的样式注释。露 / 收在这里先按当前位置定一次，
     // 之后由滚动里的 paintChatNote 接着跟。
     var moreNote = older
       ? '<div class="more-note' + (chatNoteVisible() ? '' : ' hide') + '">往上滑看更早的</div>'
       : '';
-    // 「这不是全部」要说在**内容前面**：用户往上翻到顶时，第一眼看到的就是它，
-    // 免得以为这个会话只有这么点内容。读历史有上限（见服务端 HISTORY_MAX_*）。
-    if (state.historyTruncated) {
-      html = '<div class="history-note">'
-        + escapeHtml(state.historyNote || '这个会话很大，只显示了最近一段。')
-        + '</div>' + html;
+    return { empty: null, moreNote: moreNote, rows: list.map(chatMsgHtml), list: list, all: all };
+  }
+
+  function renderChat() {
+    mainEl.classList.remove('center');
+    var built = buildChat();
+    if (built.empty) {
+      replyEl.innerHTML = built.empty;
+      return;
     }
-    // 「正在执行」不再追加一个气泡——它是常驻的 #work，排在整串消息下面。
-    // 两种模式共用同一块，改的时候两边都走一遍。
-    if (state.live) html += liveBlock(state.live);
     // 先问「在不在底部」，再改内容——顺序反了永远是「在」（见 atBottom 的注释）。
     var stick = atBottom();
-    replyEl.innerHTML = moreNote + html;
+    replyEl.innerHTML = chatFrame(built, built.rows.join(''), state.live ? liveBlock(state.live) : '');
     scrollChat(stick);
   }
 
@@ -2336,8 +3254,8 @@
    */
   function maybeGrowChat() {
     // 单帧模式那边也在往 main 上滚（回答落定要跳到页面顶端），别把那一下当成「他在往上翻」；
-    // 本地都放完了也没什么可放的。
-    if (state.mode !== 'chat' || chatLoaded <= 0) return;
+    // 本地都放完了也没什么可放的。完整模式画的也是这串聊天记录，翻页照旧要能放。
+    if (state.mode === 'minimal' || chatLoaded <= 0) return;
     if (chatWindow >= chatLoaded) return;
     if (mainEl.scrollTop > chatEdge()) {
       // 滑下来了，这一轮重新装填：**一次靠近只放一屏**。
@@ -2370,7 +3288,10 @@
   function growChat() {
     var fromBottom = mainEl.scrollHeight - mainEl.scrollTop;
     chatWindow += CHAT_PAGE;
-    renderChat();
+    // 完整模式要走 render() 总分发：直画 renderChat 会把后面那块轨迹区抹掉。
+    // （位置补偿和聊天同一套：轨迹区每次重画高度不变，底部那一截没动。）
+    if (state.mode === 'full') render();
+    else renderChat();
     mainEl.scrollTop = mainEl.scrollHeight - fromBottom;
   }
 
@@ -2440,52 +3361,618 @@
     if (stick && !liveNow) mainEl.scrollTop = mainEl.scrollHeight;
   }
 
-  function render() {
-    $('hintMode').textContent = state.mode === 'chat' ? '聊天：常规问答对话' : '单帧：只留最新一条回复';
-      if (state.mode === 'chat') renderChat(); else renderMinimal();
+  /**
+   * 三种模式各自的提示语。「完整」= 聊天那一串 **+ 每一轮的过程组**，所以三句话
+   * 必须跟着模式一起改——收在一处是防两处走样（渲染处和点击处各写一遍的旧写法，
+   * 加第三种模式时漏一处，用户看到的就是「点了完整、说明还写着聊天」）。
+   */
+  function modeHint() {
+    if (state.mode === 'chat') return '聊天：常规问答对话';
+    if (state.mode === 'full') return '完整：附加每一步过程';
+    return '单帧：只留最新一条回复';
   }
 
-  function applySnapshot(snap) {
-    if (!snap) return;
-    if ('latest' in snap) state.latest = snap.latest;
-    // 正在流出来的那一段。服务端只在自己决定要显示之后才写它，所以这里是空字符串
-    // 不代表模型没在写，只代表「还不到显示的时候」。
-    if ('live' in snap) state.live = snap.live || '';
-    // 模型此刻的自言自语（鲸鱼娘的台词）。null = 这会儿没话说，气泡回到该姿势自己的词条。
-    if ('thought' in snap) state.thought = snap.thought || null;
-    if (snap.history) state.history = snap.history;
-    // 「服务端正去读这个会话的完整记录」。点开一个没看过的会话时，那一串要读一会儿
-    // 才补上来（最大的那条日志 20 MB、约半秒），这期间不能装作「这个会话是空的」。
-    state.historyLoading = snap.historyLoading === true;
-    // 「这份历史只到最近一段」。服务端读历史有上限（会话太大只读日志尾部），
-    // 所以内容可能是截断的——**这件事必须跟着内容一起传上来**，不能只在服务端知道。
-    state.historyTruncated = snap.historyTruncated === true;
-    state.historyNote = snap.historyNote || '';
-    if (snap.sessions) state.sessions = snap.sessions;
-    if (Array.isArray(snap.queued)) state.queued = snap.queued;
-    if ('boundSessionId' in snap) {
-      var wasBound = state.boundSessionId;
-      state.boundSessionId = snap.boundSessionId;
-      // 换了会话，指令菜单那份缓存就作废了（指令表是每个会话一份的，这个会话没在跑
-      // 时一条都读不到，见「斜杠指令」那一段）。重画一次，它自己会发现数据不属于
-      // 这个会话、去重取——否则用户点到的是上一个会话的指令，点下去必然被拒。
-      if (state.boundSessionId !== wasBound) paintCmdMenu();
+  /**
+   * 「完整」的底座：聊天那一串**全部照画**（分批、往上滑补页、滚动对齐都照旧），
+   * 每一轮的过程组**穿插进它那轮对话的原位**——指令之后、回答之前（10.3-1，
+   * 对齐 DSH 聊天视图的 turn-process 位置，2026-10-03 用户裁决「一定要让执行
+   * 轨迹的逻辑符合DSH本身」）。三层折叠那套跟着组走，落点规则见 trajInterleave。
+   * 但**「正在读取」和「没有过程」必须分清**：loading=true 是服务端还在读会话记录，
+   * 不是这个会话没有过程。这期间什么都不说，人就会以为没有过程——所以那句注记
+   * 照旧垫在最前面。没轨迹且不在 loading 时一个过程组都不画（这时完整模式和聊天
+   * 长得一样，是预期）。
+   */
+  function renderFull() {
+    // 换了会话，用户手动拨过的折叠开关就作废——和聊天窗 chatWindowFor 同一个道理：
+    // 两场会话的轮号会撞在一起，留在手里的开关会去拨新会话的组。
+    if (trajFor !== state.boundSessionId) {
+      trajFor = state.boundSessionId;
+      trajGroupOpen = {};
+      trajEntryOpen = {};
     }
-    // running 也在快照里，而且算的是**当前绑定的那个会话**。不接的话，
-    // 在导航栏切到别的会话时，那个会话会继承上一个会话的「正在执行」。
-    if ('running' in snap) setRunning(snap.running);
-    paintNavCurrent();
-    render();
+    mainEl.classList.remove('center');
+    var built = buildChat();
+    var html;
+    if (built.empty) {
+      // 一条消息都没有（正在读/确实没有）：手里有过程组就兜底页尾（10.3-1 d）。
+      // 这一路不滚动，和 renderChat 的空态同口径。
+      html = built.empty + trajInterleave([], [], built.all).join('');
+    } else {
+      // 先问「在不在底部」，再改内容——顺序反了永远是「在」（见 atBottom 的注释）。
+      var stick = atBottom();
+      html = chatFrame(built, trajInterleave(built.rows, built.list, built.all).join(''),
+        state.live ? liveBlock(state.live) : '');
+      replyEl.innerHTML = state.trajectoryLoading
+        ? '<div class="history-note">正在读取这个会话的过程…</div>' + html
+        : html;
+      scrollChat(stick);
+      bindTraj();
+      return;
+    }
+    if (state.trajectoryLoading) {
+      html = '<div class="history-note">正在读取这个会话的过程…</div>' + html;
+    }
+    replyEl.innerHTML = html;
+    bindTraj();
   }
 
-  // ---------------- 左侧导航栏 ----------------
-  // 数据分两层取：先列工作区（便宜），展开某个再去要它的会话（要读日志折标题，贵）。
-  // 本机实测 35 个工作区、最多的一个有 452 个会话，一次全拉会卡住手机。
-  var navList = null;      // 工作区列表，开一次取一次
-  var navSessions = {};    // workspaceId -> { sessions, total, truncated }
-  var navExpanded = {};    // workspaceId -> 是否展开
+  /** 轨迹区的点击走一次容器委托就够（重绘都是全新 HTML，逐个绑必漏）。 */
+  function bindTraj() {
+    if (trajBound) return;
+    trajBound = true;
+    replyEl.addEventListener('click', onTrajectoryClick);
+  }
 
-  function openNav() {
+  /**
+   * 聊天那串的外框：截断说明排内容前面、流式那段接在最后、moreNote 贴顶。
+   * 聊天与完整两个模式共用这一段——两处各写一遍的旧写法走样过（见 modeHint 的说明）。
+   * liveHtml 由调用方给（完整模式的切片里没有 liveBlock，传空串就是「没有流式」）。
+   *
+   * 定义在 renderFull 之后是**测试切片的约束**：trajHarness 切的是
+   * renderFull → applySnapshot，外框函数得在切片里才调得到；页面里函数提升，
+   * 位置不影响 renderChat 调它。
+   */
+  function chatFrame(built, body, liveHtml) {
+    var html = body;
+    // 「这不是全部」要说在**内容前面**：用户往上翻到顶时，第一眼看到的就是它，
+    // 免得以为这个会话只有这么点内容。读历史有上限（见服务端 HISTORY_MAX_*）。
+    if (state.historyTruncated) {
+      html = '<div class="history-note">'
+        + escapeHtml(state.historyNote || '这个会话很大，只显示了最近一段。')
+        + '</div>' + html;
+    }
+    // 「正在执行」不再追加一个气泡——它是常驻的 #work，排在整串消息下面。
+    // 流式那段（live）接在所有行（含穿插的过程组）之后：过程在回答之前，
+    // 正在流的半句就是「回答」那个位置（10.3-1）。
+    if (liveHtml) html += liveHtml;
+    return built.moreNote + html;
+  }
+
+  // ---------------- 轨迹的折叠与长相（完整模式，对齐 PC） ----------------
+  // 数据是上一棒收进 state.trajectory 的轮次组：组 {turn, state, entries[]}，
+  // 条目 {kind:'think'|'tool', name, args, summary, output, state, …}，字段语义
+  // 见 lib/trajectory.js 头上的说明（思考正文和工具结果都放 output）。
+  // 长相对齐 DSH 桌面端的 turn-process（tasks/todo.md 11）：组头一行 = 图标 +
+  // 状态词/标题（跑着是「正在…」活动词，收官是「已读取文件并调用工具」这类组合标题），
+  // 条目一行 = 图标 + 「工具显示名 · 参数摘要」（思考行是「思考 · 首行」），
+  // 点开才见正文（工具给「参数+结果」、思考给想的内容）。
+  // 折叠口径不变：组级把「已结束的多条组」收成一行（running 还在长、error 要给人看、
+  // 单条收了没信息量，这三种默认摊开）；条目级默认收。
+  // 用户拨过的开关存在下面两个对象里（组按轮号、条目按 id），只在本会话内有效，
+  // 换会话时在 renderFull 里清掉。
+  var trajFor = null;        // 上次渲染时的会话 id（变了就清开关）
+  var trajGroupOpen = {};    // 组级手动覆写：{ 轮号字符串: true|false }
+  var trajEntryOpen = {};    // 条目级手动覆写：{ 条目 id: true|false }
+  var trajBound = false;     // replyEl 上的委托绑过没有
+
+  /**
+   * 组默认摊不摊。收的条件是**两条一起成立**：条目够多（≥2）、已经跑完
+   * （running 还在长，收了就看不见新条目；error 出错的组自己摊到条目级给人看，
+   * 不用点）。用户手动拨过的开关优先于默认值。
+   */
+  function trajGroupIsOpen(g) {
+    var key = String(g.turn);
+    if (Object.prototype.hasOwnProperty.call(trajGroupOpen, key)) return trajGroupOpen[key];
+    if (!g.entries || g.entries.length < 2) return true;
+    if (g.state === 'running' || g.state === 'error') return true;
+    return false;
+  }
+  /** 一条摊不摊：用户开关优先；没有开关时默认收（点开才见正文）。 */
+  function trajEntryIsOpen(e) {
+    if (Object.prototype.hasOwnProperty.call(trajEntryOpen, e.id)) return trajEntryOpen[e.id];
+    return false;
+  }
+
+  /**
+   * 组头的开关。key 是 data 属性上的字符串（getAttribute 回来一定是字符串，
+   * 轮号是数字，两边统一按 String 比——有一边不转换就会拨空）。
+   * 拨完立刻重画：开关唯一可见的效果就是下一次渲染，不重画等于点了没反应。
+   */
+  function toggleTrajGroup(turnKey) {
+    var groups = state.trajectory || [];
+    for (var i = 0; i < groups.length; i++) {
+      if (String(groups[i].turn) !== String(turnKey)) continue;
+      trajGroupOpen[turnKey] = !trajGroupIsOpen(groups[i]);
+      break;
+    }
+    render();
+  }
+  // 点的当下算开还是收，要按「含搜索强制摊开」的实况来（不然搜索摊开的条目点了
+  // 收不回去）：先按 id 找到那条再取反；找不到时按手里原有的开关算，和原来一致。
+  function toggleTrajEntry(id) {
+    var open = trajEntryOpen[id] === true;
+    var groups = state.trajectory || [];
+    for (var i = 0; i < groups.length; i++) {
+      var es = groups[i].entries || [];
+      for (var j = 0; j < es.length; j++) {
+        if (String(es[j].id) === String(id)) open = trajEntryIsOpen(es[j]);
+      }
+    }
+    trajEntryOpen[id] = !open;
+    render();
+  }
+
+  /**
+   * 失败首行。reason 的第一行；reason 取不到就用错误名/错误码，都没有就如实说
+   * 「失败」——**不编原因**（和 lib/trajectory.js readError 同一条口径）。
+   */
+  function trajErrLine(e) {
+    if (!e || !e.error) return '';
+    var r = typeof e.error.reason === 'string' ? e.error.reason : '';
+    if (!r && typeof e.error.name === 'string' && e.error.name) r = e.error.name;
+    if (!r && typeof e.error.code === 'string' && e.error.code) r = e.error.code;
+    if (!r) return '失败';
+    return r.split('\n')[0];
+  }
+  /** 组头上的失败首行：组里第一条带失败身份的条目的那一行。 */
+  function trajGroupErrLine(g) {
+    if (!g.entries) return '';
+    for (var i = 0; i < g.entries.length; i++) {
+      var line = trajErrLine(g.entries[i]);
+      if (line) return line;
+    }
+    return '';
+  }
+
+  /**
+   * 截断标注。N 是**原始总字符数**（truncated 里的 chars 才是留下的那段），措辞照
+   * lib/trajectory.js clipForTrajectory 的原句。服务端在正文尾部写了同一句就不再
+   * 重复；没写（truncated 字段在、句子不在）就地补上——绝不静默砍尾。
+   */
+  function trajTruncNote(t, text) {
+    if (!t || typeof t.total !== 'number') return '';
+    if (String(text).indexOf('已截断') >= 0) return '';
+    return '\n… 已截断，共 ' + t.total + ' 字符';
+  }
+
+  /**
+   * 一条的正文（照 PC 的展开卡）：
+   *   思考 = 普通 Markdown 段落（PC 的 compact 变体：13px/20px、三级灰、左缩进 22px，
+   *          **不是等宽**——它是想的东西，不是机器吐的字节）；
+   *   工具 = 「输入 / 输出」两栏卡（标签小字灰、正文等宽、细线分隔）——输入是美化后
+   *          的 JSON（两空格，解析不了就原样），输出是结果文本，出错整段红色。
+   * 自动审查被拒（照 PC）：参数不显示，只说清楚为什么没跑。
+   * 截断标注照旧如实跟在后面。
+   */
+  function trajEntryBody(e) {
+    var tr = e.truncated || {};
+    if (e.kind === 'think') {
+      if (!e.output) return '';
+      return '<div class="traj-think">' + mdToHtml(e.output) + trajTruncLine(tr.think, e.output) + '</div>';
+    }
+    if (e.error && e.error.name === 'AutoReviewDeniedError' && e.error.code === 'AUTO_REVIEW_DENIED') {
+      var reason = typeof e.error.reason === 'string' && e.error.reason
+        ? e.error.reason : 'Auto review 未授权此次操作';
+      return '<div class="traj-io"><div class="traj-io-row"><div class="traj-io-label">输出</div>'
+        + '<div class="traj-io-body traj-io-err"><pre>工具未执行。原因：'
+        + escapeHtml(reason) + '</pre></div></div></div>';
+    }
+    var rows = '';
+    if (e.args) {
+      rows += '<div class="traj-io-row"><div class="traj-io-label">输入</div>'
+        + '<div class="traj-io-body"><pre>' + escapeHtml(trajPretty(e.args)) + '</pre>'
+        + trajTruncLine(tr.args, e.args) + '</div></div>';
+    }
+    var outText = e.output;
+    if (!outText && e.error) {
+      // 照 PC 的 resultText 兜底：空内容且失败时，给一行「名字: 码」，不装作没有结果。
+      outText = (e.error.name || 'Error') + (e.error.code ? ': ' + e.error.code : '');
+    }
+    if (outText) {
+      rows += '<div class="traj-io-row"><div class="traj-io-label">输出</div>'
+        + '<div class="traj-io-body' + (e.error ? ' traj-io-err' : '') + '"><pre>'
+        + escapeHtml(outText) + '</pre>' + trajTruncLine(tr.output, e.output || '') + '</div></div>';
+    }
+    if (!rows) return '';
+    return '<div class="traj-io">' + rows + '</div>';
+  }
+
+  /** 截断标注（如实）：单起一行小字。 */
+  function trajTruncLine(t, text) {
+    var note = trajTruncNote(t, text);
+    return note ? '<div class="traj-io-note">' + escapeHtml(note.trim()) + '</div>' : '';
+  }
+
+  /** 参数按 PC 的 formatToolBody：能解析就美化 JSON（两空格），解析不了就原样。 */
+  function trajPretty(raw) {
+    try {
+      return JSON.stringify(JSON.parse(raw), null, 2);
+    } catch (err) {
+      return String(raw);
+    }
+  }
+
+  // —— PC 同款词典（照抄 DSH 桌面端 0.2.0-rc.1，一个字不自创）——
+  // 动作分类：dsh-client-ui-chat 的 activity()（工具名 → 动作）。
+  function trajActivity(name) {
+    var n = String(name || '');
+    if (n === 'read') return 'read';
+    if (n === 'read_image') return 'readImage';
+    if (n === 'grep' || n === 'glob' || /_inspect$/.test(n)) return 'search';
+    if (n === 'write') return 'write';
+    if (n === 'edit' || n === 'apply_patch') return 'edit';
+    if (n === 'bash' || n === 'pwsh' || n === 'exec_command' || n === 'write_stdin'
+      || /^terminal_/.test(n)) return 'commands';
+    if (n === 'run_code') return 'code';
+    if (n === 'web_search') return 'webSearch';
+    if (n === 'web_fetch') return 'webFetch';
+    if (n === 'subagent' || /^subagent_/.test(n)) return 'subagents';
+    if (n === 'todo_write' || n === 'create_goal' || n === 'update_goal' || n === 'get_goal') {
+      return 'plan';
+    }
+    if (n === 'ask_user_question' || n === 'request_user_input') return 'questions';
+    return 'tools';
+  }
+  // 动作 → 完成词 / 活动词（dsh-client-ui-chat 的 message.stepProcess.done.* 与 .* 本体）。
+  var TRAJ_DONE = {
+    thinking: '已完成分析', read: '已读取文件', readImage: '已读取图片', write: '已写入文件',
+    search: '已搜索代码', edit: '修改了文件', commands: '执行了命令', code: '运行了代码',
+    webSearch: '已搜索网页', webFetch: '已访问网页', subagents: '已协调子智能体',
+    plan: '更新了计划', questions: '向用户提出了问题', tools: '已调用工具',
+  };
+  var TRAJ_LIVE = {
+    thinking: '正在分析请求', read: '正在读取文件', readImage: '正在读取图片', write: '正在写入文件',
+    search: '正在搜索代码', edit: '正在编辑文件', commands: '正在运行命令', code: '正在运行代码',
+    webSearch: '正在搜索网页', webFetch: '正在访问网页', subagents: '正在协调子智能体',
+    plan: '正在更新计划', questions: '等待你的操作', tools: '正在调用工具',
+  };
+  // 工具显示名（dsh-client-ui-tool 的 tool.title.*）。认不出名字的走变体标题，
+  // 变体也没有就落「工具调用」——和 PC 的 generic 同一口径。
+  var TRAJ_TOOL_TITLE = {
+    read: '读取', read_image: '读取图片', write: '写入', edit: '编辑', apply_patch: '编辑',
+    bash: '运行命令', pwsh: '运行命令', exec_command: '运行命令', write_stdin: '运行命令',
+    grep: '搜索文件内容', glob: '查找文件', run_code: '运行代码',
+    web_search: '网页搜索', web_fetch: '网页获取',
+    todo_write: '更新任务清单', ask_user_question: '提问', request_user_input: '提问',
+    create_goal: '创建目标', get_goal: '查看目标', update_goal: '更新目标',
+    subagent: '创建子智能体', list_agents: '查看子智能体', send_message: '发送消息',
+    interrupt_agent: '中断智能体', wait_agent: '等待子智能体', spawn_teammate: '创建队友',
+  };
+  var TRAJ_VARIANT_TITLE = {
+    read: '读取', readImage: '读取', webFetch: '读取', search: '搜索',
+    write: '写入', edit: '编辑', commands: '运行命令', code: '代码',
+    thinking: '工具调用', tools: '工具调用',
+  };
+  function trajToolTitle(name) {
+    var n = String(name || '');
+    if (TRAJ_TOOL_TITLE[n]) return TRAJ_TOOL_TITLE[n];
+    return TRAJ_VARIANT_TITLE[trajActivity(n)] || '工具调用';
+  }
+  // 图标：手写细线 SVG（1.5px 描边、currentColor），和全页图标同一种画法；
+  // 画的是 PC 那套图标的角色（思考/读/搜/改/命令/代码/网页/子代理/计划/提问/工具）。
+  var TRAJ_ICO = {
+    thinking: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><circle cx="12" cy="9" r="5"/><path d="M9.5 18h5M10.5 21h3"/></svg>',
+    read: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><path d="M6 3h8l4 4v14H6z"/><path d="M14 3v4h4M9 12h6M9 16h6"/></svg>',
+    search: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><circle cx="11" cy="11" r="6"/><path d="M15.5 15.5L21 21"/></svg>',
+    edit: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><path d="M4 20l1-4L16 5l3 3L8 19z"/><path d="M14 7l3 3"/></svg>',
+    commands: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><path d="M5 7l5 5-5 5"/><path d="M12 17h7"/></svg>',
+    code: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><path d="M9 8l-5 4 5 4"/><path d="M15 8l5 4-5 4"/></svg>',
+    webSearch: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><circle cx="12" cy="12" r="8"/><path d="M4 12h16"/><path d="M12 4c3 3 3 13 0 16c-3-3-3-13 0-16z"/></svg>',
+    subagents: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><circle cx="12" cy="8" r="3"/><path d="M5 20a7 7 0 0 1 14 0"/></svg>',
+    plan: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><path d="M4 7l2 2 3-3M4 17l2 2 3-3"/><path d="M12 8h8M12 18h8"/></svg>',
+    questions: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><circle cx="12" cy="12" r="8"/><path d="M9.5 9.5a2.5 2.5 0 1 1 3.5 2.3c-.7.4-1 .8-1 1.7"/><path d="M12 16.5h.01"/></svg>',
+    tools: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><path d="M12 4l1.5 4.5L18 10l-4.5 1.5L12 16l-1.5-4.5L6 10l4.5-1.5z"/></svg>',
+  };
+  function trajIco(kind) {
+    return TRAJ_ICO[kind] || TRAJ_ICO.tools;
+  }
+  /** 折叠处给思考行的那一句：正文首行，压成一行、限 160 字（DSH 的行内摘要同款口径）。
+      星号去掉（PC 同款：摘录是给人扫的，星号只会碍眼——5854）。 */
+  function trajFirstLine(text) {
+    var s = String(text == null ? '' : text).split('\n')[0].replace(/\s+/g, ' ').trim();
+    s = s.replace(/\*\*/g, '');
+    return s.length > 160 ? s.slice(0, 159) + '…' : s;
+  }
+
+  /**
+   * 扫光的起点接「全局时钟」：页面每次整块重画都会把动画打回开头，每次都从头扫
+   * 就成了频闪。带上当前时间在 1.5 秒周期里的位置（负 delay），重画之后接着
+   * 上次的相位走，肉眼看不出断口。
+   */
+  function trajShimStyle() {
+    return ' style="animation-delay:-' + ((Date.now() % 1500) / 1000).toFixed(3) + 's"';
+  }
+  /**
+   * 收官标题：照抄 DSH 的 processTitle——工具条目按动作分类计数（多的在前，一样多按
+   * 出现先后），取前三类拼完成词；两类共享「已」字时第二个去「已」用「并」连，
+   * 三类用「，」连，超过三类加「等」；一条工具都没有（纯思考）落「已完成分析」。
+   */
+  function trajTitleOf(g) {
+    var order = [];
+    var count = {};
+    var es = g.entries || [];
+    for (var i = 0; i < es.length; i++) {
+      if (!es[i] || es[i].kind !== 'tool') continue;
+      var k = trajActivity(es[i].name || '');
+      if (count[k] === undefined) { count[k] = 0; order.push(k); }
+      count[k] += 1;
+    }
+    order.sort(function (a, b) { return count[b] - count[a]; });
+    var labels = order.slice(0, 3).map(function (k) { return TRAJ_DONE[k]; });
+    var first = labels[0];
+    if (first === undefined) return { kind: 'thinking', text: TRAJ_DONE.thinking };
+    if (labels[1] === undefined) return { kind: order[0], text: first };
+    if (labels.length === 2) {
+      var second = labels[1];
+      if (first.indexOf('已') === 0 && second.indexOf('已') === 0) second = second.slice(1);
+      return { kind: order[0], text: first + '并' + second };
+    }
+    return {
+      kind: order[0],
+      text: first + '，' + labels.slice(1).join('，') + (order.length > 3 ? '等' : ''),
+    };
+  }
+  /** 组头的图标与标题：跑着是活动词（正在…），收官是组合标题。 */
+  function trajGroupTitle(g) {
+    if (g.state === 'running') {
+      var es = g.entries || [];
+      var last = null;
+      for (var i = es.length - 1; i >= 0; i--) {
+        if (es[i] && es[i].state === 'running') { last = es[i]; break; }
+      }
+      // 还没有工具步在跑（正在想）就落「正在分析请求」——和 PC 的兜底同一个词。
+      var kind = last && last.kind === 'tool' ? trajActivity(last.name || '') : 'thinking';
+      // 活片段优先（正在想的那一句，随打字刷新，PC 的 label · detail 同款）；
+      // 没有片段才退到条目自己的摘要。
+      var detail = state.trajectoryLive
+        || (last ? (last.kind === 'think' ? trajFirstLine(last.output) : (last.summary || '')) : '');
+      return { kind: kind, live: true, text: TRAJ_LIVE[kind] + (detail ? ' · ' + detail : '') };
+    }
+    return trajTitleOf(g);
+  }
+
+  /**
+   * 旁白那一段（对用户说的话，别的模式由鲸鱼娘气泡念，2026-10-04 起完整模式塞回轨迹）：
+   * 照 PC 是过程里的一段正文——不带图标、不可点开，说完就摆在这儿。
+   * 正文走 markdown 渲染（和回答区一个待遇：粗体、行内代码、列表都认），
+   * 不是原样贴星号（同日用户顺手报的）。
+   */
+  function trajSayHtml(e) {
+    var tr = e.truncated || {};
+    return '<div class="traj-say">'
+      + mdToHtml((e.output || '') + trajTruncNote(tr.output, e.output || '')) + '</div>';
+  }
+
+  /** 一行一条（PC 的成员行）：图标 +「显示名 · 摘要」，失败/进行中顶在这一行上。 */
+  function trajEntryHtml(e) {
+    if (e.kind === 'say') return trajSayHtml(e);
+    var think = e.kind === 'think';
+    var kind = think ? 'thinking' : trajActivity(e.name || '');
+    var label = think ? '思考' : trajToolTitle(e.name || '');
+    // 自动审查拒绝（照 PC）：行上摘要直接换成「Auto review 已拒绝」，别的都不重要了。
+    var denial = e.error && e.error.name === 'AutoReviewDeniedError'
+      && e.error.code === 'AUTO_REVIEW_DENIED';
+    // 思考行展开后行上只留「思考」（照 PC：摘录是折叠态的预览，展开了就退场）；
+    // 工具行不一样——展开后标题·摘要照旧留着（PC 的 keepContentWhenOpen）。
+    var open = trajEntryIsOpen(e);
+    var detail = denial ? 'Auto review 已拒绝'
+      : think ? (open ? '' : trajFirstLine(e.output)) : (e.summary || '');
+    // 跑着的行整行扫光（2026-10-04 用户点名：「某一行正在运行时会有一个渐变的效果
+    // 闪过去」）。不跑的行一个字节不变——类名后缀为空时拼出来就是原样。
+    var shim = e.state === 'running';
+    var shimCls = shim ? ' traj-shimmer' : '';
+    var shimSty = shim ? trajShimStyle() : '';
+    // 内容段与状态段**分开**：内容段一行截断（照 PC 的折叠行——折叠行是给人扫的），
+    // 出错/进行中的字样是独立的一段，不许被省略号吃掉（2026-10-04 真机返修）。
+    var body = '<span class="traj-detail' + shimCls + '"' + shimSty
+      + '>' + (detail ? ' · ' + escapeHtml(detail) : '') + '</span>';
+    var chips = '';
+    if (e.error) chips = ' · <span class="traj-err">' + escapeHtml(trajErrLine(e)) + '</span>';
+    else if (e.state === 'running') chips = ' · <span class="traj-run">进行中</span>';
+    var row = '<button type="button" class="traj-row" data-traj-entry="'
+      + escapeHtml(e.id) + '"><span class="traj-ico">' + trajIco(kind) + '</span>'
+      + '<span class="traj-name' + shimCls + '"' + shimSty + '>' + escapeHtml(label) + '</span>'
+      + body + chips + '</button>';
+    return '<div class="traj-entry">' + row
+      + (trajEntryIsOpen(e) ? trajEntryBody(e) : '') + '</div>';
+  }
+
+  /** 一个轮次组：PC 的组头一行（图标 + 状态词/标题），摊开时下面挂条目。 */
+  function trajGroupHtml(g) {
+    var open = trajGroupIsOpen(g);
+    var t = trajGroupTitle(g);
+    var title = t.live
+      ? '<span class="traj-run traj-shimmer"' + trajShimStyle() + '>' + escapeHtml(t.text) + '</span>'
+      : '<span class="traj-title">' + escapeHtml(t.text) + '</span>';
+    // 组头只显示状态词/标题，失败信息在下方条目行里显示，不重复。
+    var head = '<button type="button" class="traj-head" data-traj-group="'
+      + escapeHtml(String(g.turn)) + '"><span class="traj-ico">' + trajIco(t.kind) + '</span>'
+      + '<span class="traj-chev">' + (open ? '▾' : '▸') + '</span>'
+      + title + '</button>';
+    var entries = open && g.entries.length
+      ? '<div class="traj-entries">' + g.entries.map(trajEntryHtml).join('') + '</div>'
+      : '';
+    return '<div class="traj-group">' + head + entries + '</div>';
+  }
+
+  /**
+   * 把每轮的过程组插回它那轮对话的原位（10.3-1，对齐 DSH 的 turn-process 位置）。
+   * 落点四条：
+   *   a 该轮**第一个回答之前**——「指令 → 过程 → 回答」；
+   *   b 该轮没有回答（跑着/失败）落该轮**簇尾**（活轮即页尾，新步骤从这里冒出来）；
+   *   c 该轮有消息但都不在窗口里 → **不画**（组跟消息走，翻页上来自然带进来）；
+   *   d 该轮一条消息都没有（排队被滤掉、本地回显没号）→ 兜底**页尾**。
+   * rows[i] 与 list[i] 一一对应（list＝裁好窗的消息，all＝滤掉排队后的全量）。
+   * 返回插好之后的新数组，不动入参。
+   */
+
+  function trajInterleave(rows, list, all) {
+    var groups = (state.trajectory || []).filter(function (g) {
+      // 空组也可能是「正在想」的那一轮：turn/start 刚到、条目要等这一步说完才落
+      // （DSH 的事件就是这么给的）。它就是进展本身，不许因为还没条目就整组不画——
+      // 真机上那正是「跑的时候一片安静、跑完一次性全冒出来」的观感
+      // （2026-10-04 用户报的）。跑完还是空的才不画：那一组确实没有过程。
+      return g && Array.isArray(g.entries) && (g.entries.length > 0 || g.state === 'running');
+    });
+    // 服务端那句「这不是全部」跟着轨迹内容走（11.1-C）：排在第一个过程组前面；
+    // 一个过程组都没有（含轨迹读不到那条路）就兜底页尾——话必须说，位置不抢戏。
+    var noteHtml = trajNoticeHtml();
+    if (!groups.length) return rows.slice().concat(noteHtml ? [noteHtml] : []);
+    var slots = [];
+    for (var i = 0; i < groups.length; i++) {
+      var g = groups[i];
+      var at = -1;
+      // a：该轮第一个回答之前
+      for (var j = 0; j < list.length && at < 0; j++) {
+        if (list[j] && list[j].role === 'assistant' && sameTurn(list[j].turn, g.turn)) at = j;
+      }
+      // b：没有回答就落簇尾
+      if (at < 0) {
+        for (var k = list.length - 1; k >= 0; k--) {
+          if (list[k] && sameTurn(list[k].turn, g.turn)) { at = k + 1; break; }
+        }
+      }
+      if (at < 0) {
+        // c/d：窗口里没有这一轮的消息——全量里有＝出窗不画；没有＝兜底页尾。
+        var anywhere = false;
+        for (var n = 0; n < (all || []).length; n++) {
+          if (all[n] && sameTurn(all[n].turn, g.turn)) { anywhere = true; break; }
+        }
+        if (anywhere) continue;
+        at = list.length;
+      }
+      slots.push({ at: at, turn: g.turn, html: trajGroupHtml(g) });
+    }
+    // 同一落点上的组按轮号排（兜底页尾时可能好几组），插的时候按落点从前往后放。
+    slots.sort(function (x, y) { return x.at - y.at || x.turn - y.turn; });
+    var out = [];
+    var s = 0;
+    var noted = false;
+    for (var p = 0; p <= rows.length; p++) {
+      while (s < slots.length && slots[s].at === p) {
+        if (noteHtml && !noted) { out.push(noteHtml); noted = true; }
+        out.push(slots[s++].html);
+      }
+      if (p < rows.length) out.push(rows[p]);
+    }
+    if (noteHtml && !noted) out.push(noteHtml);
+    return out;
+  }
+  /** 轮号对得上吗：两边都要有号，再比字符串（号来自消息字段/组字段，类型不总一致）。 */
+  function sameTurn(a, b) {
+    return a != null && b != null && String(a) === String(b);
+  }
+
+  /**
+   * 服务端「这份轨迹不是全部」的说明（state.trajectoryNote / trajectoryTruncated）。
+   * 给了原句就原样显示；只有截断标志没给句子时补一句大实话兜底。**存在才显示**——
+   * 一个字都没有时不许占地方，完整模式的观感必须和聊天一致。轨迹空了但服务端留了
+   * 话（读取失败那条路）也要说：「读不到」不等于「没有过程」。
+   */
+  function trajNoticeHtml() {
+    if (state.trajectoryNote) {
+      return '<div class="traj-note">' + escapeHtml(state.trajectoryNote) + '</div>';
+    }
+    if (state.trajectoryTruncated) return '<div class="traj-note">这份轨迹不是全部。</div>';
+    return '';
+  }
+
+  // 轨迹区的点击全走这一根委托。先认条目再认组头——行和头各带各的 data 属性，
+  // 认错一个就拨错层。
+  function onTrajectoryClick(e) {
+    var t = e.target && e.target.closest ? e.target : null;
+    if (!t) return;
+    var row = t.closest('[data-traj-entry]');
+    if (row) { toggleTrajEntry(row.getAttribute('data-traj-entry')); return; }
+    var head = t.closest('[data-traj-group]');
+    if (head) toggleTrajGroup(head.getAttribute('data-traj-group'));
+  }
+
+  function render() {
+    $('hintMode').textContent = modeHint();
+      if (state.mode === 'full') renderFull(); else if (state.mode === 'chat') renderChat(); else renderMinimal();
+    // 「完整」模式不放装饰（11.1-B）：给常驻的 #work 挂 bare，立绘、气泡、光流
+    // 进度条由 CSS 藏掉，只留「已 N 秒 / 停止」。#work 不跟着 #reply 重画，
+    // 所以这一下挂在总分发这里，切模式时各归各位。
+    $('work').className = 'work' + (state.mode === 'full' ? ' bare' : '');
+  }
+
+  function applySnapshot(snap) {
+    if (!snap) return;
+    if ('latest' in snap) state.latest = snap.latest;
+    // 正在流出来的那一段。服务端只在自己决定要显示之后才写它，所以这里是空字符串
+    // 不代表模型没在写，只代表「还不到显示的时候」。
+    if ('live' in snap) state.live = snap.live || '';
+    // 模型此刻的自言自语（鲸鱼娘的台词）。null = 这会儿没话说，气泡回到该姿势自己的词条。
+    if ('thought' in snap) state.thought = snap.thought || null;
+    if (snap.history) state.history = snap.history;
+    // 「服务端正去读这个会话的完整记录」。点开一个没看过的会话时，那一串要读一会儿
+    // 才补上来（最大的那条日志 20 MB、约半秒），这期间不能装作「这个会话是空的」。
+    state.historyLoading = snap.historyLoading === true;
+    // 「这份历史只到最近一段」。服务端读历史有上限（会话太大只读日志尾部），
+    // 所以内容可能是截断的——**这件事必须跟着内容一起传上来**，不能只在服务端知道。
+    state.historyTruncated = snap.historyTruncated === true;
+    state.historyNote = snap.historyNote || '';
+    if (snap.sessions) state.sessions = snap.sessions;
+    if (Array.isArray(snap.queued)) state.queued = snap.queued;
+    if ('boundSessionId' in snap) {
+      var wasBound = state.boundSessionId;
+      state.boundSessionId = snap.boundSessionId;
+      if (state.boundSessionId !== wasBound) {
+        saCache = null;
+        saCacheSession = null;
+        saCacheAt = 0;
+      }
+      // 手里那份轨迹属于上一个会话——换会话立刻作废：两场会话的轮号会撞在一起，
+      // 不清掉就会把新会话的过程贴到旧会话那一组上。完整模式下再拉一份新的。
+      if (state.boundSessionId !== wasBound) {
+        state.trajectory = [];
+        state.trajectorySeq = 0;
+        if (state.mode === 'full') requestTrajectory();
+      }
+      // 换了会话，指令菜单那份缓存就作废了（指令表是每个会话一份的，这个会话没在跑
+      // 时一条都读不到，见「斜杠指令」那一段）。重画一次，它自己会发现数据不属于
+      // 这个会话、去重取——否则用户点到的是上一个会话的指令，点下去必然被拒。
+      if (state.boundSessionId !== wasBound) paintCmdMenu();
+      // 权限档位也是每个会话各一份的（宿主的 currentValue 读的是这个会话那份投影）。
+      // 不重读的话，抽屉里显示的是上一个会话那一档——用户看到的就是一句假话。
+      if (state.boundSessionId !== wasBound) loadPermissions(state.boundSessionId);
+    }
+    // running 也在快照里，而且算的是**当前绑定的那个会话**。不接的话，
+    // 在导航栏切到别的会话时，那个会话会继承上一个会话的「正在执行」。
+    if ('running' in snap) setRunning(snap.running);
+    if ('subagentsRunning' in snap) {
+      state.subagentsRunning = snap.subagentsRunning === true;
+      $('btnSubagents').classList.toggle('subagent-running', state.subagentsRunning);
+      $('btnSubagents').setAttribute('aria-label', state.subagentsRunning ? '子智能体（运行中）' : '子智能体');
+    }
+    paintNavCurrent();
+    render();
+  }
+
+  // ---------------- 左侧导航栏 ----------------
+  // 数据分两层取：先列工作区（便宜），展开某个再去要它的会话（要读日志折标题，贵）。
+  // 本机实测 35 个工作区、最多的一个有 452 个会话，一次全拉会卡住手机。
+  var navList = null;      // 工作区列表，开一次取一次
+  var navSessions = {};    // workspaceId -> { sessions, total, truncated }
+  var navFollowTimers = {}; // workspaceId -> 当前标题补齐轮询定时器
+  var navExpanded = {};    // workspaceId -> 是否展开
+  var navWsFetching = {};  // workspaceId -> 会话列表请求在途（同一工作区只发一趟）
+  var navPresets = null;   // Agent 模式清单（2026-10-04：新建会话时手机上也要能选模式）
+  var navPresetsLoaded = false;
+  var navPickerWs = '';    // 正在挑模式的那个工作区（清单行内展开在它的「新建会话」下）
+
+  function openNav() {
     $('nav').classList.add('open');
     loadWorkspaces(false);
   }
@@ -2493,6 +3980,17 @@
 
   function loadWorkspaces(force) {
     if (navList && !force) { renderNav(); return; }
+    if (!force && navPrefetchPromise) {
+      $('navBody').innerHTML = '<div class="placeholder">正在读取…</div>';
+      navPrefetchPromise.then(function () {
+        if ($('nav').classList.contains('open')) renderNav();
+      }).catch(function (err) {
+        navList = null;
+        $('navBody').innerHTML = '<div class="placeholder">读不到会话列表：'
+          + escapeHtml(err.message) + '</div>';
+      });
+      return;
+    }
     $('navBody').innerHTML = '<div class="placeholder">正在读取…</div>';
     // 带 refresh=1 是给 ⟳ 用的：绕过服务端的短时缓存，真去读一遍。
     // 不带的话服务端会把最近一次的结果直接给你，导航栏就不再「每次都要重新读取」。
@@ -2507,6 +4005,46 @@
     });
   }
 
+  // 导航栏不是首屏内容，但用户通常会在连上手机后很快点左上角。
+  // 趁页面空闲先取一次；真正打开菜单时若已完成就直接画，不再把等待放在点击之后。
+  var navPrefetchPromise = null;
+  function prefetchWorkspaces() {
+    // Agent 模式清单也是导航栏要用的、也几乎不变——顺手一起预取（见 prefetchPresets）。
+    prefetchPresets();
+    if (navList || navPrefetchPromise || navView !== 'tree' || !state.token) return;
+    var run = function () {
+      navPrefetchPromise = api('/mini/api/workspaces').then(function (body) {
+        navList = body.workspaces || [];
+        navSessions = {};
+        if ($('nav').classList.contains('open')) renderNav();
+      }).finally(function () { navPrefetchPromise = null; });
+      navPrefetchPromise.catch(function () {
+        // 预取失败不改变导航栏原来的行为，用户打开时仍会再试一次。
+      });
+    };
+    if (typeof window.requestIdleCallback === 'function') {
+      window.requestIdleCallback(run, { timeout: 1200 });
+    } else {
+      setTimeout(run, 0);
+    }
+  }
+
+  /**
+   * Agent 模式清单（2026-10-04 用户要求：新建会话时手机上也要能选模式，PC 一直可以）。
+   * 只取一次；读不到就如实记「没有可选的」——建会话那条路会直接建默认，
+   * **不摆一个只有一项的选择题**，也不假装自己知道 DSH 有哪些模式。
+   */
+  function prefetchPresets() {
+    if (navPresetsLoaded || !state.token) return;
+    navPresetsLoaded = true;
+    api('/mini/api/agent-presets').then(function (body) {
+      navPresets = body && body.ok ? body : { ok: false, reason: (body && body.reason) || 'failed' };
+      if (navPickerWs && $('nav').classList.contains('open')) renderNav();
+    }).catch(function () {
+      navPresets = { ok: false, reason: 'failed' };
+    });
+  }
+
   function dayLabel(ts) {
     if (!ts) return '';
     var d = new Date(ts);
@@ -2519,6 +4057,11 @@
   function renderNav() {
     // 目录浏览那一屏接管整个面板。它自己画返回按钮，所以不走下面这套。
     if (navView === 'browse') { renderBrowse(); return; }
+    // 自愈：navigation-refresh（会话开跑/收工都会广播）清得掉数据、清不掉展开态，
+    // 重画出来的就是永远停着的「正在读取…」——取列表的请求原来只在点击时发，
+    // 没人补发就一直停着（真机报过：收起再展开才好，2026-10-03）。缺数据的补拉一次，
+    // loadWsSessions 自带在途闩，重复调用不会发第二趟。
+    Object.keys(navExpanded).forEach(function (id) { loadWsSessions(id); });
     var list = navList || [];
     // 「新建工作区」常驻在最上面：它是这一屏的入口，不该等有了会话才出现——
     // 一个工作区都还没有的人，恰恰最需要它。
@@ -2549,6 +4092,22 @@
     // 这一行都在。放在列表末尾的话，一个 452 条会话的工作区要划到底才看得到。
     var html = '<button class="ws-new" type="button" data-newws="' + escapeHtml(wsId) + '">'
       + '＋ 新建会话</button>';
+    // 模式清单（2026-10-04）：多于一种模式时，「新建会话」先把清单行内展开，
+    // 点谁建谁；坏档如实标「不可用」——不装作能点。
+    if (navPickerWs === wsId && navPresets && navPresets.ok && navPresets.presets.length > 1) {
+      html += '<div class="ws-modes">' + navPresets.presets.map(function (m) {
+        var title = '<b>' + escapeHtml(m.name || m.id) + '</b>';
+        var desc = m.description
+          ? '<span class="ws-mode-desc">' + escapeHtml(m.description) + '</span>' : '';
+        var def = navPresets.defaultId === m.id ? '<span class="ws-mode-def">默认</span>' : '';
+        if (m.broken) {
+          return '<div class="ws-mode ws-mode-broken">' + title
+            + '<span class="ws-mode-desc">不可用：' + escapeHtml(m.broken) + '</span></div>';
+        }
+        return '<button class="ws-mode" type="button" data-mode-ws="' + escapeHtml(wsId)
+          + '" data-mode-preset="' + escapeHtml(m.id) + '">' + title + desc + def + '</button>';
+      }).join('') + '</div>';
+    }
     var got = navSessions[wsId];
     if (!got) return html + '<div class="placeholder">正在读取…</div>';
     if (!got.sessions.length) return html + '<div class="placeholder">这个工作区还没有会话。</div>';
@@ -2790,7 +4349,17 @@
     }
     navExpanded[wsId] = true;
     renderNav();
-    if (navSessions[wsId]) return;
+    loadWsSessions(wsId);
+  }
+
+  // 取一个工作区的会话列表。点击和 renderNav 的自愈（见 renderNav 顶部）都走这里：
+  // navWsFetching 这道闩让同一工作区同时只有一趟在飞，别重复付读日志折标题的钱。
+  // 15 秒兜底解锁是给「请求永远不回来」留的——闩本身不能变成新的卡死点，
+  // 超过 15 秒就放行，让下一次渲染或点击还能再试（服务端有缓存，重发很便宜）。
+  function loadWsSessions(wsId) {
+    if (navSessions[wsId] || navWsFetching[wsId]) return;
+    navWsFetching[wsId] = true;
+    var bail = setTimeout(function () { delete navWsFetching[wsId]; }, 15000);
     /**
      * 接着问，直到服务端说「一条都不剩」。
      *
@@ -2802,7 +4371,8 @@
      */
     function followTitles(cur, deadline) {
       if (!(pendingCount(cur) > 0) || Date.now() >= deadline) return;
-      setTimeout(function () {
+      navFollowTimers[wsId] = setTimeout(function () {
+        delete navFollowTimers[wsId];
         // 用户收起了、或者这份数据已经被刷新换掉，就放手：别跟人抢。
         if (navSessions[wsId] !== cur || !navExpanded[wsId]) return;
         api('/mini/api/workspaces/' + encodeURIComponent(wsId) + '/sessions')
@@ -2819,11 +4389,15 @@
     }
     api('/mini/api/workspaces/' + encodeURIComponent(wsId) + '/sessions')
       .then(function (body) {
+        clearTimeout(bail);
         navSessions[wsId] = body;
+        delete navWsFetching[wsId];
         renderNav();
         followTitles(body, Date.now() + TITLE_FOLLOW_LIMIT_MS);
       })
       .catch(function (err) {
+        clearTimeout(bail);
+        delete navWsFetching[wsId];
         navSessions[wsId] = { sessions: [], total: 0 };
         renderNav();
         toast(err.message);
@@ -2835,7 +4409,17 @@
   // 服务端那道闸门拦不住这个：两个请求都是合法的。
   var creatingSession = false;
 
-  function createSession(wsId) {
+  function createSession(wsId, agentPreset) {
+    // 2026-10-04 用户要求：新建会话时手机上也要能选 agent 模式（PC 一直可以）。
+    // 多于一种模式、又没点名要哪种：先把清单行内展开让用户挑（照「新建文件夹」的
+    // 先例，不弹窗）；只有一种、或读不到清单：直接建 DSH 的默认模式——
+    // **不摆只有一个选项的选择题**，也不替用户猜。
+    if (agentPreset === undefined && navPresets && navPresets.ok && navPresets.presets.length > 1) {
+      navPickerWs = navPickerWs === wsId ? '' : wsId;
+      renderNav();
+      return Promise.resolve();
+    }
+    navPickerWs = '';
     if (creatingSession) return;
     creatingSession = true;
     Array.prototype.forEach.call($('navBody').querySelectorAll('.ws-new'), function (el) {
@@ -2855,7 +4439,7 @@
     // 不返回的话外面拿到的是 undefined，接不上任何后续。
     return api('/mini/api/workspaces/' + encodeURIComponent(wsId) + '/sessions', {
       method: 'POST',
-      body: '{}',
+      body: agentPreset ? JSON.stringify({ agentPreset: agentPreset }) : '{}',
     }).then(function (res) {
       done();
       // 接口把绑定后的快照一起给了，直接渲染——不这样的话，切过去的一瞬间
@@ -2926,6 +4510,12 @@
     if (at('[data-mkdir-cancel]')) { browseMkdir = false; renderNav(); return; }
     if (at('[data-mkdir-ok]')) { makeFolder(); return; }
 
+    // 模式清单里点一项：带着这个模式去建（2026-10-04，手机上也能选 agent 模式）。
+    var mode = at('[data-mode-preset]');
+    if (mode) {
+      createSession(mode.getAttribute('data-mode-ws'), mode.getAttribute('data-mode-preset'));
+      return;
+    }
     // 「新建会话」要排在 ws-head 之前判：它在 ws-body 里面、不是 ws-head，
     // 顺序上无所谓，但放在前面更清楚——这一支是动作，那一支是展开/收起。
     var fresh = at('.ws-new');
@@ -2936,22 +4526,138 @@
   });
 
   // ---------------- SSE ----------------
+  /** 从轨迹中取当前轮号：正在跑的那一组的轮号。没有就返回 null。 */
+  function currentTrajectoryTurn() {
+    var groups = state.trajectory || [];
+    for (var i = groups.length - 1; i >= 0; i--) {
+      var g = groups[i];
+      if (g && g.state === 'running' && g.turn != null) return g.turn;
+    }
+    // 没有正在跑的，取最近一个有轮号的
+    for (var j = groups.length - 1; j >= 0; j--) {
+      var h = groups[j];
+      if (h && h.turn != null) return h.turn;
+    }
+    return null;
+  }
+
+  /**
+   * 这条流是谁——轨迹订阅按连接记，就得先有身份。
+   *
+   * 服务端手上只有一条条 SSE 连接（`res`），一次普通的 POST 认不出「我是哪条流」。
+   * 所以由客户端自己报一个随机串，两处都带上：连流时的 `?clientId=…`，和之后每次
+   * 开关订阅的 POST。不报也能用，只是那种连接订不了轨迹。
+   *
+   * 存 `sessionStorage`（不是 localStorage）：一个标签页一个身份，第二个标签页不会
+   * 跟这一页抢同一条订阅；刷新后还在，免得每刷一次就多出一个「认不出」的连接。
+   * 无痕模式下存取会抛，就地退回「本次运行内固定」——订不上，但不影响别的功能。
+   */
+  var clientId = '';
+  try {
+    clientId = sessionStorage.getItem('dshMiniClient') || '';
+    if (!clientId) {
+      clientId = 'c' + Math.random().toString(36).slice(2, 10) + Date.now().toString(36);
+      sessionStorage.setItem('dshMiniClient', clientId);
+    }
+  } catch (e) {
+    clientId = 'c' + Math.random().toString(36).slice(2, 10) + Date.now().toString(36);
+  }
+  /** 服务端此刻认作「订了轨迹」的那个身份；空串 = 没订（切换模式的开关拿它判断）。 */
+  var subscribedClientId = '';
   var es = null;
   function connect() {
     if (es) { try { es.close(); } catch (e) {} es = null; }
     if (!state.token) { showGate(); return; }
     setStatus('', '连接中…');
-    es = new EventSource('/mini/api/stream?token=' + encodeURIComponent(state.token));
+    // clientId 每条连接都带（订阅的 POST 靠它认出这条流）；full=1 只在「完整」模式带，
+    // 服务端见到就自动把这条连接订上轨迹——断线重连沿用同一个地址，重新订上由服务端
+    // 自己完成，客户端不用再握手一次。
+    es = new EventSource('/mini/api/stream?token=' + encodeURIComponent(state.token)
+      + '&clientId=' + encodeURIComponent(clientId)
+      + (state.mode === 'full' ? '&full=1' : ''));
 
     es.addEventListener('open', function () {
       state.connected = true;
       updateStatusUI();
       $('connHint').textContent = '已连接';
+      prefetchWorkspaces();
+      prefetchSubagents();
+      if (state.mode === 'full') {
+        // 首连与重连同一处：full=1 已让服务端订上这条连接，拿住身份，再对齐一次——
+        // 断线那一段路上可能丢过帧，用这份 GET 把 epoch/seq 校正（换代就整个换新）。
+        subscribedClientId = clientId;
+        requestTrajectory();
+      }
     });
     es.addEventListener('state', function (e) {
       state.connected = true;
       updateStatusUI();
       try { applySnapshot(JSON.parse(e.data)); } catch (err) {}
+      prefetchWorkspaces();
+      prefetchSubagents();
+    });
+    // 轨迹的增量帧。JSON 解析失败就丢——宁可等下一份 GET 对齐，也不拿半帧去拼。
+    es.addEventListener('trajectory', function (e) {
+      var frame;
+      try { frame = JSON.parse(e.data); } catch (err) { return; }
+      receiveTrajectoryFrame(frame);
+    });
+    // 活片段帧（2026-10-04 用户解禁：完整模式要「正在想的片段一点点顺出来」）。
+    // 只进完整模式的轨迹组头；聊天/单帧、鲸鱼娘气泡一个字节都不碰。
+    es.addEventListener('trajectory-live', function (e) {
+      var frame;
+      try { frame = JSON.parse(e.data); } catch (err) { return; }
+      if (state.mode !== 'full') return;
+      if (frame.sessionId && state.boundSessionId && frame.sessionId !== state.boundSessionId) return;
+      state.trajectoryLive = typeof frame.detail === 'string' ? frame.detail : '';
+      render();
+    });
+    es.addEventListener('navigation-title', function (e) {
+      var payload;
+      try { payload = JSON.parse(e.data); } catch (err) { return; }
+      if (!payload || typeof payload.workspaceId !== 'string' || typeof payload.sessionId !== 'string') return;
+      var got = navSessions[payload.workspaceId];
+      if (!got || !Array.isArray(got.sessions)) return;
+      var row = got.sessions.find(function (item) { return item.id === payload.sessionId; });
+      if (!row) return;
+      row.title = typeof payload.title === 'string' ? payload.title : '';
+      if (typeof got.pending === 'number' && got.pending > 0) got.pending -= 1;
+      if (got.pending <= 0 && navFollowTimers[payload.workspaceId]) {
+        clearTimeout(navFollowTimers[payload.workspaceId]);
+        delete navFollowTimers[payload.workspaceId];
+      }
+      if (navExpanded[payload.workspaceId] && navView === 'tree') renderNav();
+    });
+    es.addEventListener('subagent-metrics', function (e) {
+      var payload;
+      try { payload = JSON.parse(e.data); } catch (err) { return; }
+      if (!payload || payload.parentSessionId !== state.boundSessionId) return;
+      var row = null;
+      for (var i = 0; i < saRows.length; i++) {
+        if (saRows[i].id === payload.childId) { row = saRows[i]; break; }
+      }
+      if (!row) return;
+      row.tokens = payload.tokens;
+      row.durationMs = payload.durationMs;
+      row.lastTurnCompleted = payload.lastTurnCompleted;
+      if (saCache && saCacheSession === state.boundSessionId) {
+        for (var k = 0; k < (saCache.subagents || []).length; k++) {
+          if (saCache.subagents[k].id === payload.childId) {
+            Object.assign(saCache.subagents[k], payload);
+            break;
+          }
+        }
+      }
+      if (saPanel.classList.contains('open') && !saCurrent) saRenderList(saCache || { ok: true, subagents: saRows });
+    });
+    es.addEventListener('navigation-refresh', function () {
+      navList = null;
+      navSessions = {};
+      saCache = null;
+      saCacheSession = null;
+      saCacheAt = 0;
+      if ($('nav').classList.contains('open')) loadWorkspaces(false);
+      else prefetchWorkspaces();
     });
     es.addEventListener('reply', function (e) {
       var payload = JSON.parse(e.data);
@@ -2963,11 +4669,16 @@
         text: payload.text, timestamp: payload.timestamp,
         sessionId: payload.sessionId, interrupted: cut,
       };
-      if (state.mode === 'chat') {
+      // 完整模式画的也是这串聊天记录（renderFull 复用 renderChat），回复落定
+      // 同样要追加进去，否则要等下一份快照才补上；单帧不画记录，照旧不进。
+      if (state.mode !== 'minimal') {
         state.history = (state.history || []).concat([
           {
             role: 'assistant', text: payload.text, timestamp: payload.timestamp,
             sessionId: payload.sessionId, interrupted: cut,
+            // 完整模式把轨迹块插回对话原位要用：从轨迹中取当前轮号。
+            // 手机本地回显时轮还没开，先留空；服务端快照补上来时会带上真轮号。
+            turn: currentTrajectoryTurn(),
           }
         ]);
       }
@@ -3133,6 +4844,31 @@
       ask = { id: payload.id, questions: payload.questions, i: 0, picked: {}, custom: false }
       askRender()
     });
+    // 这道题在**别处**被答掉了（飞书那边回的），插件主动推一条状态过来。
+    //
+    // 没有这一条，卡片就干巴巴挂在屏幕上：用户在飞书里答完了，切回手机还看得见这道题，
+    // 只能以为没生效、再答一次——那时候拿到的是「已经过期了」。所以这里就地收起来，
+    // 并说一句它是怎么没的。**只在自己正显示着同一道题时动手**，别的题（编号对不上）
+    // 一个字都不碰。
+    es.addEventListener('question-done', function (e) {
+      let payload = null
+      try { payload = JSON.parse(e.data) } catch (err) { return }
+      if (!payload || !payload.id) return
+      if (!ask || ask.id !== payload.id) return
+      ask = null
+      $('askCard').classList.remove('on')
+      // 谁答的由插件如实说（'feishu'）——猜不得，也不把「超时/断线」说成「已在别处答过」。
+      if (payload.source === 'feishu') toast('这道题已经在飞书里答过了')
+    });
+    es.addEventListener('approval-done', function (e) {
+      let payload = null
+      try { payload = JSON.parse(e.data) } catch (err) { return }
+      if (!payload || !payload.id) return
+      if (!approve || approve.id !== payload.id) return
+      approve = null
+      $('approveCard').classList.remove('on')
+      if (payload.source === 'feishu') toast('这条已经在飞书里处理过了')
+    });
     es.addEventListener('status', function (e) {
       try { setRunning(JSON.parse(e.data).running); } catch (err) {}
     });
@@ -3214,17 +4950,29 @@
         // **不能显示成空列表**：那等于说「这个会话没有指令」，是另一回事。
         state.commandsError = (res && res.error) || '读不到指令列表';
       }
-      paintCmdMenu();
+      paintCommandViews();
     }).catch(function (err) {
       state.commandsLoading = false;
       if (forSession !== state.boundSessionId) return;
       state.commandsFor = forSession;
       state.commands = null;
       state.commandsError = err.message || '读不到指令列表';
-      paintCmdMenu();
+      paintCommandViews();
     });
   }
 
+  /**
+   * 指令表换了一份之后，**所有正在看着它的地方**都要重画。
+   *
+   * 现在有两处：打 / 弹出来的菜单，和统一操作面板里的那个列表。回调那一个由面板
+   * 那一段自己挂上——因为它在这一段下面，而这一段会被测试单独抠出来跑（那时面板还不存在）。
+   */
+  var onCommandsReady = null;
+  function paintCommandViews() {
+    paintCmdMenu();
+    if (onCommandsReady) onCommandsReady();
+  }
+
   /**
    * 画（或收起）那只菜单。
    *
@@ -3235,6 +4983,9 @@
   function paintCmdMenu() {
     var el = $('cmdMenu');
     if (!el) return;
+    // 输入框被清空了 = 用户把刚才那条指令整个删了，这是「明确取消」那一步。
+    // 放在这儿而不是 send() 里：清空之后他往往还要改写成普通提问，那次 send 不该再被拦。
+    if (!inputEl.value.trim()) state.pendingCommand = null;
     var prefix = slashQuery();
     if (prefix === null) { hideCmdMenu(); return; }
     var wasOpen = !el.hidden;
@@ -3267,16 +5018,22 @@
   }
 
   /**
-   * 菜单里点了一条。
+   * 菜单/面板里点了一条。
    *
-   * 分两路，判据是服务端给的 hint（这条指令要不要参数）：
+   * 分两路，判据是服务端给的 hint（这条指令要不要参数）。两路都**不执行**，
+   * 除非是打了 / 之后从菜单里点了一条不要参数的（那种当场跑，见 deferRun 的说明）：
    *   · 不要参数 —— 直接执行。让用户再按一次发送是白白多一步。
    *   · 要参数   —— 把 `/名字 ` 填进输入框，末尾留一个空格、光标停在后面，并把
    *     hint 那句话挂到输入框的 placeholder 上。
    *     **不自己编一句「请输入参数」**：只有服务端知道这条指令要什么，
    *     编一句就等于让用户照着一个错的提示去填。
+   *
+   * @param {string} name
+   * @param {boolean} [deferRun] 面板那条路传 true：**一次点击不执行**，只把这一行放进
+   *   输入框，由「发送」那一下确认（没有参数提示的指令也照此办理，宁可多问一句）。
+   *   打 / 弹出来的那个菜单不传——它本来就是「扫一眼挑一个」，多一步反而碍事。
    */
-  function pickCommand(name) {
+  function pickCommand(name, deferRun) {
     var list = state.commands || [];
     var cmd = null;
     for (var i = 0; i < list.length; i++) { if (list[i].name === name) cmd = list[i]; }
@@ -3288,12 +5045,25 @@
     if (cmd.hint) {
       inputEl.value = '/' + cmd.name + ' ';
       inputEl.placeholder = cmd.hint;
+      // 这一行「曾经是一条指令」：名字要是被删掉，send 不许拿它当普通提问发出去。
+      state.pendingCommand = cmd.name;
       inputEl.focus();
       // 光标停在最后：停在名字中间的话，用户接着打的字会插进名字里去。
       inputEl.setSelectionRange(inputEl.value.length, inputEl.value.length);
       autoGrow();
       return;
     }
+    if (deferRun) {
+      // 面板那条路：只填不跑。等用户按「发送」——那就是明确的确认执行动作。
+      inputEl.value = '/' + cmd.name;
+      state.pendingCommand = cmd.name;
+      inputEl.focus();
+      inputEl.setSelectionRange(inputEl.value.length, inputEl.value.length);
+      autoGrow();
+      return;
+    }
+    // 当场执行：框里不留东西，也就不存在「曾是指令」这回事。
+    state.pendingCommand = null;
     inputEl.value = '';
     autoGrow();
     runCommand('/' + cmd.name);
@@ -3356,10 +5126,13 @@
     // 本地上限和服务端是同一个数（由服务端注入），先拦一道省得白传一场。
     if (MAX_UPLOAD > 0 && file.size > MAX_UPLOAD) {
       toast('「' + name + '」有 ' + humanSize(file.size) + '，超过上限 ' + humanSize(MAX_UPLOAD));
-      return;
+      // 多选时是排队传的（见 filePick 的 change），所以这里也要回一个「承诺」——
+      // 否则这一份被拦下会让整条链断掉，后面几张就再也传不出去了。
+      return Promise.resolve();
     }
     setAttachBusy(true);
-    api('/mini/api/upload?name=' + encodeURIComponent(name) + '&size=' + file.size,
+    // 返回这条链：多选时调用方靠它排队（一张传完再传下一张）。
+    return api('/mini/api/upload?name=' + encodeURIComponent(name) + '&size=' + file.size,
       { method: 'POST', body: file })
       .then(function (res) {
         state.uploads.push({ uploadId: res.uploadId, name: res.name, bytes: res.bytes });
@@ -3371,17 +5144,38 @@
       .then(function () { setAttachBusy(false); });
   }
 
-  /** 附件小条。有东西才出现，没有就整块收起来——不占地方。 */
+  /**
+   * 附件小条。有东西才出现，没有就整块收起来——不占地方。
+   *
+   * 统一操作面板里那几行「已选文件」是**同一份数据、同一份 HTML**：都由这里画，
+   * 都读 state.uploads。别在面板里另存一个附件数组——那样两处迟早对不上
+   * （面板里删了一条，小条还挂着，用户就不知道该信哪个）。
+   */
   function renderAttach() {
     var bar = $('attachBar');
     if (!bar) return;
     var list = state.uploads || [];
-    bar.hidden = !list.length;
-    bar.innerHTML = list.map(function (f, i) {
+    var chips = list.map(function (f, i) {
       return '<span class="chip"><span class="nm">' + escapeHtml(f.name) + '</span>'
         + '<span class="sz">' + humanSize(f.bytes) + '</span>'
         + '<button class="x" type="button" data-drop="' + i + '" aria-label="去掉">×</button></span>';
     }).join('');
+    bar.hidden = !list.length;
+    bar.innerHTML = chips;
+    var box = $('opsFiles');
+    if (box) { box.hidden = !list.length; box.innerHTML = chips; }
+  }
+
+  /**
+   * 去掉一条已选文件。小条和面板共用这一处，别写两份。
+   *
+   * 编号必须从**被点的按钮**上读（`closest('[data-drop]')`），不能读 e.target：
+   * ✕ 是按钮里那个图形，手指落上去 e.target 就是图形本身，读它只能拿到 null，
+   * 于是静默什么都不做（2026-09-28 实机报过的那个 bug）。
+   */
+  function dropUpload(btn) {
+    state.uploads.splice(Number(btn.getAttribute('data-drop')), 1);
+    renderAttach();
   }
 
   function send() {
@@ -3394,6 +5188,21 @@
     // 只带文件、一个字不写也是合法的：「这份文件你看一下」本来就是常见用法。
     // 两样都没有才算空。
     if (!text && !files.length) return;
+
+    // **点过指令、又把名字删掉的那一行，不许当普通提问发出去。**
+    //
+    // 从面板/菜单点了一条「要参数」的指令之后，输入框里躺着 `/名字 参数`。用户要是把
+    // 名字删了、只留参数，这一行就不再以 / 开头，原来会被当成一次普通提问发给模型——
+    // 白花一次额度，而且他还以为自己跑的是那条指令。
+    //
+    // 拦在**清空输入框之前**：那一行字要留着，补回名字就能接着发。出路有两条，
+    // 都在提示里说清楚了：补回开头的指令名，或者清空输入框（清空 = 明确取消这条指令，
+    // 由 paintCmdMenu 在每次输入时把那枚标记撤掉）。
+    if (text.charAt(0) !== '/' && state.pendingCommand) {
+      toast('这是 /' + state.pendingCommand + ' 的参数，指令名被删掉了。'
+        + '把 /' + state.pendingCommand + ' 补回开头，或者清空输入框改问别的。');
+      return;
+    }
     unlockAudio();
     // **发指令这个动作，无条件拉回底部。**
     //
@@ -3428,6 +5237,8 @@
       // 这里**不动 state.uploads**——清掉就等于把用户刚传上来的文件悄悄扔了，
       // 而他还以为跟着发出去了。留在小条上看得见，想发就配一句话再发一次。
       if (files.length) toast('指令带不了附件，附件还留在下面');
+      // 跑出去了，那枚「曾是指令」的标记就该撤掉：留着会拦住下一条普通提问。
+      state.pendingCommand = null;
       runCommand(text);
       return;
     }
@@ -3468,7 +5279,10 @@
         // 顺带也解决了发送失败时屏幕上留一条假气泡的问题。
         if (state.mode !== 'minimal') {
           state.history = (state.history || []).concat([
-            { role: 'user', text: shown, timestamp: Date.now() }
+            { role: 'user', text: shown, timestamp: Date.now(),
+              // 完整模式把轨迹块插回对话原位要用：从轨迹中取当前轮号。
+              // 手机本地回显时轮还没开，先留空；服务端快照补上来时会带上真轮号。
+              turn: currentTrajectoryTurn() }
           ]);
           render();
         }
@@ -3486,22 +5300,160 @@
       });
   }
 
-  $('btnAttach').addEventListener('click', function () { $('filePick').click(); });
+  // ---------------- 统一操作面板（输入框旁边那一个入口） ----------------
+  //
+  // 形态是用户 2026-10-02 定的：输入框旁边**一个**入口，点开是一张底部抽屉，
+  // 上面「添加文件」、下面「调用指令」。原来这两件事各有各的门——回形针直接开文件
+  // 选择器、打 `/` 才弹指令菜单——手机上没人知道打一个斜杠还能调指令。
+  //
+  // 四条复用纪律（都不许另起一套）：
+  //   · 外壳 = 设置抽屉那一套（#settings.open + .sheet），不新建样式体系；
+  //   · 指令数据 = state.commands 那份按会话缓存，与打 / 弹出来的菜单**同一份**，
+  //     判据也共用 needCommands()，不写「面板专用」的第二套；
+  //   · 指令行 = 现成的 pickCommand(name, true)，一次点击**不执行**；
+  //   · 附件 = state.uploads + renderAttach()，面板里那几行就是小条那几行。
+  //
+  // 「指令带附件一起发」这一轮**不做**（手机的上传小票 DSH 的指令接口不认，见 onCommand
+  // 那段说明）——所以对声明了要附件的指令，面板上如实标一句「手机暂时带不了附件」，
+  // 不假装支持。
+  var ops = $('ops');
+  // 面板是不是开着。指令表换一份时要按它决定要不要重画列表（见 paintCommandViews）。
+  var opsOpen = false;
+
+  function openOps() {
+    opsOpen = true;
+    // 先把键盘收起来：这张抽屉贴着底边，键盘不收，它就被顶到看不见的地方。
+    if (inputEl.blur) inputEl.blur();
+    ops.classList.add('open');
+    // 与打 / 时同一个判据：换了会话要重取，上次没取到过就再试一次。
+    if (needCommands() || state.commandsError) loadCommands();
+    paintOps();
+  }
+
+  function closeOps() {
+    opsOpen = false;
+    ops.classList.remove('open');
+  }
+
+  /**
+   * 画面板里的指令列表。
+   *
+   * 和打 / 那个菜单同源（state.commands），但这里是「搜」不是「按前缀」：面板上那个框是
+   * 一句话搜索框，名字和说明都匹配（桌面端也是名字和标题一起匹配）。顺手带个 `/c` 也算，
+   * 那是用户平时打指令的手势。
+   *
+   * **取不到就说原因**，不显示成「一条都没有」——两件事，用户能做的也不同。
+   */
+  function paintOps() {
+    var listEl = $('opsCmds');
+    if (!listEl) return;
+    if (state.commandsError) {
+      listEl.innerHTML = '<div class="cmd-note">' + escapeHtml(state.commandsError) + '</div>';
+      return;
+    }
+    if (!state.commands) {
+      // 取回来之前先占个位——不然打开面板是一片空白，看着像坏了。
+      listEl.innerHTML = '<div class="cmd-note">正在读取可用的指令…</div>';
+      return;
+    }
+    var filterEl = $('opsFilter');
+    var q = String((filterEl && filterEl.value) || '').trim().toLowerCase();
+    if (q.charAt(0) === '/') q = q.slice(1);
+    var rows = state.commands.filter(function (c) {
+      if (!q) return true;
+      return (String(c.name) + ' ' + String(c.description || '')).toLowerCase().indexOf(q) >= 0;
+    });
+    if (!rows.length) {
+      listEl.innerHTML = '<div class="cmd-note">没有对得上的指令。</div>';
+      return;
+    }
+    listEl.innerHTML = rows.map(function (c) {
+      return '<button class="cmd-row" type="button" data-cmd="' + escapeHtml(c.name) + '">'
+        + '<span class="cmd-top">'
+        + '<span class="cmd-name">/' + escapeHtml(c.name) + '</span>'
+        + '<span class="cmd-desc">' + escapeHtml(c.description || '') + '</span>'
+        + '</span>'
+        + (c.attachments ? '<span class="cmd-flag">手机暂时带不了附件</span>' : '')
+        + '</button>';
+    }).join('');
+  }
+
+  // 面板里点一行：**一次点击不执行**（deferRun）。要参数的把 hint 挂成占位提示、把
+  // `/名字 ` 填进输入框；不要参数的也只填进去，等「发送」那一下——宁可多问一句，
+  // 也不能点错一下就真跑掉。
+  $('opsCmds').addEventListener('click', function (e) {
+    var btn = e.target && e.target.closest ? e.target.closest('[data-cmd]') : null;
+    if (!btn) return;
+    closeOps();
+    pickCommand(btn.getAttribute('data-cmd'), true);
+  });
+
+  $('opsFilter').addEventListener('input', paintOps);
+  $('opsClose').addEventListener('click', closeOps);
+  // 点抽屉外面那一层 = 关掉（和设置抽屉同一条规矩）。
+  ops.addEventListener('click', function (e) { if (e.target === ops) closeOps(); });
+
+  // 「添加文件」两件事：选文件、拍照。都走原来那个藏起来的 #filePick——手机上这两件事
+  // 本来就是同一个系统选择器，区别只在「要不要限定图片、要不要调后置摄像头」。
+  //
+  // **多选只给「选文件」**（2026-10-05 用户要求：图库和文件里只能单选，改成多选）。
+  // 拍照那一条不加 multiple：相机一次就出一张，摆个多选没有意义。
+  function openFilePicker(camera) {
+    var pick = $('filePick');
+    if (!pick) return;
+    if (camera) {
+      pick.setAttribute('accept', 'image/*');
+      pick.setAttribute('capture', 'environment');
+      pick.removeAttribute('multiple');
+    } else {
+      pick.removeAttribute('accept');
+      pick.removeAttribute('capture');
+      pick.setAttribute('multiple', '');
+    }
+    pick.click();
+  }
+  $('opsPick').addEventListener('click', function () { openFilePicker(false); });
+  $('opsShot').addEventListener('click', function () { openFilePicker(true); });
+
+  // 面板里那行已选文件上的 ✕。走的是和小条同一个 dropUpload()。
+  $('opsFiles').addEventListener('click', function (e) {
+    var btn = e.target && e.target.closest ? e.target.closest('[data-drop]') : null;
+    if (!btn) return;
+    dropUpload(btn);
+  });
+
+  // 指令表换了一份（换会话、第一次取到）时，面板开着就跟着重画。
+  onCommandsReady = function () { if (opsOpen) paintOps(); };
+
+  $('btnAttach').addEventListener('click', function () { openOps(); });
   $('filePick').addEventListener('change', function (e) {
-    var f = e.target.files && e.target.files[0];
+    // 多选：一次可能挑了好几张，**一个接一个传**（2026-10-05 用户要求多选）。
+    // 为什么不用并发：上传的「忙碌」是同一个开关（setAttachBusy 控制那个回形针），
+    // 并发传的话最后一个传完就把按钮放开了，其实还有在飞的——用户会以为传完了。
+    // 排队传则从头到尾都是忙的，什么时候能再点一目了然。
+    var files = Array.prototype.slice.call(e.target.files || []);
     // 清掉 value：不清的话，连着选同一个文件第二次不会触发 change，
     // 用户会觉得「点了没反应」。
     e.target.value = '';
-    if (f) uploadFile(f);
+    if (!files.length) return;
+    // **选完就回主页面**（2026-10-05 用户要求：选完文件点完成，直接回到主页面，
+    // 不要停在这张「添加文件」面板上）。
+    // 关在这里是安全的：文件是**后台在传**的，主页面上的附件小条会一条条冒出来；
+    // 面板里那几行「已选文件」本来也只是同一份数据的另一处画法（见 renderAttach），
+    // 关掉面板不会打断上传。
+    closeOps();
+    files.reduce(function (chain, f) {
+      return chain.then(function () { return uploadFile(f); });
+    }, Promise.resolve());
   });
   $('attachBar').addEventListener('click', function (e) {
     var btn = e.target.closest ? e.target.closest('[data-drop]') : null;
     if (!btn) return;
-    state.uploads.splice(Number(btn.getAttribute('data-drop')), 1);
-    renderAttach();
+    dropUpload(btn);
   });
 
   $('btnSend').addEventListener('click', send);
+
   inputEl.addEventListener('input', autoGrow);
   // 每敲一个字重算一次菜单。它自己会先看「是不是一个没打完的 / 名字」再决定动不动，
   // 所以这里不用加判据。
@@ -3532,10 +5484,451 @@
   $('btnSettings').addEventListener('click', function () {
     sheet.classList.add('open');
     $('connHint').textContent = state.connected ? '已连接' : '未连接';
+    // 权限档位那块也在这儿重读一次：它显示的是「现在在哪一档」的实时状态（电脑端
+    // 随时能改），而且启动时那一次要是没读成，不重读就整块再也不出现。
+    loadPermissions(state.boundSessionId);
+    // 版本号那行也现读一次：它只在设置页里看得见，没必要开机就为它跑一趟。
+    // （watchBuild 是同一个 script 块里的函数声明，这里调得到。）
+    watchBuild();
+    // 繁忙时的发送行为也现读一次：**电脑上随时能改**，开机读那一次会过期。
+    loadBusyEnter();
   });
   $('btnClose').addEventListener('click', function () { sheet.classList.remove('open'); });
+  // 顶部吸顶那个关闭口（2026-10-05 设置页改整屏时加的）。
+  $('btnSettingsClose').addEventListener('click', function () { sheet.classList.remove('open'); });
   sheet.addEventListener('click', function (e) { if (e.target === sheet) sheet.classList.remove('open'); });
 
+  // ---------------- 子智能体 ----------------
+  //
+  // 数据全从 /mini/api/subagents 那三条来（见 lib/server.js）。三条都在电脑上的
+  // **同一个进程里直接问 DSH**，不经过 WebSocket——靠进程里这层关系拿到的东西
+  // （清单、某一道自己的运行记录）反而比桌面前端更直接：桌面那边只能隔着一条
+  // 只开了两个口子的线路，清单和记录得靠投影另推一份过来。
+  //
+  // 两条纪律，和主会话一模一样：**读不到就说读不到，不编**；**数字算不出来就空着**。
+  var saPanel = $('subagents');
+  var saRows = [];        // 最近一次读到的清单，点行时按 id 找回来
+  var saCurrent = null;   // 正在看运行记录的那一道；null = 现在在看清单
+  var saCache = null;
+  var saCacheSession = null;
+  var saCacheAt = 0;
+  var saInflight = null;
+  var SA_CACHE_TTL = 5000;
+
+  function saToList() {
+    saCurrent = null;
+    $('subagentsDoc').hidden = true;
+    $('subagentsList').hidden = false;
+    $('subagentsBack').hidden = true;
+    $('subagentsTitle').textContent = '子智能体';
+  }
+  function saToDoc(row) {
+    saCurrent = row;
+    $('subagentsList').hidden = true;
+    $('subagentsDoc').hidden = false;
+    $('subagentsBack').hidden = false;
+    $('subagentsTitle').textContent = row.label || shortSessionId(row.id);
+  }
+
+  /** 用量（token 数）。读不到就是 null，页面上写「—」——写 0 会被读成「一次都没跑过」。 */
+  function saTokens(n) {
+    if (typeof n !== 'number' || !isFinite(n) || n < 0) return '—';
+    if (n < 1000) return String(n);
+    if (n < 1000000) return (n / 1000).toFixed(1) + 'k';
+    return (n / 1000000).toFixed(1) + 'M';
+  }
+  /** 耗时。同样：读不到写「—」。 */
+  function saDuration(ms) {
+    if (typeof ms !== 'number' || !isFinite(ms) || ms < 0) return '—';
+    var s = Math.round(ms / 1000);
+    if (s < 60) return s + ' 秒';
+    var m = Math.floor(s / 60);
+    if (m < 60) return m + ' 分 ' + (s % 60) + ' 秒';
+    return Math.floor(m / 60) + ' 时 ' + (m % 60) + ' 分';
+  }
+  /** 目录读不动的那三种原因，翻成人话。认不出来就照原样说，不编一个像样的理由。 */
+  function saReason(r) {
+    if (r === 'corrupt') return '那一支的目录坏了';
+    if (r === 'unsupported') return '那条记录是更新的格式，这个版本读不了';
+    return '那一支暂时读不到（' + r + '）';
+  }
+
+  function saRowHtml(s) {
+    // 有一支目录读不动：DSH 会以一行「诊断」如实说原因。这里也如实转达，
+    // 不假装那一支里没有人——吞掉的表现是「明明有子代理却一个都不显示」。
+    if (s.diagnostic) {
+      return '<div class="sa-row sa-plain"><span class="dot err"></span>'
+        + '<span class="sa-main"><span class="sa-name">有一支读不出来</span>'
+        + '<span class="sa-sub">' + escapeHtml(saReason(s.diagnostic)) + '</span></span></div>';
+    }
+    // 状态点用既有 .dot，和顶栏那颗同一套：在跑 = run；没在跑但最近跑完过 = ok；
+    // 其余 = 灰。**没有动画**——那圈呼吸闪动在规格里已经被砍掉了（见 .dot 的注释）。
+    var dot = s.running ? 'dot run' : (s.lastTurnCompleted ? 'dot ok' : 'dot');
+    var kind = s.mode === 'continuable' ? '可续接' : '一次性';
+    return '<button class="sa-row" type="button" data-sa="' + escapeHtml(s.id) + '">'
+      + '<span class="' + dot + '"></span>'
+      + '<span class="sa-main"><span class="sa-name">' + escapeHtml(s.label || shortSessionId(s.id)) + '</span>'
+      + '<span class="sa-sub">' + kind + ' · ' + (s.running ? '在跑' : '已结束') + '</span></span>'
+      + '<span class="sa-num">' + saTokens(s.tokens) + '<br>' + saDuration(s.durationMs) + '</span>'
+      + '</button>';
+  }
+
+  function saRenderList(body) {
+    var listEl = $('subagentsList');
+    // 这两句空态都落在 .sa-list 里，而那个容器用负 16px 把内容拽到贴屏边
+    // （为了让分隔线横贯整屏）——所以得补上 sa-none-indent 把 16px 加回来，
+    // 否则这行字会顶到屏幕最左边。这个类是早就写好的，之前没给空态用上。
+    if (!body || !body.ok) {
+      listEl.innerHTML = '<div class="sa-none sa-none-indent">'
+        + escapeHtml((body && body.error) || '读不到子智能体。') + '</div>';
+      return;
+    }
+    saRows = body.subagents || [];
+    if (!saRows.length) {
+      listEl.innerHTML = '<div class="sa-none sa-none-indent">这个会话还没有派出过子智能体。</div>';
+      return;
+    }
+    listEl.innerHTML = saRows.map(saRowHtml).join('');
+    var btns = listEl.querySelectorAll('[data-sa]');
+    for (var i = 0; i < btns.length; i++) {
+      (function (btn) {
+        btn.addEventListener('click', function () { saOpenDoc(btn.getAttribute('data-sa')); });
+      })(btns[i]);
+    }
+  }
+
+  function saLoad(force) {
+    var sessionId = state.boundSessionId || '';
+    if (!force && saCache && saCacheSession === sessionId && Date.now() - saCacheAt < SA_CACHE_TTL) {
+      saRenderList(saCache);
+      return;
+    }
+    if (!force && saInflight && saInflight.sessionId === sessionId) return;
+    $('subagentsList').innerHTML = '<div class="sa-none sa-none-indent">正在读取…</div>';
+    var request = api('/mini/api/subagents');
+    saInflight = { sessionId: sessionId, request: request };
+    request.then(function (body) {
+      if (state.boundSessionId === sessionId && body && body.ok) {
+        saCache = body;
+        saCacheSession = sessionId;
+        saCacheAt = Date.now();
+      }
+      saRenderList(body);
+    }).catch(function (err) {
+      $('subagentsList').innerHTML = '<div class="sa-none sa-none-indent">'
+        + escapeHtml(err && err.message || '没读出来。') + '</div>';
+    }).finally(function () {
+      if (saInflight && saInflight.request === request) saInflight = null;
+    });
+  }
+
+  // 连接后趁页面空闲预取当前会话的子代理清单。首次读取可能很慢，不能把这段等待
+  // 放到用户点入口之后；入口点击时会复用 saInflight，和导航工作区同一套策略。
+  function prefetchSubagents() {
+    var sessionId = state.boundSessionId || '';
+    if (!sessionId || saCacheSession === sessionId || saInflight) return;
+    var request = api('/mini/api/subagents');
+    saInflight = { sessionId: sessionId, request: request };
+    request.then(function (body) {
+      if (state.boundSessionId !== sessionId || !body || !body.ok) return;
+      saCache = body;
+      saCacheSession = sessionId;
+      saCacheAt = Date.now();
+      if (saPanel.classList.contains('open') && !saCurrent) saRenderList(body);
+    }).catch(function () {
+      // 预取失败不影响入口；用户点开时仍会重试。
+    }).finally(function () {
+      if (saInflight && saInflight.request === request) saInflight = null;
+    });
+  }
+
+  /** 点开某一道：换成它**自己的运行记录**（和主会话同一套重放，见 lib/history.js）。 */
+  function saOpenDoc(childId) {
+    var row = null;
+    for (var i = 0; i < saRows.length; i++) if (saRows[i].id === childId) row = saRows[i];
+    if (!row) return;
+    saToDoc(row);
+    $('subagentsDoc').innerHTML = '<div class="sa-none">正在读取它的记录…</div>';
+    api('/mini/api/subagent?id=' + encodeURIComponent(childId)).then(function (body) {
+      // 读的过程中用户可能已经返回、或点开了另一道——那这一份就别再往上贴了。
+      if (saCurrent !== row) return;
+      saRenderDoc(body);
+    }).catch(function (err) {
+      if (saCurrent !== row) return;
+      $('subagentsDoc').innerHTML = '<div class="sa-none">'
+        + escapeHtml(err && err.message || '没读出来。') + '</div>';
+    });
+  }
+
+  /** 运行记录里的一条。长相和主会话**完全一样**：气泡/正文/指令行/完工卡片共用同一批样式。 */
+  function saEntryHtml(e) {
+    if (e.role === 'notice') return noticeBlock(e);
+    if (e.role === 'command') return commandBlock(e);
+    if (e.role === 'user') {
+      return '<div class="bubble user">' + escapeHtml(e.text || '')
+        + '<span class="meta">' + timeLabel(e.timestamp) + '</span></div>';
+    }
+    return '<div class="said"><div class="md">' + mdToHtml(e.text || '') + '</div>'
+      + '<div class="reply-foot"><span class="time">' + timeLabel(e.timestamp) + '</span></div></div>';
+  }
+
+  function saRenderDoc(body) {
+    var docEl = $('subagentsDoc');
+    if (!body || !body.ok) {
+      docEl.innerHTML = '<div class="sa-none">'
+        + escapeHtml((body && body.error) || '没读出来。') + '</div>';
+      return;
+    }
+    var html = '';
+    if (body.reclaimed) {
+      // 一次性子智能体跑完、记录已经被回收：**如实说没有记录**，不拿它冒充
+      // 「它没干过活」——那两件事对用户含义不同。
+      html += '<div class="sa-none">它的运行记录已经不在电脑上了，'
+        + '只能看到它当时发回来的那条完工通知。</div>';
+    } else if (!body.entries || !body.entries.length) {
+      html += '<div class="sa-none">它还没有任何记录。</div>';
+    } else {
+      if (body.truncated) {
+        html += '<div class="history-note">'
+          + escapeHtml(body.note || '只显示最近一段。') + '</div>';
+      }
+      html += body.entries.map(saEntryHtml).join('');
+    }
+    // 底部：能做什么**由类型和状态决定**，不写死。三条失败理由都由服务端翻成人话
+    // （见 lib/index.js 的 SUBAGENT_FAILURES），页面只负责把它们显示出来。
+    html += body.mode === 'continuable' ? saActsHtml(body)
+      : '<div class="sa-none">这是一次性子智能体：跑完就结束了，接不了话，'
+        + '只能看它跑过什么。</div>';
+    docEl.innerHTML = html;
+    saBindActs(body);
+  }
+
+  function saActsHtml(body) {
+    var html = '';
+    // 停：只对「正在跑的、可续接的」那一轮有意义。已经停稳的子智能体没有可停的东西。
+    if (body.running) {
+      html += '<div class="sa-acts"><button class="btn" id="saStop">停止这一轮</button></div>';
+    }
+    // 继续说话：只有「可续接」才有这一栏。父会话不在线、并发满了，DSH 都会明确拒绝，
+    // 那时候服务端把理由翻成人话给回来，这里照原样弹出来。
+    html += '<div class="sa-ask">'
+      + '<input id="saAskText" type="text" placeholder="跟它说一句…" autocomplete="off"'
+      + ' autocapitalize="off" autocorrect="off" spellcheck="false">'
+      + '<button class="btn primary" id="saSend">发送</button></div>';
+    return html;
+  }
+
+  function saBindActs(body) {
+    var stop = $('saStop');
+    if (stop) stop.addEventListener('click', function () { saStop(body, stop); });
+    var send = $('saSend');
+    if (send) send.addEventListener('click', function () { saAsk(body, send); });
+  }
+
+  function saStop(body, btn) {
+    btn.disabled = true;
+    api('/mini/api/subagent/stop', {
+      method: 'POST',
+      body: JSON.stringify({ id: body.id, mode: body.mode }),
+    }).then(function () {
+      // 递进去不等于停稳（和主会话那条一样）：重读一次，等它的状态自己翻过来。
+      toast('已经让它停下这一轮。');
+      saOpenDoc(body.id);
+    }).catch(function (err) {
+      toast(err && err.message || '停不下来。');
+      btn.disabled = false;
+    });
+  }
+
+  function saAsk(body, btn) {
+    var input = $('saAskText');
+    var text = input ? input.value.trim() : '';
+    if (!text) { toast('先说点什么。'); return; }
+    btn.disabled = true;
+    api('/mini/api/subagent/ask', {
+      method: 'POST',
+      body: JSON.stringify({ id: body.id, mode: body.mode, text: text }),
+    }).then(function () {
+      toast('已经递过去了。');
+      saOpenDoc(body.id);
+    }).catch(function (err) {
+      toast(err && err.message || '没送出去。');
+      btn.disabled = false;
+    });
+  }
+
+  $('btnSubagents').addEventListener('click', function () {
+    saToList();
+    saPanel.classList.add('open');
+    saLoad();
+  });
+  $('subagentsClose').addEventListener('click', function () { saPanel.classList.remove('open'); });
+
+  // ---------------- 插件页面（2026-10-04） ----------------
+  // 从设置里点「插件」→ 立刻盖到设置上面（#plugins 的 z-index 比 #settings 高一档）；
+  // 关掉它就回到设置，不用退出设置再去找。分层和两条留白见上面 #plugins 那段 CSS。
+  var pluginsPanel = $('plugins');
+  $('btnPlugins').addEventListener('click', function () {
+    pluginsPanel.classList.add('open');
+    loadPlugins();
+  });
+  $('pluginsClose').addEventListener('click', function () { pluginsPanel.classList.remove('open'); });
+  // 点浮层空白处也关掉（和子智能体面板同一套）。
+  pluginsPanel.addEventListener('click', function (e) {
+    if (e.target === pluginsPanel) pluginsPanel.classList.remove('open');
+  });
+
+  function loadPlugins() {
+    var listEl = $('pluginsList');
+    listEl.innerHTML = pluginNote('正在读取插件列表…');
+    api('/mini/api/plugins').then(function (r) {
+      listEl.innerHTML = renderPlugins(r || {});
+    }).catch(function (err) {
+      listEl.innerHTML = pluginNote('读不到插件列表：' + escapeHtml(err.message || '出错了'), true);
+    });
+  }
+
+  /**
+   * 三块，和 PC 的「插件」页 + 「内置插件」页对齐：
+   *
+   *   官方          —— 能装还没装的（npm 包那一层）
+   *   已安装 · 内置 —— **Cordis Loader 的实时条目表**，分「全局插件」和「会话插件」。
+   *                    这才是 DSH 的本体粒度：一整套系统是几百个插件模块拼起来的。
+   *                    （2026-10-04 用户指出：内置插件拿 npm 包充数是不对的，那只有几个。）
+   *   已安装 · 第三方 —— 用户自己装的包。DSH 自家的包不在这里列——它们在上面
+   *                    以「模块」的身份出现，那才是「一切皆插件」该有的样子。
+   */
+  function renderPlugins(r) {
+    var bundles = r.bundles || [];
+    var official = bundles.filter(function (b) { return b.optional && !b.installed; });
+    var third = bundles.filter(function (b) {
+      return b.installed && b.name.indexOf('@deepseek-ai/') !== 0;
+    });
+    var entries = r.entries || [];
+    var presets = r.presets || [];
+    var sessionRows = 0;
+    presets.forEach(function (p) { sessionRows += (p.rows || []).length; });
+
+    var html = '';
+    if (r.bundlesError) html += pluginNote('包清单读不到：' + escapeHtml(r.bundlesError), true);
+    if (r.officialError) html += pluginNote('官方卡片读不到：' + escapeHtml(r.officialError), true);
+    // 官方那一栏是两样拼的（PC 也是这个次序）：可开关的官方包在前，
+    // 注册了设置卡片的官方插件（终端 / Agent 循环 / 子智能体 / 网页搜索）在后。
+    html += pluginGroup('官方', official.concat(r.official || []), officialRow);
+
+    if (r.builtinError) {
+      html += pluginNote('内置插件读不到：' + escapeHtml(r.builtinError), true);
+    } else {
+      // 内置这一层自己也是一个可折的分组，里面再套「全局插件」「会话插件」两层。
+      var inner = '';
+      if (entries.length) inner += pluginGroup('全局插件', entries, invRow, 2);
+      if (sessionRows) {
+        // 这一层的数目是**四个预设各自行数之和**：同一个插件被好几个预设都带上，
+        // 所以会重复计（实测共 95 行、其实只有 32 个不重复的插件）。
+        // 这里**不再拿括号去解释**（2026-10-05 用户要那句去掉）——下面每个预设
+        // 各报各的数（29/30/6/30），加起来就是这个数，顺着看下去就能对上。
+        var sessionInner = '';
+        presets.forEach(function (p) {
+          var rows = p.rows || [];
+          if (!rows.length) return;
+          if (p.broken) sessionInner += pluginNote('这个预设的组合读不出来：' + escapeHtml(p.broken), true);
+          var body = rows.map(invRow).join('');
+          // 只有一个预设就不必再套一层；多预设才把预设名露出来（PC 那边是个下拉）。
+          // 「（默认）」照 PC 标上：它说的是「不指定模式时按它来」，用户得有这个参照。
+          sessionInner += presets.length > 1
+            ? pluginFold(p.name + (p.isDefault ? '（默认）' : ''), rows.length, body, 2)
+            : body;
+        });
+        inner += pluginFold('会话插件', sessionRows, sessionInner, 2);
+      }
+      html += inner
+        ? pluginFold('已安装 · 内置', entries.length + sessionRows, inner, 1)
+        : pluginNote('这台电脑没报出内置插件。');
+    }
+
+    html += pluginGroup('已安装 · 第三方', third, bundleRow);
+    if (!html) html = pluginNote('没有插件。');
+    return html;
+  }
+
+  function pluginNote(text, isErr) {
+    return '<div class="' + (isErr ? 'plugin-note' : 'sa-none sa-none-indent') + '">' + text + '</div>';
+  }
+
+  /**
+   * 一层**可折叠**的分组。默认收起——HTML 里不写 open 属性就自然是收着的，
+   * 「默认折叠」不需要额外的代码去保证。没有正文的空层整个不画（点开是个空壳没意义）。
+   *
+   * `depth` 只影响字号轻重（1 = 官方 / 已安装那一级，2 = 里面那两级）。
+   * `note` 是接在计数后面的小注（比如「32 个不重复，4 个预设各算各的」）。
+   */
+  function pluginFold(title, count, bodyHtml, depth, note) {
+    if (!bodyHtml) return '';
+    return '<details class="plugin-fold depth-' + (depth || 1) + '"><summary>'
+      + escapeHtml(title) + ' ' + count + (note ? '（' + escapeHtml(note) + '）' : '')
+      + '</summary>' + bodyHtml + '</details>';
+  }
+
+  /** 一堆插件：可折的一层。空的那堆整个不画（不占地方、也不说假话）。 */
+  function pluginGroup(title, rows, rowFn, depth) {
+    if (!rows.length) return '';
+    return pluginFold(title, rows.length, rows.map(rowFn).join(''), depth);
+  }
+
+  function rowHtml(name, desc, badge, descCls) {
+    return '<div class="plugin-row">'
+      + '<div class="plugin-info">'
+      + '<span class="plugin-name">' + escapeHtml(name) + '</span>'
+      + (desc ? '<span class="plugin-desc' + (descCls || '') + '">' + escapeHtml(desc) + '</span>' : '')
+      + '</div>'
+      + (badge ? '<span class="plugin-badge ' + badge[0] + '">' + escapeHtml(badge[1]) + '</span>' : '')
+      + '</div>';
+  }
+
+  /**
+   * 一行「包」（官方 / 第三方）。显示名用服务端给的 `title`（本地化标题），
+   * 没有就是包名——官方插件在 PC 上显示的正是「智能体团队」这类中文名。
+   */
+  function bundleRow(b) {
+    var desc = b.description || '';
+    if (b.problem) desc = desc ? desc + ' · ' + b.problem : b.problem;
+    return rowHtml(b.title || b.name, desc,
+      [b.enabled ? 'on' : 'off', b.enabled ? '已启用' : '已停用'],
+      b.problem ? ' plugin-problem' : '');
+  }
+
+  /**
+   * 官方那一栏的一行：两种东西都在这里。
+   *   · 包（bundles）——带启用状态，能开关；
+   *   · 设置卡片（cards）——不是开关，是一张设置页，所以没有状态徽标（PC 上也是这样）。
+   */
+  function officialRow(item) {
+    if (item.kind === 'card') return rowHtml(item.title, item.description || '', null);
+    return bundleRow(item);
+  }
+
+  /**
+   * 一行「内置插件」（Loader 条目 / 预设组合行）。`title` 是服务端压好的短名
+   * （`@deepseek-ai/dsh-tool-fs` → `tool-fs`），照 PC 的内置插件面板。
+   */
+  function invRow(e) {
+    return rowHtml(e.title || e.moduleName, e.description || '', invBadge(e));
+  }
+
+  /** 运行时状态。**问不到就不编**——预设没挂载时那一行本来就没有运行状态。 */
+  function invBadge(e) {
+    if (e.phase === 'failed') return ['err', '失败'];
+    if (e.conditional) return ['off', '按条件'];
+    if (!e.enabled) return ['off', '已停用'];
+    if (e.phase === 'active') return ['on', '运行中'];
+    if (e.phase === 'loading' || e.phase === 'pending') return ['off', '加载中'];
+    return null;
+  }
+  $('subagentsBack').addEventListener('click', saToList);
+  saPanel.addEventListener('click', function (e) {
+    if (e.target === saPanel) saPanel.classList.remove('open');
+  });
+
   // ---------------- 权限档位 ----------------
   //
   // 这是把 PC 端那道授权闸门搬到了手机上：**手机从此能指挥 Agent 把电脑提到
@@ -3553,17 +5946,53 @@
   // 映射不到时会退回标识符本身，所以这里拿到的一定是个真名字，不会是空格。
   // 页面只管显示拿到的东西。
   var permOptions = null;   // null = 还没读到（或这台电脑没这个能力）
+  var permFor = null;       // 手上这一份 currentValue 是**哪个会话**的
   var permArmed = '';       // 哪一档正在等「再点一次」
 
-  function loadPermissions() {
+  /**
+   * 读一次档位盘。
+   *
+   * **这是个要反复读的动作，不是启动时读一次就够。** 三个理由：
+   *   · 答案会变——电脑端随时能改档位，而这一块的作用就是「标出现在是哪一档」；
+   *   · 一次读不到就会永远缺这一块——宿主刚重启、绑定会话还没装进 `ctx.agents`
+   *     那段时间里，服务端如实回 `no-session`（见 lib/permissions.js 的 listPresets）。
+   *     启动时那一次正好撞上，不重读就再也回不来，只有整页刷新能让它出现。
+   *     所以设置抽屉每次打开都重读（见上面「设置」那一段）；
+   *   · **`currentValue` 是每个会话各一份的**（宿主的 `permission/preset` 记在会话自己
+   *     的日志里，`service.current(session)` 读的是这个会话那份投影）。换了会话就不能
+   *     拿上一个会话那一档接着显示——那是在说一个假话。所以换会话也要重读
+   *     （见 applySnapshot 里换会话那一段）。
+   *
+   * 传参就是「按这个会话读」；不传是「还是这个会话，重读一次」。
+   *
+   * 读不到时**只在这块本来就空着的情况下才藏起来**：已经画出来的档位不许因为一次
+   * 读失败当场消失——那是把「此刻读不到」错当成「这台电脑没有这个能力」。
+   * 换了会话则相反：那一份高亮**必须**当场撤掉，因为它不是这个会话的值。
+   * 档位列表本身留着不动——那是宿主的本子，所有会话共用一份。
+   */
+  function loadPermissions(forSession) {
+    var session = forSession === undefined ? permFor : (forSession || null);
+    if (session !== permFor) {
+      permFor = session;
+      permArmed = '';   // 「再点一次」那半次确认也是上一个会话的，不跟着走
+      if (permOptions) {
+        permOptions.currentValue = '';
+        renderPerms();
+      }
+    }
     api('/mini/api/permissions').then(function (body) {
-      if (!body || !body.ok) { $('permBlock').hidden = true; return; }
+      // 请求飞在路上时用户又切走了：这一份属于上一个会话，扔掉。
+      if (session !== permFor) return;
+      if (!body || !body.ok) {
+        if (!permOptions) $('permBlock').hidden = true;
+        return;
+      }
       permOptions = body;
       renderPerms();
     }).catch(function () {
-      // 读不到就整块不显示。附加能力缺了，不该影响发指令。
-      permOptions = null;
-      $('permBlock').hidden = true;
+      if (session !== permFor) return;
+      // 附加能力缺了不该影响发指令：一个档位都没读到过时，整块不显示。
+      if (!permOptions) $('permBlock').hidden = true;
     });
   }
 
@@ -3630,7 +6059,7 @@
       });
   }
 
-  loadPermissions();
+  loadPermissions(state.boundSessionId);
 
   // 档位按钮的点击。
   //
@@ -3651,10 +6080,12 @@
   Array.prototype.forEach.call($('segMode').children, function (btn) {
     btn.addEventListener('click', function () {
       state.mode = btn.dataset.mode;
-        $('hintMode').textContent = state.mode === 'chat' ? '聊天：常规问答对话' : '单帧：只留最新一条回复';
+      $('hintMode').textContent = modeHint();
       localStorage.setItem('dshMiniMode', state.mode);
       syncSeg();
       render();
+      // 切到「完整」：订上并把已有的过程拉下来；切走：退订、停推。
+      syncTrajectorySubscription();
     });
   });
   Array.prototype.forEach.call($('segSound').children, function (btn) {
@@ -3698,6 +6129,21 @@
   }
   applyTheme();   // 补上首屏那次没做的一件事：把状态栏颜色对齐
 
+  // ---------------- 字体大小（小 / 标准 / 大） ----------------
+  function applyFontSize() {
+    var sizes = { small: '13px', normal: '15.5px', large: '18px' };
+    document.documentElement.style.setProperty('--font-base', sizes[state.fontSize] || sizes.normal);
+  }
+  Array.prototype.forEach.call($('segFont').children, function (btn) {
+    btn.addEventListener('click', function () {
+      state.fontSize = btn.dataset.font;
+      localStorage.setItem('dshMiniFont', state.fontSize);
+      applyFontSize();
+      syncSeg();
+    });
+  });
+  applyFontSize();  // 首屏应用
+
   function syncSeg() {
     Array.prototype.forEach.call($('segMode').children, function (b) {
       b.classList.toggle('active', b.dataset.mode === state.mode);
@@ -3708,6 +6154,9 @@
     Array.prototype.forEach.call($('segTheme').children, function (b) {
       b.classList.toggle('active', b.dataset.theme === state.theme);
     });
+    Array.prototype.forEach.call($('segFont').children, function (b) {
+      b.classList.toggle('active', b.dataset.font === state.fontSize);
+    });
   }
 
   // 会话切换挪到左侧导航栏了（原来这里是设置里的下拉框）。
@@ -3756,6 +6205,71 @@
     });
   }
 
+  /**
+   * 繁忙时的发送行为（2026-10-05 用户要求搬进手机设置）。
+   *
+   * 这是 PC「设置 → 通用」里那一条的同款：智能体跑着的时候，你发的话是
+   * 排队等这一轮跑完，还是当场插进去让它调整方向。**两端共用宿主那一份设置**，
+   * 所以这里改完，电脑上也是这个值——这是用户拍板要的（同一个开关，别两端各存一份）。
+   *
+   * **读不到就整条不画**：拿不到宿主设置时把那一行藏起来，不摆一个点了没用的开关。
+   * 这和插件页「宁可少画，不凭空多画」是同一条口径。
+   *
+   * 写的时候带上服务端给的 revision（乐观锁）：万一电脑上刚改过，这次写入会被挡下来，
+   * 而不是把对方那次改动悄悄盖掉——那种覆盖用户看不见，最难查。
+   */
+  var busyEnter = { current: 'queue', revision: null, ready: false };
+  function paintBusyEnter() {
+    Array.prototype.forEach.call($('segBusyEnter').children, function (b) {
+      b.classList.toggle('active', b.dataset.busy === busyEnter.current);
+    });
+  }
+  function loadBusyEnter() {
+    api('/mini/api/busy-enter').then(function (r) {
+      if (!r || !r.ok) {
+        // 这台电脑没提供这个设置（老版本 DSH、或设置文档里没这一项）。
+        // 藏起来就好，不用报错——那不是「出错」，是「这里本来就没有」。
+        $('rowBusyEnter').hidden = true;
+        return;
+      }
+      busyEnter.current = r.current === 'steer' ? 'steer' : 'queue';
+      busyEnter.revision = typeof r.revision === 'number' ? r.revision : null;
+      busyEnter.ready = true;
+      $('rowBusyEnter').hidden = false;
+      paintBusyEnter();
+    }).catch(function () {
+      $('rowBusyEnter').hidden = true;
+    });
+  }
+  $('segBusyEnter').addEventListener('click', function (e) {
+    var btn = e.target.closest ? e.target.closest('button[data-busy]') : null;
+    if (!btn || !busyEnter.ready) return;
+    var next = btn.dataset.busy;
+    if (next === busyEnter.current) return;
+    // 先画再发：这一下是用户自己按的，立刻有反馈；发失败了再画回去并说清。
+    var prev = busyEnter.current;
+    busyEnter.current = next;
+    paintBusyEnter();
+    api('/mini/api/busy-enter', {
+      method: 'POST',
+      body: JSON.stringify({ value: next }),
+    }).then(function (r) {
+      if (r && r.ok) {
+        toast(r.current === 'steer' ? '繁忙时改为插话发送' : '繁忙时改为排队发送');
+        busyEnter.revision = typeof r.revision === 'number' ? r.revision : busyEnter.revision;
+        return;
+      }
+      // 失败要画回去——留着那个没生效的选中态，用户会以为改成功了。
+      busyEnter.current = prev;
+      paintBusyEnter();
+      toast(r && r.reason === 'unavailable' ? '这台电脑改不了这一项' : '没能改成，再试一次');
+    }).catch(function () {
+      busyEnter.current = prev;
+      paintBusyEnter();
+      toast('没能改成，检查一下连接');
+    });
+  });
+
   if (NOTIFY_OK) {
     // 先注册 service worker。**这一步不申请权限**——权限要用户主动点一下才给，
     // 页面一加载就弹窗会被浏览器直接拒掉，而且很讨厌。
@@ -3931,6 +6445,14 @@
   function watchBuild() {
     if (!state.token) return;
     api('/mini/api/version').then(function (r) {
+      // 设置页底部那行版本。**问到才显示**——问不到就整行不出现，
+      // 不拿「unknown」糊一行上去（那个字对用户没意义，还像页面坏了）。
+      // 产品名写全称（DeepSeek Harness）：缩写 DSH 只有我们自己人认。
+      // 大小写照 DSH 自己的界面串（实测 49 处全是这个写法）。
+      if (r && r.dshVersion && r.dshVersion !== 'unknown') {
+        var el = $('dshVersion');
+        if (el) { el.textContent = 'DeepSeek Harness ' + r.dshVersion; el.hidden = false; }
+      }
       if (!r || !r.build || r.build === BUILD) return;
       if (inputEl.value && inputEl.value.trim()) return;
       location.reload();