@co0ontty/wand 1.30.0 → 1.31.0

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

@@ -149,6 +149,12 @@
         chatModel: (function() {
           try { return localStorage.getItem("wand-chat-model") || ""; } catch (e) { return ""; }
         })(),
+        chatThinking: (function() {
+          try {
+            var v = localStorage.getItem("wand-thinking-effort") || "off";
+            return (v === "off" || v === "standard" || v === "deep" || v === "max") ? v : "off";
+          } catch (e) { return "off"; }
+        })(),
         availableModels: [],
         availableCodexModels: [],
         modelsRefreshing: false,
@@ -238,10 +244,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,
@@ -597,8 +612,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() {
@@ -619,7 +645,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();
       }
 
@@ -951,23 +1005,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() {
@@ -1464,7 +1541,6 @@
                       ? '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><polyline points="10 6 16 12 10 18"/><line x1="20" y1="5" x2="20" y2="19"/></svg>'
                       : '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><polyline points="14 6 8 12 14 18"/><line x1="4" y1="5" x2="4" y2="19"/></svg>') +
                   '</button>' +
-                  '<button id="sidebar-close-fully-btn" class="btn btn-ghost btn-sm sidebar-close-fully" type="button" title="完全关闭侧栏" aria-label="完全关闭侧栏"><svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="2.4" stroke-linecap="round" aria-hidden="true"><line x1="6" y1="6" x2="18" y2="18"/><line x1="18" y1="6" x2="6" y2="18"/></svg></button>' +
                   '<button id="close-drawer-button" class="btn btn-ghost btn-icon sidebar-close drawer-close-btn" type="button" aria-label="关闭菜单"><svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="2.4" stroke-linecap="round" aria-hidden="true"><line x1="6" y1="6" x2="18" y2="18"/><line x1="18" y1="6" x2="6" y2="18"/></svg></button>' +
                 '</div>' +
               '</div>' +
@@ -1654,13 +1730,26 @@
                       // tabindex="-1": 把这些控件移出 iOS Safari 的表单导航链，
                       // 这样 textarea 聚焦时键盘上方就不会出现 ⌃ ⌄ ✓ 表单辅助栏。
                       '<input type="file" id="file-upload-input" multiple tabindex="-1" style="position:absolute;width:1px;height:1px;opacity:0;overflow:hidden;clip:rect(0,0,0,0);pointer-events:none">' +
-                      '<select id="chat-mode-select" class="chat-mode-select" tabindex="-1" title="仅对新建会话生效">' +
-                        renderModeOptions(preferredTool, composerMode) +
-                      '</select>' +
-                      '<select id="chat-model-select" class="chat-mode-select chat-model-select" tabindex="-1" title="切换模型（对运行中会话发送 /model，对新会话作为 --model 启动）">' +
-                        renderChatModelOptions(getEffectiveModel(selectedSession), selectedSession) +
-                      '</select>' +
-                      '<button id="terminal-interactive-toggle-top" class="composer-interactive-toggle' + (state.terminalInteractive ? " active" : "") + '" type="button" title="切换终端交互模式">⌨</button>' +
+                      // 三件套 (Mode / Model / Thinking) 同属"会话设置"层：视觉上统一为同一种 pill 风格，
+                      // 由 CSS .composer-pill-group 内的轻量分隔感传达"归类"。
+                      '<span class="composer-pill-group" role="group" aria-label="会话设置">' +
+                        '<select id="chat-mode-select" class="composer-pill composer-pill-select chat-mode-select" tabindex="-1" title="新会话模式 · 托管 / 全权限 自动启用批准">' +
+                          renderModeOptions(preferredTool, composerMode) +
+                        '</select>' +
+                        '<select id="chat-model-select" class="composer-pill composer-pill-select chat-mode-select chat-model-select" tabindex="-1" title="切换模型（对运行中会话发送 /model，对新会话作为 --model 启动）">' +
+                          renderChatModelOptions(getEffectiveModel(selectedSession), selectedSession) +
+                        '</select>' +
+                        // 思考深度 trigger：与 mode / model 同形（border + chevron），保证视觉一致。
+                        // 可见层只有「档位文字」，原生 <select> 透明叠在上面，依然能调起 iOS 滚轮选择。
+                        '<span class="composer-pill composer-pill-select chat-thinking-trigger" title="思考深度（structured 立即生效；PTY 仅作用于通过 chat 视图发送的消息）">' +
+                          '<span class="chat-thinking-label" id="chat-thinking-label">' + escapeHtml(getThinkingLabel(getEffectiveThinking(selectedSession))) + '</span>' +
+                          '<select id="chat-thinking-select" class="chat-thinking-hidden-select" tabindex="-1" aria-label="思考深度">' +
+                            renderChatThinkingOptions(getEffectiveThinking(selectedSession)) +
+                          '</select>' +
+                        '</span>' +
+                      '</span>' +
+                      renderAutoApproveChip(selectedSession) +
+                      '<button id="terminal-interactive-toggle-top" class="composer-pill composer-pill-chip composer-interactive-toggle' + (state.terminalInteractive ? " active" : "") + '" type="button" title="切换终端交互模式">⌨</button>' +
                       '<span class="permission-actions hidden" id="permission-actions">' +
                         '<span class="permission-actions-divider"></span>' +
                         '<span class="permission-actions-label" id="permission-actions-label">等待授权</span>' +
