dsh-neotui 0.4.3 → 0.4.4

package/src/views.js

@@ -2,20 +2,23 @@
 import { Screen } from "./screen.js";
 import { renderMd, C } from "./md.js";
 import { truncate, strWidth, pad, bars, fmtDuration, fmtClock, fmtDateTime, graphemes, graphemeWidth, takeGraphemes, bytesLabel, prettyJson, looksLikeJson } from "./text.js";
-import { readFileSync, appendFileSync, mkdirSync, existsSync, statSync } from "node:fs";
-import { join, basename } from "node:path";
+import { readFileSync, appendFileSync, mkdirSync, existsSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { join, basename } from "node:path";
+import { tmpdir, homedir } from "node:os";
 import { createRequire } from "node:module";
 import { Widget, ScrollView, Input, Popup, Menu, StatusBar, wrapIndex } from "./widgets.js";
 import { UploadPicker } from "./file-picker.js";
-import { userPrefix, saveTuiConfig, loadTuiConfig, userName, busyEnter, foldDefaults, keyBindings, tuiConfigFile, reloadTuiConfig, searchHistory, rememberSearchQuery } from "./config.js";
+import { userPrefix, saveTuiConfig, loadTuiConfig, userName, busyEnter, foldDefaults, keyBindings, tuiConfigFile, reloadTuiConfig, searchHistory, rememberSearchQuery, promptHistory, rememberPrompt, prefixKeys } from "./config.js";
 import { bindingMatchFor, matchKeyBinding, CHAT_BINDING_ORDER, SIDEBAR_BINDING_ORDER, KEYBINDING_ORDER, INPUT_BINDING_ORDER, INPUT_EDIT_BINDING_ORDER } from "./keybindings.js";
-export { userPrefix, saveTuiConfig, loadTuiConfig, userName, busyEnter, foldDefaults } from "./config.js";
+export { userPrefix, saveTuiConfig, loadTuiConfig, userName, busyEnter, foldDefaults, promptHistory, rememberPrompt } from "./config.js";
 import {
   Picker, buildCommandPalette, buildModelPicker, buildModePicker, buildPermissionPicker,
   modeName, permName, WorkspacePanel, TrajectoryPanel, DirPicker, AttachmentPanel,
-  ImagePopup, kittyCapable, buildGoalPopup, GoalPanel, SettingsPanel, SubagentPanel,
-  SkillsPanel, ControlPanel, JobsPanel, QueuePanel, ModelPanel, fmtMs, ThemePickerBuffer,
+  ImagePopup, kittyCapable, GoalPanel, SettingsPanel,
+  SkillsPanel, ControlPanel, QueuePanel, ModelPanel, fmtMs, ThemePickerBuffer,
+  SubagentPage, TasksPage,
 } from "./panels.js";
 
 import { T, themeName, cycleTheme } from "./theme.js";
@@ -1052,6 +1055,8 @@ class SidebarTree extends Widget {
     this.sel = 0;
     this.focused = false;
     this.collapsed = new Set(); // group keys
+    this.preview = { open: false, sessionId: null, title: "", lines: [], loading: false, error: null };
+    this.previewToken = 0;
   }
   setData(workspaces, sessions, archivedIds, currentSessionId) {
     const archived = new Set(archivedIds ?? []);
@@ -1230,11 +1235,68 @@ class SidebarTree extends Widget {
     }
     return false;
   }
+  /** Attached preview card (not a modal): p toggles it (Tab switched to the
+   *  window toggle); it never steals focus — ↑/↓ still moves the tree and the
+   *  card follows the selection. */
+  #togglePreview() {
+    const row = this.currentRow();
+    if (!row || row.kind !== "session") return;
+    if (this.preview.open && this.preview.sessionId === row.session.sessionId) {
+      this.preview.open = false;
+      this.app.redraw();
+      return;
+    }
+    this.preview.open = true;
+    void this.#refreshPreview(row.session, true);
+  }
+  /** Load the preview for a session (token-guarded, throttled at 250ms). */
+  async #refreshPreview(session, force = false) {
+    const app = this.app;
+    const token = ++this.previewToken;
+    this.preview.sessionId = session.sessionId;
+    this.preview.title = session.title ?? session.sessionId.slice(0, 8);
+    this.preview.loading = true;
+    this.preview.error = null;
+    this.preview.lines = [];
+    app.redraw();
+    try {
+      const res = await app.api.call("session.history", { sessionId: session.sessionId, maxMessages: 12 });
+      if (token !== this.previewToken) return; // stale
+      const lines = [];
+      for (const item of (res?.events ?? [])) {
+        const ev = item?.event ?? item;
+        const event = ev?.event ?? ev;
+        const type = event?.type ?? ev?.type;
+        const data = event?.data ?? ev?.data ?? {};
+        if (type === "user/message") {
+          const d = data.message ?? data;
+          const text = partsToText(data.content ?? d.content ?? []).replace(/\s+/g, " ").trim();
+          lines.push(["你", truncate(text || data.id || "（无文本）", 28)]);
+        } else if (type === "assistant/message") {
+          const d = data.message ?? data;
+          const text = partsToText(d.content ?? []).replace(/\s+/g, " ").trim();
+          lines.push(["AI", truncate(text || "（无文本）", 28)]);
+        } else if (type === "tool/call") {
+          const name = (data.call ?? data).name ?? data.name ?? "tool";
+          lines.push(["⚙", truncate(String(name), 28)]);
+        }
+      }
+      this.preview.lines = lines;
+    } catch (e) {
+      if (token === this.previewToken) this.preview.error = e.message;
+    }
+    if (token === this.previewToken) { this.preview.loading = false; app.redraw(); }
+  }
+
   onKey(ev) {
     if (ev.type !== "key") return false;
     switch (ev.name) {
-      case "up": return this.move(-1);
-      case "down": return this.move(1);
+      case "up":
+        if (this.move(-1)) { if (this.preview.open) { const r = this.currentRow(); if (r?.kind === "session") void this.#refreshPreview(r.session); } return true; }
+        return false;
+      case "down":
+        if (this.move(1)) { if (this.preview.open) { const r = this.currentRow(); if (r?.kind === "session") void this.#refreshPreview(r.session); } return true; }
+        return false;
       case "pgup": this.scroll(-this.h); return true;
       case "pgdn": this.scroll(this.h); return true;
       case "home": this.sel = 0; this.#scrollToSel(); return true;
@@ -1243,7 +1305,7 @@ class SidebarTree extends Widget {
         const row = this.currentRow();
         if (!row) return false;
         if (row.kind === "group") { this.toggle(row.group); this.app.redraw(); }
-        else this.app.openSession(row.session.sessionId); // pane focus intentionally stays here
+        else { this.preview.open = false; this.app.openSession(row.session.sessionId); } // pane focus intentionally stays here
         return true;
       }
       case "left": {
@@ -1263,6 +1325,13 @@ class SidebarTree extends Widget {
       case "char":
         if (ev.ctrl && ev.key === "r") return this.openCurrentMenu();
         if (ev.ctrl) return false;
+        // p (no ctrl): toggle the attached preview card (Tab now switches the
+        // focused window at the App layer, so the preview trigger moved here).
+        if (ev.key === "p") {
+          const row = this.currentRow();
+          if (row?.kind === "session") { this.#togglePreview(); return true; }
+          return false;
+        }
         {
           const sbHit = bindingMatchFor(ev, keyBindings(), false, SIDEBAR_BINDING_ORDER);
           if (sbHit?.id === "insert") { this.app.focus(this.app.chat.input); this.app.redraw(); return true; }
@@ -1293,6 +1362,8 @@ class SidebarTree extends Widget {
 /** Slash commands offered by the input's candidate bar (Tab completes). */
 const SLASH_COMMANDS = [
   { name: "/reload", desc: "重新载入界面（不重启进程）" },
+  { name: "/rewind", desc: "回退到某条提问之前（分支会话 + 原消息回填入输入框）" },
+  { name: "/btw", hint: "<问题>", desc: "侧问：不打断主回合的单轮问题（HoST 无通道时由 TUI 直连）" },
   { name: "/restart", desc: "重启 TUI 加载新版本" },
   { name: "/model", desc: "切换模型" },
   { name: "/theme", desc: "切换配色主题" },
@@ -1332,7 +1403,7 @@ export class ChatView extends Widget {
       x: this.x, y: this.y + this.h - 2, w: this.w, h: 1,
       multi: true, maxLines: 6, app: this.app, commands: SLASH_COMMANDS,
       bg: T.PANEL,
-      placeholder: "输入消息…（Shift+Enter/Ctrl+J 换行，Ctrl+L 展开，↑/↓ 历史，Tab 补全 / 命令，Enter 发送）",
+      placeholder: "输入消息…（Shift+Enter/Ctrl+J 换行，Ctrl+L 展开，↑/↓ 历史，Tab 补全 / 命令 / 文件，Enter 发送）",
       onEnter: (v) => this.send(v),
       onChange: () => this.inputChanged(),
     });
@@ -1553,6 +1624,8 @@ export class ChatView extends Widget {
   async open(sessionId, epoch = this.app.sessionEpoch, maxMessages = 80) {
     this.sessionId = sessionId;
     this.nodes = [];
+    const cwd = this.app.sessions?.find((s) => s.sessionId === sessionId)?.cwd;
+    if (cwd) this.input.fileRoot = cwd; // file-path completion base
     this.blockSel = -1;
     this.cursorMode = "block";
     this.visualAnchor = null;
@@ -1745,7 +1818,12 @@ export class ChatView extends Widget {
   send(text) {
     if (!this.sessionId) return;
     const trimmed = text.trim();
+    if (!trimmed.startsWith("/")) rememberPrompt(trimmed);
+    const hist = this.app.chat?.input?.history;
+    if (Array.isArray(hist)) this.app.chat.input.history = [trimmed, ...hist.filter((x) => x !== trimmed)].slice(0, 50);
     if (trimmed === "/reload") { this.app.softReload(); return; }
+    if (trimmed === "/rewind") { this.app.showRewindPicker(); return; }
+    if (trimmed.startsWith("/btw")) { void this.app.sideQuestion(trimmed.slice(4).trim()); return; }
     if (trimmed === "/restart") { this.app.restartApp(); return; }
     if (trimmed === "/model") { this.app.overlay = buildModelPicker(this.app); this.app.redraw(); return; }
     if (trimmed === "/theme") { this.app.showThemePicker(); return; }
@@ -1758,6 +1836,25 @@ export class ChatView extends Widget {
       },
     });
     for (const e of errors) this.app.toast(`图片读取失败: ${e}`);
+    // @-mentioned non-image files/directories attach as bounded text blocks
+    // (Claude-Code parity; the token stays in the prompt as a reference).
+    const atRoot = this.app.sessions?.find((s) => s.sessionId === this.sessionId)?.cwd ?? process.cwd();
+    for (const m of trimmed.matchAll(/@([^\s@]+)/g)) {
+      const ref = m[1];
+      if (IMAGE_EXT.test(ref)) continue;
+      const full = ref.startsWith("~") ? join(homedir(), ref.slice(1)) : join(atRoot, ref);
+      if (!existsSync(full)) continue;
+      const display = `@${ref}`;
+      try {
+        if (statSync(full).isDirectory()) {
+          const names = readdirSync(full).slice(0, 200);
+          parts.push({ type: "text", text: `\n<${display} 目录内容>\n${names.join("\n")}`.slice(0, 8192) });
+        } else {
+          const buf = readFileSync(full, "utf8");
+          parts.push({ type: "text", text: `\n<${display} 文件内容>\n${buf}`.slice(0, 8192) });
+        }
+      } catch (e) { this.app.toast(`@${ref} 读取失败: ${e.message}`); }
+    }
     const clipParts = this.clipboardImages.map(({ mediaType, data, name }) => ({ type: "image", mediaType, data, name }));
     const clipboardCount = clipParts.length;
     parts.push(...clipParts);
@@ -3035,8 +3132,24 @@ export class ChatView extends Widget {
     screen.text(Math.max(this.x + 1, this.x + this.w - 22), y, "Ctrl+O 附件管理器", { fg: K.FAINT, bg: T.BG2 });
   }
 
-  /** / command candidate bar above the input (↑/↓ cycle, Tab completes). */
+  /** / command candidate bar above the input (↑/↓ cycle, Tab completes);
+   *  also shows file-path completion candidates. */
   #renderCmdBar(screen) {
+    const inp = this.input;
+    if (!inp.cmdOpen && inp.fileCands.length === 0 && inp.atCands.length === 0) return;
+    if (inp.cmdOpen && inp.cmds.length > 0) { this.#renderCmdBarCommands(screen); return; }
+    // file completion hint line
+    const n = 1;
+    const w = Math.min(this.view.w, 44);
+    const y0 = Math.max(this.view.y, inp.y - n - 1);
+    screen.fillRect(this.x, y0, this.x + w - 1, y0 + n - 1, " ", { bg: T.BG2 });
+    const cands = inp.atCands.length ? inp.atCands : inp.fileCands;
+    const shown = cands.slice(0, 6).map((n) => n.startsWith("@") ? n : n).join("  ");
+    screen.text(this.x + 1, y0, `▸ ${truncate(shown, w - 3)}`, { fg: T.SELFG, bg: T.BG2 });
+    return;
+  }
+
+  #renderCmdBarCommands(screen) {
     const inp = this.input;
     if (!inp.cmdOpen || inp.cmds.length === 0) return;
     const n = Math.min(inp.cmds.length, 6);
@@ -3613,6 +3726,8 @@ export class ApprovalPopup extends Popup {
 // ---- App ----
 
 export class App {
+  #workspacePicker = null; // Ctrl+W 工作区选择小 buffer（用于重命名行取选中项）
+  #splitDrag = null;       // { node, axis, rect } — dragging a split divider
   constructor({ screen, term, api, base, log, versionFetcher = latestNpmVersion, launcherAnime = false }) {
     this.screen = screen;
     this.term = term;
@@ -3629,6 +3744,15 @@ export class App {
     this.logoData = null;       // decoded custom logo: { palette, grid }
     this.logoLoadError = null;
     this.brandShimmer = -1;     // welcome wordmark diagonal sweep phase (-1 = idle)
+    // /btw default transport: spawn the standalone helper (one-shot key read)
+    const helper = fileURLToPath(new URL("side-question.mjs", import.meta.url));
+    this.sideQuestionRunner = (q, ctx, helperPath = helper) => new Promise((resolve) => {
+      try {
+        const res = spawnSync(process.execPath, [helperPath, "--question", q, "--context", ctx], { timeout: 60000, encoding: "utf8", maxBuffer: 8 * 1024 * 1024 });
+        if (res.status === 0) { try { const data = JSON.parse(res.stdout); resolve({ answer: data.answer, err: null }); return; } catch { resolve({ answer: null, err: "答案解析失败" }); return; } }
+        resolve({ answer: null, err: (res.stderr || "子进程失败").split("\n")[0] });
+      } catch (e) { resolve({ answer: null, err: String(e?.message ?? e) }); }
+    });
     this.brandSweep0 = -1;
     this.brandShimmerNext = null;
     this.popup = null;
@@ -3663,7 +3787,16 @@ export class App {
     this.searchActive = false;
     this.overlay = null;       // Picker / Popup / ImagePopup modal
     this.fullBuffer = null;    // full-screen panel buffer (workspace/settings/models/subagent/skills)
-    this.mode = "chat";        // chat | workspace | trajectory
+    this.mainTab = "chat";     // main-area tab: chat | trajectory | subagent | tasks (Shift+Tab cycles)
+    this.mode = "chat";        // chat | trajectory (legacy mirror of mainTab)
+    this.focusedWindow = "main"; // focused window: list (会话列表) | main (主窗口); Tab/Ctrl+Left+Right switch
+    this.winTree = null;         // split window tree (built lazily on the first split)
+    this.focusedLeaf = null;     // current leaf node of winTree
+    this.lastMainLeaf = null;    // Tab: list ↔ last focused main window
+    this.pendingPrefix = null;   // nvim-style pending layer (prefix tables)
+    this.prefixTimeoutMs = 2000; // pending-layer timeout (tests may override)
+    this.subagentPane = null;  // lazy SubagentPage (tab 子代理)
+    this.tasksPane = null;     // lazy TasksPage (tab 后台任务)
     this.sidebarWanted = true;
     this.sidebarVisible = true; // auto-collapses on narrow terminals
     this.tooSmall = false;
@@ -3712,7 +3845,10 @@ export class App {
     this.sidebar.x = 0; this.sidebar.y = 0; this.sidebar.w = this.sidebarWidth; this.sidebar.h = this.screen.h - 1;
     this.searchInput.w = this.sidebarWidth;
     this.chat.resize(x, 1, w, mainH);
-    if (this.trajectoryPanel?.relayout) this.trajectoryPanel.relayout(x, 1, w, mainH);
+    // The active main-area pane (trajectory/subagent/tasks) sits in exactly the
+    // rect the ChatView occupies; non-active panes keep their last geometry.
+    const pane = this.paneWidget();
+    if (pane?.relayout) pane.relayout(x, 1, w, mainH);
     if (this.fullBuffer?.relayout) this.fullBuffer.relayout(0, 0, this.screen.w, this.screen.h);
     this.status.y = this.screen.h - footerH;
     this.status.h = footerH;
@@ -3736,30 +3872,354 @@ export class App {
 
   toggleChatTrajectory() {
     if (!this.currentSession) { this.toast("先打开一个会话"); return; }
-    this.setMode(this.mode === "trajectory" ? "chat" : "trajectory");
-  }
-
-  /** tmux-style pane focus. The sequence wraps and skips unavailable panes. */
-  focusPane(delta) {
-    const panes = [];
-    if (this.sidebarVisible) panes.push("sidebar");
-    panes.push("chat");
-    if (this.currentSession) panes.push("trajectory");
-    const current = this.focused === this.sidebar ? "sidebar" : this.mode === "trajectory" ? "trajectory" : "chat";
-    const next = panes[wrapIndex(Math.max(0, panes.indexOf(current)) + delta, panes.length)];
-    if (next === "sidebar") {
+    this.setTab(this.mainTab === "trajectory" ? "chat" : "trajectory");
+  }
+
+  /** The main-area content rect — the exact rect the ChatView occupies. */
+  mainAreaRect() {
+    const x = this.sidebarVisible ? this.sidebarWidth : 0;
+    const w = Math.max(1, this.screen.w - x);
+    const footerH = Math.min(this.footerHeight(), Math.max(1, this.screen.h - 2));
+    const mainH = Math.max(1, this.screen.h - 1 - footerH);
+    return { x, y: 1, w, h: mainH };
+  }
+
+  /** The currently-active non-chat pane widget (null when the chat tab is
+   *  active). Does NOT construct — panes are only grown by setTab(). */
+  paneWidget() {
+    if (this.mainTab === "trajectory") return this.trajectoryPanel;
+    if (this.mainTab === "subagent") return this.subagentPane;
+    if (this.mainTab === "tasks") return this.tasksPane;
+    return null;
+  }
+  ensureTrajectoryPane() {
+    if (!this.trajectoryPanel) this.trajectoryPanel = new TrajectoryPanel(this);
+    return this.trajectoryPanel;
+  }
+  ensureSubagentPane() {
+    if (!this.subagentPane) this.subagentPane = new SubagentPage(this);
+    return this.subagentPane;
+  }
+  ensureTasksPane() {
+    if (!this.tasksPane) this.tasksPane = new TasksPage(this);
+    return this.tasksPane;
+  }
+
+  /** Set the main-area tab (chat | trajectory | subagent | tasks) and focus
+   *  the main window. Non-chat panes are lazy-grown and seeded on first entry;
+   *  re-entry (including a cycle back) keeps their live state. */
+  setTab(which) {
+    this.mainTab = which;
+    this.mode = which === "trajectory" ? "trajectory" : "chat";
+    this.focusedWindow = "main";
+    let pane = null;
+    if (which === "trajectory") {
+      pane = this.ensureTrajectoryPane();
+      if (this.currentSession) pane.load(this.currentSession);
+    } else if (which === "subagent") {
+      pane = this.ensureSubagentPane();
+      pane.onActivate?.();
+    } else if (which === "tasks") {
+      pane = this.ensureTasksPane();
+      pane.onActivate?.();
+    }
+    this.layout();
+    if (pane) this.focus(pane);
+    else this.focus(this.chat);
+    this.redraw();
+  }
+
+  /** Window stops: list (会话列表) + main (主窗口). The list stop is omitted
+   *  when the sidebar is hidden. */
+  windowStops() {
+    return this.sidebarVisible ? ["list", "main"] : ["main"];
+  }
+
+  /** tmux-style window focus over the 2-stop ring (list ↔ main, wrap). The
+   *  list stop is omitted when the sidebar is hidden. */
+  focusWindow(delta) {
+    if (!this.winTree) {
+      const stops = this.windowStops();
+      const idx = stops.indexOf(this.focusedWindow);
+      const next = stops[wrapIndex(Math.max(0, idx) + delta, stops.length)];
+      this.setFocusedWindow(next);
+      return true;
+    }
+    const leaves = this.#leaves();
+    const idx = leaves.indexOf(this.focusedLeaf ?? (this.focusedWindow === "list" ? this.#leafList() : this.#mainLeaves()[0]));
+    const next = leaves[wrapIndex(Math.max(0, idx) + delta, leaves.length)];
+    this.#focusLeaf(next);
+    return true;
+  }
+
+  /** Focus the given window. "list" focuses the session list; "main" focuses
+   *  whatever the active tab hosts (chat or the active pane). */
+  setFocusedWindow(which) {
+    if (this.winTree) {
+      if (which === "list") this.#focusLeaf(this.#leafList());
+      else this.#focusLeaf(this.lastMainLeaf ?? this.#mainLeaves()[0] ?? this.focusedLeaf);
+      return;
+    }
+    this.focusedWindow = which;
+    if (which === "list") {
       this.focus(this.sidebar);
-    } else if (next === "trajectory") {
-      this.setMode("trajectory");
-      this.focus(this.trajectoryPanel ?? this.chat);
     } else {
-      this.setMode("chat");
-      this.focus(this.chat);
+      const pane = this.paneWidget();
+      if (pane) this.focus(pane);
+      else this.focus(this.chat);
     }
     this.redraw();
+  }
+
+  /** Cycle the main-window tab: chat → trajectory → subagent → tasks → chat.
+   *  Tabs are always reachable regardless of an open session. */
+  cycleTab(delta) {
+    const tabs = ["chat", "trajectory", "subagent", "tasks"];
+    const idx = tabs.indexOf(this.mainTab);
+    const next = tabs[wrapIndex(Math.max(0, idx) + delta, tabs.length)];
+    this.setTab(next);
     return true;
   }
 
+  // ---- Window split tree + prefix layers ----
+
+  /** Lazy window tree: built when the first split happens (list + one main). */
+  #ensureWinTree() {
+    if (this.winTree) return;
+    const main = { type: "leaf", kind: "main", id: "m1", sessionId: this.currentSession, mainTab: this.mainTab };
+    const list = { type: "leaf", kind: "list", id: "list" };
+    this.winTree = { type: "split", dir: "right", a: list, b: main };
+    this.focusedLeaf = this.focusedWindow === "list" ? list : main;
+    this.lastMainLeaf = main;
+  }
+  /** Leaves in visual order (left→right, top→bottom). */
+  #leaves(node = this.winTree) {
+    if (!node) return [];
+    if (node.type === "leaf") return [node];
+    const l = this.#leaves(node.a), r = this.#leaves(node.b);
+    return (node.dir === "left" || node.dir === "up") ? [...r, ...l] : [...l, ...r];
+  }
+  #mainLeaves() { return this.#leaves().filter((l) => l.kind === "main"); }
+  #leafList(node = this.winTree) { return this.#leaves(node).find((l) => l.kind === "list"); }
+  #contains(node, target) {
+    if (!node || node.type === "leaf") return node === target;
+    return this.#contains(node.a, target) || this.#contains(node.b, target);
+  }
+  #leafDepth(node, target, d = 0) {
+    if (node.type === "leaf") return d;
+    if (this.#contains(node.a, target) || this.#contains(node.b, target)) {
+      const d1 = node.a.type === "split" || node.a === target || this.#contains(node.a, target) ? this.#leafDepth(node.a, target, d + 1) : d + 1;
+      return this.#leafDepth(this.#contains(node.a, target) ? node.a : node.b, target, d + 1);
+    }
+    return d;
+  }
+  /** Replace leaf with a node in the tree (mutating). */
+  #replaceLeaf(leaf, withNode, node = this.winTree) {
+    if (!node || node.type === "leaf") return;
+    if (node.a === leaf) { node.a = withNode; return; }
+    if (node.b === leaf) { node.b = withNode; return; }
+    if (this.#contains(node.a, leaf)) this.#replaceLeaf(leaf, withNode, node.a);
+    else if (this.#contains(node.b, leaf)) this.#replaceLeaf(leaf, withNode, node.b);
+  }
+  /** Prune the parent split of target; returns the new root. */
+  #prune(node, target) {
+    if (node.type !== "split") return node;
+    if (node.a === target) return node.b;
+    if (node.b === target) return node.a;
+    if (this.#contains(node.a, target)) return { ...node, a: this.#prune(node.a, target) };
+    if (this.#contains(node.b, target)) return { ...node, b: this.#prune(node.b, target) };
+    return node;
+  }
+  /** Rect of a leaf; the main-area rect for main leaves, the sidebar slot for list. */
+  #leafRect(leaf) {
+    const main = this.mainAreaRect();
+    if (leaf.kind === "list") return { x: 0, y: 0, w: this.sidebarVisible ? this.sidebarWidth : 0, h: this.screen.h - 1 };
+    return main;
+  }
+  /** Recompute the leaf rects and render each leaf (focused leaf renders its real
+   *  content; others draw a placeholder cell). Returns the rect map. */
+  #layoutLeaves() {
+    const map = new Map();
+    const main = this.mainAreaRect();
+    const listRect = { x: 0, y: 0, w: this.sidebarVisible ? this.sidebarWidth : 0, h: this.screen.h - 1 };
+    // simple recursive rect assignment with 1-cell separators
+    const place = (node, rect, depth = 0) => {
+      if (node.type === "leaf") { map.set(node, rect); return; }
+      const border = 1;
+      if (node.dir === "right" || node.dir === "left") {
+        const total = Math.max(2, rect.w - border);
+        const r = Math.min(0.8, Math.max(0.2, node.ratio ?? 0.5));
+        const aW = Math.max(1, Math.round(total * r));
+        const bW = Math.max(1, total - aW);
+        if (node.dir === "right") {
+          place(node.a, { ...rect, w: aW }, depth + 1);
+          place(node.b, { x: rect.x + aW + border, y: rect.y, w: bW, h: rect.h }, depth + 1);
+        } else {
+          place(node.b, { ...rect, w: bW }, depth + 1);
+          place(node.a, { x: rect.x + bW + border, y: rect.y, w: aW, h: rect.h }, depth + 1);
+        }
+      } else {
+        const total = Math.max(2, rect.h - border);
+        const r = Math.min(0.8, Math.max(0.2, node.ratio ?? 0.5));
+        const aH = Math.max(1, Math.round(total * r));
+        const bH = Math.max(1, total - aH);
+        if (node.dir === "down") {
+          place(node.a, { ...rect, h: aH }, depth + 1);
+          place(node.b, { x: rect.x, y: rect.y + aH + border, w: rect.w, h: bH }, depth + 1);
+        } else {
+          place(node.b, { ...rect, h: bH }, depth + 1);
+          place(node.a, { x: rect.x, y: rect.y + bH + border, w: rect.w, h: aH }, depth + 1);
+        }
+      }
+    };
+    if (!this.winTree) { map.set(null, main); return map; }
+    place(this.winTree, this.winTree.b?.kind === "main" && this.#leafList() === this.winTree.a ? main : main);
+    // The tree root's split spans the WHOLE area, but the list leaf must occupy
+    // the sidebar slot and mains the remaining main area. Handle that by
+    // placing the list specially when it is a direct child:
+    if (this.winTree.type === "split" && this.winTree.a?.kind === "list") {
+      map.set(this.winTree.a, listRect);
+      place(this.winTree.b, main);
+    } else {
+      place(this.winTree, { x: this.sidebarVisible ? this.sidebarWidth : 0, y: 1, w: main.w, h: main.h });
+      if (this.#leafList()) map.set(this.#leafList(), listRect);
+    }
+    return map;
+  }
+  /** Split the focused leaf in a direction; the new window is a main window
+   *  adopting a blank session. Guards: 8 windows, depth 4, min 40x12. */
+  splitWindow(dir) {
+    this.#ensureWinTree();
+    const leaf = this.focusedLeaf ?? (this.focusedWindow === "list" ? this.#leafList() : this.#mainLeaves()[0]);
+    if (!leaf) { this.toast("请先打开一个会话"); return false; }
+    if (this.#leaves().length >= 8) { this.toast("窗口已达上限 (8)"); return false; }
+    if (this.#leafDepth(this.winTree, leaf) >= 4) { this.toast("分屏嵌套已达深度上限 (4)"); return false; }
+    const r = this.#leafRect(leaf);
+    if ((dir === "right" || dir === "left") && r.w < 40 * 2 + 1) { this.toast("空间不足：分屏后各窗口需 ≥40 列"); return false; }
+    if ((dir === "up" || dir === "down") && r.h < 12 * 2 + 1) { this.toast("空间不足：分屏后各窗口需 ≥12 行"); return false; }
+    const newLeaf = { type: "leaf", kind: "main", id: `m${Date.now()}`, sessionId: null, mainTab: "chat" };
+    const node = { type: "split", dir, a: leaf, b: newLeaf, ratio: 0.5 };
+    this.#replaceLeaf(leaf, node);
+    this.focusedLeaf = newLeaf;
+    this.lastMainLeaf = newLeaf;
+    this.focusedWindow = "main";
+    void this.#adoptBlankSession(newLeaf);
+    this.layout();
+    this.redraw();
+    return true;
+  }
+  /** Close the focused main window (p c). Never deletes the session; if no
+   *  main window remains, a fresh blank-session main window appears. */
+  closeWindow() {
+    if (!this.winTree) { this.toast("还没有可分屏窗口"); return false; }
+    const leaf = this.focusedLeaf ?? (this.focusedWindow === "list" ? this.#leafList() : this.#mainLeaves()[0]);
+    if (!leaf || leaf.kind === "list") { this.toast("不能关闭会话列表"); return false; }
+    const closedSession = leaf.sessionId;
+    this.winTree = this.#prune(this.winTree, leaf);
+    const mains = this.#mainLeaves();
+    if (mains.length === 0) {
+      const blank = { type: "leaf", kind: "main", id: `m${Date.now()}`, sessionId: null, mainTab: "chat" };
+      const list = this.#leafList();
+      this.winTree = list ? { type: "split", dir: "right", a: list, b: blank } : blank;
+      this.focusedLeaf = blank;
+      this.lastMainLeaf = blank;
+      void this.#adoptBlankSession(blank);
+    } else {
+      this.focusedLeaf = mains[0];
+      this.lastMainLeaf = mains[0];
+      if (mains[0].sessionId && mains[0].sessionId !== this.chat.sessionId) this.openSession(mains[0].sessionId);
+    }
+    this.toast(closedSession ? `已关闭窗口（会话保留在侧栏）` : "已关闭窗口");
+    this.layout();
+    this.redraw();
+    return true;
+  }
+  /** A blank session for a new window (reuse drafts like newSessionIn). */
+  async #adoptBlankSession(leaf) {
+    try {
+      const blanks = this.sessions.filter((s) => s.blank && !s.running && s.sessionId !== this.currentSession);
+      const blank = blanks.find((s) => s.cwd === process.cwd()) ?? blanks[0];
+      if (blank) { await this.refreshSessions(); leaf.sessionId = blank.sessionId; this.openSession(blank.sessionId); return; }
+      const { sessionId } = await this.api.call("session.create", { cwd: process.cwd() });
+      if (typeof sessionId !== "string" || !sessionId) throw new Error("Host 未返回会话 ID");
+      await this.refreshSessions();
+      leaf.sessionId = sessionId;
+      this.openSession(sessionId);
+    } catch (e) { this.toast(`新建会话失败: ${e.message}`); }
+  }
+  /** Focus the given leaf (tree-aware). */
+  #focusLeaf(leaf) {
+    if (!leaf) return;
+    this.focusedLeaf = leaf;
+    if (leaf.kind === "list") {
+      this.focusedWindow = "list";
+      this.focus(this.sidebar);
+    } else {
+      this.focusedWindow = "main";
+      this.lastMainLeaf = leaf;
+      const tab = leaf.mainTab ?? "chat";
+      if (tab !== this.mainTab) this.setTab(tab);
+      else { const pane = this.paneWidget(); this.focus(pane ?? this.chat); }
+      if (leaf.sessionId && leaf.sessionId !== this.chat.sessionId) this.openSession(leaf.sessionId);
+    }
+    this.redraw();
+  }
+
+  /** Hit-test a split separator position (within ±1). */
+  #hitSplitSeparator(px, py) {
+    const walk = (node, rect) => {
+      if (node.type !== "split") return null;
+      const border = 1;
+      if (node.dir === "right" || node.dir === "left") {
+        const total = Math.max(2, rect.w - border);
+        const r = Math.min(0.8, Math.max(0.2, node.ratio ?? 0.5));
+        const aW = Math.max(1, Math.round(total * r));
+        const x = rect.x + aW;
+        if (Math.abs(px - x) <= 1 && py >= rect.y && py < rect.y + rect.h) return { node, rect };
+        // recurse into the child containing the pointer
+        const child = px < x ? node.a : node.b;
+        const childRect = px < x ? { ...rect, w: aW } : { x: rect.x + aW + border, y: rect.y, w: Math.max(1, total - aW), h: rect.h };
+        return walk(child, childRect);
+      }
+      const total = Math.max(2, rect.h - border);
+      const r = Math.min(0.8, Math.max(0.2, node.ratio ?? 0.5));
+      const aH = Math.max(1, Math.round(total * r));
+      const y = rect.y + aH;
+      if (Math.abs(py - y) <= 1 && px >= rect.x && px < rect.x + rect.w) return { node, rect };
+      const child = py < y ? node.a : node.b;
+      const childRect = py < y ? { ...rect, h: aH } : { x: rect.x, y: rect.y + aH + border, w: rect.w, h: Math.max(1, total - aH) };
+      return walk(child, childRect);
+    };
+    const rootRect = { x: this.sidebarVisible ? this.sidebarWidth : 0, y: 1, w: this.mainAreaRect().w, h: this.mainAreaRect().h };
+    return walk(this.winTree, rootRect);
+  }
+
+  /** Prefix rows for the panel reference page — THE SAME table the engine
+   *  dispatches (single source of truth; chars from prefixKeys config). */
+  prefixRowsData() {
+    const k = prefixKeys();
+    const t = this.#prefixTables().main;
+    const meta = [
+      ["search", "跨会话全文搜索", "Ctrl+F 已释放"],
+      ["history", "输入历史搜索（可筛选）", "最近 50 条提问"],
+      ["rewind", "回退（分支会话 + 原消息回填）", "/rewind"],
+      ["model", "切换模型", "Ctrl+M 已释放"],
+      ["theme", "配色主题", "Ctrl+D 已释放"],
+      ["permission", "权限模式（沙箱 + 审批）", "F8 已释放"],
+      ["config", "打开配置文件（改 prefixKeys 前缀键）", "Ctrl+K"],
+      ["help", "帮助（按场景）", "Shift+/ 或前缀 ?"],
+      ["editor", "外部编辑器编辑输入", "$VISUAL · 非零退出保留原稿"],
+      ["panes", "窗格/分屏子表", "p r/l/u/n/c（NORMAL 亦可用）"],
+    ];
+    return meta
+      .filter(([action]) => t.entries[k[action]])
+      .map(([action, desc, hint]) => [k[action], desc, hint, () => { this.closeOverlay(); t.entries[k[action]](); }]);
+  }
+
+  /** Public window-tree inspection (tests/diagnostics). */
+  splitLeaves() { return this.#leaves(); }
+  mainLeafCount() { return this.#mainLeaves().length; }
+
   async checkUpdates(target = null, notify = false) {
     const specs = {
       dsh: { package: "@deepseek-ai/dsh", current: this.dshVersion, label: "DeepSeek Harness" },
@@ -3830,6 +4290,11 @@ export class App {
     this.focused = w;
     if (this.sidebar) this.sidebar.focused = w === this.sidebar;
     if (this.chat?.input) this.chat.inputActive = w === this.chat.input;
+    // The focused window follows what is actually focused: the session list when
+    // the sidebar is focused, the main window for chat / its input / the active
+    // tab's pane. Overlays (modal) never change the focused window.
+    if (w === this.sidebar) this.focusedWindow = "list";
+    else if (w === this.chat || w === this.chat?.input || w === this.paneWidget()) this.focusedWindow = "main";
   }
 
   openMenu(items, ev) {
@@ -3887,6 +4352,17 @@ export class App {
   }
 
   setStatus(msg) { this.statusMsg = msg; this.redraw(); }
+  /** Live-frame fan-out into the active main-area pane. The subagent pane
+   *  reloads (throttled); the tasks pane repaints (it reads live data). */
+  notifyPaneLive(kind) {
+    if (kind === "subagent" && this.mainTab === "subagent") {
+      const page = this.subagentPane;
+      if (page && typeof page.reload === "function") page.reload();
+    } else if (kind === "tasks" && this.mainTab === "tasks") {
+      this.redraw();
+    }
+  }
+
   setJobs(jobs, sessionId = null) {
     // snapshot buffered per session: the mux baseline arrives at connect
     // time, possibly before the chat opens that session
@@ -3904,7 +4380,7 @@ export class App {
       if (this.chat.sessionId) this.chat.pollTail();
       // session.list is expensive (~100ms); refresh the sidebar every ~5s, not
       // on every streaming poll.
-      if (ticks++ % 10 === 0) { this.refreshSessions(); this.refreshSubagentStats(); }
+      if (ticks++ % 10 === 0) { this.refreshSessions(); this.refreshSubagentStats(); this.notifyPaneLive("subagent"); }
       const delay = this.chat.pollSlow ? 2000 : (this.chat.running ? 500 : 1500);
       this.pollTimer = setTimeout(tick, delay);
     };
@@ -3970,6 +4446,10 @@ export class App {
     }
   }
 
+  /** Frame injection entry (tests & external callers): routes through the
+   *  private handler so the live fan-out is exercised exactly like the wire. */
+  deliverFrame(frame) { this.#onFrame(frame); }
+
   #onFrame(frame) {
     this.injectFrame(frame);
   }
@@ -3991,6 +4471,7 @@ export class App {
           if (frame.type === "session/queue") {
             this.queueItems = frame.items ?? [];
             if (this.overlay instanceof QueuePanel) this.overlay.syncItems(this.queueItems);
+            this.notifyPaneLive("tasks");
           }
           this.chat.onFrame(frame);
         }
@@ -4002,6 +4483,7 @@ export class App {
         // connect-time baseline would otherwise be dropped by the filter
         // below and the footer would stick at "0已完成")
         this.setJobs(frame.jobs ?? [], frame.sessionId ?? null);
+        this.notifyPaneLive("tasks");
         if (this.chat.sessionId === frame.sessionId) this.chat.onFrame(frame);
         break;
       case "session/projection": {
@@ -4017,6 +4499,7 @@ export class App {
         // Reflow immediately so the tail remains reachable above fixed docks.
         if (["todos", "goal", "subagent"].includes(frame.key)) this.chat.inputChanged();
         if (["todos", "goal"].includes(frame.key) && this.overlay instanceof GoalPanel) this.overlay.sync();
+        if (frame.key === "subagent") this.notifyPaneLive("subagent");
         break;
       }
       case "approval/resolved":
@@ -4215,6 +4698,212 @@ export class App {
 
   /** Fork the whole session, or — with `atSeq` — everything up to that message
    *  (web forkAt parity: branch from a chosen point of a completed turn). */
+  /** /btw side question: a single-turn, tool-less answer from the session
+   *  context without interrupting the running turn. Runs the standalone
+   *  side-question.mjs in a child process (the API key never enters this
+   *  process); the answer shows in a scrollable popup. */
+  async sideQuestion(question) {
+    const q = String(question ?? "").trim();
+    if (!q) { this.toast("/btw <问题> — 请输入问题"); return; }
+    this.toast("侧问中…（单轮、无工具，不打断主回合）");
+    // context: the most recent visible transcript lines, capped
+    const context = (this.chat.nodes ?? [])
+      .flatMap((n) => (n.blocks ?? []).map((b) => b.text ?? ""))
+      .filter((t) => t.trim())
+      .slice(-6).join("\n").slice(0, 6000);
+    let answer = null, err = null;
+    const run = this.sideQuestionRunner;
+    if (run) {
+      try { ({ answer, err } = await run(q, context)); } catch (e) { err = String(e?.message ?? e); }
+    } else {
+      err = "sideQuestionRunner 未配置";
+    }
+    if (err || answer == null) { this.toast(`侧问失败: ${err ?? "无返回"}`); return; }
+    const lines = answer.split("\n").map((l) => truncate(l, Math.min(78, this.screen.w - 8)));
+    const h = Math.min(Math.max(6, lines.length + 2), Math.max(8, this.screen.h - 6));
+    this.overlay = new Popup({
+      x: Math.max(0, Math.floor((this.screen.w - Math.min(80, this.screen.w - 4)) / 2)),
+      y: Math.max(0, Math.floor(this.screen.h / 2) - Math.floor(h / 2)),
+      w: Math.min(80, this.screen.w - 4), h,
+      title: `侧问 · ${truncate(q, 40)} · ↑↓ 滚动 · Esc 关闭`,
+      lines, scrollable: true, buttons: [],
+      onAction: () => { this.overlay = null; this.focus(this.chat); this.redraw(); },
+    });
+    this.focus(this.overlay);
+    this.redraw();
+  }
+
+  /** Scenario help: `?` (Shift+/) routes by the focused pane; the prefix
+   *  page's `?` reuses the focus recorded when the panel opened. Scrollable
+   *  buffer, Esc returns to the source pane. */
+  showHelp(forceFocus = null) {
+    const focusTarget = forceFocus ?? this.focused;
+    const scenario = focusTarget === this.sidebar ? "sidebar" : (focusTarget === this.chat || focusTarget === this.chat.input) ? "chat" : "global";
+    const lines = [];
+    const pushTitle = (t) => lines.push([{ t: " " + t, fg: T.PURPLE, bg: T.PANEL, bold: true }]);
+    const pushRow = (a, d) => lines.push([{ t: `  ${a}`, fg: T.ACCENT, bg: T.PANEL, bold: true }, { t: ` ${d}`, fg: T.TXT, bg: T.PANEL }]);
+    const kb = keyBindings();
+    if (scenario === "sidebar") {
+      pushTitle("会话树（侧栏）帮助");
+      pushRow("↑/↓", "选择会话 / 分组       Enter 打开（组=折叠/展开）");
+      pushRow("Space", "组: 折叠/展开并回到组顶点");
+      pushRow("Tab", "会话预览卡片（纯开关，焦点不离开；↑↓ 跟随）");
+      pushRow("Ctrl+R", "会话菜单（重命名/移动/归档/删除/分叉/导出）");
+      pushRow("[ / ]", "把会话移入上一/下一分组");
+      pushRow("Ctrl+N", "新建会话（优先复用空白草稿）");
+      pushRow("Ctrl+O", "附件管理器 / 文件选择器");
+    } else if (scenario === "chat") {
+      pushTitle("对话场景帮助");
+      pushRow("g / G", "跳到首个 / 最新正文块       ↑/↓ 滚动历史");
+      pushRow("[ / ]", "上一 / 下一提问的终点       Ctrl+E 步跳");
+      pushRow("t / b", "全部思考块 / 工具块 展开折叠");
+      pushRow("v / Shift+V", "正文块选择（复制走 OSC 52）");
+      pushRow("Ctrl+R", "块菜单（复制/展开/分叉/文件预览）");
+      pushRow("Ctrl+B", "侧栏显示/隐藏");
+      pushRow(`?`, `本帮助（${scenario}场景）      双击 Ctrl+C 退出`);
+      pushTitle("对话中的常用命令");
+      pushRow("", SLASH_COMMANDS.map((c) => `${c.name}${c.hint ? " " + c.hint : ""}`).join(" · "));
+      pushRow("", "Tab：输入中补全路径 / /命令（候选栏 ↑↓ 循环）");
+    } else {
+      pushTitle("全局约定");
+      pushRow("Esc 层级", "输入 → 关命令栏 → 面板；NORMAL Esc 中断回合，INSERT 不打断");
+      pushRow("Ctrl+Space", "控制面板 → 前缀页（首屏）");
+      pushTitle("前缀键（Ctrl+Space 后按）");
+      for (const [k, d, hint] of ControlPanel.prototype.prefixRows()) pushRow(k, `${d}${hint ? " · " + hint : ""}`);
+      pushRow("Ctrl+P / F9", "命令面板 / 模式选择       Ctrl+G 目标 · Ctrl+T 轨迹页");
+      pushRow("Ctrl+K / Ctrl+H", "编辑配置 / 技能");
+      pushRow("双击 Ctrl+C / Ctrl+Q", "退出 TUI");
+      pushRow("? / 前缀页 ?", "本帮助（按场景）");
+    }
+    const h = Math.min(Math.max(8, lines.length + 2), Math.max(10, this.screen.h - 4));
+    const popup = new Popup({
+      x: Math.max(0, Math.floor((this.screen.w - Math.min(78, this.screen.w - 4)) / 2)),
+      y: Math.max(0, Math.floor(this.screen.h / 2) - Math.floor(h / 2)),
+      w: Math.min(78, this.screen.w - 4), h,
+      title: `${scenario === "sidebar" ? "侧栏" : scenario === "chat" ? "对话" : "全局"}帮助 · ↑↓ 滚动 · Esc 返回`,
+      lines, scrollable: true, buttons: [],
+      onAction: () => { this.overlay = null; this.focus(focusTarget ?? this.chat); this.redraw(); },
+    });
+    this.overlay = popup; this.focus(popup); this.redraw();
+  }
+
+  /** External editor for the input draft (Claude-Code Ctrl+G parity, prefix e):
+   *  $VISUAL/$EDITOR edits the current draft in a temp file; a clean exit
+   *  refills the input, a non-zero exit (:cq) keeps the original draft,
+   *  and clearing the file abandons the edit. */
+  editExternal() {
+    const input = this.chat.input;
+    const editor = process.env.VISUAL || process.env.EDITOR || "";
+    if (!editor) { this.toast("未设置 $VISUAL/$EDITOR，无法打开外部编辑器"); return; }
+    const tmp = join(tmpdir(), `dsh-tui-draft-${process.pid}-${Date.now()}.txt`);
+    try { writeFileSync(tmp, input.value, "utf8"); } catch (e) { this.toast(`草稿写入失败: ${e.message}`); return; }
+    const runner = this.externalEditRunner ?? ((file) => {
+      const res = spawnSync(editor, [file], { stdio: "inherit" });
+      return res.status;
+    });
+    let status = 0;
+    try { status = Number(runner(tmp) ?? 0); } catch (e) { status = 1; this.toast(`编辑器失败: ${e.message}`); }
+    let content = null;
+    try { content = readFileSync(tmp, "utf8"); } catch {}
+    try { unlinkSync(tmp); } catch {}
+    if (status !== 0) { this.toast("编辑器非零退出（:cq）；保留原稿"); return; }
+    if (content == null || content.trim() === "") { this.toast("内容为空：放弃编辑"); return; }
+    const old = input.value;
+    input.setValue(content.replace(/\n$/, ""));
+    if (input.value === old) this.toast("内容未变化");
+    else { this.focus(input); this.toast("已从外部编辑器回填"); }
+    this.redraw();
+  }
+
+  /** Input-history search: filterable picker over the last ~50 typed prompts
+   *  (persisted), Enter refills the input. Reached from the prefix page (h). */
+  showHistorySearch() {
+    const merged = [];
+    const seen = new Set();
+    for (const t of [...this.chat.input.history, ...promptHistory()]) {
+      const s = String(t ?? "").trim();
+      if (!s || seen.has(s)) continue;
+      seen.add(s); merged.push(s);
+    }
+    if (!merged.length) { this.toast("还没有输入历史"); return; }
+    const items = merged.slice(0, 50).map((t) => ({ label: truncate(t.replace(/\s+/g, " "), 56), hint: "回车填入输入框", text: t }));
+    const w = Math.max(1, Math.min(76, this.screen.w - 4)), ph = Math.max(1, Math.min(14, this.screen.h - 4));
+    this.overlay = new Picker({
+      x: Math.floor((this.screen.w - w) / 2), y: Math.floor((this.screen.h - ph) / 2),
+      w, h: ph, title: "输入历史（输入过滤 / ↑↓ 选择 / Esc 取消）",
+      items,
+      onPick: (it) => {
+        this.closeOverlay();
+        const input = this.chat.input;
+        input.setValue(it.text);
+        this.focus(input);
+        this.redraw();
+      },
+      onCancel: () => this.closeOverlay(),
+    });
+    this.redraw();
+  }
+
+  /** Rewind: pick a previous user message, fork the session before that turn,
+   *  reopen the branch and put the original message back into the input.
+   *  Reached from /rewind (deliberately not a double-Esc global). */
+  showRewindPicker() {
+    const nodes = this.chat.nodes ?? [];
+    const messages = [];
+    for (const node of nodes) {
+      if (node?.kind !== "user" || node.firstSeq == null) continue;
+      const text = (node.blocks ?? []).filter((b) => b?.type === "text").map((b) => b.text ?? "").join("").trim();
+      if (!text) continue;
+      messages.push({ seq: node.firstSeq, text });
+    }
+    if (!messages.length) { this.toast("当前会话没有可回退的用户提问"); return; }
+    const items = [...messages].reverse().map((m, i) => ({
+      label: `${String(messages.length - i).padStart(2, " ")} ${truncate(m.text.replace(/\s+/g, " "), 40)}`,
+      hint: `第 ${m.seq} 步`,
+      seq: m.seq, text: m.text,
+    }));
+    const w = Math.max(1, Math.min(76, this.screen.w - 4)), ph = Math.max(1, Math.min(14, this.screen.h - 4));
+    this.overlay = new Picker({
+      x: Math.floor((this.screen.w - w) / 2), y: Math.floor((this.screen.h - ph) / 2),
+      w, h: ph, title: "回退到…（Esc 取消）",
+      items,
+      onPick: (it) => this.#confirmRewind(it),
+      onCancel: () => this.closeOverlay(),
+    });
+    this.redraw();
+  }
+
+  #confirmRewind(it) {
+    const title = "确认真回溯？";
+    const lines = [`将回退到这条提问所属回合开始之前，并创建分支会话：`, "", `  ${truncate(it.text, Math.min(56, this.screen.w - 10))}`, "", "原消息会放回输入框供修改重发（原会话不变）。"];
+    const popup = new Popup({
+      x: Math.max(0, Math.floor((this.screen.w - Math.min(72, this.screen.w - 4)) / 2)),
+      y: Math.max(0, Math.floor(this.screen.h / 2) - 4), w: Math.min(72, this.screen.w - 4), h: lines.length + 3,
+      title, lines, buttons: [{ label: "是 (y)", action: "yes" }, { label: "否 (n)", action: "no" }],
+      onAction: (b) => {
+        this.closeOverlay();
+        if (b?.action === "yes") void this.#executeRewind(it);
+        else this.redraw();
+      },
+    });
+    this.overlay = popup; this.focus(popup); this.redraw();
+  }
+
+  async #executeRewind(it) {
+    const s = this.sessions.find((x) => x.sessionId === this.currentSession);
+    if (!s) return;
+    if (it.seq <= 1) { this.toast("第一条消息不能作为回退边界"); return; }
+    if (this.chat.running || s.running) { this.cancelSession({ sessionId: s.sessionId }); this.toast("已请求中断当前回合…"); await new Promise((r) => setTimeout(r, 600)); }
+    try {
+      const { sessionId } = await this.api.call("session.fork", { sessionId: s.sessionId, atSeq: it.seq - 1 });
+      await this.refreshSessions();
+      this.openSession(sessionId);
+      const input = this.chat.input;
+      if (!input.value) { input.setValue(it.text); this.focus(input); }
+      this.toast(`已回退并分支: ${sessionId.slice(0, 8)}；原消息已回到输入框`);
+    } catch (e) { this.toast(`回退失败: ${e.message}`); }
+  }
+
   async forkSession(s, atSeq = null) {
     try {
       const { sessionId } = await this.api.call("session.fork", { sessionId: s.sessionId, ...(atSeq != null ? { atSeq } : {}) });
@@ -4391,7 +5080,7 @@ export class App {
     this.chat.input?.setValue(this.draftsBySession.get(sessionId) ?? "");
     // A sidebar Enter intentionally preserves sidebar focus, but every
     // session-scoped panel must immediately follow the newly opened session.
-    if (this.mode === "trajectory" && this.trajectoryPanel) await this.trajectoryPanel.load(sessionId);
+    if (this.mainTab === "trajectory" && this.trajectoryPanel) await this.trajectoryPanel.load(sessionId);
     else if (this.fullBuffer && this.fullBuffer === this.subagentPanel) this.subagentPanel.load(sessionId);
     else if (this.fullBuffer && this.fullBuffer === this.skillsPanel) this.skillsPanel.load?.(sessionId);
     if (epoch !== this.sessionEpoch || sessionId !== this.currentSession) return;
@@ -4433,20 +5122,17 @@ export class App {
   }
 
   setMode(mode) {
-    this.mode = mode === "trajectory" ? "trajectory" : "chat";
-    if (this.mode === "trajectory") {
-      if (!this.currentSession) { this.toast("先打开一个会话"); this.mode = "chat"; this.redraw(); return; }
-      if (!this.trajectoryPanel) this.trajectoryPanel = new TrajectoryPanel(this);
-      this.trajectoryPanel.load(this.currentSession);
-    }
-    const panel = this.panelForMode();
-    if (panel && this.focused !== this.sidebar) this.focus(panel);
-    else if (this.focused !== this.sidebar) this.focus(this.chat);
-    this.layout();
-    this.redraw();
+    // Trajectory requires an open session (tab-click / chat-toggle path); the
+    // tab cycle (cycleTab) reaches trajectory regardless.
+    if (mode === "trajectory" && !this.currentSession) {
+      this.toast("先打开一个会话");
+      this.setTab("chat");
+      return;
+    }
+    this.setTab(mode);
   }
 
-  panelForMode() { return this.mode === "trajectory" ? this.trajectoryPanel : null; }
+  panelForMode() { return this.paneWidget(); }
 
   /** Full-screen modal buffers replace the old tab-page modes: they coexist
    *  with the sidebar/chat/trajectory pane focus instead of fighting it. */
@@ -4465,6 +5151,56 @@ export class App {
     this.redraw();
     return true;
   }
+  /** Ctrl+W: small workspace picker — choose the current session's workspace
+   *  (move), rename it, or add a new one from a path. */
+  showWorkspacePicker() {
+    const items = (this.workspaceItems ?? []).map((w) => ({
+      label: truncate(w.title ?? w.path ?? w.workspaceId, 40),
+      hint: w.path ?? "",
+      workspace: w,
+    }));
+    items.push({ label: "✎ 重命名当前工作区…", hint: "选中后重命名所选工作区", rename: true });
+    items.push({ label: "+ 新建工作区…", hint: "输入路径", create: true });
+    const w = Math.max(1, Math.min(72, this.screen.w - 4)), ph = Math.max(1, Math.min(14, this.screen.h - 4));
+    this.overlay = new Picker({
+      x: Math.floor((this.screen.w - w) / 2), y: Math.floor((this.screen.h - ph) / 2),
+      w, h: ph, title: "工作区 · Enter 选择/执行 · Esc 关闭",
+      items,
+      onPick: (it) => {
+        this.closeOverlay();
+        if (it.create) { this.addWorkspace(); return; }
+        if (it.rename) { const ws = this.#workspacePicker?.items?.[this.#workspacePicker.sel]?.workspace; this.#beginWorkspaceRename(ws); return; }
+        if (it.workspace) { void this.#moveCurrentToWorkspace(it.workspace); }
+      },
+      onCancel: () => this.closeOverlay(),
+    });
+    // remember selection index for the rename row
+    this.#workspacePicker = this.overlay;
+    this.focus(this.overlay);
+    this.redraw();
+  }
+  /** Move the current session into a workspace (append at its end). */
+  async #moveCurrentToWorkspace(ws) {
+    if (!this.currentSession) { this.toast("先打开一个会话"); return; }
+    if ((ws.sessionIds ?? []).includes(this.currentSession)) { this.toast("当前会话已在该工作区"); return; }
+    try {
+      await this.api.call("workspace.insertSessionBefore", { workspaceId: ws.workspaceId, sessionId: this.currentSession });
+      await this.refreshSessions();
+      this.toast(`已移动到工作区: ${truncate(ws.title ?? ws.path ?? ws.workspaceId, 20)}`);
+    } catch (e) { this.toast(`移动失败: ${e.message}`); }
+  }
+  /** Begin the inline rename of a workspace (reuses the existing rename UI). */
+  #beginWorkspaceRename(ws) {
+    const group = this.sidebar.groups.find((g) => g.workspaceId === ws?.workspaceId) ?? null;
+    if (!group) { this.toast("未找到该工作区"); return; }
+    // the existing rename flow is driven by the sidebar group; reuse its input
+    const input = new Input({ x: this.sidebar.x + 2, y: 1, w: this.sidebar.w - 4, h: 1, prompt: "新标题: ", allowEmptyEnter: true, onEnter: () => this.#commitWorkspaceRename(group, input), onKey: (ev) => { if (ev?.name === "escape") { this.#closeRename(); return true; } return Input.prototype?.onKey ? false : false; } });
+    input.value = group.title ?? "";
+    input.cursor = graphemes(input.value).length;
+    this.renameInput = input;
+    this.redraw();
+  }
+
   showWorkspaceBuffer() { if (!this.workspacePanel) this.workspacePanel = new WorkspacePanel(this); this.openFullBuffer(this.workspacePanel); this.workspacePanel.load(); }
   /** Open a local file path in the workspace panel's preview pane. */
   openWorkspaceFile(path) {
@@ -4476,11 +5212,7 @@ export class App {
   }
   showSettingsBuffer() { if (!this.settingsPanel) this.settingsPanel = new SettingsPanel(this); this.openFullBuffer(this.settingsPanel); this.settingsPanel.load(); }
   showModelsBuffer() { if (!this.modelPanel) this.modelPanel = new ModelPanel(this); this.openFullBuffer(this.modelPanel); this.modelPanel.load(); }
-  showSubagentBuffer() {
-    if (!this.currentSession) { this.toast("先打开一个会话"); return; }
-    if (!this.subagentPanel) this.subagentPanel = new SubagentPanel(this);
-    this.openFullBuffer(this.subagentPanel); this.subagentPanel.load(this.currentSession);
-  }
+  showSubagentBuffer() { this.setTab("subagent"); }
   showSkillsBuffer() {
     if (!this.currentSession) { this.toast("先打开一个会话"); return; }
     if (!this.skillsPanel) this.skillsPanel = new SkillsPanel(this);
@@ -4512,7 +5244,7 @@ export class App {
     else this.toast("先打开一个会话");
   }
 
-  showJobs() { this.overlay = new JobsPanel(this); this.refreshSubagentStats(); this.redraw(); }
+  showJobs() { this.setTab("tasks"); }
   async refreshSubagentStats(sessionId = this.currentSession) {
     if (!sessionId) return;
     try {
@@ -4523,8 +5255,8 @@ export class App {
       if (sessionId === this.currentSession) this.redraw();
     } catch {}
   }
-  showQueue() { this.overlay = new QueuePanel(this); this.redraw(); }
-  showGoal() { this.overlay = buildGoalPopup(this); this.redraw(); }
+  showQueue() { this.setTab("tasks"); }
+  showGoal() { this.overlay = new GoalPanel(this); this.focus(this.overlay); this.redraw(); }
   showModePicker() { this.overlay = buildModePicker(this); this.redraw(); }
   showThemePicker() { this.overlay = new ThemePickerBuffer(this); this.redraw(); }
 
@@ -4640,17 +5372,20 @@ export class App {
     this.popup = null;
     this.activePrompt = null;
     this.promptQueue = [];
-    for (const p of [this.workspacePanel, this.trajectoryPanel, this.settingsPanel, this.modelPanel, this.subagentPanel, this.skillsPanel]) {
+    for (const p of [this.workspacePanel, this.trajectoryPanel, this.settingsPanel, this.modelPanel, this.subagentPanel, this.skillsPanel, this.subagentPane, this.tasksPane]) {
       if (p?.dispose) { try { p.dispose(); } catch {} }
     }
     this.workspacePanel = this.trajectoryPanel = this.settingsPanel = this.modelPanel = this.subagentPanel = this.skillsPanel = null;
+    this.subagentPane = this.tasksPane = null;
     this.chat.cache.clear();
     this.chat.nodes = [];
     this.chat.collapsedBlocks.clear();
     this.chat.expanded.clear();
     this.chat.queueRebuild();
     this.chat.view.anchorLock = null;
+    this.mainTab = "chat";
     this.mode = "chat";
+    this.focusedWindow = "main";
     this.focus(this.chat);
     this.toast("正在重新加载…");
     await this.refreshSessions();
@@ -4809,21 +5544,28 @@ export class App {
   #runBinding(id, slot) {
     switch (id) {
       case "sessionFilter": this.startSearch(); this.redraw(); return true;
-      case "panel": this.overlay = new ControlPanel(this, { startPage: 0 }); this.redraw(); return true;
-      case "panePrev": this.focusPane(-1); return true;
-      case "paneNext": this.focusPane(1); return true;
+      case "panel":
+        this.focusBeforePanel = this.focused; // prefix ? 帮助回到此场景
+        this.overlay = new ControlPanel(this, { startPage: 0 });
+        this.redraw();
+        return true;
+      case "help": this.showHelp(); return true;
+      case "panePrev": this.focusWindow(-1); return true;
+      case "paneNext": this.focusWindow(1); return true;
+      case "tabNext": this.#tabCycle(1); return true;
+      case "tabPrev": this.#tabCycle(-1); return true;
       case "permissionRotate": this.rotatePermission(); return true;
       case "editConfig": this.editConfigFile(); return true;
       case "quit": this.stop(); return true;
       case "model": this.overlay = buildModelPicker(this); this.redraw(); return true;
-      case "trajectory": this.setMode("trajectory"); return true;
-      case "workspace": this.showWorkspaceBuffer(); return true;
+      case "trajectory": this.setTab("trajectory"); return true;
+      case "workspace": this.showWorkspacePicker(); return true;
       case "settings": this.showSettingsBuffer(); return true;
-      case "subagent": this.showSubagentBuffer(); return true;
+      case "subagent": this.setTab("subagent"); return true;
       case "skills": this.showSkillsBuffer(); return true;
       case "goal": this.showGoal(); return true;
-      case "jobs": this.showJobs(); return true;
-      case "queue": this.showQueue(); return true;
+      case "jobs": this.setTab("tasks"); return true;
+      case "queue": this.setTab("tasks"); return true;
       case "busyEnter": {
         const next = busyEnter() === "queue" ? "steer" : "queue";
         saveTuiConfig({ busyEnter: next });
@@ -4834,7 +5576,7 @@ export class App {
       case "stepJump": this.quickJumpStep(); return true;
       case "sidebar": this.toggleSidebar(); return true;
       case "addWorkspace": this.addWorkspace(); return true;
-      case "commandPalette": this.overlay = new ControlPanel(this, { startPage: 1 }); this.redraw(); return true;
+      case "commandPalette": this.overlay = new ControlPanel(this, { startPage: 2 }); this.redraw(); return true;
       case "modePicker": this.showModePicker(); return true;
       case "themePicker": this.showThemePicker(); return true;
       case "logoPicker": this.showLogoPicker(); return true;
@@ -4901,27 +5643,84 @@ export class App {
   }
 
   #modeTabs() {
-    // Ctrl+Left/Right pane targets. The other panels are full-screen buffers.
+    // Main-window tab strip: 对话 | 轨迹 | 子代理 | 后台任务 (Shift+Tab cycles).
     return [
       ["chat", "对话"],
       ["trajectory", "轨迹"],
+      ["subagent", "子代理"],
+      ["tasks", "后台任务"],
     ];
   }
 
+  /** Draw the split-tree chrome: the focused main leaf keeps its real content
+   *  (rendered above); every OTHER leaf gets a faint placeholder cell with its
+   *  window id + short session, and the separators get border chars. */
+  #renderSplitOverlay(s) {
+    const map = this.#layoutLeaves();
+    const leaves = this.#leaves();
+    const focused = this.focusedLeaf ?? (this.focusedWindow === "list" ? this.#leafList() : this.#mainLeaves()[0]);
+    // separators: for each split node, draw the border line between a and b
+    const drawSep = (node, rect) => {
+      if (node.type === "leaf") return;
+      const border = 1;
+      if (node.dir === "right" || node.dir === "left") {
+        const total = Math.max(2, rect.w - border);
+        const aW = Math.max(1, Math.floor(total / 2));
+        const x = rect.x + aW;
+        for (let y = Math.max(0, rect.y); y < rect.y + rect.h; y++) s.put(x, y, "│", { fg: T.BORDER });
+      } else {
+        const total = Math.max(2, rect.h - border);
+        const aH = Math.max(1, Math.floor(total / 2));
+        const y = rect.y + aH;
+        for (let x = Math.max(0, rect.x); x < rect.x + rect.w; x++) s.put(x, y, "─", { fg: T.BORDER });
+      }
+      drawSep(node.a, { ...rect, ...(node.dir === "right" || node.dir === "left" ? { w: Math.max(1, Math.floor(total / 2)) } : { h: Math.max(1, Math.floor(total / 2)) }) });
+      drawSep(node.b, { ...rect, ...(node.dir === "right" || node.dir === "left" ? { x: rect.x + (node.dir === "right" ? Math.max(1, Math.floor(total / 2)) + border : 0), w: Math.max(1, total - Math.floor(total / 2)) } : { y: rect.y + (node.dir === "down" ? Math.max(1, Math.floor(total / 2)) + border : 0), h: Math.max(1, total - Math.floor(total / 2)) }) });
+    };
+    const rootRect = { x: this.sidebarVisible ? this.sidebarWidth : 0, y: 1, w: this.mainAreaRect().w, h: this.mainAreaRect().h };
+    if (leaves.length > 2) drawSep(this.winTree, rootRect);
+    // placeholders for non-focused leaves
+    let n = 1;
+    for (const leaf of leaves) {
+      if (leaf.kind === "main") {
+        const rect = map.get(leaf);
+        if (leaf === focused || !rect || rect.w < 8 || rect.h < 3) continue;
+        const label = `W${n} · ${leaf.sessionId ? leaf.sessionId.slice(0, 8) : "空白会话"} · Shift+Tab/Ctrl+←→ 切换`;
+        s.fillRect(rect.x + 1, rect.y, rect.x + rect.w - 1, rect.y + rect.h - 1, " ", { bg: T.BG });
+        s.text(rect.x + 2, rect.y + 1, truncate(label, Math.max(0, rect.w - 4)), { fg: T.FAINT, bg: T.BG });
+      }
+      n++;
+    }
+    // the focused leaf also gets a small W# marker at its top-left
+    const frect = map.get(focused);
+    if (frect && focused?.kind === "main") {
+      const idx = leaves.indexOf(focused) + 1;
+      s.text(frect.x + 1, frect.y, `W${idx}`, { fg: T.DIM, bg: T.PANEL });
+    }
+  }
+
   #renderTabBar(s) {
     const x = this.sidebarVisible ? this.sidebarWidth : 0;
     const w = this.screen.w - x;
     s.fillRect(x, 0, x + w - 1, 0, " ", { bg: T.PANEL });
     const tabs = [...this.#modeTabs()];
     let tx = x;
-    const sidebarFocused = this.focused === this.sidebar;
     for (const [id, label] of tabs) {
-      const sel = !sidebarFocused && id === this.mode;
+      const sel = id === this.mainTab;
       const seg = ` ${label} `;
-      s.text(tx, 0, seg, { fg: sel ? T.SELFG : T.DIM, bg: sel ? T.ACCENT : T.PANEL, attrs: sel ? 1 : 0 });
+      // The active tab stays highlighted even while the list window is focused;
+      // the strip simply indicates which tab would be active in the main window.
+      const fg = sel ? T.SELFG : T.DIM;
+      const bg = sel ? T.ACCENT : T.PANEL;
+      s.text(tx, 0, seg, { fg, bg, attrs: sel ? 1 : 0 });
       tx += strWidth(seg);
     }
-    if (this.currentSession == null) s.text(x + w - 16, 0, "未选会话", { fg: T.FAINT, bg: T.PANEL });
+    // Flow the key hint right after the tabs: it never overlaps the sidebar,
+    // and clips at the right edge on narrow mains (Screen.text truncates).
+    const hint = " Shift+Tab 切标签 · Tab/Ctrl+←→ 切窗口 ";
+    s.text(tx, 0, truncate(hint, Math.max(0, x + w - tx)), { fg: T.FAINT, bg: T.PANEL });
+    tx += strWidth(hint);
+    if (this.currentSession == null) s.text(tx + 1, 0, "未选会话", { fg: T.FAINT, bg: T.PANEL });
   }
 
   #clickTab(px) {
@@ -4939,6 +5738,115 @@ export class App {
     return false;
   }
 
+  /** Whether an editor (INSERT) surface owns the keyboard: the chat input or a
+   *  pane's own message input (subagent/tasks inputMode). */
+  #inInsertMode() {
+    if (this.focused === this.chat?.input) return true;
+    return this.focused?.inputMode === true;
+  }
+
+  /** Structural window/tab keys (NORMAL mode only; see dispatch). Returns true
+   *  when handled so the key never reaches a binding or the focused widget.
+   *  Ctrl+Left/Right (panePrev/paneNext) are editable bindings and route through
+   *  the binding matcher to focusWindow; here we only own Tab/Backtab. */
+  #handleStructuralKey(ev) {
+    if (ev.type !== "key") return false;
+    if (this.#inInsertMode()) return false; // INSERT keeps editor semantics
+    if (ev.name === "tab" && !ev.ctrl && !ev.alt) {
+      // Toggle focused window: list ↔ main (fast toggle, same as the cycle).
+      if (this.sidebarVisible) this.focusWindow(1);
+      else this.setFocusedWindow("main");
+      return true;
+    }
+    if (ev.name === "backtab" && !ev.ctrl && !ev.alt) {
+      // Cycle the main-window tabs. From the list window, focus main first.
+      if (this.focusedWindow !== "main") this.setFocusedWindow("main");
+      this.cycleTab(1);
+      return true;
+    }
+    return false;
+  }
+
+  /** Tab cycling shared by Shift+Tab (structural) and Ctrl+H/L bindings:
+   *  from the list window, focus the main window first. */
+  #tabCycle(delta) {
+    if (this.focusedWindow !== "main") this.setFocusedWindow("main");
+    this.cycleTab(delta);
+    return true;
+  }
+
+  // ---- chained prefix layers (nvim-style pending keys) ----
+
+  /** Generic pending-layer tables. The p table is the first user; future
+   *  g/z tables register here too. Entries: (ev) => run. */
+  #prefixTables() {
+    const k = prefixKeys();
+    return {
+      // 主表：Ctrl+Space 面板首屏与 NORMAL 前缀层共用（同一张表，同一语义）
+      main: {
+        hint: `${k.search}=搜索 ${k.model}=模型 ${k.theme}=主题 ${k.history}=历史 ${k.rewind}=回退 ${k.config}=配置 ${k.help}=帮助 ${k.editor}=编辑 ${k.permission}=权限 ${k.panes}=窗格 · Esc 取消`,
+        entries: {
+          [k.search]: () => { this.closeOverlay(); this.startSearch(); this.redraw(); },
+          [k.model]: () => { this.closeOverlay(); this.overlay = buildModelPicker(this); this.redraw(); },
+          [k.theme]: () => { this.closeOverlay(); this.showThemePicker(); },
+          [k.history]: () => { this.closeOverlay(); this.showHistorySearch(); },
+          [k.rewind]: () => { this.closeOverlay(); this.showRewindPicker(); },
+          [k.config]: () => { this.closeOverlay(); this.editConfigFile(); },
+          [k.help]: () => { this.closeOverlay(); this.showHelp(this.focusBeforePanel ?? null); },
+          [k.editor]: () => { this.closeOverlay(); this.editExternal(); },
+          [k.permission]: () => { this.closeOverlay(); this.showPermissionPicker(); },
+          [k.panes]: () => { this.closeOverlay(); this.armPrefix("p"); },
+        },
+      },
+      p: {
+        hint: "p · r=右 l=左 u=上 n=下 c=关窗 · Esc/2s 取消",
+        entries: {
+          r: () => this.splitWindow("right"),
+          l: () => this.splitWindow("left"),
+          u: () => this.splitWindow("up"),
+          n: () => this.splitWindow("down"),
+          c: () => this.closeWindow(),
+        },
+      },
+    };
+  }
+  /** Arm a pending layer programmatically (e.g. the panel chaining into p). */
+  armPrefix(key) {
+    const table = this.#prefixTables()[key];
+    if (!table) return false;
+    this.pendingPrefix = { table, key, timer: null };
+    this.pendingPrefix.timer = setTimeout(() => {
+      if (this.pendingPrefix?.key === key) this.#cancelPrefix();
+    }, this.prefixTimeoutMs);
+    this.redraw();
+    return true;
+  }
+  #handlePrefixKey(ev) {
+    if (ev.type !== "key") return false;
+    const pending = this.pendingPrefix;
+    if (pending) {
+      if (ev.name === "escape") { this.#cancelPrefix(); return true; }
+      const entry = pending.table.entries[ev.key];
+      if (entry) { pending.table; this.#cancelPrefix(); entry(ev); return true; }
+      this.#cancelPrefix("已取消 p 前缀");
+      return true;
+    }
+    // Arm only from a main window, not in INSERT (list window: p = preview).
+    if (ev.name === "char" && ev.key === "p" && !ev.ctrl && !ev.alt && !ev.shift
+        && this.focusedWindow === "main" && !this.#inInsertMode()) {
+      this.armPrefix("p");
+      return true;
+    }
+    return false;
+  }
+  #cancelPrefix(message = "") {
+    if (!this.pendingPrefix) return;
+    if (this.pendingPrefix.timer) clearTimeout(this.pendingPrefix.timer);
+    this.pendingPrefix = null;
+    if (message) this.toast(message);
+    this.redraw();
+  }
+
   // ---- dispatch ----
 
   onEvent(ev) {
@@ -5045,27 +5953,54 @@ export class App {
       return;
     }
 
+    if (this.#handlePrefixKey(ev)) return;
     // tab bar clicks (row 0 of the main area)
     if (ev.type === "mouse" && ev.kind === "press" && ev.button === 0 && ev.y === 0 && ev.x >= (this.sidebarVisible ? this.sidebarWidth : 0)) {
       if (this.#clickTab(ev.x)) { this.redraw(); return; }
     }
     // mouse routes by position (click = focus + dispatch)
-    if (this.mode !== "chat") {
-      if (ev.type === "mouse" && this.sidebarVisible && this.sidebar.inside(ev.x, ev.y)) {
-        if (this.focused !== this.chat.input) this.focus(this.sidebar); // INSERT exits only via Esc
-        if (this.sidebar.onMouse(ev)) this.redraw();
-        return;
-      }
-      const panel = this.panelForMode();
-      const paneSwitch = ev.type === "key" && ev.ctrl && (ev.name === "left" || ev.name === "right");
-      if (panel && this.focused !== this.sidebar && !paneSwitch) {
+    if (this.mainTab !== "chat") {
+      const panel = this.paneWidget();
+      if (panel && this.focused === panel) {
+        // The pane owns keyboard while it is focused. Intercept the pane-level
+        // close (q / Esc) and insert (i) keys BEFORE delegating — the panes'
+        // own close handlers would close an overlay; here they switch back to
+        // the chat tab. Tab/Shift+Tab (window/tab layer) and Ctrl+Left/Right
+        // (panePrev/paneNext) never leak into a pane: they fall through to the
+        // global shortcuts below and are switched at the window/tab layer.
+        if (ev.type === "key") {
+          if (ev.name === "escape" || (ev.name === "char" && ev.key === "q" && !ev.ctrl)) {
+            this.setTab("chat");
+            this.redraw();
+            return;
+          }
+          if (bindingMatchFor(ev, keyBindings(), false, ["insert"])?.id === "insert") {
+            // In the 子代理 pane, i belongs to the pane (focus its message
+            // input); elsewhere i returns to chat and focuses the input.
+            if (this.mainTab !== "subagent") {
+              this.setTab("chat");
+              this.focus(this.chat.input);
+              this.redraw();
+              return;
+            }
+          }
+        } else if (ev.type === "text" && graphemes(ev.text).length === 1) {
+          // Legacy terminals deliver q/i as text; mirror the key intercepts.
+          const t = graphemes(ev.text)[0].toLowerCase();
+          if (t === "q") { this.setTab("chat"); this.redraw(); return; }
+          if (t === "i") { this.setTab("chat"); this.focus(this.chat.input); this.redraw(); return; }
+        }
         const handled = ev.type === "key" || ev.type === "text" || ev.type === "paste" ? panel.onKey(ev) : panel.onMouse(ev);
         if (handled) { this.redraw(); return; }
-        // A visible modal panel owns non-global text/paste even when it declines
-        // the event; never leak it into the hidden chat/Input behind the panel.
+        // A visible panel owns non-global text/paste even when it declines
+        // the event; never leak it into the hidden chat/Input behind it.
         if (ev.type === "text" || ev.type === "paste") { this.redraw(); return; }
+        // unhandled key events fall through to global shortcuts
+      } else if (ev.type === "mouse" && this.sidebarVisible && this.sidebar.inside(ev.x, ev.y)) {
+        if (this.focused !== this.chat.input) this.focus(this.sidebar); // INSERT exits only via Esc
+        if (this.sidebar.onMouse(ev)) this.redraw();
+        return;
       }
-      // unhandled key events fall through to global shortcuts
     }
     if (ev.type === "mouse") {
       // input drag-selection: the gesture continues across motion events
@@ -5075,6 +6010,24 @@ export class App {
         if (this.chat.input.onMouse(ev)) this.redraw();
         return;
       }
+      // Split-window divider drag: press within ±1 of a split separator.
+      if (this.winTree && ev.kind === "press" && ev.button === 0 && !this.draggingDivider) {
+        const sep = this.#hitSplitSeparator(ev.x, ev.y);
+        if (sep) { this.#splitDrag = sep; this.redraw(); return; }
+      }
+      if (this.#splitDrag) {
+        const sd = this.#splitDrag;
+        if (ev.kind === "drag" && ev.button === 0) {
+          const { node, rect } = sd;
+          const horizontal = node.dir === "right" || node.dir === "left";
+          const span = horizontal ? Math.max(2, rect.w - 1) : Math.max(2, rect.h - 1);
+          const pos = horizontal ? (ev.x - rect.x) : (ev.y - rect.y);
+          node.ratio = Math.min(0.8, Math.max(0.2, pos / span));
+          this.layout(); this.redraw();
+          return;
+        }
+        if (ev.kind === "release" && ev.button === 0) { this.#splitDrag = null; this.redraw(); return; }
+      }
       // Draggable sidebar divider: press on the boundary column (±1) starts a
       // resize; drag events (motion flag) update the width live.
       const divX = this.sidebarVisible ? this.sidebarWidth : -1;
@@ -5164,6 +6117,13 @@ export class App {
         this.redraw();
         return;
       }
+      // Structural window/tab keys (NORMAL mode only — INSERT keeps editor
+      // semantics: Tab still completes in the input, Ctrl+Left/Right are editor
+      // motions). Tab toggles the focused window (list ↔ main); Backtab cycles
+      // the main-window tabs (chat → trajectory → subagent → tasks). Ctrl+Left/
+      // Right (panePrev/paneNext) are editable bindings matched below and also
+      // switch the focused window.
+      if (this.#handleStructuralKey(ev)) return;
       // Editable global bindings: two slots per function, resolved by the
       // keybindings registry (tui-config.json keyBindings.<id>).
       const hit = bindingMatchFor(ev, keyBindings(), false, KEYBINDING_ORDER);
@@ -5188,8 +6148,8 @@ export class App {
         // Esc in NORMAL mode interrupts a running turn (one press, regardless
         // of focus); otherwise it steps back toward the chat view.
         if (this.#interruptIfRunning()) return;
-        if (this.focused === this.sidebar) { this.focus(this.chat); this.redraw(); }
-        else if (this.mode !== "chat") this.setMode("chat");
+        if (this.focused === this.sidebar) { this.setFocusedWindow("main"); this.focus(this.chat); this.redraw(); }
+        else if (this.mainTab !== "chat") this.setTab("chat");
         return;
       }
     }
@@ -5970,6 +6930,7 @@ export class App {
       if (this.popup) this.popup.render(s);
       if (this.menu) this.menu.render(s);
       if (this.overlay) this.overlay.render(s);
+      if (this.sidebar.preview.open) this.#renderPreviewCard(s);
       this.#renderToast(s);
       this.term.output.write(s.render() + "\x1b[?25l");
       return;
@@ -5982,8 +6943,14 @@ export class App {
       for (let y = 1; y < s.h - 1; y++) s.put(this.sidebar.w - 1, y, "│", { fg: T.BORDER });
     }
     const modePanel = this.panelForMode();
-    if (modePanel) modePanel.render(s);
-    else this.chat.render(s);
+    if (modePanel) {
+      // The active pane occupies exactly the chat-area rect; ensure it is
+      // relaid there (it may have diverged after the last resize).
+      const r = this.mainAreaRect();
+      if (modePanel.relayout) modePanel.relayout(r.x, r.y, r.w, r.h);
+      modePanel.render(s);
+    } else this.chat.render(s);
+    if (this.winTree) this.#renderSplitOverlay(s);
 
     // footer: multi-row powerline-style status
     const t = this.titleOf();
@@ -6002,6 +6969,7 @@ export class App {
     // Ctrl+Space (command panel) earns the prime spot right after the mode
     // badge — the shortcut every session needs to discover first.
     row0.left.push({ t: " Ctrl+Space 面板 ", fg: T.DIM, bg: T.STATUSBG });
+    if (this.pendingPrefix) row0.left.push({ t: ` ${this.pendingPrefix.table.hint} `, fg: 0x000000, bg: T.WARN, bold: true });
     // Left badge: the session's permission/mode (e.g. "工作区写入/创造模式"),
     // which is far more meaningful than a static "工作区" label.
     const perm = this.projections.permissions?.currentValue;
@@ -6013,8 +6981,10 @@ export class App {
     if (rawGoal && !["complete", "completed", "cleared"].includes(rawGoal.phase)) {
       row0.left.push({ t: ` 🎯 ${truncate(rawGoal.objective ?? "目标", 14)} · Ctrl+G `, fg: 0x000000, bg: T.WARN, bold: true });
     }
-    if (this.sidebarVisible) row0.left.push({ t: " " + truncate(t || "（未选择会话）", 40) + " ", fg: T.TXT, bg: T.STATUSBG });
-    else row0.left.push({ t: " " + truncate(t || "（未选择会话）", 40) + " ", fg: T.TXT, bg: T.STATUSBG });
+    const winTag = this.winTree ? `W${(this.splitLeaves().indexOf(this.focusedLeaf) + 1) || 1} · ` : "";
+    const titleSeg = winTag + truncate((winTag ? t : t || "（未选择会话）"), 40);
+    if (this.sidebarVisible) row0.left.push({ t: " " + titleSeg + " ", fg: T.TXT, bg: T.STATUSBG });
+    else row0.left.push({ t: " " + titleSeg + " ", fg: T.TXT, bg: T.STATUSBG });
     if (cur?.running) row0.left.push({ t: " ●运行 ", fg: T.OK, bg: T.STATUSBG });
     // session elapsed/start: effective time (model+tool work, not wall clock)
     // right after the session name; start = the earliest event time loaded
@@ -6112,12 +7082,12 @@ export class App {
       });
       // Ctrl+J belongs beside the two activity summaries it opens, not alone
       // at the far-right edge (especially once the queue badge also appears).
-      row2.left.push({ t: " Ctrl+J 任务/子代理 ", fg: T.DIM, bg: T.STATUSBG });
+      row2.left.push({ t: " 任务/子代理 · Ctrl+Space ", fg: T.DIM, bg: T.STATUSBG });
       if (sub) row2.left.push({
         t: ` ◇ ${truncate(sub.label ?? sub.mode ?? "子代理", 20)} `,
         fg: subStats.running > 0 ? T.WARN : subStats.completed > 0 ? T.OK : T.FAINT, bg: T.STATUSBG,
       });
-      if(this.queueItems.length)row2.left.push({t:` 有${this.queueItems.length}条命令正在排队 Ctrl+N查看详情 `,fg:0x000000,bg:T.WARN,bold:true});
+      if(this.queueItems.length)row2.left.push({t:` 排队${this.queueItems.length}条 · Ctrl+Space→任务 查看 `,fg:0x000000,bg:T.WARN,bold:true});
       rows.push(row2);
     }
     this.status.rows = rows;
@@ -6144,6 +7114,32 @@ export class App {
     this.term.output.write(out + tail);
   }
 
+  /** Attached preview card beside the sidebar: purely rendered state, never
+   *  a modal — the tree keeps focus and the card follows the selection. */
+  #renderPreviewCard(s) {
+    const p = this.sidebar.preview;
+    const x = this.sidebarWidth + 1;
+    const w = Math.min(34, Math.max(20, this.screen.w - x - 2));
+    const y = 1, h = Math.max(5, this.screen.h - 2);
+    s.fillRect(x, y, x + w - 1, y + h - 1, " ", { bg: T.PANEL });
+    s.box(x, y, x + w - 1, y + h - 1, { fg: T.ACCENT, bg: T.PANEL }, ` 预览 · ${truncate(p.title ?? "", 14)} · Tab 关闭`);
+    const rows = h - 4;
+    if (p.loading) { s.text(x + 2, y + 2, "加载中…", { fg: T.FAINT, bg: T.PANEL }); }
+    else if (p.error) { s.text(x + 2, y + 2, truncate(`读取失败: ${p.error}`, w - 6), { fg: T.ERR, bg: T.PANEL }); }
+    else if (!p.lines.length) { s.text(x + 2, y + 2, "（还没有往来记录）", { fg: T.FAINT, bg: T.PANEL }); }
+    else {
+      for (let i = 0; i < rows; i++) {
+        const [kind, text] = p.lines[i];
+        if (!kind) break;
+        const fg = kind === "你" ? T.OK : kind === "AI" ? T.TXT : T.PURPLE;
+        s.text(x + 2, y + 2 + i, kind, { fg, bg: T.PANEL, bold: kind === "你", attrs: kind === "你" ? 1 : 0 });
+        s.text(x + 5, y + 2 + i, truncate(text, w - 7), { fg: T.TXT, bg: T.PANEL });
+      }
+      if (p.lines.length > rows) s.text(x + w - 4, y + h - 1, `…${p.lines.length - rows} 更多`, { fg: T.FAINT, bg: T.PANEL });
+    }
+    s.text(x + 2, y + h - 1, "↑↓ 随选区更新 · Tab 关闭", { fg: T.FAINT, bg: T.PANEL });
+  }
+
   #renderToast(s) {
     if (!this.toastMsg) return;
     // Toasts land in the LOWER half (just above the input/footer) where the