@co0ontty/wand 1.29.6 → 1.30.3

package/dist/web-ui/content/scripts.js

@@ -86,7 +86,22 @@
         terminalFitInProgress: false,
         terminalSessionId: null,
         terminalOutput: "",
+        // R8: /clear marker。Claude 的 /clear 不发任何 ANSI 清屏序列，它只
+        // 就地把对话框重画成空、把旧对话推进 scrollback。但 wand 的
+        // state.terminalOutput 是 append-only buffer，softResync 一触发就
+        // 把 /clear 之前的历史全部重放回 wterm（用户看到"/clear 后短暂闪
+        // 回旧内容"）。marker 表示 buffer 里"用户上次 /clear 时刻的位置"，
+        // softResync 只重放 slice(marker)，从根上避免历史被重放。
+        terminalOutputMarker: 0,
         terminalLiveStreamSessions: {},
+        // CSI ?2026h..l 同步输出缓冲：begin 时拿到 "\x1b[?2026h" 后开始缓冲，
+        // end 时拿到 "\x1b[?2026l" 一次性 flush 给 wterm。null 表示当前不在
+        // sync 包帧内。@wterm/core 0.1.8 不实现 sync output，begin/end 之间
+        // 每个 write 立即落到 grid + mark dirty —— 跨 server-debounce 窗口
+        // 时浏览器看到中间帧 + 触发 softResync 时状态机被打断，正是
+        // askuserquestion 菜单多份叠加的最强候选根因。
+        syncOutputBuffer: null,
+        syncOutputDeadline: 0,
         lastChunkAt: 0,
         terminalHealthTimer: null,
         lastTerminalResyncAt: 0,
@@ -223,10 +238,19 @@
         chatUnreadCount: 0,
         // state.currentMessages 中第一条未读消息的 index，-1 表示没有未读。
         chatUnreadStartIndex: -1,
-        chatScrollThreshold: 120,
+        // 业界共识 150-180px：120px 在触控板/移动端惯性下边界来回弹。
+        chatScrollThreshold: 160,
         chatIsProgrammaticScroll: false,
         chatScrollElement: null,
         chatScrollHandler: null,
+        chatScrollWheelHandler: null,
+        chatScrollTouchStartHandler: null,
+        chatScrollTouchMoveHandler: null,
+        chatTouchStartY: 0,
+        // 仅在"首次渲染当前会话视图"时才允许 fullRenderChat 强制贴底。
+        // resetChatRenderCache 会把它设回 false；fullRenderChat 第一次跑完就置 true。
+        // page-refresh / ws 重连不重置此标记，避免把用户拽到底部。
+        chatInitialRenderDone: false,
         lastForegroundSyncAt: 0,
         foregroundSyncTimer: null,
         wsReconnectAttempts: 0,
@@ -582,8 +606,19 @@
           updateChatUnreadBubble();
           return;
         }
-        if (state.chatScrollElement && state.chatScrollHandler) {
-          state.chatScrollElement.removeEventListener("scroll", state.chatScrollHandler);
+        if (state.chatScrollElement) {
+          if (state.chatScrollHandler) {
+            state.chatScrollElement.removeEventListener("scroll", state.chatScrollHandler);
+          }
+          if (state.chatScrollWheelHandler) {
+            state.chatScrollElement.removeEventListener("wheel", state.chatScrollWheelHandler);
+          }
+          if (state.chatScrollTouchStartHandler) {
+            state.chatScrollElement.removeEventListener("touchstart", state.chatScrollTouchStartHandler);
+          }
+          if (state.chatScrollTouchMoveHandler) {
+            state.chatScrollElement.removeEventListener("touchmove", state.chatScrollTouchMoveHandler);
+          }
         }
         state.chatScrollElement = chatMsgs;
         state.chatScrollHandler = function() {
@@ -604,7 +639,35 @@
           }
           updateChatUnreadBubble();
         };
+        // wheel/touch 提前下台：浏览器要等惯性产生位移才触发 scroll 事件，
+        // 这一帧空窗里如果有 streaming chunk 进来，会在 sticky=true 状态下
+        // 被强制贴底。监听用户开始上滚的瞬间立刻把 sticky 翻成 false，
+        // 避免那一帧的拽回。column-reverse 下 deltaY<0（滚轮上推）= 看历史。
+        state.chatScrollWheelHandler = function(e) {
+          if (state.chatIsProgrammaticScroll) return;
+          if (e.deltaY < 0) {
+            state.chatStickToBottom = false;
+            updateChatUnreadBubble();
+          }
+        };
+        state.chatScrollTouchStartHandler = function(e) {
+          if (!e.touches || e.touches.length === 0) return;
+          state.chatTouchStartY = e.touches[0].clientY;
+        };
+        state.chatScrollTouchMoveHandler = function(e) {
+          if (state.chatIsProgrammaticScroll) return;
+          if (!e.touches || e.touches.length === 0) return;
+          // column-reverse 下：手指向下拖（clientY 变大）= 内容向下走 = 看历史。
+          var deltaY = e.touches[0].clientY - state.chatTouchStartY;
+          if (deltaY > 4) {
+            state.chatStickToBottom = false;
+            updateChatUnreadBubble();
+          }
+        };
         chatMsgs.addEventListener("scroll", state.chatScrollHandler, { passive: true });
+        chatMsgs.addEventListener("wheel", state.chatScrollWheelHandler, { passive: true });
+        chatMsgs.addEventListener("touchstart", state.chatScrollTouchStartHandler, { passive: true });
+        chatMsgs.addEventListener("touchmove", state.chatScrollTouchMoveHandler, { passive: true });
         updateChatUnreadBubble();
       }
 
@@ -936,23 +999,46 @@
         });
       }
 
-      function resetChatRenderCache() {
+      // options.preserveStickState=true：仅清渲染缓存，不动 sticky/未读
+      // 状态。用于 page-refresh、ws 重连等"用户停留在当前会话，只是想刷新
+      // DOM"的场景——不能把用户从历史位置拽回底部。
+      // 默认（false）：切会话 / 新建 / home 等真正"换上下文"路径用，全清。
+      function resetChatRenderCache(options) {
+        var opts = options || {};
         state.lastRenderedHash = 0;
         state.lastRenderedMsgCount = 0;
         state.lastRenderedEmpty = null;
         state.renderPending = false;
         state.chatRenderedCount = state.chatPageSize;
         state.askUserSelections = {};
-        if (state.chatScrollElement && state.chatScrollHandler) {
-          state.chatScrollElement.removeEventListener("scroll", state.chatScrollHandler);
+        if (state.chatScrollElement) {
+          if (state.chatScrollHandler) {
+            state.chatScrollElement.removeEventListener("scroll", state.chatScrollHandler);
+          }
+          if (state.chatScrollWheelHandler) {
+            state.chatScrollElement.removeEventListener("wheel", state.chatScrollWheelHandler);
+          }
+          if (state.chatScrollTouchStartHandler) {
+            state.chatScrollElement.removeEventListener("touchstart", state.chatScrollTouchStartHandler);
+          }
+          if (state.chatScrollTouchMoveHandler) {
+            state.chatScrollElement.removeEventListener("touchmove", state.chatScrollTouchMoveHandler);
+          }
         }
         state.chatScrollElement = null;
         state.chatScrollHandler = null;
+        state.chatScrollWheelHandler = null;
+        state.chatScrollTouchStartHandler = null;
+        state.chatScrollTouchMoveHandler = null;
         state.chatIsProgrammaticScroll = false;
-        // 切会话时未读状态归零、贴底重置——避免上一个会话残留的"未读气泡"。
-        state.chatStickToBottom = true;
-        state.chatUnreadCount = 0;
-        state.chatUnreadStartIndex = -1;
+        if (!opts.preserveStickState) {
+          // 切会话时未读状态归零、贴底重置——避免上一个会话残留的"未读气泡"。
+          state.chatStickToBottom = true;
+          state.chatUnreadCount = 0;
+          state.chatUnreadStartIndex = -1;
+          // 真正换会话时才允许首帧贴底；preserve 路径下保留旧 initial 状态。
+          state.chatInitialRenderDone = false;
+        }
       }
 
       function getEffectiveCwd() {
@@ -1660,6 +1746,11 @@
                       '<button id="stop-button" class="btn-circle btn-circle-stop' + (state.selectedId ? "" : " hidden") + '" title="停止">' +
                         '<svg width="12" height="12" viewBox="0 0 16 16" fill="currentColor"><rect x="3" y="3" width="10" height="10" rx="2"/></svg>' +
                       '</button>' +
+                      // 结构化模式且正在出 token 时显示：中断当前回复、立刻发送新输入。
+                      // 默认走 #send-input-button → 排队；想插队的人显式按这颗。
+                      '<button id="interrupt-send-button" class="btn-circle btn-circle-interrupt hidden" type="button" title="中断当前回复并立即发送" aria-label="立即发送">' +
+                        '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"><polyline points="13 17 18 12 13 7"/><polyline points="6 17 11 12 6 7"/></svg>' +
+                      '</button>' +
                       '<button id="send-input-button" class="btn-circle btn-circle-send" title="发送">' +
                         '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"><line x1="22" y1="2" x2="11" y2="13"/><polygon points="22 2 15 22 11 13 2 9 22 2"/></svg>' +
                       '</button>' +
@@ -3078,29 +3169,44 @@
         '</section>';
       }
 
+      // 「最近」分组的统一数据源：未归档 active sessions + 24h 内 Claude 历史，
+      // 一起按"创建时间"倒序排（session 用 startedAt，history 用 timestamp）。
+      // 展开侧栏的「最近」和折叠侧栏的窄条都基于这份列表渲染，序号严格对应。
+      function getRecentEntries() {
+        var cutoff = Date.now() - 24 * 60 * 60 * 1000;
+        var entries = [];
+        state.sessions.forEach(function(s) {
+          if (s.archived) return;
+          var t = s.startedAt ? new Date(s.startedAt).getTime() : 0;
+          entries.push({ kind: "session", ref: s, t: isFinite(t) ? t : 0 });
+        });
+        if (state.claudeHistoryLoaded) {
+          getVisibleClaudeHistorySessions().forEach(function(h) {
+            if (!h.timestamp) return;
+            var t = new Date(h.timestamp).getTime();
+            if (!isFinite(t) || t <= cutoff) return;
+            entries.push({ kind: "history", ref: h, t: t });
+          });
+        }
+        entries.sort(function(a, b) { return b.t - a.t; });
+        return entries;
+      }
+
       function renderSessions() {
-        var activeSessions = state.sessions.filter(function(session) { return !session.archived; });
         var archivedSessions = state.sessions.filter(function(session) { return session.archived; });
         var groups = [];
         groups.push(renderSessionManageBar());
 
-        // Split claude history into recent (24h) and older
-        var recentHistorySessions = [];
-        if (state.claudeHistoryLoaded) {
-          var cutoff = Date.now() - 24 * 60 * 60 * 1000;
-          recentHistorySessions = getVisibleClaudeHistorySessions().filter(function(s) {
-            return s.timestamp && new Date(s.timestamp).getTime() > cutoff;
-          });
-        }
+        var recentEntries = getRecentEntries();
 
-        if (activeSessions.length > 0 || recentHistorySessions.length > 0) {
-          groups.push(renderRecentGroup(activeSessions, recentHistorySessions));
+        if (recentEntries.length > 0) {
+          groups.push(renderRecentGroup(recentEntries));
         }
         if (archivedSessions.length > 0) {
           groups.push(renderArchivedGroup(archivedSessions));
         }
         groups.push(renderClaudeHistorySection());
-        if (activeSessions.length === 0 && archivedSessions.length === 0 && recentHistorySessions.length === 0) {
+        if (recentEntries.length === 0 && archivedSessions.length === 0) {
           return renderSessionManageBar() + '<div class="empty-state"><strong>还没有会话记录</strong><br>点击上方「新对话」开始你的第一次对话。</div>' + renderClaudeHistorySection();
         }
         return groups.join("");
@@ -3111,24 +3217,24 @@
       }
 
       function renderCollapsedSessionTiles() {
-        var running = state.sessions.filter(function(s) {
-          return !s.archived && s.status === "running";
-        });
-        running.sort(function(a, b) {
-          var ta = a.startedAt ? new Date(a.startedAt).getTime() : 0;
-          var tb = b.startedAt ? new Date(b.startedAt).getTime() : 0;
-          return ta - tb;
-        });
-        if (running.length === 0) {
-          return '<div class="sidebar-collapsed-empty" title="无运行中的会话">—</div>';
-        }
-        return '<div class="sidebar-collapsed-tiles">' +
-          running.map(function(s, i) {
+        var entries = getRecentEntries();
+        if (entries.length === 0) {
+          return '<div class="sidebar-collapsed-empty" title="无会话">—</div>';
+        }
+        var tiles = entries.map(function(e, i) {
+          var idx = i + 1;
+          if (e.kind === "session") {
+            var s = e.ref;
             var activeCls = s.id === state.selectedId ? " active" : "";
-            var title = s.summary || s.command || ("会话 " + (i + 1));
-            return '<button class="sidebar-collapsed-tile' + activeCls + '" type="button" data-collapsed-session-id="' + escapeHtml(s.id) + '" title="' + escapeHtml(title) + '">' + (i + 1) + '</button>';
-          }).join("") +
-        '</div>';
+            var title = s.summary || s.command || ("会话 " + idx);
+            return '<button class="sidebar-collapsed-tile' + activeCls + '" type="button" data-collapsed-session-id="' + escapeHtml(s.id) + '" title="' + escapeHtml(title) + '">' + idx + '</button>';
+          }
+          var h = e.ref;
+          var preview = h.firstUserMessage || "(空会话)";
+          var hTitle = preview + " · " + formatHistoryTime(h.timestamp);
+          return '<button class="sidebar-collapsed-tile history" type="button" data-collapsed-history-id="' + escapeHtml(h.claudeSessionId) + '" data-cwd="' + escapeHtml(h.cwd || "") + '" title="' + escapeHtml(hTitle) + '">' + idx + '</button>';
+        }).join("");
+        return '<div class="sidebar-collapsed-tiles">' + tiles + '</div>';
       }
 
       function renderSessionsListContent() {
@@ -3194,11 +3300,14 @@
         return '<section class="session-group">' + header + items + '</section>';
       }
 
-      function renderRecentGroup(activeSessions, recentHistorySessions) {
+      function renderRecentGroup(entries) {
         var html = '<section class="session-group">' +
           '<div class="session-group-title">最近</div>';
-        html += activeSessions.map(function(session) { return renderSessionItem(session, "sessions"); }).join("");
-        html += recentHistorySessions.map(function(session) { return renderClaudeHistoryItem(session, "history"); }).join("");
+        html += entries.map(function(e) {
+          return e.kind === "session"
+            ? renderSessionItem(e.ref, "sessions")
+            : renderClaudeHistoryItem(e.ref, "history");
+        }).join("");
         html += '</section>';
         return html;
       }
@@ -4918,6 +5027,32 @@
         return "";
       }
 
+      /** Get the most recent user-sent text from messages (for narrow-strip hover bubble). */
+      function getSessionLatestUserText(session) {
+        var msgs = session && session.messages;
+        if (!msgs || msgs.length === 0) return "";
+        for (var i = msgs.length - 1; i >= 0; i--) {
+          var msg = msgs[i];
+          if (!msg || msg.role !== "user") continue;
+          var content = msg.content;
+          if (typeof content === "string") {
+            var t = content.trim();
+            if (t) return t;
+            continue;
+          }
+          if (Array.isArray(content)) {
+            for (var j = 0; j < content.length; j++) {
+              var block = content[j];
+              if (!block || block.type !== "text" || !block.text) continue;
+              if (block.__queued) continue;
+              var bt = String(block.text).trim();
+              if (bt) return bt;
+            }
+          }
+        }
+        return "";
+      }
+
       /** Get the last meaningful assistant text from messages for notification/display */
       function getLastAssistantSummary(session) {
         var msgs = session && session.messages;
@@ -5504,8 +5639,12 @@
         if (sessionsList) {
           sessionsList.addEventListener("click", handleSessionItemClick);
           sessionsList.addEventListener("keydown", handleSessionItemKeydown);
+          sessionsList.addEventListener("mouseover", handleCollapsedTileHover);
+          sessionsList.addEventListener("mouseout", handleCollapsedTileLeave);
           initSwipeToDelete(sessionsList);
         }
+        window.addEventListener("scroll", hideCollapsedTileBubble, true);
+        window.addEventListener("resize", hideCollapsedTileBubble);
 
         // Claude session ID badge click-to-copy (event delegation on document)
         document.addEventListener("click", handleClaudeIdCopy);
@@ -5833,6 +5972,11 @@
           closeSessionsDrawer();
           sendOrStart();
         });
+        var interruptSendBtn = document.getElementById("interrupt-send-button");
+        if (interruptSendBtn) interruptSendBtn.addEventListener("click", function() {
+          closeSessionsDrawer();
+          sendOrStart({ interrupt: true });
+        });
         var stopBtn = document.getElementById("stop-button");
         if (stopBtn) stopBtn.addEventListener("click", stopSession);
         var modeSelect = document.getElementById("chat-mode-select");
@@ -6081,7 +6225,8 @@
             return;
           }
           softResyncTerminal();
-          resetChatRenderCache();
+          // 用户停留在当前会话，只是想刷一下 DOM——保留其阅读位置和 sticky 状态。
+          resetChatRenderCache({ preserveStickState: true });
           scheduleChatRender(true);
         });
         var jumpBottomBtn = document.getElementById("terminal-jump-bottom");