@@ -1670,26 +1759,41 @@
                       renderApprovalStatsBadge() +
                     '</div>' +
                     '<div class="input-composer-right">' +
-                      '<span id="queue-counter" class="queue-counter hidden">队列: 0</span>' +
+                      // queue-counter：当 queuedMessages 不为空时显示，提示用户后面还堆了几条。
+                      // 比小角标更显眼一点——加图标 + 强对比色，避免 v1.30.3 那一版用户没看见。
+                      '<span id="queue-counter" class="queue-counter hidden" title="正在排队的输入条数"><span class="queue-counter-dot"></span><span class="queue-counter-text">队列 0</span></span>' +
                       '<span class="input-hint' + (state.terminalInteractive ? ' terminal-interactive-hint' : state.currentView === "terminal" ? " hidden" : "") + '">' + (state.terminalInteractive ? '终端交互中 · Ctrl+C 中断 · Ctrl+L 清屏' : 'Enter 发送 · Shift+Enter 换行') + '</span>' +
                       renderInlineKeyboard() +
                       '<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 → 排队；想插队的人显式按这颗。
+                      // 用 pill 形态 + 文字 + 脉动，让用户一眼就看到「立即发送」这条快捷路径。
+                      '<button id="interrupt-send-button" class="btn-pill btn-pill-interrupt hidden" type="button" title="中断当前回复并立即发送新输入（Cmd/Ctrl+Enter）" aria-label="立即发送">' +
+                        '<svg class="btn-pill-icon" 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>' +
+                        '<span class="btn-pill-label">立即</span>' +
+                      '</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>' +
                     '</div>' +
                   '</div>' +
                   renderExpandedShortcutsRow() +
-                  // Session info bar at bottom — only keeps unique controls/info
-                  // (cwd / mode / status / kind are already shown in topbar or composer dropdown)
+                  // Session info bar at bottom — 仅保留信息类徽章（Claude session id / exit code）。
+                  // 自动批准已从这里移到主 pill 行（renderAutoApproveChip）。
                   (selectedSession
-                    ? '<div class="input-session-info-bar">' +
-                        (selectedSession.autoApprovePermissions ? '<span id="auto-approve-toggle" class="auto-approve-indicator active" title="自动批准已启用 — 点击关闭">🛡 自动批准</span>' : '<span id="auto-approve-toggle" class="auto-approve-indicator" title="自动批准已关闭 — 点击开启">🛡 手动</span>') +
-                        (selectedSession.provider === "claude" && selectedSession.claudeSessionId ? '<span class="session-info-separator">|</span><span id="claude-session-id-badge" class="claude-session-id-badge" data-claude-id="' + escapeHtml(selectedSession.claudeSessionId) + '" title="点击复制 Claude 会话 ID">☁ ' + escapeHtml(selectedSession.claudeSessionId.slice(0, 8)) + '</span>' : '') +
-                        (!isStructuredSession(selectedSession) && selectedSession.exitCode !== undefined && selectedSession.exitCode !== null ? '<span class="session-info-separator">|</span><span id="session-exit-display" class="session-exit-display">退出码=' + selectedSession.exitCode + '</span>' : '') +
-                      '</div>'
+                    ? (function() {
+                        var bits = "";
+                        if (selectedSession.provider === "claude" && selectedSession.claudeSessionId) {
+                          bits += '<span id="claude-session-id-badge" class="claude-session-id-badge" data-claude-id="' + escapeHtml(selectedSession.claudeSessionId) + '" title="点击复制 Claude 会话 ID">☁ ' + escapeHtml(selectedSession.claudeSessionId.slice(0, 8)) + '</span>';
+                        }
+                        if (!isStructuredSession(selectedSession) && selectedSession.exitCode !== undefined && selectedSession.exitCode !== null) {
+                          if (bits) bits += '<span class="session-info-separator">|</span>';
+                          bits += '<span id="session-exit-display" class="session-exit-display">退出码=' + selectedSession.exitCode + '</span>';
+                        }
+                        return bits ? '<div class="input-session-info-bar">' + bits + '</div>' : '';
+                      })()
                     : '') +
                 '</div>' +
                 '<p id="action-error" class="error-message hidden"></p>' +
