magic-agent 1.0.49 → 1.0.108

package/client-ui/shared/conv/03-chat-message.js

@@ -49,10 +49,16 @@ function qaHasContent(){
 function qaSyncChatMode(){ qaSetChatMode(qaHasContent()); qaDotsSync(); }
 /* 用户**离开底部**（点圆点跳转 / 自己滚上去看历史）→ 后续流式增量不再把他拽回底部。
    ⚠️ 2026-10-20 用户：「滚动不了」—— 旧口径只认圆点跳转，手动上滚仍被每条增量拽回底部，
-     长答复流式期间根本没法看上面。现在以「是否贴近底部」为准（见 qaDotsBind 的 scroll 监听）。
-   回到底部 / 发新消息即复位。 */
+     长答复流式期间根本没法看上面。现在以「是否贴近底部」为准（见 qaScrollGateBind 的监听）。
+   回到底部 / 发新消息即复位。
+   ⚠️ 这个标记**只有绑了 qaScrollGateBind 才会被改动** —— 宿主不绑，它就恒为 false。 */
 let qaUserAway = false;
 function qaNearBottom(s){ return !!s && (s.scrollHeight - s.scrollTop - s.clientHeight) < 24; }
+/** 画布**装得下比一屏更多**的内容吗 —— 手势要不要当帧关闸就看它。
+ *  ⚠️ 不能用「此刻是否已离开底部」当门槛：手指刚抬起时 scrollTop 还贴在底部（浏览器要到
+ *     下一帧才滚），那一刻判 nearBottom 恒为真 → 手势永远关不掉闸，手机上还是会被拽回。
+ *     反过来也不能不判：内容不足一屏时（没得滚）若把手势当真，一次误触就再也不跟随新内容了。 */
+function qaCanScroll(s){ return !!s && s.scrollHeight > s.clientHeight + 4; }
 function qaScrollIntoView(){
   if(qaPaintBg) return;                          // 后台 run 的增量不许拽动前台画布（见 qaPaintBg）
   if(qaUserAway) return;                         // 用户跳上去看历史了，别抢他的滚动位置
@@ -201,11 +207,37 @@ function qaDotsFlash(msg){
  *  ⚠️ MutationObserver 只盯 childList（不盯 subtree）：圆点数只跟顶层消息有关，
  *     正文/工具卡内部怎么长都不影响 —— 少一层回调，流式期间也不至于每笔都刷。 */
 function qaDotsBind(){
+  qaScrollGateBind();                            // 圆点轨与滚动闸共用同一批监听（见下）
   const s = $("#qa-stream");
-  if(!s || s.dataset.dotsBound === "1") return;
-  s.dataset.dotsBound = "1";
+  if(!s || s.dataset.dotsObserved === "1") return;
+  s.dataset.dotsObserved = "1";
   let raf = 0;
   const kick = ()=>{ if(raf) return; raf = requestAnimationFrame(()=>{ raf = 0; qaDotsSync(); }); };
+  new MutationObserver(kick).observe(s, { childList: true });
+  window.addEventListener("resize", kick);
+  qaDotsSync();
+}
+/** 滚动闸：**流式增量能不能把你拽回底部**，全靠这里维护的 `qaUserAway`。
+ *
+ *  ⚠️ 2026-10-21 用户：「移动端对话框向上滑动看历史时总又自动跳回聚焦到结尾」。
+ *     根因不在判断逻辑，而在**没人绑**：这套监听原来只写在 qaDotsBind 里（圆点轨的一部分），
+ *     而 qaDotsBind 只有 magic-test 工作台调（`src/js/17-bind.js`）；两个组件宿主
+ *     （PC / 移动）引的是 `shared/conversation.js`，它从来没调过 —— 于是
+ *     `qaUserAway` 恒为 false，`qaScrollIntoView()` 每一笔增量都 `scrollTop = scrollHeight`。
+ *     桌面端还能靠触控板把内容顶住（scroll 后下一笔增量又拽回，表现为「抖」），
+ *     手机上手指一松就是「跳到结尾」。
+ *     所以把它**从圆点轨里拆出来**独立成函数，由画布自己绑（见 conversation.js 的 create），
+ *     圆点轨只是顺带复用（qaDotsBind 里也调一次，幂等）。
+ *
+ *  三条手势各自为什么要有：真机上 scroll 事件是**下一帧**才来的，而流式增量可能在那之前
+ *  就贴了底 —— 只靠 scroll 监听仍会「刚滚上去又被拽回」。所以手势**当帧**就置位：
+ *    · wheel（桌面滚轮 / 触控板）；
+ *    · touchmove（手机拖动）—— 移动端根本没有 wheel 事件，缺这条等于没有闸；
+ *    · scroll（惯性滑动 / 程序滚动兜底，回到底部时复位）。 */
+function qaScrollGateBind(){
+  const s = $("#qa-stream");
+  if(!s || s.dataset.scrollGate === "1") return;
+  s.dataset.scrollGate = "1";
   s.addEventListener("scroll", ()=>{
     /* 贴近底部 → 恢复「贴底」跟随；离开底部（手动上滚、点圆点、翻历史）→ 停止跟随，
        否则流式每个增量都把用户拽回底部（2026-10-20「滚动不了」）。 */
@@ -214,17 +246,30 @@ function qaDotsBind(){
   }, { passive: true });
   /* 真人滚动手势 → 放掉「刚点过的那一轮」，高亮重新跟着视口走
      （只认滚轮 / 触摸：平滑滚动的 scroll 事件不算，否则跳转自己就把 pin 冲掉了）。
-     ⚠️ 上滚手势在这里**立刻**置 `qaUserAway`（2026-10-20）：scroll 事件要到下一帧才来，
+     ⚠️ 上滚手势在这里**立刻**置 `qaUserAway`（见上面的函数头）：scroll 事件要到下一帧才来，
         流式增量却可能在这之前就贴底 —— 只靠 scroll 监听仍有「刚滚上去又被拽回」的竞态。 */
   const unpin = ()=>{ const r = $("#qa-dots"); if(r) r.__pin = null; };
   s.addEventListener("wheel", (ev)=>{
-    if(ev && ev.deltaY < 0 && !qaNearBottom(s)) qaUserAway = true;
+    if(ev && ev.deltaY < 0 && qaCanScroll(s) && !qaNearBottom(s)) qaUserAway = true;
     unpin(); qaDotsMark();
   }, { passive: true });
-  s.addEventListener("touchstart", ()=>{ unpin(); qaDotsMark(); }, { passive: true });
-  new MutationObserver(kick).observe(s, { childList: true });
-  window.addEventListener("resize", kick);
-  qaDotsSync();
+  /* 手机：手指往下拖 = 内容往上翻（`touchmove` 里比较上一次 Y 才判得出方向）。
+     ⚠️ 门槛是「**装得下**能滚的内容」而不是「此刻已经离开底部」：手指一落的瞬间 scrollTop
+        还贴在底部（浏览器下一帧才滚），拿 nearBottom 当门槛的话手势永远关不掉闸。
+     ⚠️ passive 不能省：这个监听**不阻止滚动**，只读坐标。 */
+  let lastTouchY = 0;
+  s.addEventListener("touchstart", (ev)=>{
+    const t = ev && ev.touches && ev.touches[0];
+    if(t) lastTouchY = t.clientY;
+    unpin(); qaDotsMark();
+  }, { passive: true });
+  s.addEventListener("touchmove", (ev)=>{
+    const t = ev && ev.touches && ev.touches[0];
+    if(!t) return;
+    /* 手指**向下**移动（clientY 变大）＝ 内容往上翻 = 在看历史 → 立刻停止跟随。 */
+    if(t.clientY - lastTouchY > 2 && qaCanScroll(s)) qaUserAway = true;
+    lastTouchY = t.clientY;
+  }, { passive: true });
 }
 /* ── 头像的两个**可覆盖默认值**（2026-10-17）────────────────────────────
    它们是「内核有默认、宿主可在加载后覆盖」的那种符号，**不是**必须实现品：
@@ -298,6 +343,40 @@ function qaBotAvatarHtml(){
   if(src) return `<span class="qa-av"><img class="qa-av-img" src="${escHtml(src)}" alt="" draggable="false"></span>`;
   return `<span class="qa-av qa-av-bot" aria-hidden="true">${QA_AV_BOT_SVG}</span>`;
 }
+/* 模型 id → **展示用** id：剥掉 codebuddy 系自定义模型的 `custom-local:` 前缀。
+   （2026-10-21 用户：「codebuddy的custom-local的模型前缀不用显示」）
+   前缀只是 App / CLI 内部区分自定义端点的约定，对用户是噪点；`--engines` 的清单早就
+   剥过了（agent.StripCustomLocalPrefix），但**会话登记表 / start 事件 / 引擎 result 行**
+   里仍是完整 id —— 那些是传给 `-m` 与落库的值，不能改，只能在渲染这一层剥。
+   ⚠️ 只用于显示：`-m`、任务落库、payload 一律仍用完整 id（见 codebuddyCore.modelArg）。 */
+function qaModelText(id){
+  return String(id == null ? "" : id).trim().replace(/^custom-local:/, "");
+}
+/* 模型 → **展示用倍率**（`"×0.34"`）；没有倍率（引擎不给数据 / 该模型不计费）→ `""`。
+   数据来自 `--engines` 的 `model_credits`（见 internal/cli/root.go）：键与 `models[]` 同形，
+   都已剥过 `custom-local:`，所以这里也按 qaModelText 归一后再查。
+   PC 宿主在 glue 层把 snake_case 归一成了 `modelCredits`，两种拼写这里都认 —— 内核不知道
+   宿主拿的是哪一份原样 JSON。**不给倍率时返回空串而不是 "×1"**：编一个默认倍率等于替
+   引擎宣称计费口径，宁可不显示。
+   `engine` 给了就只查那一个引擎（不同引擎的同名模型倍率可能不同）；没给就取清单里第一个
+   有值的 —— 给「这条消息用的模型」这类宿主没记引擎的场景兜底。 */
+function qaModelCredit(engines, engine, id){
+  const key = qaModelText(id);
+  if(!key) return "";
+  const list = Array.isArray(engines) ? engines : [];
+  const read = (e)=>{
+    const map = (e && (e.model_credits || e.modelCredits)) || null;
+    if(!map || typeof map !== "object") return "";
+    const v = String(map[key] == null ? "" : map[key]).trim();
+    return v ? "×" + v : "";
+  };
+  if(engine){
+    for(const e of list) if(e && e.engine === engine) return read(e);
+    return "";
+  }
+  for(const e of list){ const c = read(e); if(c) return c; }
+  return "";
+}
 /* **引擎名小标**（2026-09-22 用户：「头像旁边显示引擎名字」；同日追加「名字显示的大一点
    再加上模型显示」→ 文案 = 「引擎 · 模型」，字号见 app.css M8）：左侧消息头像独占一行（见文末 M7）
    之后，头像那一行右侧空着 —— 把「这一条是哪个引擎、哪个模型说的」挂在头像右边。
@@ -305,7 +384,8 @@ function qaBotAvatarHtml(){
    见 app.css 的 `.qa-who` 只认左侧形状；⚠️ 审核引擎那条 2026-09-30 起也在左侧，但它的小标挂在
    **机器侧那条独立消息**上，报告本体不重复挂 —— 见 13-dispatch-stream 与 qaTraceToLeft）。
    空引擎名 → 空串：宁可没有，也不写「未知」占位。
-   模型存的是 **id**，显示走 qaModelName（与「生成中」胶囊同一套分工：名字只活在展示层）。
+   模型存的是 **id**，显示走 qaModelName（与「生成中」胶囊同一套分工：名字只活在展示层）；
+   自定义模型的 `custom-local:` 前缀在显示前经 qaModelText 剥掉。
    ⚠️ `modelOnly`（2026-10-20 用户：「只显示模型即可 不然现在换行了」）：头像那一行上并着
       「运行中 · 耗时计时」，而这一行是 `flex-flow:row wrap` —— 「引擎 · 模型」整串
       （引擎名 + 模型显示名，两段都能很长）会把余下宽度吃光，秒数被挤到**换行**，
@@ -314,7 +394,7 @@ function qaWhoLabel(engine, model, modelOnly){
   const nm = String(engine == null ? "" : engine).trim();
   if(!nm) return "";
   const md = String(model == null ? "" : model).trim();
-  const mName = md ? qaModelName(md, nm) : "";
+  const mName = md ? qaModelName(qaModelText(md), nm) : "";
   if(modelOnly) return mName || nm;
   return mName ? `${nm} · ${mName}` : nm;
 }
@@ -383,6 +463,13 @@ function qaMsgRetry(msg){
 function qaRenderMine(text, atts){
   const s = $("#qa-stream"); if(!s) return;
   s.hidden = false;
+  /* 空态那句「还没有事件」得先让位：它只在画布一条都还没有时该在。
+     ⚠️ 以前只有**事件流**那条路径会摘它（conversation.js 的 ingest），而用户气泡
+        是宿主直接调这里画的、不经过事件流 —— 于是发出第一句之后，画布上同时挂着
+        「还没有事件。写一句任务…」和用户那句，看着像消息没进去（2026-10-21 截图）。
+        放在这里摘是**唯一**不会漏的位置：实时发送 / 排队提交 / 历史回放三条路径都经过它。 */
+  const empty = s.querySelector(".conv__empty");
+  if(empty) empty.remove();
   const div = document.createElement("div");
   div.className = "qa-msg qa-mine";
   div.innerHTML = `<div class="qa-ico">${qaAvatarHtml("mine")}</div><div class="qa-bd"><div class="qa-t md-body"></div></div>`;
@@ -436,6 +523,9 @@ function qaRenderMine(text, atts){
         否则他跳上去看历史之后发的那条会落在折线以下、看不见自己刚问的话。 */
   qaUserAway = false;
   qaScrollIntoView();
+  /* 返回这条消息的根节点：调用方要给它挂状态（比如排队中的 `is-queued`）。
+     ⚠️ 老调用方一律不看返回值，加上它不影响任何人。 */
+  return div;
 }
 /** 「引擎 · 模型 · 生成中」= 1 枚胶囊（用户 2026-09-17）：
  *  转圈 + 文字同装一枚圆角胶囊（.qa-run-pill），实时生成行与派发快照的「生成中」状态行
@@ -758,7 +848,7 @@ function qaRenderAnswer(host){
 
   const run = document.createElement("div");
   run.className = "qa-run";
-  run.innerHTML = qaRunPillHtml(`${qaEngine}${qaModel ? " · " + qaModelName(qaModel, qaEngine) : ""} · 生成中`);
+  run.innerHTML = qaRunPillHtml(`${qaEngine}${qaModel ? " · " + qaModelName(qaModelText(qaModel), qaEngine) : ""} · 生成中`);
   s.appendChild(run);
   /* ⚠️ 落笔即贴底（2026-09-23，与 qaRenderMine / qaRenderDone 同一约定）。
      为什么必须在**这一行之后**：这条应答的立身有两块 —— 气泡节点（上面那个 div）+ 这枚
@@ -1033,8 +1123,9 @@ function qaRenderAnswer(host){
     t.count.textContent = " · " + t.num + "个";             // 实时更新计数
     return t;
   }
-  /** 落定即收进本段的折叠组：只认 toolCall / agentCall 落在**流里**的那些卡
-   *  （子代理内部卡 subTool 挂在父卡体内，不在流里）。幂等。
+  /** 落定即收进本段的折叠组：只认 toolCall 落在**流里**的那些卡
+   *  （子代理内部卡 subTool 挂在父卡体内，不在流里；委派卡 agentCall 刻意不设
+   *  `__qaFlow`，它是里程碑、始终留在正文里，见那里的说明）。幂等。
    *  ⚠️ 归属组记在**节点属性**上（`__qaGroup`）：这一笔跑完时 `curGroup` 可能早已换段清空，
    *     靠它才能回到**本段**那个组，而不是现建一个新组（那会把这张卡甩到整条流的末尾）。 */
   function collapseIntoGroup(card){
@@ -1187,7 +1278,9 @@ function qaRenderAnswer(host){
      生命周期由 ② 的 system 事件驱动（start/progress/notify 只改胶囊）；
      最终结果仍按 tool_use id 配对写进「输出」（done）—— 没等到 task_notification
      就收账时，胶囊在 done 里一并落定，不会留下常驻转圈。 */
-  function agentCall(name, argsPreview, argsFull, promptText){
+  /* chipText：初始胶囊文案（可选）。团队模式预开的卡里，等上游的子任务写
+     「等待上游 t1」—— 比一律「等待启动」更能说明它为什么不动。 */
+  function agentCall(name, argsPreview, argsFull, promptText, chipText){
     // 委派卡的摘要本来就是 description（见调用处的 desc 取值）→ 按人话渲染
     const t = mkCard(name, argsPreview, argsFull, true);
     const card = t.card;
@@ -1195,7 +1288,7 @@ function qaRenderAnswer(host){
     card.querySelector(".qa-tool-ico").innerHTML = QA_ICONS.agent;
     const chip = document.createElement("span");
     chip.className = "qa-agent-chip";
-    chip.textContent = "等待启动";
+    chip.textContent = chipText || "等待启动";
     card.querySelector(".qa-tool-meta").prepend(chip);
     const bdEl = card.querySelector(".qa-tool-bd");
     if(promptText != null && String(promptText).length){
@@ -1212,28 +1305,55 @@ function qaRenderAnswer(host){
     sub.innerHTML = `<div class="qa-sub-h">子代理活动</div>`;
     bdEl.appendChild(sub);
     /* 委派卡是里程碑：正文/思考在这一笔处封口，但**不封工具段** —— 它仍属于这一段的
-       「内部活动」，与前后的工具卡同处一段。**运行中留在外面**（卡里挂着子代理的实时活动，
-       藏进折叠组等于把正在跑的委派藏起来）；**落定后同样收进「已调用工具 · N个」**
-       （2026-10-12 口径：历史都进组，外面只留还在跑的那张 —— 见 collapseIntoGroup）。 */
-    const g = ensureGroup();
+       「内部活动」，与前后的工具卡同处一段。
+       ⚠️ **不设 `__qaFlow`**（2026-10-21 用户：「应该子任务也在对话中可见，类似于引擎的
+          subagent」）：委派的是「一段活」，它的结局就是用户要看的结果，落定后必须留在
+          正文里。于是 `collapseIntoGroup` 的 `__qaFlow` 闸门直接跳过它 —— 不进
+          「已调用工具 · N个」，也不被 `segFold` / `wrapTurn` 搬走（那两个只认
+          `.qa-think` / `.qa-tools` / `.qa-turn`）。普通工具卡维持原口径不变。 */
     sealThink(); sealText();
-    card.__qaFlow = true;
-    card.__qaGroup = g;
     bd.appendChild(card);
     qaScrollIntoView();
     const api = {
       done(resultText, ok = true){
         t.done(resultText, ok);
-        if(chip.classList.contains("run")){       // 通知缺失时兜底落定（完成 → jade 绿）
+        /* 通知缺失时兜底落定（完成 → jade 绿）。
+           ⚠️ 判据不能是「胶囊还在 run」（2026-10-21）：团队模式的子任务由 core 合成，
+              不走引擎的 task_started / task_progress，胶囊到收卡时可能还停在初始的
+              「等待启动」—— 只认 run 的话那条一直写着「等待启动」，看起来像卡死。
+              真正该跳过的只有「已经被 task_notification 明确落定过」的（下面打 settled 标）。 */
+        if(chip.dataset.settled !== "1"){
           chip.classList.remove("run");
           if(ok) chip.classList.add("ok");
           chip.textContent = ok ? "完成" : "未完成";
         }
       },
       get state(){ return t.state; },
-      start(){ chip.textContent = "运行中"; chip.classList.add("run"); },
+      /* 子会话徽标（2026-10-21，团队模式）：子任务自己的引擎会话 id。
+         它与「完成/运行中」胶囊并排，说明这段活跑在哪个会话 —— 会话列表里不单列，
+         但在这里看得见，历史回放时同样能复原。幂等：同一个 id 只更新不重复插。 */
+      subSession(sid){
+        const s = String(sid || "");
+        if(!s) return;
+        let el = card.querySelector(".qa-agent-sess");
+        if(!el){
+          el = document.createElement("span");
+          el.className = "qa-agent-sess";
+          chip.insertAdjacentElement("afterend", el);
+        }
+        if(el.dataset.sid === s) return;
+        el.dataset.sid = s;
+        el.textContent = "子会话 " + s.slice(0, 8);
+        el.title = s;
+      },
+      /* 开跑 = 卡里开始有子代理的活动。核心脏路径（claude 系）由 system/task_started 驱动，
+         但**团队模式**的子任务是 core 自己合成的、没有那套 system 事件 —— 由渲染层在
+         第一条子事件到达时自己点亮（见 09-stream-apply.js 的 agStart），否则胶囊会一直
+         写着「等待启动」直到收卡。落定之后不再回退（notify 打过 settled）。 */
+      start(){ if(chip.dataset.settled === "1") return; chip.textContent = "运行中"; chip.classList.add("run"); },
       progress(label){ if(chip.classList.contains("run")) chip.textContent = String(label || "进行中"); },
       notify(label, ok = true){
+        chip.dataset.settled = "1";               // 明确落定过 → done 不再改写它
         chip.classList.remove("run");
         if(ok) chip.classList.add("ok");
         chip.textContent = String(label || (ok ? "完成" : "已结束"));

package/client-ui/shared/conv/09-stream-apply.js

@@ -61,6 +61,11 @@ function qaStreamApplyOne(ev, ctx){
   const evParent = ev.parent != null ? String(ev.parent)
     : (ev.parent_tool_use_id != null ? String(ev.parent_tool_use_id) : null);
   const agOf = (id)=> id != null ? agents.get(id) : null;
+  /* 委派卡里**第一条子事件**到达 = 这次委派真的开跑了。
+     claude 系原生流由 system/task_started 驱动胶囊；而**团队模式**的子事件是 core 自己
+     合成的、没有那套 system 事件 —— 不在这里点亮的话，那张卡从头到尾写着「等待启动」，
+     用户看到的是「子任务好像卡死了」（2026-10-21 实测）。start() 自带幂等：已落定就退出。 */
+  const agStart = (ag)=>{ if(ag && typeof ag.start === "function") ag.start(); return ag; };
   /* 会话锚点：**任何**带 session_id 的事件都当场认（2026-10-15）。
      ⚠️ 以前只在 ask / result / error / turn_failed / end / turn_end 这六条分支里认 ——
      等于「等到终点事件才绑锚点」。而 core 在 `--events` 下一拿到 id 就**每行都带**
@@ -71,6 +76,14 @@ function qaStreamApplyOne(ev, ctx){
      历史回放不受影响：那条路径的 ctx.onSession 是空函数（宿主侧只读回放）。 */
   const sidAny = ev.session_id || ev.sessionId;
   if(sidAny && typeof ctx.onSession === "function") ctx.onSession(sidAny);
+  /* 子会话徽标（2026-10-21，团队模式）：团队事件带 sub_session_id = 这个子任务**自己的**
+     引擎会话 id。它**不**是这条对话的锚点（锚点只认 session_id，别拿它调 onSession），
+     只把「这段活跑在哪个会话」标到父委派卡头上 —— 子会话绑定在主会话里一起显示/存档，
+     会话列表不单列。子事件一条条来，subSession 自己幂等。 */
+  if(ev.sub_session_id && evParent){
+    const agSs = agOf(evParent);
+    if(agSs && typeof agSs.subSession === "function") agSs.subSession(String(ev.sub_session_id));
+  }
   const finishTools = (ok)=>{                 // 流结束/失败时兜底：还在转圈的工具卡一律收账
     ctx.tools.forEach(tc=>{ if(tc.state === "running") tc.done("", ok); });
     ctx.tools.clear();
@@ -95,7 +108,7 @@ function qaStreamApplyOne(ev, ctx){
       const mdl = String(ev.model || "");
       const retry = Number(ev.attempt || 0) > 0;
       if(typeof h.setRunLabel === "function"){
-        h.setRunLabel(`${eng}${mdl ? " · " + qaModelName(mdl, eng) : ""} · 生成中`);
+        h.setRunLabel(`${eng}${mdl ? " · " + qaModelName(qaModelText(mdl), eng) : ""} · 生成中`);
       }
       /* 头像右边的「引擎 · 模型」小标同一时机跟成实际值（与胶囊同一条口径：
          界面说 A、实际跑 B 不行）。机器侧 `.qa-trace`（审查轮 / 数字分身的活动行）
@@ -126,7 +139,7 @@ function qaStreamApplyOne(ev, ctx){
     }
     case "thinking":
       // ③ 子代理思考 → 父卡嵌套区注脚；主会话思考 → 思考区
-      if(evParent && agOf(evParent)) agOf(evParent).subNote(ev.text || "");
+      if(evParent && agOf(evParent)) agStart(agOf(evParent)).subNote(ev.text || "");
       else {
         h.appendThinking(ev.text || "");
         /* 过程步骤（2026-09-23）：主会话思考也记进台账 —— 收尾时随消息一起落库，
@@ -137,7 +150,7 @@ function qaStreamApplyOne(ev, ctx){
       break;
     case "text":
       // ③ 子代理正文 → 父卡嵌套区；主会话正文 → 逐字正文
-      if(evParent && agOf(evParent)) agOf(evParent).subText(ev.text || "");
+      if(evParent && agOf(evParent)) agStart(agOf(evParent)).subText(ev.text || "");
       else {
         h.appendText(ev.text || "");
         /* 消息台账（2026-09-22）：主会话正文逐段累加进 run.msgText —— 收尾时它就是要落进
@@ -177,17 +190,24 @@ function qaStreamApplyOne(ev, ctx){
          「这一轮工具全带 description」时留下一个「已调用工具 · 0个」的空组。 */
       const tid = ev.tid != null ? ev.tid : ev.id;
       const argsText = ev.text || ev.args || "";
-      const ag = agOf(evParent);
+      const ag = evParent ? agStart(agOf(evParent)) : null;
       /* 提问卡判定：qaAskParse 只跑一次（形状不稳、解析不便宜，下面还要用结果） */
       const askQs = (typeof h.askCard === "function" && qaIsAskTool(ev.name)) ? qaAskParse(argsText) : null;
       if(/^agent$|^task$/i.test(String(ev.name || "")) && !ag){
         // ① 主会话委派：专属卡（任务词 + 状态胶囊 + 嵌套区），按 id 登记
         let o = ev.inputObj || null;
         if(!o && argsText){ try { o = JSON.parse(argsText); } catch(e2){ /* 非 JSON 参数只显示原文 */ } }
+        /* 团队模式的第二条同 id tool_use = **开跑信号**（core 在计划确定时就为全部子任务
+           预开了卡；等上游的那些先显示「等待上游 tN」）。命中已有卡只点亮它 ——
+           重画的话一个子任务会变成两张卡。 */
+        const prev = tid != null ? agents.get(String(tid)) : null;
+        if(prev){ agStart(prev); break; }
         const desc = (o && (o.description || o.subagent_type)) || ev.preview || "";
         const prompt = (o && (o.prompt || o.task || o.promptText)) || "";
+        const deps = (o && Array.isArray(o.deps)) ? o.deps.map(String).filter(Boolean) : [];
+        const chipText = deps.length ? ("等待上游 " + deps.join(" / ")) : "";
         const card = typeof h.agentCall === "function"
-          ? h.agentCall(ev.name || "Agent", String(desc || ""), argsText, String(prompt))
+          ? h.agentCall(ev.name || "Agent", String(desc || ""), argsText, String(prompt), chipText)
           : h.toolCall(ev.name || "Agent", ev.preview || "", argsText);   // 旧手柄无 agentCall → 退普通卡
         if(tid != null){ ctx.tools.set(tid, card); agents.set(String(tid), card); }
       }else if(ag && typeof ag.subTool === "function"){
@@ -249,7 +269,11 @@ function qaStreamApplyOne(ev, ctx){
       // 期望载荷: { tid|id, text(结果串,可缺省), ok(布尔,缺省 true) }
       const tid = ev.tid != null ? ev.tid : ev.id;
       const tc = tid != null ? ctx.tools.get(tid) : null;
-      if(tc) tc.done(qaToolOutForDisplay(ev.text || ""), ev.ok !== false);
+      if(tc){
+        tc.done(qaToolOutForDisplay(ev.text || ""), ev.ok !== false);
+        /* 收卡兜底再补一次子会话徽标（渲染开始前的子事件可能没赶上，回放时尤其如此）。 */
+        if(ev.sub_session_id && typeof tc.subSession === "function") tc.subSession(String(ev.sub_session_id));
+      }
       else if(evParent && agOf(evParent) && typeof agOf(evParent).subNote === "function")
         agOf(evParent).subNote("结果回执：" + String(ev.text || "").slice(0, 400)); // ③ 无卡可填 → 父卡注脚
       else if(typeof h.marker === "function"){
@@ -383,6 +407,31 @@ function qaStreamApplyOne(ev, ctx){
                    detail: Object.assign({}, ev, { kind: "notice" }), status: ev.status || "" });
       else if(typeof h.note === "function") h.note(String(ev.text || ev.notice || ""));
       break;
+    /* 团队模式的任务列表（KindTasks，见 internal/team/board.go）：一条团队会话里**唯一**那张任务卡。
+       快照语义 —— core 每次任务状态变化都把整份清单重发一次（`text` = {"tasks":[…]}），
+       这里只做「整块换内容」：h.todoList 原地更新同一块面板（见 03-chat-message），
+       不增量拼接、也不会变成「一个子任务一张卡」。
+       ⚠️ 状态词表是 core 侧的 pending / running / done / failed / skipped，
+          画面统一用任务列表的 is-* 类（running 就是任务列表里的 in_progress）。
+       ⚠️ 以前没有这条分支 → 掉进 default 被画成「未识别事件 · tasks」。 */
+    case "tasks": {
+      let snap = null;
+      try { snap = JSON.parse(ev.text || ""); } catch(_) { snap = null; }
+      const arr = (snap && Array.isArray(snap.tasks)) ? snap.tasks : [];
+      const rows = arr.filter(t=>t && typeof t === "object").map(t=>{
+        const st = String(t.status || "pending").toLowerCase();
+        return {
+          text: String(t.title || t.id || ""),
+          status: st === "running" ? "in_progress"
+            : st === "done" ? "completed"
+            : (st === "failed" || st === "skipped") ? st : "pending",
+          /* 行尾标注「引擎 · 角色」：主会话的任务列表卡要能一眼看出这一行派给了谁 */
+          meta: [t.engine, t.role || t.kind].filter(Boolean).join(" · "),
+        };
+      }).filter(r=>r.text);
+      if(typeof h.todoList === "function") h.todoList(rows);
+      break;
+    }
     /* 模型产出的图片（KindImage，见 internal/agent/stream.go）：`text` 就是图片本体
        `data:<media_type>;base64,…`。图算**正文的一部分**（对齐 h.appendImage 的约定：
        插在当前正文块的打字预览之前，图后到的文字自然排在图下）。

package/client-ui/shared/conv/19-attachments.js

@@ -183,7 +183,9 @@ async function attSave(a){
   let item = null;
   if(window.desk && typeof window.desk.pasteImage === "function"){
     const buf = await a.blob.arrayBuffer();
-    const r = await window.desk.pasteImage({ buf, label: "paste" });
+    /* type 一并给桥：压缩后可能是 WebP/JPEG（见 attCompress），落盘端要靠它选扩展名。
+       老桥忽略多出来的字段，行为不变。 */
+    const r = await window.desk.pasteImage({ buf, type: a.blob.type || "image/png", label: "paste" });
     if(!r || !r.ok) throw new Error((r && r.error) || "写入本机失败");
     item = r.item;
   }else{
@@ -412,6 +414,18 @@ function qaArtBase(){
   }catch(e){ /* 拿不到就当没有基准 */ }
   return "";
 }
+/** 取宿主桥函数。`window.desk` 可能是**冻结**的宿主桥（桌面壳 preload 注入的那份），
+ *  宿主补不进去的方法由 conversation.js 的 installDeskProbe 挪到 `window.__qaDeskExtra`
+ *  —— 两处都问一遍，冻结与否都能拿到通道。 */
+function qaDeskFn(name){
+  try{
+    if(typeof window !== "undefined" && window.desk && typeof window.desk[name] === "function") return window.desk[name];
+    const x = (typeof window !== "undefined") ? window.__qaDeskExtra : null;
+    if(x && typeof x[name] === "function") return x[name];
+  }catch(e){ /* 通道不通 -> null */ }
+  return null;
+}
+
 /** 落盘地址：宿主给了回读通道（`window.desk.mediaUrl`，组件宿主走 /desk/media）就用它；
  *  桌面壳的页面是 `file://` → 拼 `file://`（与 qaShotSrc 同一招）；
  *  产物库里的（`~/.magic-test/images|pastes/…`）走内置后端，预览态也通。 */
@@ -419,9 +433,10 @@ function qaArtUrl(abs){
   const p = String(abs || "");
   if(!p) return "";
   try{
-    if(typeof window !== "undefined" && window.desk && typeof window.desk.mediaUrl === "function"){
-      const u = window.desk.mediaUrl(p);
-      if(u) return u;
+    const u = qaDeskFn("mediaUrl");
+    if(u){
+      const u2 = u(p);
+      if(u2) return u2;
     }
   }catch(e){ /* 宿主通道不通就退下面的 */ }
   if(typeof qaShotSrc === "function"){
@@ -645,7 +660,7 @@ function qaArtNode(it){
  *  返回画出来的张数（Promise）：收尾那条链要**等它画完**再落 HTML 快照（见 qaTurnArtsMount）。 */
 function qaArtMount(host, paths, opts){
   const o = opts || {};
-  const api = (window.desk && typeof window.desk.pathProbe === "function") ? window.desk.pathProbe : null;
+  const api = qaDeskFn("pathProbe");
   if(!host || !api || !Array.isArray(paths) || !paths.length) return Promise.resolve(0);
   const list = paths.slice(0, 12);
   return Promise.resolve(api({ base: qaArtBase(), paths: list })).then((r)=>{
@@ -680,6 +695,46 @@ function qaArtMount(host, paths, opts){
   }).catch(()=> 0);                                           // 探针失败 = 当作「都不是产物」，正文照旧
 }
 
+/* ── 破图收尾（2026-10-20 用户：「是图片不存在吗 不存在的不显示」）────────────
+   探针只说「这会儿在盘上」，图却仍可能取不回来：手机连的是另一台/另一个实例、
+   快照里存的是换过的旧令牌、文件在渲染后被删。别留一张 alt + 碎图标的空卡：
+     ① 先用**当下的**回读地址重试一次（快照里的 src 可能带的是旧令牌 / 旧 origin）；
+     ② 还失败就把这张卡摘掉；行空了连行一起摘，只剩「本轮产物」标题也把标题摘掉。
+   `error` 不冒泡，所以监听挂在 document 的**捕获阶段**（一次，页面级）。
+   快照恢复走 `innerHTML = snapshot`，内联 onerror 会随序列化丢掉，捕获监听不会。 */
+function qaArtDrop(card){
+  const row = card && card.parentNode;
+  if(row) row.removeChild(card);
+  if(!row || !row.classList || !row.classList.contains("qa-arts") || row.children.length) return;
+  const cap = row.previousElementSibling;
+  const host = row.parentNode;
+  if(host) host.removeChild(row);
+  if(cap && cap.classList && cap.classList.contains("qa-arts-cap") && host && !host.querySelector(".qa-arts")){
+    host.removeChild(cap);                                    // 标题下已经一张卡都不剩 → 标题也摘
+  }
+}
+
+(function(){                                                 // 页面级一次性挂载（不占全局名）
+  if(typeof document === "undefined" || window.__qaArtErrSweep) return;
+  window.__qaArtErrSweep = true;
+  document.addEventListener("error", function(e){
+    const im = e && e.target;
+    if(!im || im.tagName !== "IMG" || !im.closest) return;
+    const card = im.closest(".qa-art-image");                 // 只管产物卡；正文缩略图不在此列
+    if(!card) return;
+    const p = card.dataset.path;
+    if(p && !im.dataset.qaRetry && typeof qaArtUrl === "function"){
+      const u = qaArtUrl(p);
+      if(u && u !== im.getAttribute("src")){
+        im.dataset.qaRetry = "1";
+        im.src = u;
+        return;                                               // 换新地址再试一次
+      }
+    }
+    qaArtDrop(card);                                          // 真取不回来 → 不显示
+  }, true);
+})();
+
 /* ── 会话产物 · 消息末尾的「本轮产物」（2026-10-15）─────────────────────────
    用户原话：「会话有新的图片、视频文件产生 应该在消息结束时附加在末尾作为会话产物显示预览」。
    正文里写出来的产物路径早就有渲染（qaShotsMount / qaArtMount：图变缩略图、视频变就地播放器），
@@ -862,9 +917,14 @@ function qaShotsMount(host, text){
   qaArtMount(host, qaArtCollect(rest));
 }
 
-/** 附件条 + 粘贴 / 拖拽接线（逐实例各绑一次，与 ＋ 菜单同款） */
+/** 附件条 + 粘贴 / 拖拽接线（逐实例各绑一次，与 ＋ 菜单同款）
+ *  ⚠️ 幂等：`askBoxMountAll` 会调它，宿主也可能自己再调一次（magic-test 的 bindHomeEntry）。
+ *     重复绑定的症状不是报错，而是**一次粘贴挂两张图**（每份监听各跑一遍）——
+ *     用 DOM 上的标记挡住，比要求所有调用方都记得「只能调一次」可靠。 */
 function askAttBind(p){
   const box = $("#" + p + "-box"); if(!box) return;
+  if(box.dataset.attBound === "1") return;
+  box.dataset.attBound = "1";
   const row = $("#" + p + "-atts");
   if(row){
     row.addEventListener("click", (e)=>{
@@ -998,6 +1058,10 @@ function askBoxMountAll(){
     host.innerHTML = askBoxMarkup(ASK_CFG[p]);
     askAddMenuBuild(p);                  // 先填一次，保证 DOM 里始终有菜单（含引擎提示行）
     askChipsSync(p);
+    /* 粘贴 / 拖拽的接线**必须在挂载时就绑上**（2026-10-21：`askAttBind` 此前没有任何调用点，
+       于是这条 UI 的「粘贴截图」一直是死代码 —— 用户：「对话框中现在没支持粘贴图片」）。
+       幂等，见函数自己的注释。 */
+    askAttBind(p);
   });
 }
 

package/client-ui/shared/conv/27-conv-ledger.js

@@ -263,6 +263,18 @@ function qaSessionPlayer(){
       }catch(e){ /* 收尾失败不影响回放 */ }
       h = null;
     },
+    /** 把这半轮**交出去**（2026-10-21 用户：「同一轮对话 显示成了两个」）。
+     *  场景：内存闸门把这一轮的 `user` 起点截掉了（`openCut`），窗口里整段都属于**还在长的一轮** ——
+     *  回放已经把它画在同一张还没封口的卡上。宿主如果照旧 `finish()` 封口、再让续传
+     *  `qaRenderAnswer()` 另开一张，同一轮就会变成两张卡（过程组孤零零留在第一张）。
+     *  这里把在画的句柄连同配对表 / 产物收集器 / 起算时间一起交出，本 player 不再持有任何一轮；
+     *  续传接着往**同一张卡**上写，一轮只有一张。 */
+    handoff(){
+      if(!h) return null;
+      const keep = { h, tools, agents, arts, t0 };
+      h = null;
+      return keep;
+    },
   };
   /* 拆成内层函数：feed 里原来的 `return`（qaRenderAnswer 失败）只退出这一批，语义与改造前一致 */
   function qaSessionPlayerFeed(list){
@@ -340,6 +352,12 @@ function qaSessionPlayer(){
         null, turnMs || null);
       if(arts) arts.flush(h);                   // 终态之后这一轮的产物补在消息末尾（与实时 onDone 同位）
       t0 = 0;                                   // 这一轮收尾了：下一轮（若没有 user 事件）重新起算
+      /* ⚠️ 句柄必须一起置空（2026-10-21 用户：「同一轮对话 显示成了两个」）：
+         收尾后它已经是**封口**的卡（`closed = true`、过程块已折进组里），再往它上面喂事件
+         `ensureText()` 只会在队尾新开一块正文 —— 同一轮的后续正文就落在收尾行下面，与续传
+         另起的那张卡并排，看起来就是「一轮两卡 + 正文重复」。置空后下一批事件按新一轮开卡，
+         与宿主续传（qaTailFeed 的终态分支）同口径。 */
+      h = null;
     }
   }
   }

package/client-ui/shared/conv/29-msg-variants.js

@@ -510,11 +510,21 @@ function qaTodoFill(host, rows, opts){
     ico.className = "qa-todo-ico";
     if(t.status === "completed") ico.innerHTML = QA_V_ICONS.ok;
     else if(t.status === "in_progress") ico.innerHTML = QA_V_ICONS.clock;
+    /* 团队模式的任务列表（KindTasks）多两档终态：失败要说出来、跳过要看得出来
+       （以前只认 completed / in_progress，这两个状态会退化成「空圈 = 没开始」）。 */
+    else if(t.status === "failed") ico.innerHTML = QA_V_ICONS.alert;
     const txt = document.createElement("span");
     txt.className = "qa-todo-t";
     txt.textContent = (t.status === "in_progress" && t.active) ? t.active : t.text;
     r.appendChild(ico);
     r.appendChild(txt);
+    /* 行尾标注（可选，`引擎 · 角色`）：只有团队任务列表给这一档，待办清单没有 */
+    if(t.meta){
+      const mt = document.createElement("span");
+      mt.className = "qa-todo-meta";
+      mt.textContent = String(t.meta);
+      r.appendChild(mt);
+    }
     list.appendChild(r);
   });
   host.appendChild(list);

package/client-ui/shared/conv/README.md

@@ -37,6 +37,12 @@ const convShards = JSON.parse(fs.readFileSync(path.join(convDir, 'manifest.json'
 `wsDirOf` / `qaWorkspace` / `reqHas` …）。另有两个**可选**宿主能力不在清单里（缺了只是不画产物卡）：
 `window.desk.pathProbe` 与 `window.desk.mediaUrl`。
 
+**画布挂好之后必须调一次 `qaScrollGateBind()`**（幂等）。它维护「用户正在上翻历史」的闸
+（`qaUserAway`）—— 流式增量能不能把你拽回底部全靠它。组件宿主（`shared/conversation.js`）
+已在 `create()` 里调过；工作台是在 `qaDotsBind()` 里顺带调。**不调的表现**：手机上一上滑就
+被下一笔增量弹回结尾（2026-10-21 就是这么坏了一个版本 —— 那段监听原本只写在圆点轨里，
+而圆点轨只有工作台用）。
+
 ### 命名与「半个文件」的规矩
 
 - 被整份搬走的（`03` `06` `08` `19` `29`）：内核分片沿用原文件名。