@@ -6590,11 +6735,31 @@
         if (!target || !(target instanceof Element)) return;
 
         var collapsedTile = target.closest(".sidebar-collapsed-tile");
-        if (collapsedTile && collapsedTile instanceof HTMLElement && collapsedTile.dataset.collapsedSessionId) {
-          event.preventDefault();
-          event.stopPropagation();
-          activateSessionItem(collapsedTile.dataset.collapsedSessionId);
-          return;
+        if (collapsedTile && collapsedTile instanceof HTMLElement) {
+          if (collapsedTile.dataset.collapsedSessionId) {
+            event.preventDefault();
+            event.stopPropagation();
+            activateSessionItem(collapsedTile.dataset.collapsedSessionId);
+            return;
+          }
+          if (collapsedTile.dataset.collapsedHistoryId) {
+            event.preventDefault();
+            event.stopPropagation();
+            var historyCid = collapsedTile.dataset.collapsedHistoryId;
+            var historyCwd = collapsedTile.dataset.cwd || "";
+            resumeClaudeHistorySession(historyCid, historyCwd)
+              .then(function(data) {
+                if (data && data.id) {
+                  state.selectedId = data.id;
+                  persistSelectedId();
+                  state.drafts[data.id] = "";
+                  loadSessions().then(function() {
+                    selectSession(data.id);
+                  });
+                }
+              });
+            return;
+          }
         }
 
         var historyToggle = target.closest("#claude-history-toggle");
@@ -7145,10 +7310,93 @@
         return out;
       }
 
+      // CSI ?2026 同步输出（DEC mode 2026）的 wand 软实现。Claude Code 用
+      //   \x1b[?2026h ... 重画 ... \x1b[?2026l
+      // 包裹每一帧 askuserquestion / model / 任意菜单的原地重绘，期望终端
+      // 在 end 之前不渲染中间态。@wterm/core 0.1.8 未实现 sync output，于是
+      // 我们在 JS 层先 buffer，遇到 end 时一次性下发。这条修复直接解决
+      // 菜单逐帧叠加（image 2 的主因）。
+      //
+      // 安全护栏：
+      //   - 单帧字节 > SYNC_OUTPUT_MAX_BYTES → 强制 flush（防 buffer 爆）
+      //   - 单帧滞留 > SYNC_OUTPUT_MAX_BUFFER_MS → 强制 flush（防 begin 没 end）
+      //   - 没有 ?2026 字节流时透传，零开销
+      var SYNC_OUTPUT_BEGIN = "\x1b[?2026h";
+      var SYNC_OUTPUT_END = "\x1b[?2026l";
+      var SYNC_OUTPUT_MAX_BUFFER_MS = 200;
+      var SYNC_OUTPUT_MAX_BYTES = 256 * 1024;
+
+      function processSyncOutputFraming(data) {
+        if (!data) return data;
+        // 快路径：当前不在 sync 内、本批数据也不含 begin → 直接透传
+        if (state.syncOutputBuffer === null && data.indexOf(SYNC_OUTPUT_BEGIN) === -1) {
+          return data;
+        }
+        var out = "";
+        var i = 0;
+        while (i < data.length) {
+          if (state.syncOutputBuffer !== null) {
+            // 在 sync 内：扫到 end 才 flush
+            var endIdx = data.indexOf(SYNC_OUTPUT_END, i);
+            if (endIdx === -1) {
+              state.syncOutputBuffer += data.slice(i);
+              if (state.syncOutputBuffer.length > SYNC_OUTPUT_MAX_BYTES
+                  || Date.now() > state.syncOutputDeadline) {
+                // 护栏：超长/超时强制 flush，避免永久卡死
+                out += state.syncOutputBuffer;
+                state.syncOutputBuffer = null;
+              }
+              return out;
+            }
+            state.syncOutputBuffer += data.slice(i, endIdx + SYNC_OUTPUT_END.length);
+            out += state.syncOutputBuffer;
+            state.syncOutputBuffer = null;
+            i = endIdx + SYNC_OUTPUT_END.length;
+          } else {
+            // 不在 sync 内：扫 begin
+            var beginIdx = data.indexOf(SYNC_OUTPUT_BEGIN, i);
+            if (beginIdx === -1) {
+              out += data.slice(i);
+              return out;
+            }
+            // begin 之前的字节立即透传给 wterm
+            out += data.slice(i, beginIdx);
+            state.syncOutputBuffer = SYNC_OUTPUT_BEGIN;
+            state.syncOutputDeadline = Date.now() + SYNC_OUTPUT_MAX_BUFFER_MS;
+            i = beginIdx + SYNC_OUTPUT_BEGIN.length;
+          }
+        }
+        return out;
+      }
+
+      function flushSyncOutputBuffer() {
+        if (state.syncOutputBuffer !== null) {
+          var buffered = state.syncOutputBuffer;
+          state.syncOutputBuffer = null;
+          return buffered;
+        }
+        return "";
+      }
+
+      // NEW-B (DA1/XTVERSION 应答) 已暂缓：实测在 PTY ECHO 阶段（claude
+      // 启动早期 / claude 不在 raw mode 的窗口）回灌的字节会被 PTY 自动
+      // echo 到 stdout 并显示成 ^[[?6c^[P>|wterm-wand^[\ 字面字符，污染
+      // 终端。需要先在服务端 ProcessManager 写到 PTY master 时识别 ECHO
+      // 状态再决定是否回包，挪到 Phase 2 重新设计。
+
       function wandTerminalWrite(terminal, data) {
         if (!terminal || data == null) return;
         if (!state.wideParserState) state.wideParserState = createWideParserState();
-        terminal.write(widePadAnsi(data, state.wideParserState));
+        var padded = widePadAnsi(data, state.wideParserState);
+        var framed = processSyncOutputFraming(padded);
+        if (framed) terminal.write(framed);
+        // R6: 在 chunk 热路径上识别原地重绘序列（CSI nA/B/C/D/f/H/J/K），
+        // 节流安排一次 softResync 兜底。Claude 用相对光标位移重画菜单时，
+        // 如果 NEW-A 的 sync output buffer 因某种原因没拦截到完整帧（比如
+        // ?2026 begin 之后跨 200ms 超时强制 flush），CSI 序列残留会让 wterm
+        // 错位。此 fallback 仅在真出现错位序列时触发，正常输出零开销。
+        // 与 R2 策略 A 配合：移除被动 5 处触发后，这是唯一的主动救场路径。
+        maybeScheduleResyncForChunk(data);
         // wterm.write 内部用 5px 阈值判定"在底部"，下一帧 _doRender 据此强制
         // scrollTop = scrollHeight。这与 wand 的 autoFollow（"真正到底"才为
         // true，2px 阈值）独立，会把用户主动向上滚的几像素吞掉。覆写为 wand
@@ -7195,10 +7443,27 @@
       // scrollback），所以必须限长，否则长跑会话每次 resync 都喂几 MB 给 wterm。
       // 裁切优先在行边界（ANSI 状态机此时一定 idle，重放等价），找不到再按字节切
       // 并避开 UTF-16 半截 / ANSI 半截。
-      var CLIENT_OUTPUT_MAX = 256 * 1024;
-      var CLIENT_OUTPUT_TRIM_AT = 320 * 1024;
+      //
+      // R10: 客户端 buffer 必须 < 服务端 PTY_OUTPUT_MAX_SIZE=200KB，否则长跑会话
+      // 服务端先于客户端裁头，发 init 时携带的 output 是字节 ~56KB 起的尾段，
+      // 与客户端本地 0..256KB 的完整 buffer 做 prefix 检查必然失败 → fall back
+      // 到 replace 全量重写 → 每次 ws-reconnect / 切 tab 都踩一次 softResync 灾难。
+      // 让 client < server 保证客户端永远是服务端的子集，prefix 永远成立。
+      var CLIENT_OUTPUT_MAX = 160 * 1024;
+      var CLIENT_OUTPUT_TRIM_AT = 192 * 1024;
       function clampClientTerminalOutput(buf) {
         if (!buf || buf.length <= CLIENT_OUTPUT_TRIM_AT) return buf;
+        var preTrimLen = buf.length;
+        // 内部 helper：根据裁掉的字节数同步缩减 marker，保证 marker 始终指向
+        // "/clear 之后的字节"。如果 marker 落到了被裁掉的区间里，clamp 到 0
+        // （/clear 之前的历史本来就要丢，marker=0 等于 fall back 重放全部）。
+        var _adjustMarker = function(trimmedLen) {
+          if (typeof state === "undefined" || !state) return;
+          var mk = state.terminalOutputMarker | 0;
+          if (mk <= 0) return;
+          var dropped = preTrimLen - trimmedLen;
+          state.terminalOutputMarker = mk > dropped ? mk - dropped : 0;
+        };
         var start = buf.length - CLIENT_OUTPUT_MAX;
         // UTF-16 low surrogate
         if (start > 0 && start < buf.length) {
@@ -7209,7 +7474,11 @@
         var LOOKAHEAD = 4096;
         var upper = Math.min(start + LOOKAHEAD, buf.length);
         for (var i = start; i < upper; i++) {
-          if (buf.charCodeAt(i) === 0x0a) return buf.slice(i + 1);
+          if (buf.charCodeAt(i) === 0x0a) {
+            var trimmed1 = buf.slice(i + 1);
+            _adjustMarker(trimmed1.length);
+            return trimmed1;
+          }
         }
         // 没换行 → 检查 start 是否落在未结束的 ESC 序列里
         var lookback = Math.max(0, start - 256);
@@ -7232,12 +7501,16 @@
             for (var m = start; m < ahead; m++) {
               var cm = buf.charCodeAt(m);
               if (cm === 0x07 || (cm >= 0x40 && cm <= 0x7e)) {
-                return buf.slice(m + 1);
+                var trimmed2 = buf.slice(m + 1);
+                _adjustMarker(trimmed2.length);
+                return trimmed2;
               }
             }
           }
         }
-        return buf.slice(start);
+        var trimmed3 = buf.slice(start);
+        _adjustMarker(trimmed3.length);
+        return trimmed3;
       }
 
       function resetTerminal() {
@@ -7250,12 +7523,16 @@
         if (typeof state.terminal.reset === "function") {
           state.terminal.reset();
           resetWideParserState();
+          state.syncOutputBuffer = null;
+          state.syncOutputDeadline = 0;
           return;
         }
         if (typeof state.terminal.write === "function") {
           state.terminal.write("\x1bc");
         }
         resetWideParserState();
+        state.syncOutputBuffer = null;
+        state.syncOutputDeadline = 0;
       }
 
       // Reset wterm WASM grid and replay the full output buffer to clear stale