@@ -3094,29 +3198,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("");
@@ -3127,36 +3246,23 @@
       }
 
       function renderCollapsedSessionTiles() {
-        var activeSessions = state.sessions.filter(function(s) { return !s.archived; });
-        activeSessions.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;
-        });
-        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;
-          });
-        }
-        if (activeSessions.length === 0 && recentHistorySessions.length === 0) {
+        var entries = getRecentEntries();
+        if (entries.length === 0) {
           return '<div class="sidebar-collapsed-empty" title="无会话">—</div>';
         }
-        var tiles = "";
-        var idx = 0;
-        activeSessions.forEach(function(s) {
-          idx += 1;
-          var activeCls = s.id === state.selectedId ? " active" : "";
-          var title = s.summary || s.command || ("会话 " + idx);
-          tiles += '<button class="sidebar-collapsed-tile' + activeCls + '" type="button" data-collapsed-session-id="' + escapeHtml(s.id) + '" title="' + escapeHtml(title) + '">' + idx + '</button>';
-        });
-        recentHistorySessions.forEach(function(s) {
-          idx += 1;
-          var preview = s.firstUserMessage || "(空会话)";
-          var title = preview + " · " + formatHistoryTime(s.timestamp);
-          tiles += '<button class="sidebar-collapsed-tile history" type="button" data-collapsed-history-id="' + escapeHtml(s.claudeSessionId) + '" data-cwd="' + escapeHtml(s.cwd || "") + '" title="' + escapeHtml(title) + '">' + idx + '</button>';
-        });
+        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 || ("会话 " + 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>';
       }
 
@@ -3223,11 +3329,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;
       }
@@ -5627,8 +5736,6 @@
         if (pinBtn) pinBtn.addEventListener("click", toggleSidebarPin);
         var collapseBtn = document.getElementById("sidebar-collapse-btn");
         if (collapseBtn) collapseBtn.addEventListener("click", toggleSidebarCollapsed);
-        var closeFullyBtn = document.getElementById("sidebar-close-fully-btn");
-        if (closeFullyBtn) closeFullyBtn.addEventListener("click", closeSidebarCompletely);
         var sidebarMoreBtn = document.getElementById("sidebar-more-btn");
         var sidebarOverflow = document.getElementById("sidebar-overflow-menu");
         if (sidebarMoreBtn && sidebarOverflow) {
@@ -5894,6 +6001,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");
@@ -5905,6 +6017,10 @@
         if (modelSelect) modelSelect.addEventListener("change", function() {
           onChatModelChange(this.value);
         });
+        var thinkingSelect = document.getElementById("chat-thinking-select");
+        if (thinkingSelect) thinkingSelect.addEventListener("change", function() {
+          onChatThinkingChange(this.value);
+        });
 
         var sessionModal = document.getElementById("session-modal");
         if (sessionModal) sessionModal.addEventListener("click", function(e) {
@@ -6142,7 +6258,8 @@
             return;
           }
           softResyncTerminal();
-          resetChatRenderCache();
+          // 用户停留在当前会话，只是想刷一下 DOM——保留其阅读位置和 sticky 状态。
+          resetChatRenderCache({ preserveStickState: true });
           scheduleChatRender(true);
         });
         var jumpBottomBtn = document.getElementById("terminal-jump-bottom");
@@ -7909,6 +8026,11 @@
           if (canAutoResumeSession(session)) return "";
           return "会话已结束";
         }
+        // 结构化会话在出 token 时，输入框仍然可用——告诉用户默认行为是排队，
+        // 想插队请按右侧的 » 按钮。短语保持单行不换行。
+        if (isStructuredSession(session) && session.structuredState && session.structuredState.inFlight) {
+          return "回复中…Enter 排队 · 旁边的「» 立即」按钮中断并立即发送";
+        }
         return "";
       }
 