@@ -7274,10 +7551,17 @@
       function softResyncTerminal(options) {
         if (!state.terminal || !state.terminalOutput) return false;
         var opts = options || {};
-        var bufLen = state.terminalOutput.length;
+        // R8: 只重放 marker 之后的字节。marker = 0 时等同于"重放整段"（与旧
+        // 行为一致）；用户输入过 /clear 后 marker 标到当时 buffer 长度，重放
+        // 跳过 /clear 之前的历史，杜绝"/clear 后短暂闪回旧内容"。
+        var marker = state.terminalOutputMarker | 0;
+        if (marker < 0) marker = 0;
+        if (marker > state.terminalOutput.length) marker = state.terminalOutput.length;
+        var replaySource = marker > 0 ? state.terminalOutput.slice(marker) : state.terminalOutput;
+        var bufLen = replaySource.length;
         var startedAt = (typeof performance !== "undefined" && performance.now) ? performance.now() : Date.now();
         resetTerminal();
-        wandTerminalWrite(state.terminal, state.terminalOutput);
+        wandTerminalWrite(state.terminal, replaySource);
         state.lastTerminalResyncAt = Date.now();
         maybeScrollTerminalToBottom("output");
         if (!opts.skipFit) ensureTerminalFit("refresh");
@@ -7317,9 +7601,14 @@
       // 触发用 leading + tail 节流而非 debounce：用户持续按键时每次 chunk 都会
       // reset debounce timer，永远等不到静默期。leading 立即 resync、窗口内
       // 用尾巴 timer 收尾，不依赖按键停顿。
+      // R6 chunk 热路径救场 throttle：原值 400/350 让 Claude thinking 期间
+      // 大量 CSI A/B/K 重绘（spinner、状态行）每秒触发 ~2.5 次 softResync，
+      // 13 次/5s 直接撞警戒线。NEW-A 已经把 askuserquestion 这种 ?2026 包帧
+      // 重绘原子化，R6 退化为"NEW-A 失手时的弱兜底"，频率拉到 1.5s/0.8s
+      // 即可。代价：错位状态最长滞留 1.5s 才修，可接受。
       var IN_PLACE_REDRAW_RE = /\x1b\[\d*(?:;\d*)?[ABCDfHJK]/;
-      var RESYNC_THROTTLE_MS = 400;
-      var RESYNC_TAIL_MS = 350;
+      var RESYNC_THROTTLE_MS = 1500;
+      var RESYNC_TAIL_MS = 800;
       var _resyncChunkLastAt = 0;
       var _resyncChunkTailTimer = null;
       function maybeScheduleResyncForChunk(chunk) {
@@ -7368,6 +7657,7 @@
           resetTerminal();
           currentOutput = "";
           state.terminalOutput = "";
+          state.terminalOutputMarker = 0; // R8: 切会话重置 /clear marker
           state.terminalAutoFollow = true;
           clearTerminalScrollIdleTimer();
           updateTerminalJumpToBottomButton();
@@ -7410,6 +7700,11 @@
 
         state.terminalSessionId = nextSessionId;
         state.terminalOutput = normalizedOutput;
+        // R8: syncTerminalBuffer 是整段 replace / sessionChanged 路径，旧
+        // marker 已不属于新 buffer，重置为 0。append-delta 子路径（startsWith
+        // 命中那条）虽然在 buffer 末尾延伸，但 normalizedOutput 也是延续值，
+        // 把 marker 截到不超过新长度即可；为简单起见统一 reset 0。
+        state.terminalOutputMarker = 0;
         if (shouldScroll && (wrote || sessionChanged || mode === "replace")) {
           maybeScrollTerminalToBottom(sessionChanged || mode === "replace" ? "force" : "output");
         } else {
@@ -7698,6 +7993,11 @@
           if (canAutoResumeSession(session)) return "";
           return "会话已结束";
         }
+        // 结构化会话在出 token 时，输入框仍然可用——告诉用户默认行为是排队，
+        // 想插队请按右侧的 » 按钮。短语保持单行不换行。
+        if (isStructuredSession(session) && session.structuredState && session.structuredState.inFlight) {
+          return "回复中…继续输入将排队（» 立即发送）";
+        }
         return "";
       }
 
@@ -8111,6 +8411,7 @@
         var hasSession = !!state.selectedId;
         var terminalContainer = document.getElementById("output");
         var chatContainer = document.getElementById("chat-output");
+        var blankChat = document.getElementById("blank-chat");
         var selectedSession = state.sessions.find(function(s) { return s.id === state.selectedId; });
         var structured = isStructuredSession(selectedSession);
         var showTerminal = hasSession && !structured && state.currentView === "terminal";
@@ -8129,6 +8430,14 @@
           chatContainer.classList.toggle("active", showChat);
           chatContainer.classList.toggle("hidden", !showChat);
         }
+        // blank-chat 的可见性由 applyCurrentView 收口：updateShellChrome 在
+        // selectedSession 缺失（启动期 selectedId 已恢复但 /api/sessions 未回 /
+        // activateSession 在 updateSessionSnapshot 之前调 switchToSessionView 等
+        // 瞬态）时会走 else 分支把 blank-chat 显示出来，但紧接着调到这里，应
+        // 以 hasSession 为准重新隐藏，避免与 terminal/chat 同屏并存。
+        if (blankChat) {
+          blankChat.classList.toggle("hidden", hasSession);
+        }
         if (chatContainer && showChat) {
           ensureChatMessagesContainer(chatContainer);
         }
@@ -8204,13 +8513,19 @@
           // redraw sequences from Claude CLI. When they appear or dismiss, schedule a
           // debounced terminal resync so residual DOM rows get cleaned up automatically
           // — same fix the user used to have to reach for via the refresh button.
-          var prevEsc = prevSession && prevSession.pendingEscalation ? 1 : 0;
-          var nextEsc = updatedSession && updatedSession.pendingEscalation ? 1 : 0;
-          var prevBlocked = prevSession && prevSession.permissionBlocked ? 1 : 0;
-          var nextBlocked = updatedSession && updatedSession.permissionBlocked ? 1 : 0;
-          if (prevEsc !== nextEsc || prevBlocked !== nextBlocked) {
-            scheduleSoftResyncTerminal(200);
-          }
+          // R2 策略 A：移除 permissionBlocked / pendingEscalation 翻转触发的
+          // softResync。原本是为了"权限菜单消失后清掉残留 DOM 行"，但 softResync
+          // 全量重放在 fresh buffer 上会把 Claude 用相对位移画的菜单帧顺序堆叠
+          // （截图 2 的根因之一）。NEW-A（CSI ?2026 同步输出缓冲）已经把菜单帧
+          // 渲染原子化，R6（wandTerminalWrite 内的 maybeScheduleResyncForChunk）
+          // 在出现原地重绘序列时兜底。这条翻转触发现在是多余且有害的。
+          // var prevEsc = prevSession && prevSession.pendingEscalation ? 1 : 0;
+          // var nextEsc = updatedSession && updatedSession.pendingEscalation ? 1 : 0;
+          // var prevBlocked = prevSession && prevSession.permissionBlocked ? 1 : 0;
+          // var nextBlocked = updatedSession && updatedSession.permissionBlocked ? 1 : 0;
+          // if (prevEsc !== nextEsc || prevBlocked !== nextBlocked) {
+          //   scheduleSoftResyncTerminal(200);
+          // }
         }
         // When a session transitions to a non-running state, try flushing cross-session queue
         if (normalizedSnapshot.status && normalizedSnapshot.status !== "running" && state.crossSessionQueue.length > 0) {
@@ -8387,7 +8702,8 @@
             } else if (state.selectedId) {
               var sel = state.sessions.find(function(s) { return s.id === state.selectedId; });
               if (isStructuredSession(sel)) {
-                resetChatRenderCache();
+                // ws 重连后的同会话刷新——保留用户阅读位置。
+                resetChatRenderCache({ preserveStickState: true });
                 scheduleChatRender(true);
               }
             }