@@ -8040,10 +8162,109 @@
 
       function syncComposerModelSelect(session) {
         var select = document.getElementById("chat-model-select");
+        if (select) {
+          var effective = getEffectiveModel(session);
+          select.innerHTML = renderChatModelOptions(effective, session);
+          select.value = effective;
+        }
+        // thinking 选择器与 model 选择器属于同一组"会话级设置"，
+        // 任何刷新 model 的时机也应该同步刷新 thinking，避免漂移。
+        syncComposerThinkingSelect(session);
+      }
+
+      // ── 思考深度 (thinkingEffort) —— 与 model 选择三件套对称 ──
+
+      // 标签直接用 Claude CLI 原生 magic word：think / think hard / ultrathink。
+      // 这样用户一眼能对上官方文档里的思考强度档位，PTY 模式下也是这几个词被注入到 prompt 前缀。
+      var THINKING_LEVELS = [
+        { id: "off",      label: "off",        hint: "不启用思考（CLI 无前缀；SDK 关闭 thinking；Codex --reasoning-effort minimal）" },
+        { id: "standard", label: "think",      hint: "Claude CLI: think · SDK budget 4096 · Codex low" },
+        { id: "deep",     label: "think hard", hint: "Claude CLI: think hard · SDK budget 16000 · Codex medium" },
+        { id: "max",      label: "ultrathink", hint: "Claude CLI: ultrathink · SDK budget 31999 · Codex high" }
+      ];
+
+      function getThinkingLabel(id) {
+        for (var i = 0; i < THINKING_LEVELS.length; i++) {
+          if (THINKING_LEVELS[i].id === id) return THINKING_LEVELS[i].label;
+        }
+        return THINKING_LEVELS[0].label;
+      }
+
+      function getEffectiveThinking(session) {
+        if (session && session.thinkingEffort) return session.thinkingEffort;
+        if (state.chatThinking) return state.chatThinking;
+        return "off";
+      }
+
+      function renderChatThinkingOptions(selected) {
+        var v = selected || "off";
+        var html = "";
+        for (var i = 0; i < THINKING_LEVELS.length; i++) {
+          var lvl = THINKING_LEVELS[i];
+          html += '<option value="' + escapeHtml(lvl.id) + '"' + (lvl.id === v ? ' selected' : '') + ' title="' + escapeHtml(lvl.hint) + '">' + escapeHtml(lvl.label) + '</option>';
+        }
+        return html;
+      }
+
+      function syncComposerThinkingSelect(session) {
+        var select = document.getElementById("chat-thinking-select");
         if (!select) return;
-        var effective = getEffectiveModel(session);
-        select.innerHTML = renderChatModelOptions(effective, session);
+        var effective = getEffectiveThinking(session);
+        select.innerHTML = renderChatThinkingOptions(effective);
         select.value = effective;
+        var labelEl = document.getElementById("chat-thinking-label");
+        if (labelEl) labelEl.textContent = getThinkingLabel(effective);
+      }
+
+      function onChatThinkingChange(value) {
+        var normalized = (value || "off").trim();
+        if (normalized !== "off" && normalized !== "standard" && normalized !== "deep" && normalized !== "max") {
+          normalized = "off";
+        }
+        state.chatThinking = normalized;
+        try { localStorage.setItem("wand-thinking-effort", normalized); } catch (e) {}
+        var labelEl = document.getElementById("chat-thinking-label");
+        if (labelEl) labelEl.textContent = getThinkingLabel(normalized);
+        var session = getSelectedSession();
+        if (!session) return;
+        fetch("/api/sessions/" + encodeURIComponent(session.id) + "/thinking-effort", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          credentials: "same-origin",
+          body: JSON.stringify({ thinkingEffort: normalized })
+        })
+        .then(function(res) { return res.json(); })
+        .then(function(data) {
+          if (data && data.error) {
+            showToast(data.error, "error");
+            return;
+          }
+          if (data && data.id) {
+            updateSessionSnapshot(data);
+            if (typeof showToast === "function") {
+              showToast("已切换思考深度 → " + getThinkingLabel(normalized), "success");
+            }
+          }
+        })
+        .catch(function() { showToast("切换思考深度失败", "error"); });
+      }
+
+      // 自动批准 chip：与原 .auto-approve-indicator 等价，但用统一的 .composer-pill 风格放主行。
+      // Codex 会话固定全权限不可切；结构化 Claude 会话后端 toggle-auto-approve 路由会拒绝。
+      // 当会话已经处于 managed / full-access 模式时，"自动批准"语义已经由模式表达，
+      // 重复显示一个独立 chip 只会占用空间又制造歧义 —— 此时直接折叠掉。
+      function isAutoApproveImpliedByMode(session) {
+        if (!session) return false;
+        var m = session.mode;
+        return m === "managed" || m === "full-access";
+      }
+      function renderAutoApproveChip(session) {
+        if (!session) return "";
+        if (isAutoApproveImpliedByMode(session)) return "";
+        var enabled = !!session.autoApprovePermissions;
+        return enabled
+          ? '<span id="auto-approve-toggle" class="composer-pill composer-pill-chip auto-approve-indicator active" title="自动批准已启用 — 点击关闭">🛡 自动</span>'
+          : '<span id="auto-approve-toggle" class="composer-pill composer-pill-chip auto-approve-indicator" title="自动批准已关闭 — 点击开启">🛡 手动</span>';
       }
 
       function fetchAvailableModels() {
@@ -8281,6 +8502,7 @@
       function createStructuredSession(prompt, cwdOverride, modeOverride, worktreeEnabled) {
         var provider = state.sessionTool === "codex" ? "codex" : "claude";
         var modelPref = state.chatModel || (state.config && state.config.defaultModel) || "";
+        var thinkingPref = state.chatThinking || "off";
         var payload = {
           cwd: cwdOverride || getEffectiveCwd(),
           mode: modeOverride || state.chatMode || (state.config && state.config.defaultMode) || "default",
@@ -8288,7 +8510,8 @@
           runner: provider === "codex" ? "codex-cli-exec" : ((state.config && state.config.structuredRunner === "sdk") ? "claude-sdk" : (state.structuredRunner || "claude-cli-print")),
           prompt: prompt || undefined,
           worktreeEnabled: worktreeEnabled === true,
-          model: modelPref || undefined
+          model: modelPref || undefined,
+          thinkingEffort: thinkingPref
         };
         console.log("[WAND] createStructuredSession payload:", JSON.stringify(payload));
         return fetch("/api/structured-sessions", {
@@ -8322,6 +8545,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";
@@ -8340,6 +8564,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);
         }
@@ -8604,7 +8836,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);
               }
             }