@@ -8427,6 +8743,7 @@
         var countEl = document.getElementById("session-count");
         if (listEl) listEl.innerHTML = renderSessionsListContent();
         if (countEl) countEl.textContent = String(state.sessions.length);
+        if (typeof hideCollapsedTileBubble === "function") hideCollapsedTileBubble();
         updateShellChrome();
         // Re-render cross-session queue (container may have been destroyed by DOM rebuild)
         if (state.crossSessionQueue.length > 0) renderCrossSessionQueue();
@@ -8481,6 +8798,7 @@
         if (!selectedSession) {
           state.terminalSessionId = null;
           state.terminalOutput = "";
+          state.terminalOutputMarker = 0; // R8: 取消选中会话时重置 /clear marker
         }
         // 之前这里会用 selectedSession.output 再 syncTerminalBuffer 一次。
         // 但 updateShellChrome 在 updateSessionsList、status 推送、init
@@ -8692,6 +9010,69 @@
         updateLayoutState();
       }
 
+      var collapsedTileBubbleEl = null;
+      function ensureCollapsedTileBubble() {
+        if (collapsedTileBubbleEl && document.body.contains(collapsedTileBubbleEl)) {
+          return collapsedTileBubbleEl;
+        }
+        collapsedTileBubbleEl = document.createElement("div");
+        collapsedTileBubbleEl.className = "sidebar-tile-bubble";
+        collapsedTileBubbleEl.setAttribute("role", "tooltip");
+        document.body.appendChild(collapsedTileBubbleEl);
+        return collapsedTileBubbleEl;
+      }
+      function hideCollapsedTileBubble() {
+        if (collapsedTileBubbleEl) collapsedTileBubbleEl.classList.remove("visible");
+      }
+      function showCollapsedTileBubble(tile, text) {
+        if (!text) { hideCollapsedTileBubble(); return; }
+        var bubble = ensureCollapsedTileBubble();
+        bubble.textContent = text.length > 400 ? text.slice(0, 400) + "…" : text;
+        var rect = tile.getBoundingClientRect();
+        bubble.classList.add("visible");
+        // Measure after content set; clamp vertically to viewport.
+        var bubbleRect = bubble.getBoundingClientRect();
+        var centerY = rect.top + rect.height / 2;
+        var top = centerY - bubbleRect.height / 2;
+        var minTop = 8;
+        var maxTop = window.innerHeight - bubbleRect.height - 8;
+        if (top < minTop) top = minTop;
+        if (top > maxTop) top = Math.max(minTop, maxTop);
+        bubble.style.left = (rect.right + 12) + "px";
+        bubble.style.top = top + "px";
+        bubble.style.setProperty("--bubble-tail-y", (centerY - top) + "px");
+      }
+      function getCollapsedTileBubbleText(tile) {
+        if (tile.dataset.collapsedSessionId) {
+          var session = state.sessions.find(function(s) { return s.id === tile.dataset.collapsedSessionId; });
+          if (!session) return "";
+          var latest = getSessionLatestUserText(session);
+          if (latest) return latest;
+          return session.summary || session.command || "";
+        }
+        if (tile.dataset.collapsedHistoryId) {
+          var hist = state.claudeHistory.find(function(s) { return s.claudeSessionId === tile.dataset.collapsedHistoryId; });
+          if (hist && hist.firstUserMessage) return hist.firstUserMessage;
+        }
+        return "";
+      }
+      function handleCollapsedTileHover(event) {
+        var target = event.target;
+        if (!target || !(target instanceof Element)) return;
+        var tile = target.closest(".sidebar-collapsed-tile");
+        if (!tile) { hideCollapsedTileBubble(); return; }
+        var text = getCollapsedTileBubbleText(tile);
+        if (!text) { hideCollapsedTileBubble(); return; }
+        showCollapsedTileBubble(tile, text);
+      }
+      function handleCollapsedTileLeave(event) {
+        var related = event.relatedTarget;
+        if (related && related instanceof Element && related.closest(".sidebar-collapsed-tile")) {
+          return;
+        }
+        hideCollapsedTileBubble();
+      }
+
       function toggleSidebarCollapsed() {
         if (isMobileLayout()) return;
         // 在 drawer 模式（未 pin）下点 collapse 视为「先固定、再收起为窄条」——
@@ -10287,17 +10668,42 @@
         return body;
       }
 