@@ -8974,29 +9207,6 @@
         hideCollapsedTileBubble();
       }
 
-      function closeSidebarCompletely() {
-        if (isMobileLayout()) return;
-        state.sidebarPinned = false;
-        state.sidebarCollapsed = false;
-        state.sessionsDrawerOpen = false;
-        try {
-          localStorage.setItem("wand-sidebar-pinned", "false");
-          localStorage.setItem("wand-sidebar-collapsed", "false");
-        } catch (e) {}
-        render();
-        var mainLayout = document.querySelector(".main-layout");
-        if (mainLayout) {
-          var onEnd = function(e) {
-            if (e.propertyName === "padding-left") {
-              mainLayout.removeEventListener("transitionend", onEnd);
-              scheduleTerminalResize(true);
-            }
-          };
-          mainLayout.addEventListener("transitionend", onEnd);
-        }
-        setTimeout(function() { scheduleTerminalResize(true); }, 350);
-      }
-
       function toggleSidebarCollapsed() {
         if (isMobileLayout()) return;
         // 在 drawer 模式（未 pin）下点 collapse 视为「先固定、再收起为窄条」——
@@ -10931,7 +11141,10 @@
             return;
           }
           event.preventDefault();
-          sendInputFromBox();
+          // Cmd/Ctrl+Enter → 立即发送（中断当前回复）。仅对正在 inFlight 的
+          // 结构化会话生效；其它情况下退化为普通发送，避免无谓的中断信号。
+          var interruptShortcut = !!(event.metaKey || event.ctrlKey);
+          sendInputFromBox(interruptShortcut ? { interrupt: true } : undefined);
           return;
         }
 
@@ -11640,7 +11853,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");
@@ -11651,7 +11865,7 @@
         // If we have a selected ID, try to send input to it
         if (state.selectedId) {
           if (value) {
-            sendInputFromBox();
+            sendInputFromBox(opts);
           }
           return;
         }
@@ -11750,7 +11964,9 @@
       }
 
 
-      function sendInputFromBox() {
+      function sendInputFromBox(opts) {
+        opts = opts || {};
+        var interruptFlag = !!opts.interrupt;
         if (state.terminalInteractive) {
           showToast("终端交互模式开启时，请直接在终端中输入。", "info");
           return Promise.resolve();
@@ -11789,7 +12005,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);
@@ -11834,41 +12050,87 @@
         return Promise.resolve();
       }
 
-      // 防止同一会话并发提交（快速双击 / 重复触发）
-      var _structuredSubmittingSessions = {};
+      // 防止同一会话「快速双击 / 重复触发」。原来这是个布尔 flag，绑在 fetch 的
+      // promise 上 —— 但 structured-sessions/:id/messages 的 POST 对首条消息会 await
+      // 整段流式 streaming，flag 会被卡到回复完才释放。结果：用户点发送 → 服务端
+      // 流式 30s 不响应 → 这 30s 里再点发送全被这里静默 drop，看起来"排队 / 立即发送
+      // 都没效果"。改成时间戳 + 短窗口（350ms）只挡真正的连击。idempotencyKey 已经
+      // 在后端兜底防 webview 网络层重发，这里的 hot-path 守门只需要应付 UI 双触发。
+      var _structuredLastSubmitAt = {};
+      var DUPLICATE_SUBMIT_WINDOW_MS = 350;
 
-      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");
           return Promise.resolve();
         }
-        // 同一会话的上一次提交尚未落地，直接忽略防止重复发送
-        if (_structuredSubmittingSessions[session.id]) {
-          console.log("[wand] postStructuredInput: duplicate submit ignored for session", session.id);
+        // 短窗口内的连击当作重复点击丢掉；正常间隔的两次提交（哪怕第一次还在流式）
+        // 都放行，让 queue / interrupt 真正生效。
+        var nowTs = Date.now();
+        var lastTs = _structuredLastSubmitAt[session.id] || 0;
+        if (nowTs - lastTs < DUPLICATE_SUBMIT_WINDOW_MS) {
+          console.log("[wand] postStructuredInput: duplicate submit (within " + DUPLICATE_SUBMIT_WINDOW_MS + "ms) ignored for session", session.id);
           return Promise.resolve();
         }
+        _structuredLastSubmitAt[session.id] = nowTs;
+
+        var sessionInFlight = !!(session.structuredState && session.structuredState.inFlight && session.status === "running");
+        var isInterrupting = sessionInFlight && requestedInterrupt;
+        var isQueueing = sessionInFlight && !requestedInterrupt;
 
-        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 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();
+          // 乐观 toast：原本只在 POST 完成后才提示，Claude 流式拖太久时用户根本
+          // 看不到反馈，会误判"点了没反应"。点击瞬间就给一条短提示。
+          showToast(nextQueue.length > 1 ? ("已加入排队（共 " + nextQueue.length + " 条等待）") : "已加入排队，等当前回复完成会自动发送。", "info");
+        } 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);
+          // 中断模式：乐观给一条提示，让用户立刻知道"中断成功了"，否则跟 queue 一样会
+          // 觉得"点了没反应"。原 toast 在 then() 里，等 SIGTERM/HTTP roundtrip 完才出。
+          if (isInterrupting) {
+            showToast("已中断上一条回复，正在处理新消息…", "info");
+          }
+        }
 
         if (inputBox) {
           inputBox.value = "";
@@ -11891,7 +12153,6 @@
 
         // 用 session.id（参数绑定，in-flight 期间不变）而不是 state.selectedId
         // 拼 URL，避免用户切到别的会话后 fetch 落到错误 sessionId。
-        _structuredSubmittingSessions[session.id] = true;
         return fetch("/api/structured-sessions/" + session.id + "/messages", {
           method: "POST",
           headers: { "Content-Type": "application/json" },
@@ -11910,7 +12171,6 @@
           return res.json();
         })
         .then(function(snapshot) {
-          _structuredSubmittingSessions[session.id] = false;
           if (snapshot && snapshot.error) {
             throw new Error(snapshot.error);
           }
@@ -11924,15 +12184,13 @@
               var refreshedSession = state.sessions.find(function(s) { return s.id === snapshot.id; }) || snapshot;
               state.currentMessages = buildMessagesForRender(refreshedSession, getPreferredMessages(refreshedSession, snapshot.output, false));
               renderChat(true);
-              if (isInterrupting) {
-                showToast("已中断上一条回复，正在处理新消息…", "info");
-              }
+              updateStructuredQueueCounter();
+              // toast 已在 click 时乐观 fire（见 isQueueing / isInterrupting 分支），
+              // 这里不再重复推送，避免同一动作出两条一样的 toast。
             }
           }
         })
         .catch(function(error) {
-          _structuredSubmittingSessions[session.id] = false;
-
           // duplicate_idempotency_key：服务端识别出 WebView 底层重发的副本，
           // 直接拦截不处理。这里**不**回滚乐观更新——第一次的请求实际上已经
           // 被服务端接收并处理（或正在处理），ws 推送会带回真实状态；如果在
@@ -11943,20 +12201,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 =
@@ -11980,7 +12254,15 @@
         var counter = document.getElementById("queue-counter");
         var count = getSelectedStructuredQueuedInputs().length;
         if (counter) {
-          counter.textContent = "队列: " + count;
+          // counter 现在是 dot + text 双节点结构，只更新文字节点；如果用 textContent
+          // 直接覆盖会把内嵌的 .queue-counter-dot 也一并干掉，CSS 上做的脉动小红点就没了。
+          var textNode = counter.querySelector(".queue-counter-text");
+          var label = count > 0 ? ("排队 " + count + " 条") : "队列 0";
+          if (textNode) {
+            textNode.textContent = label;
+          } else {
+            counter.textContent = label;
+          }
           if (count > 0) {
             counter.classList.remove("hidden");
           } else {
@@ -12564,11 +12846,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);
@@ -12949,7 +13239,8 @@
             command: command,
             cwd: cwd || "",
             mode: state.chatMode || state.config.defaultMode || "default",
-            model: modelPref || undefined
+            model: modelPref || undefined,
+            thinkingEffort: state.chatThinking || undefined
           }))
         })
         .then(function(res) { return res.json(); })
@@ -13091,7 +13382,8 @@
             cwd: defaultCwd,
             mode: mode,
             initialInput: value,
-            model: modelPref || undefined
+            model: modelPref || undefined,
+            thinkingEffort: state.chatThinking || undefined
           }))
         })
         .then(function(res) { return res.json(); })
@@ -13129,7 +13421,8 @@
             cwd: defaultCwd,
             mode: mode,
             initialInput: value || undefined,
-            model: modelPref || undefined
+            model: modelPref || undefined,
+            thinkingEffort: state.chatThinking || undefined
           }))
         })
         .then(function(res) { return res.json(); })
@@ -13287,7 +13580,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);
       }