+      // 会话创建路径：保证 wterm 已经按真实容器尺寸校准，再向服务端 POST
+      // 新会话——否则 withTerminalDimensions 拿不到 cols/rows，body 不带尺寸
+      // → 服务端兜底 120/36 → Claude 按 120 列画 banner/box → wterm 实际渲
+      // 染宽 ≠ 120 → 横线断行（图 1 现象）。带 2s 兜底超时，避免
+      // initTerminal 失败时 UI 永久卡在"创建会话"按钮。
+      function ensureTerminalReady() {
+        if (state.terminal && state.terminal.cols) return Promise.resolve();
+        return new Promise(function(resolve) {
+          var done = false;
+          var settle = function() { if (!done) { done = true; resolve(); } };
+          var hardTimeout = setTimeout(settle, 2000);
+          try { initTerminal(); } catch (e) {}
+          requestAnimationFrame(function() {
+            requestAnimationFrame(function() {
+              if (state.terminal && state.terminal.cols) {
+                clearTimeout(hardTimeout);
+                settle();
+              }
+            });
+          });
+        });
+      }
+
       function quickStartSession() {
         var command = getPreferredTool();
         var defaultCwd = getEffectiveCwd();
         var defaultMode = getSafeModeForTool(command, (state.config && state.config.defaultMode) ? state.config.defaultMode : "default");
         state.preferredCommand = command;
         state.chatMode = getSafeModeForTool(command, state.chatMode);
-        fetch("/api/commands", {
+        ensureTerminalReady().then(function() {
+          return fetch("/api/commands", {
           method: "POST",
           headers: { "Content-Type": "application/json" },
           credentials: "same-origin",
           body: JSON.stringify(withTerminalDimensions({ command: command, provider: command, cwd: defaultCwd, mode: defaultMode }))
+        });
         })
         .then(function(res) { return res.json(); })
         .then(function(data) {
@@ -10374,7 +10780,8 @@
         state.preferredCommand = command;
         syncComposerModeSelect();
 
-        fetch("/api/commands", {
+        ensureTerminalReady().then(function() {
+          return fetch("/api/commands", {
           method: "POST",
           headers: { "Content-Type": "application/json" },
           credentials: "same-origin",
@@ -10385,6 +10792,7 @@
             mode: mode,
             worktreeEnabled: worktreeEnabled
           }))
+        });
         })
         .then(function(res) { return res.json(); })
         .then(function(data) {
@@ -10599,7 +11007,10 @@
             return;
           }
           event.preventDefault();
-          sendInputFromBox();
+          // Cmd/Ctrl+Enter → 立即发送（中断当前回复）。仅对正在 inFlight 的
+          // 结构化会话生效；其它情况下退化为普通发送，避免无谓的中断信号。
+          var interruptShortcut = !!(event.metaKey || event.ctrlKey);
+          sendInputFromBox(interruptShortcut ? { interrupt: true } : undefined);
           return;
         }
 
@@ -11308,7 +11719,8 @@
         });
       }
 
-      function sendOrStart() {
+      function sendOrStart(opts) {
+        opts = opts || {};
         // Support welcome input as well as the main input box
         var welcomeInput = document.getElementById("welcome-input");
         var inputBox = document.getElementById("input-box");
@@ -11319,7 +11731,7 @@
         // If we have a selected ID, try to send input to it
         if (state.selectedId) {
           if (value) {
-            sendInputFromBox();
+            sendInputFromBox(opts);
           }
           return;
         }
@@ -11418,7 +11830,9 @@
       }
 
 
-      function sendInputFromBox() {
+      function sendInputFromBox(opts) {
+        opts = opts || {};
+        var interruptFlag = !!opts.interrupt;
         if (state.terminalInteractive) {
           showToast("终端交互模式开启时，请直接在终端中输入。", "info");
           return Promise.resolve();
@@ -11457,7 +11871,7 @@
             if (todoEl) todoEl.classList.add("hidden");
 
             if (isStructuredSession(selectedSession)) {
-              return postStructuredInput(finalValue, inputBox, selectedSession);
+              return postStructuredInput(finalValue, inputBox, selectedSession, { interrupt: interruptFlag });
             }
 
             var submitChunks = getTerminalSubmitChunks(selectedSession, finalValue);
@@ -11505,8 +11919,13 @@
       // 防止同一会话并发提交（快速双击 / 重复触发）
       var _structuredSubmittingSessions = {};
 
-      function postStructuredInput(input, inputBox, session) {
-        console.log("[WAND] postStructuredInput selectedId:", state.selectedId, "input:", input && input.substring(0, 50), "session:", session && { id: session.id, sessionKind: session.sessionKind, runner: session.runner, status: session.status, inFlight: session.structuredState && session.structuredState.inFlight });
+      function postStructuredInput(input, inputBox, session, opts) {
+        opts = opts || {};
+        // 用户显式点击"立即发送"才会传 interrupt:true。普通 Enter / 点发送
+        // 在上一条还在流式时默认走 queue —— 后端 sendMessage(...) 会把它
+        // 追加到 queuedMessages，等当前 turn 结束自动 flush。
+        var requestedInterrupt = !!opts.interrupt;
+        console.log("[WAND] postStructuredInput selectedId:", state.selectedId, "input:", input && input.substring(0, 50), "requestedInterrupt:", requestedInterrupt, "session:", session && { id: session.id, sessionKind: session.sessionKind, runner: session.runner, status: session.status, inFlight: session.structuredState && session.structuredState.inFlight });
         if (!state.selectedId || !input) return Promise.resolve();
         if (!session) {
           showToast("会话不存在，请重新选择或新建会话。", "error");
@@ -11518,25 +11937,48 @@
           return Promise.resolve();
         }
 
-        var isInterrupting = !!(session.structuredState && session.structuredState.inFlight && session.status === "running");
-        // Immediately render user message with thinking indicator
-        var userTurn = { role: "user", content: [{ type: "text", text: input }] };
+        var sessionInFlight = !!(session.structuredState && session.structuredState.inFlight && session.status === "running");
+        var isInterrupting = sessionInFlight && requestedInterrupt;
+        var isQueueing = sessionInFlight && !requestedInterrupt;
+
         var userMsgs = stripRenderOnlyStructuredMessages(Array.isArray(session.messages) ? session.messages.slice() : []);
-        userMsgs.push(userTurn);
-        var optimisticStructuredState = Object.assign({}, session.structuredState || {}, { inFlight: true });
-        updateSessionSnapshot({
-          id: session.id,
-          status: "running",
-          messages: userMsgs,
-          structuredState: optimisticStructuredState,
-        });
-        state.currentMessages = buildMessagesForRender(Object.assign({}, session, {
-          status: "running",
-          messages: userMsgs,
-          structuredState: optimisticStructuredState,
-        }), userMsgs);
-        updateInputHint("思考中…");
-        renderChat(true);
+        var optimisticPatch;
+
+        if (isQueueing) {
+          // Queue 模式：不要乐观 push user turn —— buildMessagesForRender 会把
+          // queuedMessages 渲成 __queued 占位（带"排队中"徽章），再 push 一份
+          // 真 user turn 会被去重逻辑遮蔽掉，徽章就丢了。inFlight / status 维持。
+          var nextQueue = Array.isArray(session.queuedMessages) ? session.queuedMessages.slice() : [];
+          nextQueue.push(input);
+          optimisticPatch = {
+            id: session.id,
+            queuedMessages: nextQueue,
+          };
+          updateSessionSnapshot(optimisticPatch);
+          var queueRefreshed = state.sessions.find(function(s) { return s.id === session.id; }) || session;
+          state.currentMessages = buildMessagesForRender(queueRefreshed, getPreferredMessages(queueRefreshed, queueRefreshed.output, false));
+          updateInputHint("已加入排队，等待当前回复完成…");
+          renderChat(true);
+          updateStructuredQueueCounter();
+        } else {
+          // 普通发送 / interrupt 发送：照旧乐观推 user turn + inFlight=true
+          var userTurn = { role: "user", content: [{ type: "text", text: input }] };
+          userMsgs.push(userTurn);
+          var optimisticStructuredState = Object.assign({}, session.structuredState || {}, { inFlight: true });
+          updateSessionSnapshot({
+            id: session.id,
+            status: "running",
+            messages: userMsgs,
+            structuredState: optimisticStructuredState,
+          });
+          state.currentMessages = buildMessagesForRender(Object.assign({}, session, {
+            status: "running",
+            messages: userMsgs,
+            structuredState: optimisticStructuredState,
+          }), userMsgs);
+          updateInputHint(isInterrupting ? "已中断，正在处理新消息…" : "思考中…");
+          renderChat(true);
+        }
 
         if (inputBox) {
           inputBox.value = "";
@@ -11592,8 +12034,12 @@
               var refreshedSession = state.sessions.find(function(s) { return s.id === snapshot.id; }) || snapshot;
               state.currentMessages = buildMessagesForRender(refreshedSession, getPreferredMessages(refreshedSession, snapshot.output, false));
               renderChat(true);
+              updateStructuredQueueCounter();
               if (isInterrupting) {
                 showToast("已中断上一条回复，正在处理新消息…", "info");
+              } else if (isQueueing) {
+                var qLen = Array.isArray(refreshedSession.queuedMessages) ? refreshedSession.queuedMessages.length : 0;
+                showToast(qLen > 1 ? ("已加入排队（共 " + qLen + " 条等待）") : "已加入排队，等待当前回复完成。", "info");
               }
             }
           }
@@ -11611,20 +12057,36 @@
             return;
           }
 
-          // 回滚乐观更新：恢复发送前的 messages（去掉刚加的 userTurn）和 inFlight 状态
-          var rollbackMsgs = userMsgs.slice(0, -1);
-          updateSessionSnapshot({
-            id: session.id,
-            status: session.status,
-            messages: rollbackMsgs,
-            structuredState: Object.assign({}, session.structuredState || {}, { inFlight: false }),
-          });
-          if (session.id === state.selectedId) {
-            state.currentMessages = buildMessagesForRender(
-              Object.assign({}, session, { messages: rollbackMsgs, structuredState: Object.assign({}, session.structuredState || {}, { inFlight: false }) }),
-              rollbackMsgs
-            );
-            renderChat(true);
+          if (isQueueing) {
+            // Queue 模式回滚：把刚 push 的那条 queuedMessages 撤掉。inFlight / messages
+            // 都没动过，不必复位，否则会把后端真实的 inFlight=true 误改成 false。
+            var prevQueue = Array.isArray(session.queuedMessages) ? session.queuedMessages.slice() : [];
+            updateSessionSnapshot({
+              id: session.id,
+              queuedMessages: prevQueue,
+            });
+            if (session.id === state.selectedId) {
+              var rolledQueueSession = state.sessions.find(function(s) { return s.id === session.id; }) || session;
+              state.currentMessages = buildMessagesForRender(rolledQueueSession, getPreferredMessages(rolledQueueSession, rolledQueueSession.output, false));
+              renderChat(true);
+              updateStructuredQueueCounter();
+            }
+          } else {
+            // 回滚乐观更新：恢复发送前的 messages（去掉刚加的 userTurn）和 inFlight 状态
+            var rollbackMsgs = userMsgs.slice(0, -1);
+            updateSessionSnapshot({
+              id: session.id,
+              status: session.status,
+              messages: rollbackMsgs,
+              structuredState: Object.assign({}, session.structuredState || {}, { inFlight: false }),
+            });
+            if (session.id === state.selectedId) {
+              state.currentMessages = buildMessagesForRender(
+                Object.assign({}, session, { messages: rollbackMsgs, structuredState: Object.assign({}, session.structuredState || {}, { inFlight: false }) }),
+                rollbackMsgs
+              );
+              renderChat(true);
+            }
           }
           var message = (error && error.message) || "";
           var isTransientAbort =
@@ -11878,8 +12340,26 @@
         });
       }
 
+      // R8: 检测用户输入是否包含 /clear 命令，命中时把 marker 标到当前 buffer
+      // 长度，下次 softResync 时就不会重放 /clear 之前的历史。
+      // 检测点放在 queueDirectInput 是因为：所有用户 input（chat 框发送、终端
+      // interactive 直写、shortcut 按键、bracketed paste 等）最终都汇到这条
+      // 路径。先 strip bracketed-paste 包络（\x1b[200~ ... \x1b[201~）再做行首
+      // 匹配，覆盖多种粘贴形式。
+      function _detectAndMarkClear(input) {
+        if (typeof input !== "string" || !input) return;
+        var stripped = input.replace(/\x1b\[200~/g, "").replace(/\x1b\[201~/g, "");
+        // 必须 /clear 在某一行起始位置，且后接 \r 或 \n 或行尾
+        if (/(?:^|\n)\s*\/clear\s*(?:\r|\n|$)/.test(stripped)) {
+          if (typeof state !== "undefined" && state) {
+            state.terminalOutputMarker = (state.terminalOutput && state.terminalOutput.length) | 0;
+          }
+        }
+      }
+
       function queueDirectInput(input, shortcutKey, viewOverride) {
         if (!input || !state.selectedId) return Promise.resolve();
+        _detectAndMarkClear(input);
         state.messageQueue.push(input);
         state.inputQueue = state.inputQueue.then(function() {
           return postInput(input, shortcutKey, viewOverride).finally(function() {
@@ -12214,11 +12694,19 @@
           composer.classList.toggle("is-terminal-passthrough", !!state.terminalInteractive);
         }
         var sendBtn = document.getElementById("send-input-button");
+        var structuredInFlight = structured && isRunning;
         if (sendBtn) {
           sendBtn.disabled = !structured && !!selectedSession && !isRunning && !canResumeOnSend;
           sendBtn.setAttribute("title", structured
-            ? "发送"
+            ? (structuredInFlight ? "排队发送（当前回复结束后处理）" : "发送")
             : (isCodex ? (isRunning ? "发送给 Codex" : "Codex 会话已结束") : (!selectedSession || isRunning || canResumeOnSend ? "发送" : "会话已结束")));
+          sendBtn.classList.toggle("queue-mode", structuredInFlight);
+        }
+        var interruptBtn = document.getElementById("interrupt-send-button");
+        if (interruptBtn) {
+          // 仅结构化 + inFlight 时显示。pty 会话有自己的 Ctrl+C / stop 按钮，
+          // 用不上这套语义。
+          interruptBtn.classList.toggle("hidden", !structuredInFlight);
         }
         var container = document.getElementById("output");
         if (container) container.classList.toggle("interactive", !structured && state.terminalInteractive);
@@ -12937,7 +13425,10 @@
           // fill the expanded space, and the scroll position needs resetting.
           if (isTouchDevice()) {
             ensureTerminalFit("keyboard-blur", { forceReplay: true });
-            maybeScrollTerminalToBottom("force");
+            // "keyboard" 而非 "force"：用户原本在终端历史里翻看时，键盘
+            // 收起不该把视图拽走。maybeScrollTerminalToBottom 会按
+            // terminalAutoFollow 决定——贴底者继续贴底，离底者保位。
+            maybeScrollTerminalToBottom("keyboard");
           }
         }, 100);
       }
@@ -13731,7 +14222,9 @@
                 syncAppViewportHeight();
               }
               ensureTerminalFit("keyboard-close", { forceReplay: true });
-              maybeScrollTerminalToBottom("force");
+              // 同 handleInputBoxBlur：尊重 terminalAutoFollow，避免把上滚
+              // 阅读历史的用户在键盘关闭瞬间拽回底部。
+              maybeScrollTerminalToBottom("keyboard");
             }, 200);
           }
 
@@ -13980,8 +14473,13 @@
         // 中间态，下一个 wterm 实例的首批字节会被错误归类（首字符被吃成
         // ANSI 序列尾巴）。重建终端前显式复位，避免状态泄漏到新实例。
         resetWideParserState();
+        // sync output 缓冲跨会话也要清，否则旧会话最后没收完的 ?2026h 帧
+        // 会让新会话的首批 PTY 字节全部被吞进 buffer 等永远不会来的 end。
+        state.syncOutputBuffer = null;
+        state.syncOutputDeadline = 0;
         state.terminalSessionId = null;
         state.terminalOutput = "";
+        state.terminalOutputMarker = 0; // R8: teardown 时重置 /clear marker
         state.terminalAutoFollow = true;
         state.showTerminalJumpToBottom = false;
         updateTerminalJumpToBottomButton();
@@ -14010,6 +14508,9 @@
         // 直接 400/404，console 留一条红色错误；这里提前剪掉，避免噪音。
         if (!selectedSess || selectedSess.status !== "running") return;
         if (isStructuredSession(selectedSess)) return;
+        // wterm WASM grid 的 maxCols 硬编码 256。POST 给服务端的 cols 也同步
+        // clamp，避免服务端 pty.resize 给 Claude 一个 wterm 实际渲不下的列宽。
+        if (cols > 256) cols = 256;
         var nextSize = { cols: cols, rows: rows };
         if (state.lastResize.cols !== nextSize.cols || state.lastResize.rows !== nextSize.rows) {
           state.lastResize = nextSize;
@@ -14366,21 +14867,11 @@
             if (msg.data && msg.sessionId
                 && Object.prototype.hasOwnProperty.call(msg.data, 'isResponding')) {
               if (!state._lastIsResponding) state._lastIsResponding = {};
-              var _prevResp = !!state._lastIsResponding[msg.sessionId];
-              var _nextResp = !!msg.data.isResponding;
-              state._lastIsResponding[msg.sessionId] = _nextResp;
-              if (_prevResp && !_nextResp
-                  && msg.sessionId === state.selectedId
-                  && state.terminal
-                  && state.terminalOutput) {
-                if (state._idleResyncTimer) clearTimeout(state._idleResyncTimer);
-                var _idleResyncSid = msg.sessionId;
-                state._idleResyncTimer = setTimeout(function() {
-                  state._idleResyncTimer = null;
-                  if (state.selectedId !== _idleResyncSid) return;
-                  try { softResyncTerminal({ skipFit: true }); } catch (e) {}
-                }, 120);
-              }
+              state._lastIsResponding[msg.sessionId] = !!msg.data.isResponding;
+              // R2 策略 A：移除 isResponding true→false 翻转触发的 softResync。
+              // 原本是想在"流式回答结束"瞬间洗掉错位的 cursor 定位残留，但
+              // softResync 全量重放在 fresh buffer 上会把 askuserquestion 的多
+              // 帧字节顺序堆叠（截图 2 的根因之一）。NEW-A + R6 兜底后不再需要。
             }
             if (msg.data && msg.sessionId) {
               var isIncremental = !!msg.data.incremental;
@@ -14478,8 +14969,12 @@
                 // "被覆盖中间帧"反复塞进 scrollback。thinking→idle 兜底就够了。
                 state.terminalSessionId = msg.sessionId;
                 if (msg.data.output) {
+                  // R8: full output replace → marker 失效，重置为 0
                   state.terminalOutput = clampClientTerminalOutput(normalizeTerminalOutput(msg.data.output));
+                  state.terminalOutputMarker = 0;
                 } else {
+                  // append-delta：buffer 延续，marker 保持（clampClientTerminalOutput
+                  // 内部已经按裁掉字节数同步缩减 marker）
                   state.terminalOutput = clampClientTerminalOutput((state.terminalOutput || "") + normalizeTerminalOutput(msg.data.chunk));
                 }
                 maybeScrollTerminalToBottom("output");
@@ -15145,6 +15640,9 @@
         }
 
         var allMessages = state.currentMessages;
+        // 预扫一遍全量 messages，构建 task id → subagent meta 的 map，
+        // 供老消息 tool_result（没有 __subagent 盖章）按 tool_use_id 反查兜底。
+        var legacyTaskMap = collectLegacyTaskIdMap(allMessages);
 
         if (allMessages.length === 0) {
           if (state.lastRenderedEmpty !== "empty") {
@@ -15221,10 +15719,11 @@
 
         // 在动 DOM 之前先看用户是不是贴在底部——这决定后面我们要不要让视图
         // "继续粘在底部"。column-reverse 下 scrollTop 接近 0 = 视觉底部。
-        // 同时把 state.chatStickToBottom 同步到当前真实状态，避免长时间不滚动后
-        // 的状态漂移（比如新会话 init 的瞬间）。
+        // 注意：state.chatStickToBottom 的维护**完全交给 scroll handler**
+        // （bindChatScrollListener + wheel/touch 提前下台），这里不再做
+        // "近底即锁回 true"的自愈，避免 resize / 键盘动画 / 锚点回填瞬间
+        // 把已经上滚阅读的用户误判回贴底状态。
         var renderWasAtBottom = isChatNearBottom(chatMessages);
-        if (renderWasAtBottom) state.chatStickToBottom = true;
 
         // 把 .system-info 卡片从计数里剔除——它由 extractPtySystemInfo 在
         // fullRenderChat 里穿插注入，不存在于 messages 数组中，混进 existingCount
@@ -15268,7 +15767,7 @@
             }
 
             // Render message
-            html += renderChatMessage(msg, roundUsageByIndex[originalIndex] || null, originalIndex);
+            html += renderChatMessage(msg, roundUsageByIndex[originalIndex] || null, originalIndex, legacyTaskMap);
           }
 
           // Add sentinel for loading older messages (DOM end = visual top in column-reverse)
@@ -15282,9 +15781,12 @@
           // 的 data-msg-index 和它到容器顶部的偏移。重写完成后找到同一 data-msg-index
           // 的新节点，把它放回原来的偏移——这是 column-reverse 下保住用户视线的
           // 标准锚点法。没有锚点时（首次渲染、空 → 非空）才走 scrollTop=0 兜底。
+          // 改用 existingCount 而非 prevMsgCount：page-refresh 等 preserveStickState
+          // 路径下 prevMsgCount 被重置为 0，但 DOM 里仍有节点可作锚点，必须保住
+          // 用户的阅读位置。
           var anchorMsgIndex = -1;
           var anchorOffset = 0;
-          if (prevMsgCount > 0 && !renderWasAtBottom) {
+          if (existingCount > 0 && !renderWasAtBottom) {
             var containerTop = chatMessages.getBoundingClientRect().top;
             var preEls = chatMessages.querySelectorAll(".chat-message:not(.system-info)");
             for (var pi = 0; pi < preEls.length; pi++) {
@@ -15314,13 +15816,19 @@
           })();
           // 会话切换 / 首次渲染后，浏览器会把旧的 scrollTop 钳制到新内容
           // 的最大值——column-reverse 下这意味着视觉上跳到最上面（最旧消息），
-          // 也就是用户反馈的"退出再回来时被重定向到最上面"。这里在
-          // prevMsgCount === 0（resetChatRenderCache 后或刚从空状态进入）
-          // 强制 scrollTop=0（视觉底部 = 最新消息），避免错位。
-          if (prevMsgCount === 0) {
+          // 也就是用户反馈的"退出再回来时被重定向到最上面"。
+          // 关键：只在该会话视图的**首次**渲染（chatInitialRenderDone=false）
+          // 才执行这个强制贴底；之后即便 prevMsgCount===0（page-refresh /
+          // ws 重连等保留 sticky 的 reset 路径），也尊重 chatStickToBottom，
+          // 不再把上滚的用户拽回去。
+          if (prevMsgCount === 0 && !state.chatInitialRenderDone) {
             chatMessages.scrollTop = 0;
             state.chatStickToBottom = true;
             clearChatUnread({ removeDivider: true });
+            state.chatInitialRenderDone = true;
+          } else if (prevMsgCount === 0 && state.chatStickToBottom) {
+            // 非首次但缓存重置后的 re-render——仅在用户原本贴底时回贴。
+            chatMessages.scrollTop = 0;
           } else if (renderWasAtBottom) {
             // 同一会话内的全量重渲染：用户原本贴底就保持贴底，浏览器在 innerHTML
             // 重置后可能把 scrollTop 钳到一个奇怪的值，这里显式拉回 0。
@@ -15453,7 +15961,7 @@
           for (var i = 0; i < newMessages.length; i++) {
             var div = document.createElement("div");
             var nmOrigIdx = visibleOffset + existingCount + (newMessages.length - 1 - i);
-            div.innerHTML = renderChatMessage(newMessages[i], roundUsageByIndex[nmOrigIdx] || null, nmOrigIdx);
+            div.innerHTML = renderChatMessage(newMessages[i], roundUsageByIndex[nmOrigIdx] || null, nmOrigIdx, legacyTaskMap);
             var el = div.firstElementChild;
             if (el) {
               el.classList.add("animate-in");
@@ -15511,7 +16019,7 @@
             var currentEl = existingEls[mi];
             var tmpWrap = document.createElement("div");
             var srOrigIdx = visibleOffset + reversedMessages.length - 1 - mi;
-            tmpWrap.innerHTML = renderChatMessage(reversedMessages[mi], roundUsageByIndex[srOrigIdx] || null, srOrigIdx);
+            tmpWrap.innerHTML = renderChatMessage(reversedMessages[mi], roundUsageByIndex[srOrigIdx] || null, srOrigIdx, legacyTaskMap);
             var replacementEl = tmpWrap.firstElementChild;
             if (!replacementEl) continue;
             if (currentEl.innerHTML !== replacementEl.innerHTML || currentEl.className !== replacementEl.className) {
@@ -16386,55 +16894,137 @@
       }
 
       // ── 像素风猫咪头像 ──
-      var PIXEL_AVATAR = (function() {
-        var _ = "transparent";
-        function buildSvg(grid, size) {
-          var s = size || 3;
-          var w = grid[0].length * s;
-          var h = grid.length * s;
-          var rects = "";
-          for (var y = 0; y < grid.length; y++) {
-            for (var x = 0; x < grid[y].length; x++) {
-              if (grid[y][x] !== _) {
-                rects += '<rect x="' + (x * s) + '" y="' + (y * s) + '" width="' + s + '" height="' + s + '" fill="' + grid[y][x] + '"/>';
-              }
+      // 统一的 10×10 猫咪 grid 模板：父 assistant = 加菲（橙），user = 美短（灰），
+      // subagent = 一组按 taskId/agentType 哈希选色的备选 palette。同一模板让多个
+      // 角色看起来是"同种生物的不同毛色"，群聊感更自然。
+      var _AVATAR_T = "transparent";
+      function buildPixelSvg(grid, size) {
+        var s = size || 3;
+        var w = grid[0].length * s;
+        var h = grid.length * s;
+        var rects = "";
+        for (var y = 0; y < grid.length; y++) {
+          for (var x = 0; x < grid[y].length; x++) {
+            if (grid[y][x] !== _AVATAR_T) {
+              rects += '<rect x="' + (x * s) + '" y="' + (y * s) + '" width="' + s + '" height="' + s + '" fill="' + grid[y][x] + '"/>';
             }
           }
-          return '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ' + w + ' ' + h + '" class="pixel-avatar-svg">' + rects + '</svg>';
-        }
-        // 加菲猫 (勤劳初二 / AI) — 橙色系
-        var o = "#F0923A", d = "#C46A1A", w = "#FFFFFF", k = "#2D2D2D", p = "#F28B9A", n = "#E87D5A";
-        var garfield = [
-          [_,d,_,_,_,_,_,_,d,_],
-          [d,o,d,_,_,_,_,d,o,d],
-          [d,o,o,o,o,o,o,o,o,d],
-          [o,o,w,k,o,o,w,k,o,o],
-          [o,o,w,w,o,o,w,w,o,o],
-          [o,o,o,o,p,p,o,o,o,o],
-          [o,d,o,n,o,o,n,o,d,o],
-          [_,o,o,o,o,o,o,o,o,_],
-          [_,_,o,d,o,o,d,o,_,_],
-          [_,_,_,o,_,_,o,_,_,_],
-        ];
-        // 美短 (赛博虎妞 / 用户) — 灰色系
-        var g = "#9EAAB8", dg = "#6B7B8D", lg = "#C5CED8", gn = "#7EC88B";
-        var shorthair = [
-          [_,dg,_,_,_,_,_,_,dg,_],
-          [dg,g,dg,_,_,_,_,dg,g,dg],
-          [dg,g,g,g,g,g,g,g,g,dg],
-          [g,g,w,gn,g,g,w,gn,g,g],
-          [g,g,w,w,g,g,w,w,g,g],
-          [g,g,g,g,p,p,g,g,g,g],
-          [g,dg,g,lg,g,g,lg,g,dg,g],
-          [_,g,g,g,g,g,g,g,g,_],
-          [_,_,g,dg,g,g,dg,g,_,_],
-          [_,_,_,g,_,_,g,_,_,_],
+        }
+        return '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ' + w + ' ' + h + '" class="pixel-avatar-svg">' + rects + '</svg>';
+      }
+      function buildCatGrid(palette) {
+        // palette: { base, dark, light, accent, eye, mouth, nose }
+        var T = _AVATAR_T;
+        var b = palette.base;
+        var d = palette.dark;
+        var l = palette.light || palette.base;
+        var w = palette.accent || "#FFFFFF";
+        var k = palette.eye || "#2D2D2D";
+        var p = palette.mouth || "#F28B9A";
+        var n = palette.nose || palette.dark;
+        return [
+          [T,d,T,T,T,T,T,T,d,T],
+          [d,b,d,T,T,T,T,d,b,d],
+          [d,b,b,b,b,b,b,b,b,d],
+          [b,b,w,k,b,b,w,k,b,b],
+          [b,b,w,w,b,b,w,w,b,b],
+          [b,b,b,b,p,p,b,b,b,b],
+          [b,n,b,l,b,b,l,b,n,b],
+          [T,b,b,b,b,b,b,b,b,T],
+          [T,T,b,d,b,b,d,b,T,T],
+          [T,T,T,b,T,T,b,T,T,T],
         ];
-        return {
-          assistant: buildSvg(garfield),
-          user: buildSvg(shorthair)
-        };
-      })();
+      }
+      var GARFIELD_PALETTE = {
+        base: "#F0923A", dark: "#C46A1A", light: "#F0923A",
+        accent: "#FFFFFF", eye: "#2D2D2D", mouth: "#F28B9A", nose: "#E87D5A",
+      };
+      var SHORTHAIR_PALETTE = {
+        base: "#9EAAB8", dark: "#6B7B8D", light: "#C5CED8",
+        accent: "#FFFFFF", eye: "#7EC88B", mouth: "#F28B9A",
+      };
+      // 子 agent palette 池。色相与父/用户都拉开距离，避免群聊里多只猫颜色相近难辨认。
+      // primary 用来暴露成 CSS 变量 --agent-color，给气泡左边框 / handoff 文字着色。
+      var SUBAGENT_PALETTES = [
+        { base: "#5A8FE0", dark: "#2E5BB3", light: "#9CC0F2", accent: "#FFFFFF", eye: "#FFD66E", mouth: "#F28B9A", primary: "#5A8FE0" }, // 蓝猫
+        { base: "#A06FE0", dark: "#6B45A8", light: "#C8A4F2", accent: "#FFFFFF", eye: "#FFE36E", mouth: "#F28B9A", primary: "#A06FE0" }, // 紫猫
+        { base: "#7BB76B", dark: "#4F8A40", light: "#A9D49C", accent: "#FFFFFF", eye: "#2D2D2D", mouth: "#F28B9A", primary: "#7BB76B" }, // 抹茶猫
+        { base: "#D86A88", dark: "#9C3A57", light: "#E8A4B5", accent: "#FFFFFF", eye: "#2D2D2D", mouth: "#FFFFFF", primary: "#D86A88" }, // 樱花猫
+        { base: "#5BB7B0", dark: "#2E7873", light: "#9CD6D2", accent: "#FFFFFF", eye: "#FFD66E", mouth: "#F28B9A", primary: "#5BB7B0" }, // 青苔猫
+        { base: "#4A4A60", dark: "#1F1F2E", light: "#6E6E84", accent: "#F5F5F5", eye: "#FFD66E", mouth: "#F28B9A", primary: "#4A4A60" }, // 黑猫
+        { base: "#D8A85A", dark: "#9C7028", light: "#EBC78A", accent: "#FFFFFF", eye: "#2D2D2D", mouth: "#F28B9A", primary: "#D8A85A" }, // 焦糖猫
+      ];
+      function hashStringToIndex(str, mod) {
+        var s = String(str || "");
+        var h = 0;
+        for (var i = 0; i < s.length; i++) h = ((h << 5) - h + s.charCodeAt(i)) | 0;
+        return Math.abs(h) % mod;
+      }
+      // agentType → 中文名映射。命中映射就用映射名，否则用 agentType 原文；
+      // 都没有则退化为 "协作猫·<taskId 后 4 位>"。
+      var SUBAGENT_NAME_MAP = {
+        "general-purpose": "万能猫",
+        "Explore": "侦探猫",
+        "code-explorer": "侦探猫",
+        "code-reviewer": "审查猫",
+        "code-architect": "架构猫",
+        "code-simplifier": "简化猫",
+        "code-guide": "向导猫",
+        "Plan": "策划猫",
+        "feature-dev": "开发猫",
+        "pr-test-analyzer": "测试猫",
+        "silent-failure-hunter": "护卫猫",
+        "type-design-analyzer": "类型猫",
+        "comment-analyzer": "注释猫",
+      };
+      function getSubagentDisplayName(sub) {
+        if (!sub) return "";
+        var agentType = sub.agentType || "";
+        if (agentType && SUBAGENT_NAME_MAP[agentType]) return SUBAGENT_NAME_MAP[agentType];
+        if (agentType) return agentType;
+        var tail = (sub.taskId || "").slice(-4) || "未知";
+        return "协作猫·" + tail;
+      }
+      function getSubagentPalette(sub) {
+        // 哈希优先用 agentType，让同类型 agent 跨 turn 颜色稳定；没有 agentType 时
+        // 退化用 taskId，至少同 turn 内同一只猫颜色稳定。
+        var seed = (sub && (sub.agentType || sub.taskId)) || "subagent";
+        return SUBAGENT_PALETTES[hashStringToIndex(seed, SUBAGENT_PALETTES.length)];
+      }
+      function subagentAvatarHtml(sub) {
+        var palette = getSubagentPalette(sub);
+        var name = getSubagentDisplayName(sub);
+        var svg = buildPixelSvg(buildCatGrid(palette));
+        return '<div class="chat-message-avatar assistant subagent" style="--agent-color:' + palette.primary + '">' +
+          '<div class="pixel-avatar">' + svg + '</div>' +
+          '<span class="avatar-name">' + escapeHtml(name) + '</span>' +
+        '</div>';
+      }
+
+      // subagent tool_result → 独立 reply 气泡（markdown 渲染）。出错时显示红色错误体，
+      // 没文本时显示打字指示器（subagent 还在跑）。
+      function renderSubagentReplyBubble(block, role) {
+        if (!block || block.type !== "tool_result") return "";
+        var text = extractToolResultText(block.content);
+        var isError = block.is_error === true;
+
+        if (isError) {
+          return '<div class="subagent-reply error">' +
+            '<span class="subagent-reply-icon">✗</span>' +
+            '<div class="subagent-reply-body">' + (text ? renderMarkdown(text) : escapeHtml("（无输出）")) + '</div>' +
+          '</div>';
+        }
+
+        if (!text || !String(text).trim()) {
+          return '<div class="subagent-reply pending"><span class="typing-indicator"><span></span><span></span><span></span></span></div>';
+        }
+
+        return '<div class="subagent-reply">' + renderMarkdown(text) + '</div>';
+      }
+      var PIXEL_AVATAR = {
+        assistant: buildPixelSvg(buildCatGrid(GARFIELD_PALETTE)),
+        user: buildPixelSvg(buildCatGrid(SHORTHAIR_PALETTE)),
+      };
 
       var DEFAULT_CHAT_PERSONA = {
         user: {
@@ -16484,16 +17074,20 @@
         '</div>';
       }
 
-      function renderChatMessage(msg, roundUsage, messageIndex) {
+      function renderChatMessage(msg, roundUsage, messageIndex, legacyTaskMap) {
         // Thinking card (deep thought) — from PTY parsing
         if (msg.role === "thinking") {
+          // 空 / 全空白的 thinking 没有任何信息量，渲染出来只是一条带"展开"的紫色窄条，
+          // 展开了也看不到内容——直接跳过。
+          var ptyThinkingText = typeof msg.content === "string" ? msg.content : "";
+          if (!ptyThinkingText.trim()) return "";
           var thinkingKey = buildExpandKey("thinking", [getMessageKey(msg, messageIndex), "pty"]);
           var thinkingPersisted = getPersistedExpandState(thinkingKey);
           var thinkingExpanded = thinkingPersisted === null ? getCardDefault("thinking") : thinkingPersisted;
           return '<div class="chat-message thinking">' +
-            '<div class="thinking-inline thinking-pty ' + (thinkingExpanded ? 'expanded' : 'collapsed') + '" data-expand-kind="thinking" data-expand-key="' + escapeHtml(thinkingKey) + '" data-thinking="" onclick="__thinkingToggle(this)">' +
+            '<div class="thinking-inline thinking-pty ' + (thinkingExpanded ? 'expanded' : 'collapsed') + '" data-expand-kind="thinking" data-expand-key="' + escapeHtml(thinkingKey) + '" data-thinking="' + escapeHtml(ptyThinkingText) + '" onclick="__thinkingToggle(this)">' +
               '<span class="thinking-inline-icon">⦿</span>' +
-              '<span class="thinking-inline-preview">' + escapeHtml(msg.content) + '</span>' +
+              '<span class="thinking-inline-preview">' + escapeHtml(ptyThinkingText) + '</span>' +
               '<span class="thinking-inline-action">' + (thinkingExpanded ? '收起' : '展开') + '</span>' +
             '</div>' +
           '</div>';
@@ -16511,7 +17105,7 @@
 
         // Structured content blocks (from JSON chat mode)
         if (Array.isArray(msg.content)) {
-          return renderStructuredMessage(msg, roundUsage, messageIndex);
+          return renderStructuredMessage(msg, roundUsage, messageIndex, legacyTaskMap);
         }
 
         // Legacy string content (from PTY parsing)
@@ -16567,6 +17161,8 @@
       }
 
       // ── 连续同类工具调用分组 ──
+      // 注意：禁止把 Task/Agent 加入 GROUPABLE_TOOLS——它们由 renderContentBlock 入口屏蔽返空，
+      // 加入分组会导致空 group 包裹一堆空字符串，留下视觉空盒子。
       var GROUPABLE_TOOLS = { Read: 1, Glob: 1, Grep: 1, WebFetch: 1, WebSearch: 1, TodoRead: 1 };
 
       function groupConsecutiveTools(content) {
@@ -16663,61 +17259,223 @@
         persistElementExpandState(el, "tool-group");
       };
 
-      function renderStructuredMessage(msg, roundUsage, messageIndex) {
-        var role = msg.role;
-        var avatar = chatAvatar(role);
-        var messageKey = getMessageKey(msg, messageIndex);
-
-        // Check if this is a queued user message
-        var isQueued = role === "user" && msg.content && msg.content.some(function(b) { return b.__queued; });
+      // 老消息（SQLite 历史 turn）后端还没盖章。前端给 name === "Task"/"Agent"
+      // 或 input.subagent_type 非空的 tool_use 虚拟盖章，让现有 multi-agent 渲染路径吃到。
+      function deriveLegacySubagent(block) {
+        if (!block || block.type !== "tool_use") return null;
+        var input = block.input || {};
+        var agentType = typeof input.subagent_type === "string" ? input.subagent_type : null;
+        if (!agentType && block.name !== "Task" && block.name !== "Agent") return null;
+        return {
+          taskId: block.id,
+          agentType: agentType || undefined,
+          taskDescription: typeof input.description === "string" ? input.description : undefined,
+        };
+      }
 
-        if (!msg.content || msg.content.length === 0) {
-          if (role === "assistant") {
-            return '<div class="chat-message ' + role + '">' +
-              avatar +
-              '<div class="chat-message-bubble"><div class="typing-indicator"><span></span><span></span><span></span></div></div>' +
-            '</div>';
+      // tool_result 老消息靠 tool_use_id 关联 task。由外层预扫一遍 messages，构建 task id → meta 的 map。
+      function collectLegacyTaskIdMap(allMessages) {
+        var map = new Map();
+        if (!Array.isArray(allMessages)) return map;
+        for (var i = 0; i < allMessages.length; i++) {
+          var m = allMessages[i];
+          if (!m || m.role !== "assistant" || !Array.isArray(m.content)) continue;
+          for (var j = 0; j < m.content.length; j++) {
+            var b = m.content[j];
+            if (!b || b.type !== "tool_use") continue;
+            var derived = b.__subagent || deriveLegacySubagent(b);
+            if (derived) map.set(b.id, derived);
+          }
+        }
+        return map;
+      }
+
+      // 把一条 assistant turn 按相邻 block 的 __subagent.taskId 切成段。
+      // 输出每段附带原数组中的 firstIndex，方便渲染时 expand key 用全局 index
+      // 避免不同段冲突。
+      // legacyTaskMap：老消息没有 __subagent 盖章时，按 tool_use_id 反查兜底。
+      function splitTurnBySubagent(blocks, legacyTaskMap) {
+        var segs = [];
+        if (!Array.isArray(blocks) || !blocks.length) return segs;
+        var current = null;
+        for (var i = 0; i < blocks.length; i++) {
+          var b = blocks[i];
+          // __processing 占位 block（流式中的 typing indicator）没有 __subagent 盖章，
+          // 强制延续上一段（若已有），避免"父-Task-占位-子内容"反复切段导致 DOM 抖动。
+          // 边界：若占位是第一个 block（current 仍为 null），走正常路径开 parent 段。
+          var isPlaceholder = b && b.type === "text" && b.__processing === true;
+          if (isPlaceholder && current) {
+            current.blocks.push(b);
+            continue;
           }
-          return "";
+          var sub = b && b.__subagent ? b.__subagent : null;
+          if (!sub) sub = deriveLegacySubagent(b);
+          // 老消息 tool_result 兜底：用 tool_use_id 反查 map
+          if (!sub && b && b.type === "tool_result" && legacyTaskMap && legacyTaskMap.has(b.tool_use_id)) {
+            sub = legacyTaskMap.get(b.tool_use_id);
+          }
+          var key = sub ? sub.taskId : null;
+          if (!current || current.key !== key) {
+            current = { key: key, subagent: sub, blocks: [], firstIndex: i };
+            segs.push(current);
+          }
+          current.blocks.push(b);
         }
+        return segs;
+      }
 
-        var toolResults = buildToolResultMap(msg.content);
-        var blocksHtml = "";
-
+      // 渲染一段内的 blocks。独立 group consecutive tools，避免父/子 agent 的工具
+      // 调用跨边界被合并；grp.index 偏移到原数组全局位置，保持 expand key 唯一。
+      function buildSegmentBlocksHtml(segmentBlocks, segmentFirstIndex, role, toolResults, messageKey) {
+        var html = "";
         try {
-          var groups = groupConsecutiveTools(msg.content);
+          var groups = groupConsecutiveTools(segmentBlocks);
           for (var g = 0; g < groups.length; g++) {
             var grp = groups[g];
             try {
               if (grp.type === "group") {
-                blocksHtml += renderToolGroup(grp.items, role, toolResults, messageKey);
+                var shifted = [];
+                for (var k = 0; k < grp.items.length; k++) {
+                  shifted.push({ block: grp.items[k].block, index: grp.items[k].index + segmentFirstIndex });
+                }
+                html += renderToolGroup(shifted, role, toolResults, messageKey);
               } else {
-                blocksHtml += renderContentBlock(grp.block, role, toolResults, grp.index, messageKey);
+                html += renderContentBlock(grp.block, role, toolResults, grp.index + segmentFirstIndex, messageKey);
               }
             } catch (e) {
-              blocksHtml += '<div class="render-error">消息块渲染失败</div>';
+              html += '<div class="render-error">消息块渲染失败</div>';
             }
           }
         } catch (e) {
-          return '<div class="chat-message ' + role + '">' +
-            avatar +
-            '<div class="chat-message-content"><div class="render-error">消息渲染失败</div></div>' +
+          html += '<div class="render-error">消息渲染失败</div>';
+        }
+        return html;
+      }
+
+      // 抽出 multi-agent 渲染共用块。assistant turn 与 user turn 都可能含 subagent 段
+      // （user turn 的 Task tool_result 由后端反查盖章），但 user turn 不再输出 handoff
+      // 行，避免与 assistant turn 的 handoff 重复。
+      // TODO：嵌套 subagent（子 subagent 在外层 subagent 段内再切）时，
+      // parentPersonaName 应是外层 subagent.name 而不是固定父 persona；目前先不处理。
+      function buildMultiAgentHtml(segments, role, parentPersonaName, toolResults, messageKey, options) {
+        var opts = options || {};
+        var showHandoff = opts.showHandoff !== false; // 默认 true；user turn 传 false
+        var html = "";
+        var lastSubId = null;
+        for (var si = 0; si < segments.length; si++) {
+          var seg = segments[si];
+          var segHtml = buildSegmentBlocksHtml(seg.blocks, seg.firstIndex, role, toolResults, messageKey);
+          // 段内所有 block 都被短路返空（典型场景：父段只剩一个空 thinking）时，
+          // 跳过整段。否则会渲染出"只有头像没内容"的空气泡。
+          if (!segHtml || !segHtml.trim()) continue;
+          if (seg.subagent) {
+            var subPalette = getSubagentPalette(seg.subagent);
+            if (showHandoff && lastSubId !== seg.subagent.taskId) {
+              var subName = getSubagentDisplayName(seg.subagent);
+              var desc = seg.subagent.taskDescription
+                ? '：<span class="chat-handoff-desc">' + escapeHtml(seg.subagent.taskDescription) + '</span>'
+                : '';
+              html += '<div class="chat-handoff" style="--agent-color:' + subPalette.primary + '">' +
+                '<span class="chat-handoff-arrow">↳</span> ' +
+                escapeHtml(parentPersonaName) + ' 让 <strong>' + escapeHtml(subName) + '</strong> 帮忙' + desc +
+              '</div>';
+            }
+            html += '<div class="chat-message-segment subagent" data-agent-id="' + escapeHtml(seg.subagent.taskId) + '" style="--agent-color:' + subPalette.primary + '">' +
+              subagentAvatarHtml(seg.subagent) +
+              '<div class="chat-message-content">' + segHtml + '</div>' +
+            '</div>';
+            lastSubId = seg.subagent.taskId;
+          } else {
+            html += '<div class="chat-message-segment parent">' +
+              chatAvatar(role) +
+              '<div class="chat-message-content">' + segHtml + '</div>' +
+            '</div>';
+            lastSubId = null;
+          }
+        }
+        return html;
+      }
+
+      function renderStructuredMessage(msg, roundUsage, messageIndex, legacyTaskMap) {
+        var role = msg.role;
+        var messageKey = getMessageKey(msg, messageIndex);
+
+        // 排队中的用户消息标记（subagent 不会出现在 user role 的 user input 中）
+        var isQueued = role === "user" && msg.content && msg.content.some(function(b) { return b.__queued; });
+
+        if (!msg.content || msg.content.length === 0) {
+          if (role === "assistant") {
+            return '<div class="chat-message ' + role + '">' +
+              chatAvatar(role) +
+              '<div class="chat-message-bubble"><div class="typing-indicator"><span></span><span></span><span></span></div></div>' +
+            '</div>';
+          }
+          // 空 user 消息（极少出现，但快速发送的边界场景会让消息"消失"）。
+          // 给个明确占位避免视觉断层。
+          return '<div class="chat-message ' + role + ' empty-message" data-message-key="' + escapeHtml(messageKey) + '">' +
+            chatAvatar(role) +
+            '<div class="chat-message-content"><span class="empty-message-hint">（空消息）</span></div>' +
+          '</div>';
+        }
+
+        var toolResults = buildToolResultMap(msg.content);
+        var parentPersona = getStructuredChatPersona("assistant");
+
+        // user role：可能含 Task tool_result（subagent 反查盖章过的）。检测一下，
+        // 有 subagent 段就走 multi-agent 渲染（不输出 handoff，避免重复）。
+        if (role !== "assistant") {
+          var userSegments = splitTurnBySubagent(msg.content, legacyTaskMap);
+          var userHasSub = userSegments.some(function(s) { return s.subagent; });
+          var queuedClass = isQueued ? " queued" : "";
+          var queuedBadge = isQueued ? '<span class="queued-badge">排队中</span>' : "";
+          if (userHasSub) {
+            var userMultiHtml = buildMultiAgentHtml(userSegments, role, parentPersona.name, toolResults, messageKey, { showHandoff: false });
+            return '<div class="chat-message ' + role + queuedClass + ' multi-agent" data-message-key="' + escapeHtml(messageKey) + '">' +
+              userMultiHtml + queuedBadge +
+            '</div>';
+          }
+          var userHtml = buildSegmentBlocksHtml(msg.content, 0, role, toolResults, messageKey);
+          return '<div class="chat-message ' + role + queuedClass + '" data-message-key="' + escapeHtml(messageKey) + '">' +
+            chatAvatar(role) +
+            '<div class="chat-message-content">' + userHtml + queuedBadge + '</div>' +
           '</div>';
         }
 
-        var usageHtml = "";
-        var queuedClass = isQueued ? " queued" : "";
-        var queuedBadge = isQueued ? '<span class="queued-badge">排队中</span>' : "";
+        // assistant：检测是否有 subagent 段，没有就走单段渲染（兼容老消息 / 无 subagent 的 turn）
+        var segments = splitTurnBySubagent(msg.content, legacyTaskMap);
+        var hasSubagent = segments.some(function(s) { return s.subagent; });
 
-        return '<div class="chat-message ' + role + queuedClass + '" data-message-key="' + escapeHtml(messageKey) + '">' +
-          avatar +
-          '<div class="chat-message-content">' + blocksHtml + queuedBadge + '</div>' +
-          usageHtml +
-        '</div>';
+        if (!hasSubagent) {
+          var html = buildSegmentBlocksHtml(msg.content, 0, role, toolResults, messageKey);
+          return '<div class="chat-message ' + role + '" data-message-key="' + escapeHtml(messageKey) + '">' +
+            chatAvatar(role) +
+            '<div class="chat-message-content">' + html + '</div>' +
+          '</div>';
+        }
+
+        // 多段：父 assistant 段 + 各 subagent 段。同一根 .chat-message 容器，
+        // 内部多个 .chat-message-segment 子段，每段自带头像；切到新 subagent 时
+        // 插入一行 handoff 提示（"勤劳初二 ↳ 让 侦探猫 帮忙"）。
+        var multiHtml = '<div class="chat-message ' + role + ' multi-agent" data-message-key="' + escapeHtml(messageKey) + '">';
+        multiHtml += buildMultiAgentHtml(segments, role, parentPersona.name, toolResults, messageKey, { showHandoff: true });
+        multiHtml += '</div>';
+        return multiHtml;
       }
       function renderContentBlock(block, role, toolResults, index, messageKey) {
         if (!block || !block.type) return "";
 
+        // Task/Agent tool_use 自带 __subagent.taskId === block.id（后端自盖章）：
+        // 不画工具卡片，由 handoff 行表达"派遣"语义。
+        if (block.type === "tool_use" && block.__subagent && block.__subagent.taskId === block.id) {
+          return "";
+        }
+        // 只有父 Task 的 tool_result（taskId === tool_use_id）走 reply bubble；
+        // 子 agent 内部工具的 tool_result（taskId === parent_tool_use_id ≠ tool_use_id）
+        // 走普通工具卡片，不能误判为 reply bubble。
+        if (block.type === "tool_result" && block.__subagent && block.__subagent.taskId === block.tool_use_id) {
+          return renderSubagentReplyBubble(block, role);
+        }
+
         switch (block.type) {
           case "text":
             if (role === "assistant" && block.__processing) {
@@ -16727,7 +17485,6 @@
 
           case "thinking":
             var thinkingText = block.thinking || "";
-            var preview = thinkingText.length > 60 ? thinkingText.slice(0, 57) + "…" : thinkingText;
             var isStreaming = block.thinking === undefined && block.type === "thinking";
             if (isStreaming) {
               return '<div class="thinking-inline thinking-streaming" data-thinking="">' +
@@ -16737,6 +17494,10 @@
                 '</div>' +
               '</div>';
             }
+            // 非流式分支：thinking 字段是空字符串时，UI 上只会出现一条带"展开"
+            // 的紫色窄条，展开了也是空——直接不渲染，避免视觉噪音。
+            if (!thinkingText.trim()) return "";
+            var preview = thinkingText.length > 60 ? thinkingText.slice(0, 57) + "…" : thinkingText;
             var thinkingKey = buildExpandKey("thinking", [messageKey, index]);
             var thinkingPersisted = getPersistedExpandState(thinkingKey);
           var thinkingExpanded = thinkingPersisted === null ? getCardDefault("thinking") : thinkingPersisted;
@@ -16755,10 +17516,26 @@
             return rendered;
 
           case "tool_result":
+            // tool_result 通常被对应的 tool_use 卡片以"结果"区域消化掉，不在主流渲染。
+            // 但如果父 tool_use 在另一条 turn 或被裁剪掉了，结果会变成孤儿——返回空字符串
+            // 会让这条消息看起来"消失"。下面 renderStructuredMessage 在切段前会再做一次
+            // orphan 兜底，这里保持空返回以维持旧行为不变。
             return "";
 
           default:
-            return '<div class="unknown-block">' + escapeHtml(JSON.stringify(block)) + '</div>';
+            // 兜底：未来后端新增 block 类型时（image / chart / 文件等）不让 JSON 裸露在
+            // 用户面前。给一个折叠卡片，默认收起，展开后是原始 JSON。
+            var unknownType = block && block.type ? String(block.type) : "未知";
+            var unknownJson = "";
+            try { unknownJson = JSON.stringify(block, null, 2); } catch (_e) { unknownJson = "{}"; }
+            return '<div class="unknown-block collapsed" onclick="this.classList.toggle(\'collapsed\')">' +
+              '<div class="unknown-block-header">' +
+                '<span class="unknown-block-icon">?</span>' +
+                '<span class="unknown-block-label">未识别的内容块：' + escapeHtml(unknownType) + '</span>' +
+                '<span class="unknown-block-toggle">▼</span>' +
+              '</div>' +
+              '<pre class="unknown-block-body">' + escapeHtml(unknownJson) + '</pre>' +
+            '</div>';
         }
       }