@@ -14042,7 +14338,27 @@
           // Without an immediate refit, any chunk arriving while the keyboard
           // animates in renders against the old grid and tears the screen.
           if (!keyboardOpen && isKeyboardOpen) {
+            // Snapshot bottom-pinned intent BEFORE the layout starts shifting.
+            // visualViewport.resize fires while the keyboard is still mid-
+            // animation on iOS; if we wait until ensureTerminalFit's rAF
+            // body executes, clientHeight has already shrunk and the user
+            // who was visibly at the bottom registers as "scrolled up".
+            // We pass the snapshot through to a delayed catch-up so the
+            // final scroll lands AFTER the animation settles.
+            var wasStickToBottom = state.terminalAutoFollow || isTerminalNearBottom();
             ensureTerminalFit("keyboard-open", { forceReplay: true });
+            // Mirror the keyboard-close 200ms delay: by then the iOS / Android
+            // keyboard slide-in animation is done, vv.height is final, and
+            // scrollHeight reflects the post-replay grid. One more force
+            // scroll closes the gap between "we scrolled during animation
+            // when scrollHeight was still in flux" and "user expects to see
+            // the bottom now that the keyboard has fully settled".
+            if (wasStickToBottom) {
+              setTimeout(function() {
+                if (!state.terminal) return;
+                maybeScrollTerminalToBottom("force");
+              }, 220);
+            }
           }
 
           // Keyboard just closed — force terminal refit and scroll to bottom
@@ -14081,7 +14397,9 @@
                 syncAppViewportHeight();
               }
               ensureTerminalFit("keyboard-close", { forceReplay: true });
-              maybeScrollTerminalToBottom("force");
+              // 同 handleInputBoxBlur：尊重 terminalAutoFollow，避免把上滚
+              // 阅读历史的用户在键盘关闭瞬间拽回底部。
+              maybeScrollTerminalToBottom("keyboard");
             }, 200);
           }
 
@@ -14409,6 +14727,21 @@
           ensureTerminalFitWithRetry(reason || "fit-retry", { forceReplay: forceReplay });
           return false;
         }
+        // Snapshot stick-to-bottom intent NOW, before any layout work.
+        // Two concrete bugs this guards against:
+        //   1. Mobile keyboard opens → visualViewport shrinks → terminal
+        //      clientHeight drops while scrollTop stays put → by the time
+        //      the rAF body runs, isTerminalNearBottom() reads false even
+        //      though the user was visibly pinned to the bottom a frame ago.
+        //   2. Any softResyncTerminal triggered below does resetTerminal()
+        //      (scrollTop snaps to 0) then re-writes; the wterm element
+        //      can fire intermediate scroll events that flip
+        //      terminalAutoFollow to false before we get a chance to
+        //      scroll back.
+        // Both failure modes left users mid-buffer after a resize. We
+        // capture the intent up front and use "force" below to bypass
+        // the (now-poisoned) flag check inside maybeScrollTerminalToBottom.
+        var shouldStickToBottom = state.terminalAutoFollow || isTerminalNearBottom();
         var prevCols = state.terminal.cols;
         var prevRows = state.terminal.rows;
         requestAnimationFrame(function() {
@@ -14428,8 +14761,8 @@
             if (!didResize && forceReplay && state.terminalOutput) {
               softResyncTerminal({ skipFit: true });
             }
-            if (state.terminalAutoFollow || isTerminalNearBottom()) {
-              maybeScrollTerminalToBottom("resize");
+            if (shouldStickToBottom) {
+              maybeScrollTerminalToBottom("force");
             }
           });
         });
@@ -14486,9 +14819,15 @@
 
       function syncTerminalSize() {
         if (!state.terminal) return;
-        var shouldFollow = state.terminalAutoFollow || isTerminalNearBottom();
-        if (shouldFollow) {
-          maybeScrollTerminalToBottom("resize");
+        // Force-scroll (vs the weaker maybeScrollTerminalToBottom("resize"))
+        // for the same reason ensureTerminalFit does: between this entry
+        // and the actual scroll, the wterm DOM may fire scroll events that
+        // poison terminalAutoFollow. Capturing intent now + force-scrolling
+        // keeps a user who was visibly at the bottom pinned there across
+        // window/orientation/viewport resizes.
+        var shouldStickToBottom = state.terminalAutoFollow || isTerminalNearBottom();
+        if (shouldStickToBottom) {
+          maybeScrollTerminalToBottom("force");
         }
         sendTerminalResize(state.terminal.cols, state.terminal.rows);
       }
@@ -15284,21 +15623,22 @@
 
       function updateAutoApproveIndicator() {
         var toggle = document.getElementById("auto-approve-toggle");
-        if (!toggle) return;
         var selectedSession = state.sessions.find(function(s) { return s.id === state.selectedId; });
-        if (selectedSession && selectedSession.provider === "codex") {
-          toggle.className = "auto-approve-indicator active";
-          toggle.title = "Codex 固定以 full-access PTY 启动，不支持切换自动批准";
-          toggle.textContent = "🛡 Codex 固定全权限";
+        // 当模式（managed / full-access）已隐含自动批准，chip 应该不存在；如果上一次渲染留下来了，
+        // 在这里清理掉，避免视觉上还有冗余 chip。
+        if (isAutoApproveImpliedByMode(selectedSession)) {
+          if (toggle && toggle.parentNode) toggle.parentNode.removeChild(toggle);
           return;
         }
+        if (!toggle) return;
+        var base = "composer-pill composer-pill-chip auto-approve-indicator";
         var enabled = selectedSession && selectedSession.autoApprovePermissions;
         if (enabled) {
-          toggle.className = "auto-approve-indicator active";
+          toggle.className = base + " active";
           toggle.title = "自动批准已启用 — 点击关闭";
-          toggle.textContent = "🛡 自动批准";
+          toggle.textContent = "🛡 自动";
         } else {
-          toggle.className = "auto-approve-indicator";
+          toggle.className = base;
           toggle.title = "自动批准已关闭 — 点击开启";
           toggle.textContent = "🛡 手动";
         }
@@ -15497,6 +15837,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") {
@@ -15573,10 +15916,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
@@ -15620,7 +15964,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)
@@ -15634,9 +15978,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++) {
@@ -15666,13 +16013,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。
@@ -15805,7 +16158,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");
@@ -15863,7 +16216,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) {
@@ -16844,6 +17197,27 @@
           '<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)),
@@ -16897,16 +17271,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>';
@@ -16924,7 +17302,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)
@@ -16980,6 +17358,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) {
@@ -17076,16 +17456,61 @@
         persistElementExpandState(el, "tool-group");
       };
 
+      // 老消息（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,
+        };
+      }
+
+      // 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
       // 避免不同段冲突。
-      function splitTurnBySubagent(blocks) {
+      // 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;
+          }
           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 };
@@ -17124,11 +17549,55 @@
         return html;
       }
 
-      function renderStructuredMessage(msg, roundUsage, messageIndex) {
+      // 抽出 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）
+        // 排队中的用户消息标记（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) {
@@ -17147,12 +17616,22 @@
         }
 
         var toolResults = buildToolResultMap(msg.content);
+        var parentPersona = getStructuredChatPersona("assistant");
 
-        // user role 不会有 subagent，保持旧路径
+        // user role：可能含 Task tool_result（subagent 反查盖章过的）。检测一下，
+        // 有 subagent 段就走 multi-agent 渲染（不输出 handoff，避免重复）。
         if (role !== "assistant") {
-          var userHtml = buildSegmentBlocksHtml(msg.content, 0, role, toolResults, messageKey);
+          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>' +
@@ -17160,7 +17639,7 @@
         }
 
         // assistant：检测是否有 subagent 段，没有就走单段渲染（兼容老消息 / 无 subagent 的 turn）
-        var segments = splitTurnBySubagent(msg.content);
+        var segments = splitTurnBySubagent(msg.content, legacyTaskMap);
         var hasSubagent = segments.some(function(s) { return s.subagent; });
 
         if (!hasSubagent) {
@@ -17174,43 +17653,26 @@
         // 多段：父 assistant 段 + 各 subagent 段。同一根 .chat-message 容器，
         // 内部多个 .chat-message-segment 子段，每段自带头像；切到新 subagent 时
         // 插入一行 handoff 提示（"勤劳初二 ↳ 让 侦探猫 帮忙"）。
-        var parentPersona = getStructuredChatPersona("assistant");
         var multiHtml = '<div class="chat-message ' + role + ' multi-agent" data-message-key="' + escapeHtml(messageKey) + '">';
-        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);
-          if (seg.subagent) {
-            var subPalette = getSubagentPalette(seg.subagent);
-            if (lastSubId !== seg.subagent.taskId) {
-              var subName = getSubagentDisplayName(seg.subagent);
-              var desc = seg.subagent.taskDescription
-                ? '：<span class="chat-handoff-desc">' + escapeHtml(seg.subagent.taskDescription) + '</span>'
-                : '';
-              multiHtml += '<div class="chat-handoff" style="--agent-color:' + subPalette.primary + '">' +
-                '<span class="chat-handoff-arrow">↳</span> ' +
-                escapeHtml(parentPersona.name) + ' 让 <strong>' + escapeHtml(subName) + '</strong> 帮忙' + desc +
-              '</div>';
-            }
-            multiHtml += '<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 {
-            multiHtml += '<div class="chat-message-segment parent">' +
-              chatAvatar("assistant") +
-              '<div class="chat-message-content">' + segHtml + '</div>' +
-            '</div>';
-            lastSubId = null;
-          }
-        }
+        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) {
@@ -17220,7 +17682,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="">' +
@@ -17230,6 +17691,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;