dsh-quick-toc 0.6.3 → 0.7.0

package/lib/client.js

@@ -13,13 +13,65 @@ window.__ModuleLoader__.load({
 
     // ---------- constants ----------
     var PANEL_WIDTH = 288;
-    // Very high base so the portal-rendered panel (top-level stacking context)
-    // always sits above DSH content and its transcript width handles.
-    // Panel layer: above the app's popovers (z 100) and the transcript width
-    // handles (z 8), but BELOW DSH's modal layer (settings/image viewer, z 1000)
-    // so opening settings covers the panel instead of the panel floating on top.
-    var Z_BASE = 500;
+    // ---------- layers ----------
+    // This plugin floats over the conversation, so it belongs in the ONE free band
+    // of the stacking order: above the app's own content, below everything that
+    // claims to be an overlay. Outranking other overlays is not a neutral choice —
+    // the previous flat z 500 painted the handles and the panel over other plugins'
+    // dialogs, and anything sitting on a dialog's close button makes that dialog
+    // impossible to dismiss.
+    //
+    // Measured neighbours (dsh-web-frontend/dist CSS plus every @deepseek-ai
+    // dsh-client-ui-* bundle and the installed plugins — values, not guesses):
+    //    0-6    trajectory view internals
+    //    7-10   conversation: sticky composer seat 7, transcript width grips 8
+    //           ([data-width-handle], width cap 40px, visible only on hover),
+    //           composer with a trigger menu 9, workspace row 10
+    //    11     layout frame
+    //    20     layout overlay layer (pointer-events:none, holds floating chrome)
+    //    25     dsh-better-sidebar panel host (its panels live inside it)
+    //    30     dsh-client-ui-cordis panel
+    //    40/60  right sidebar fullscreen panel / float host
+    //    100    menus and popovers (six packages)
+    //    200    dsh-context modal mask + card (.lc-modal-backdrop, .lc-ov-backdrop)
+    //    1000   DSH modals (settings, image viewer)
+    //    1100   tooltips and the app's top overlays
+    // So the whole band from 12 to 18 is free, and it is exactly where a reading
+    // aid belongs: above the transcript (including the width grips, which would
+    // otherwise take the pointer over our left edge) and below everything that is
+    // an overlay, the app's own floating chrome included.
+    var Z_HANDLE = 12; // the two edge handles
+    var Z_PANEL = 14;  // the docked panel
+    var Z_SHEET = 16;  // the curtain, which replaces the docked panel while it is up
+    var Z_HOVER = 18;  // hover preview card: above both, still inside the free band
+    var Z_ERROR = 32;  // crash banner: above our layers and the app's chrome, below
+                       // DSH's popovers (100) and modals (1000)
     var EASE = "cubic-bezier(0.22, 0.9, 0.3, 1)"; // smooth non-linear slide
+    // How long the docked panel takes to get out of the curtain's way. It is the
+    // panel's own collapse duration (0.28s) plus a hair, so the curtain's drop only
+    // starts once the panel has actually finished travelling.
+    var PANEL_TUCK_MS = 300;
+    // The row-end control ("jump to the end of this section") lives in the last 24px
+    // of a row (a 20px button inset 4px). Every box a row can paint — the hover
+    // highlight, a group header's hover label, the right-aligned context text — stops
+    // END_ZONE from the row's right edge, so such a box can never touch the round
+    // backdrop the button paints on hover, let alone overlap it: the reader saw the
+    // two "fight" on long group headers, the label's box running right up to the
+    // circle.
+    var END_ZONE = 32;
+    // How long the collapsed edge handle takes to slip back into the edge when it is
+    // the thing that was clicked. The panel's own slide waits exactly this long, so the
+    // two motions are sequential instead of crossing over.
+    var EDGE_OUT_MS = 170;
+    // Same idea for the curtain handle: it is pressed flat and held for a beat before it
+    // leaves the tree, otherwise the flatten had no frame to play on (the curtain used
+    // to open and unmount it in the same commit). It covers the whole 200ms press — the
+    // press is deliberately slow-then-fast (see the element), so the curtain must not
+    // start before it has finished.
+    var DROP_OUT_MS = 220;
+    // Width of the curtain's search column: it is pushed in from the right edge and
+    // pushes the outline left by exactly this much while a search is up.
+    var SHEET_SEARCH_W = 360;
 
     // ---------- UI strings ----------
     // Every string the panel renders goes through T(). 0.5.0 ships the Chinese
@@ -35,16 +87,41 @@ window.__ModuleLoader__.load({
         "handle.dockRight": "移到右侧",
         "handle.collapse": "收起",
         "handle.expand": "展开大纲",
+        "a11y.list": "大纲列表：上下键移动，回车跳转，Esc 收起面板",
+        "a11y.hits": "第 {n} 个命中，共 {total} 个",
+        "a11y.results": "共 {n} 条结果",
+        "a11y.loading": "正在检索",
+        "a11y.crossEmpty": "没有结果",
+        "sheet.open": "全屏大纲（从顶部展开一层幕布）",
+        "sheet.openHandle": "展开幕布：全宽大纲从顶部落下",
+        "sheet.close": "收起幕布",
+        "sheet.noDrag": "幕布铺满对话区，不能拖动尺寸或位置",
         "levels.tip": "标题层级筛选",
         "levels.show": "显示 H",
         "levels.hide": "隐藏 H",
+        "levels.offInQuestions": "只看提问时没有标题行，层级筛选不生效",
+        "view.questions.tipOn": "当前：只看提问（每轮只显示时间与你的提问）。点击回到完整大纲",
+        "view.questions.tipOff": "当前：完整大纲。点击只看提问（每轮只显示时间与你的提问）",
         "search.open": "搜索标题",
         "search.word": "搜索",
         "search.tail": "，回车定位…",
         "search.scope.title": "标题",
         "search.scope.full": "全文",
+        "search.scope.cross": "会话",
         "search.scope.tipTitle": "当前：仅搜索标题。点击切换为全文搜索",
-        "search.scope.tipFull": "当前：全文搜索。点击切换为仅标题",
+        "search.scope.tipFull": "当前：全文搜索。点击切换为跨会话检索",
+        "search.scope.tipCross": "当前：跨会话检索（用宿主的全文索引搜所有会话的消息正文）。点击回到仅搜索标题",
+        "search.cross.loading": "检索中…",
+        "search.cross.empty": "其他会话里没有匹配",
+        "search.cross.error": "检索失败：",
+        "search.cross.unavailable": "宿主没有提供跨会话检索接口",
+        "search.cross.disabled": "宿主没开启会话全文索引（session-query 的 openAt 被设成 never），跨会话检索暂时用不了",
+        "search.cross.more": "宿主一次最多返回 20 条，可能还有更多",
+        "search.cross.note": "跨会话检索走宿主的全文索引，只搜消息正文，模糊开关对它不生效",
+        "search.cross.hidden": "另有 {n} 条命中属于已归档、子会话或当前不在列表里的会话，已略过（这些会话现在打不开）",
+        "search.cross.goneHit": "这条命中所在的会话现在打不开（已归档或不在会话列表里），已跳过",
+        "search.cross.switched": "已切换到该会话，同关键词已开始在本会话内查找",
+        "search.cross.noSpot": "该会话已打开，但这处位置还没加载，没能跳过去；可用搜索框继续查找",
         "search.fuzzy": "模糊",
         "search.fuzzy.tipOn": "模糊匹配已开启：允许关键字中间夹少量其他文字，命中更多",
         "search.fuzzy.tipOff": "模糊匹配已关闭：只匹配连续的文字。点击开启",
@@ -54,9 +131,12 @@ window.__ModuleLoader__.load({
         "hint.bottom": "已经到底了",
         "outline.bottom": "回到底部",
         "turn.jumpReply": "跳转到该回合的模型回答开头",
+        "row.end": "跳到本节末尾",
         "turn.jumpTurn": "跳转到该回合开头",
         "turn.unloaded": "未加载",
         "turn.loadTip": "点击加载这个回合并跳转过去",
+        "turn.noMoreHistory": "宿主说这个会话没有更早的历史可翻了（它的翻页窗口已到开头），这一回合加载不出来",
+        "turn.loadFailed": "这个回合没能加载出来（这段历史可能已经不在会话日志里）",
         "turn.failed": "请求失败",
         "turn.jumpFailed": "跳转到该回合的报错位置",
         "time.yesterday": "昨天",
@@ -83,6 +163,8 @@ window.__ModuleLoader__.load({
         "settings.off": "关闭",
         "settings.fuzzy": "模糊搜索",
         "settings.hover": "悬停预览卡片",
+        "settings.remember": "记住阅读位置",
+        "settings.remember.tip": "开启后，重新打开某个会话会回到上次读到的那一轮；位置只保存在这台浏览器里",
         "settings.debug": "在控制台打印诊断日志",
         "settings.debug.tip": "开启后控制台会打印一行挂载诊断（宿主能力与跳转加载器状态）",
         "settings.overridden": "已自定义",
@@ -97,16 +179,41 @@ window.__ModuleLoader__.load({
         "handle.dockRight": "Move to the right",
         "handle.collapse": "Collapse",
         "handle.expand": "Expand the outline",
+        "a11y.list": "Outline list: arrow keys move, Enter jumps, Esc collapses the panel",
+        "a11y.hits": "Match {n} of {total}",
+        "a11y.results": "{n} result(s)",
+        "a11y.loading": "Searching",
+        "a11y.crossEmpty": "No results",
+        "sheet.open": "Full-width outline (a sheet that drops from the top)",
+        "sheet.openHandle": "Open the curtain: a full-width outline drops from the top",
+        "sheet.close": "Close the sheet",
+        "sheet.noDrag": "The sheet spans the conversation area, so it cannot be dragged or resized",
         "levels.tip": "Heading level filter",
         "levels.show": "Show H",
         "levels.hide": "Hide H",
+        "levels.offInQuestions": "Questions-only view has no heading rows, so the level filter does not apply",
+        "view.questions.tipOn": "Questions only: each turn shows just its time and your prompt. Click for the full outline",
+        "view.questions.tipOff": "Full outline. Click to show each turn's time and your prompt only",
         "search.open": "Search headings",
         "search.word": "Search",
         "search.tail": ", Enter to jump…",
         "search.scope.title": "Title",
         "search.scope.full": "Full text",
+        "search.scope.cross": "Session",
         "search.scope.tipTitle": "Titles only. Click for full-text search",
-        "search.scope.tipFull": "Full text. Click for titles only",
+        "search.scope.tipFull": "Full text. Click for cross-session search",
+        "search.scope.tipCross": "Cross-session search (the host's full-text index over every session's message text). Click to go back to titles only",
+        "search.cross.loading": "Searching…",
+        "search.cross.empty": "No matches in other sessions",
+        "search.cross.error": "Search failed: ",
+        "search.cross.unavailable": "The host does not expose cross-session search",
+        "search.cross.disabled": "This deployment keeps the host's full-text session index off (session-query openAt: never), so cross-session search is unavailable",
+        "search.cross.more": "The host returns at most 20 results; more may exist",
+        "search.cross.note": "Cross-session search reads the host's full-text index over message text; the fuzzy switch does not apply",
+        "search.cross.hidden": "Also skipped {n} hit(s) from archived, subagent or unlisted sessions — they cannot be opened",
+        "search.cross.goneHit": "That hit's session cannot be opened right now (archived or not in the session list); skipped",
+        "search.cross.switched": "Switched to that session and started the same keyword search here",
+        "search.cross.noSpot": "The session is open, but that spot is not loaded yet — the jump was skipped; keep searching in the box",
         "search.fuzzy": "Fuzzy",
         "search.fuzzy.tipOn": "Fuzzy matching is on: a few other characters may sit between the keywords, so more matches hit",
         "search.fuzzy.tipOff": "Fuzzy matching is off: only contiguous text matches. Click to turn it on",
@@ -116,9 +223,12 @@ window.__ModuleLoader__.load({
         "hint.bottom": "You have reached the end",
         "outline.bottom": "Back to the newest entry",
         "turn.jumpReply": "Jump to the start of this turn's model reply",
+        "row.end": "Jump to the end of this section",
         "turn.jumpTurn": "Jump to the start of this turn",
         "turn.unloaded": "Not loaded",
         "turn.loadTip": "Click to load this turn and jump to it",
+        "turn.noMoreHistory": "The host reports no earlier history left for this session (its page window is already at the start), so this turn cannot be paged in",
+        "turn.loadFailed": "That turn could not be loaded (its history may no longer be in the session log)",
         "turn.failed": "Request failed",
         "turn.jumpFailed": "Jump to this turn's error",
         // NB: "time.beforeYesterday" stays Chinese-only on purpose — English has no
@@ -147,6 +257,8 @@ window.__ModuleLoader__.load({
         "settings.off": "Off",
         "settings.fuzzy": "Fuzzy search",
         "settings.hover": "Hover preview card",
+        "settings.remember": "Remember the reading position",
+        "settings.remember.tip": "When on, reopening a session returns to the turn you were last reading; the position is stored in this browser only",
         "settings.debug": "Print the mount diagnostic to the console",
         "settings.debug.tip": "The console then prints one mount line (host capabilities and jump-loader state)",
         "settings.overridden": "Customized",
@@ -177,6 +289,16 @@ window.__ModuleLoader__.load({
       if (s === undefined && activeLang !== "zh") s = DICTS.zh[key];
       return s === undefined ? key : s;
     }
+    // Same lookup, with `{name}` placeholders filled in. Kept separate from T so the
+    // host-locale path (which returns a plain string) still works: a translation that
+    // drops a placeholder simply loses that number rather than printing the braces.
+    function Tp(key, params) {
+      var s = T(key);
+      if (typeof s !== "string" || params === undefined || params === null) return s;
+      return s.replace(/\{(\w+)\}/g, function (match, name) {
+        return Object.prototype.hasOwnProperty.call(params, name) ? String(params[name]) : match;
+      });
+    }
     // The host reports the language it resolved for us; `auto` follows it, an explicit
     // preference wins, and an unknown host language falls back to Chinese.
     function setLanguage(pref, hostLang) {
@@ -209,14 +331,15 @@ window.__ModuleLoader__.load({
     // purpose — they describe THIS screen, not the account.
     var NAMESPACE = "dsh-quick-toc";
     // Fields backed by the Host settings document; everything else is localStorage.
-    var HOST_FIELDS = { dock: 1, lang: 1, levels: 1, zoom: 1, handle: 1, fuzzy: 1, hover: 1, debug: 1 };
+    var HOST_FIELDS = { dock: 1, lang: 1, levels: 1, zoom: 1, handle: 1, fuzzy: 1, hover: 1, debug: 1, remember: 1 };
     // The schema defaults (mirrored here for the card's per-field reset and for the
     // one-time import of a 0.5.x install's stored values).
     var DEFAULTS = {
       dock: "left", y: 0, w: 0, h: 0,
       levels: [1, 2, 3, 4, 5, 6],
       zoom: 1, handle: 0.5,
-      fuzzy: false, hover: true, lang: "auto", debug: false
+      fuzzy: false, hover: true, lang: "auto", debug: false,
+      remember: true
     };
     var PREF_KEYS = {
       dock: "dsh-quick-toc.dock.v2",
@@ -229,6 +352,7 @@ window.__ModuleLoader__.load({
       fuzzy: "dsh-quick-toc.fuzzy.v1",
       hover: "dsh-quick-toc.hover.v1",
       lang: "dsh-quick-toc.lang.v1",
+      remember: "dsh-quick-toc.remember.v1",
       debug: "dsh-quick-toc.debug"
     };
     // Writing a field's schema default through the card IS its reset — a value that
@@ -247,6 +371,54 @@ window.__ModuleLoader__.load({
     };
     var OLD_MAX_LEVEL_KEY = "dsh-quick-toc.maxLevel.v1";
     var LEVELS_ALL = [1, 2, 3, 4, 5, 6];
+    // ---- per-session reading position (browser-local, like panelW/H) ----------
+    // One small map in localStorage: sessionId -> { turn, seq, at }. Turn numbers are
+    // the stable coordinate (a node key can disappear with a re-framed log; the turn is
+    // what the host's turn index and the jump loader both speak), and `seq` is the
+    // turn's own start seq — the jump loader needs it to page a turn back in, so a
+    // remembered position outside the loaded window can actually be restored.
+    var READ_POS_KEY = "dsh-quick-toc.readPos.v1";
+    var READ_POS_MAX = 200;
+    // How long a remembered position stays worth resuming. "Where was I" is a
+    // convenience within a working session; coming back hours later to a stale anchor
+    // is how the reader ends up somewhere they did not ask for (they expect the newest
+    // messages). Past this window the position is dropped and the session opens at the
+    // bottom, where the live content is.
+    var READ_POS_TTL_MS = 30 * 60 * 1000;
+    var readPosMap = function () {
+      try {
+        var raw = localStorage.getItem(READ_POS_KEY);
+        var parsed = raw ? JSON.parse(raw) : null;
+        return parsed && typeof parsed === "object" ? parsed : {};
+      } catch (e) { return {}; }
+    };
+    var readPos = function (sessionId) {
+      if (!sessionId) return null;
+      var entry = readPosMap()[sessionId];
+      return entry && typeof entry.turn === "number" ? entry : null;
+    };
+    var writeReadPos = function (sessionId, turn, seq) {
+      if (!sessionId || typeof turn !== "number") return;
+      try {
+        var map = readPosMap();
+        map[sessionId] = typeof seq === "number" ? { turn: turn, seq: seq, at: Date.now() } : { turn: turn, at: Date.now() };
+        var ids = Object.keys(map);
+        if (ids.length > READ_POS_MAX) {
+          ids.sort(function (a, b) { return (map[a].at || 0) - (map[b].at || 0); });
+          for (var i = 0; i < ids.length - READ_POS_MAX; i++) delete map[ids[i]];
+        }
+        localStorage.setItem(READ_POS_KEY, JSON.stringify(map));
+      } catch (e) { /* storage full or blocked: a remembered position is a convenience */ }
+    };
+    var clearReadPos = function (sessionId) {
+      if (!sessionId) return;
+      try {
+        var map = readPosMap();
+        if (!Object.prototype.hasOwnProperty.call(map, sessionId)) return;
+        delete map[sessionId];
+        localStorage.setItem(READ_POS_KEY, JSON.stringify(map));
+      } catch (e) {}
+    };
     var prefsStore = (function () {
       var hasOwn = function (obj, key) { return Object.prototype.hasOwnProperty.call(obj, key); };
       var read = function (key, legacy) {
@@ -310,6 +482,8 @@ window.__ModuleLoader__.load({
           fuzzy: read(PREF_KEYS.fuzzy) === "1",
           // absent means "on": the hover card predates this switch
           hover: read(PREF_KEYS.hover) !== "0",
+          // absent means "on" too (the reader asked for this to default on)
+          remember: read(PREF_KEYS.remember) !== "0",
           lang: langRaw === "zh" || langRaw === "en" ? langRaw : "auto",
           debug: read(PREF_KEYS.debug) === "1"
         };
@@ -325,6 +499,7 @@ window.__ModuleLoader__.load({
           handle: function (v) { return String(v); },
           fuzzy: function (v) { return v ? "1" : "0"; },
           hover: function (v) { return v ? "1" : "0"; },
+          remember: function (v) { return v ? "1" : "0"; },
           lang: function (v) { return v; },
           debug: function (v) { return v ? "1" : "0"; }
         };
@@ -355,6 +530,7 @@ window.__ModuleLoader__.load({
           handle: isFinite(handleNum) ? Math.min(1, Math.max(0, Math.round(handleNum * 100) / 100)) : 0.5,
           fuzzy: v.fuzzy === true,
           hover: v.hover !== false,
+          remember: v.remember !== false,
           debug: v.debug === true
         };
       };
@@ -365,7 +541,7 @@ window.__ModuleLoader__.load({
         return {
           dock: over.dock, y: local.y, w: local.w, h: local.h,
           levels: over.levels, zoom: over.zoom, handle: over.handle, fuzzy: over.fuzzy, hover: over.hover,
-          lang: over.lang, debug: over.debug
+          lang: over.lang, remember: over.remember, debug: over.debug
         };
       };
       var notify = function () {
@@ -1185,7 +1361,7 @@ window.__ModuleLoader__.load({
               position: "fixed",
               top: 80,
               right: 16,
-              zIndex: Z_BASE + 1,
+              zIndex: Z_ERROR,
               background: "rgba(120,30,30,0.95)",
               border: "1px solid rgba(255,120,120,0.4)",
               color: "#ffdada",
@@ -1210,6 +1386,13 @@ window.__ModuleLoader__.load({
     // different number of hooks makes React abort the whole panel with
     // "Rendered more hooks than during the previous render" (#310). The hooks all
     // live in the body below, which is only ever mounted with complete props.
+    // Cross-session hand-off. A host search hit is `{sessionId, snippet}` with no
+    // seq, so the panel cannot scroll to it: it switches the session and leaves this
+    // request here, and the panel that comes up for that session re-runs the keyword
+    // and jumps to the first match it can actually reach. Module scope on purpose —
+    // the panel for the new session may be a fresh mount.
+    var pendingLocate = null;
+
     function OutlinePanel(props) {
       if (!props.useChat) {
         console.warn("[dsh-quick-toc] useChat prop missing (requires DSH >= 0.1.5-rc.1)");
@@ -1251,6 +1434,10 @@ window.__ModuleLoader__.load({
       };
       // Which stage of the bridge is actually ready — reported once at mount so a
       // missing jump loader can be diagnosed from the console instead of guessed.
+      // Past "the loader exists" the PAGE STATE is what decides whether a jump can do
+      // anything: a window the host considers complete (hasMore false) or one whose
+      // base already covers the target makes loadThrough resolve without loading, and
+      // from the outline that is indistinguishable from "loading stopped working".
       var jumpLoaderState = function () {
         var sessions = hostSessions();
         if (!sessions) return "no-sessions-service";
@@ -1263,7 +1450,9 @@ window.__ModuleLoader__.load({
         }
         var face = binding && binding.session;
         if (!face) return "no-binding-for-session";
-        return typeof face.loadThrough === "function" ? "ready" : "no-loadThrough";
+        if (typeof face.loadThrough !== "function") return "no-loadThrough";
+        return "ready(open=" + String(face.openState) + ",hasMore=" + String(face.hasMore)
+          + ",baseSeq=" + String(face.baseSeq) + ")";
       };
 
       // Structural narrowing of that projection (its value crosses the wire):
@@ -1300,23 +1489,47 @@ window.__ModuleLoader__.load({
       var viewport = _s2[0];
       var setViewport = _s2[1];
       react.useEffect(function () {
+        // Self-healing, because the layout AROUND the conversation can change without
+        // a resize: the host's own controls move that column about (measured in a real
+        // browser: 40px of margin-left on the centre column shifted the scroller's
+        // rect, no window resize was involved, and the plugin followed on this beat).
+        // A stale rect parks the panel — and its collapse handle — on a line that no
+        // longer exists, which reads as "the panel cannot be closed any more". The
+        // observer is re-attached whenever the host swaps the scroller node out.
+        var observed = null;
+        var obs = null;
+        var publish = function (next) {
+          // the observer fires often; publishing an identical box would re-render
+          // the whole list for nothing
+          setViewport(function (prev) {
+            if (prev &&
+              Math.abs(prev.left - next.left) < 1 && Math.abs(prev.right - next.right) < 1 &&
+              Math.abs(prev.top - next.top) < 1 && Math.abs(prev.height - next.height) < 1) {
+              return prev;
+            }
+            return next;
+          });
+        };
         var compute = function () {
           var sp = document.querySelector("[data-conversation-scroll]");
-          if (sp) {
-            var r = sp.getBoundingClientRect();
-            setViewport({ left: r.left, right: window.innerWidth - r.right, top: r.top, height: r.height });
+          if (!sp) return;
+          if (sp !== observed) { // a replaced scroller: the old observation is worthless
+            observed = sp;
+            if (obs) obs.disconnect();
+            if (typeof ResizeObserver !== "undefined") {
+              obs = new ResizeObserver(function () { compute(); });
+              obs.observe(sp);
+            }
           }
+          var r = sp.getBoundingClientRect();
+          publish({ left: r.left, right: window.innerWidth - r.right, top: r.top, height: r.height });
         };
         compute();
         window.addEventListener("resize", compute);
-        var sp = document.querySelector("[data-conversation-scroll]");
-        var obs = null;
-        if (typeof ResizeObserver !== "undefined" && sp) {
-          obs = new ResizeObserver(compute);
-          obs.observe(sp);
-        }
+        var beat = setInterval(compute, 500);
         return function () {
           window.removeEventListener("resize", compute);
+          clearInterval(beat);
           if (obs) obs.disconnect();
         };
       }, []);
@@ -1336,18 +1549,47 @@ window.__ModuleLoader__.load({
       var setPanelY = _s4[1];
       var handleRef = react.useRef(null);      // panel top drag bar
       var edgeRef = react.useRef(null);        // edge collapse handle
+      var sheetHandleRef = react.useRef(null); // curtain handle along the top edge
 
       // handle reveal: after the panel fully slides away, the handle fades+pops in
       var _s5 = react.useState(false);
       var handleShown = _s5[0];
       var setHandleShown = _s5[1];
+      // ...and it is NOT unmounted the instant it is clicked: the collapse-side handle
+      // used to disappear on the click's own frame, which read as a hard cut. It stays
+      // mounted for the length of its fade-out and only then leaves the tree.
+      var _s5b = react.useState(false);
+      var edgeGone = _s5b[0];
+      var setEdgeGone = _s5b[1];
+      // ...and the panel itself waits for it: clicking the edge handle used to start the
+      // panel's slide on the same frame, so the two crossed over and the panel looked
+      // like it came out before the handle had gone in. While `edgeLeaving` is set the
+      // panel's transition is delayed, so the handle slips home first and only then does
+      // the panel slide out. (Its inline geometry is the open one from the first frame —
+      // only the animation is held back — so nothing else has to move.)
+      var _s5c = react.useState(false);
+      var edgeLeaving = _s5c[0];
+      var setEdgeLeaving = _s5c[1];
+      var openFromEdge = function () {
+        if (open) return;
+        setEdgeLeaving(true);
+        setOpen(true);
+      };
+      react.useEffect(function () {
+        if (!edgeLeaving) return;
+        var t = setTimeout(function () { setEdgeLeaving(false); }, EDGE_OUT_MS);
+        return function () { clearTimeout(t); };
+      }, [edgeLeaving]);
       react.useEffect(function () {
         if (!open) {
           setHandleShown(false);
+          setEdgeGone(false);
           var t = setTimeout(function () { setHandleShown(true); }, 300); // right after the panel slides away
           return function () { clearTimeout(t); };
         }
         setHandleShown(false);
+        var t2 = setTimeout(function () { setEdgeGone(true); }, EDGE_OUT_MS + 30); // the fade-out, then unmount
+        return function () { clearTimeout(t2); };
       }, [open]);
       // panel hover: clear when mouse inside, transparent when outside
       var _s6 = react.useState(false);
@@ -1578,6 +1820,202 @@ window.__ModuleLoader__.load({
         };
       }, []);
 
+      // ---- questions-only view ------------------------------------------------
+      // A second way to read a long session: keep every turn's header (time + the
+      // prompt) and drop the heading rows. The switch is a cross-fade, not a swap:
+      // the list fades out, the mode changes while it is invisible, then it fades
+      // back in — the two lists never blend into each other mid-swap. Session-local
+      // on purpose (a reading mode, like the open search box, not a stored
+      // preference).
+      var _sQ = react.useState(false);
+      var questionsOnly = _sQ[0];
+      var setQuestionsOnly = _sQ[1];
+      var _sQF = react.useState("idle"); // "idle" | "out" | "in"
+      var listFade = _sQF[0];
+      var setListFade = _sQF[1];
+      var listFadeTimers = react.useRef({ out: null, in: null });
+      var toggleQuestions = function () {
+        if (listFadeTimers.current.out) clearTimeout(listFadeTimers.current.out);
+        if (listFadeTimers.current.in) clearTimeout(listFadeTimers.current.in);
+        // reduce motion is a real preference: swap without the two-phase fade
+        var calm = false;
+        try {
+          calm = typeof window !== "undefined" && typeof window.matchMedia === "function"
+            && window.matchMedia("(prefers-reduced-motion: reduce)").matches === true;
+        } catch (e) { calm = false; }
+        if (calm) {
+          setQuestionsOnly(function (cur) { return !cur; });
+          setListFade("idle");
+          return;
+        }
+        setListFade("out");
+        listFadeTimers.current.out = setTimeout(function () {
+          listFadeTimers.current.out = null;
+          setQuestionsOnly(function (cur) { return !cur; });
+          // entering questions-only makes the level filter meaningless: close its
+          // popup rather than leave a disabled control's menu open over the list
+          if (!questionsOnly && typeof closeLevels === "function") closeLevels();
+          setListFade("in");
+          listFadeTimers.current.in = setTimeout(function () {
+            listFadeTimers.current.in = null;
+            setListFade("idle");
+          }, 260);
+        }, 150);
+      };
+      react.useEffect(function () {
+        return function () {
+          if (listFadeTimers.current.out) clearTimeout(listFadeTimers.current.out);
+          if (listFadeTimers.current.in) clearTimeout(listFadeTimers.current.in);
+        };
+      }, []);
+
+      // ---- keyboard navigation -------------------------------------------------
+      // The list is a real widget: ↑/↓ walk its rows in visual order, Home/End jump
+      // to the ends, Enter activates the row under the cursor (each row keeps its own
+      // click semantics — jump / page-in / switch session), Esc collapses the panel.
+      // The cursor is a keyboard artefact, NOT the reading position: the blue box
+      // follows the conversation, this outline follows the keys, and they may sit on
+      // different rows. -1 = no cursor (nothing is painted).
+      var _sNav = react.useState(-1);
+      var navIdx = _sNav[0];
+      var setNavIdx = _sNav[1];
+      // Polite live region: match stepping, result counts and cursor moves are
+      // announced for screen readers (and read out by any a11y layer the host adds).
+      var _sLive = react.useState("");
+      var liveText = _sLive[0];
+      var setLiveText = _sLive[1];
+
+      // ---- full-width sheet ("幕布") -------------------------------------------
+      // The same panel content, dropped from the top of the conversation area at full
+      // width. It REPLACES the docked panel while open (the list keeps its ref, so
+      // scrolling, page-in, the keyboard cursor and the hover card all keep working
+      // against one element, not two).
+      var _sSheet = react.useState(false);
+      var sheetOpen = _sSheet[0];
+      var setSheetOpen = _sSheet[1];
+      var sheetRef = react.useRef(null);
+      var sheetTimerRef = react.useRef(null);
+      // Handing the docked panel over to the curtain. They are ONE list — while the
+      // curtain is down the panel element IS the curtain's content — so switching
+      // surfaces used to make the panel teleport: gone from the dock on the way
+      // down, popping straight back in when the curtain retracted. The reader read
+      // that as a flash. Now the panel always travels the way it always does:
+      // while it is "aside" it renders at its collapsed spot and the existing
+      // left/clip transition does the moving — it slides home just before the
+      // curtain drops ("tuck"), and slides back in just after the curtain is gone
+      // ("return") instead of popping into place.
+      //   "tuck"   panel sliding home BEFORE the curtain opens (state must persist)
+      //   "return" panel sliding back in AFTER the curtain closed (one painted frame)
+      var _sAside = react.useState(null);
+      var panelAside = _sAside[0];
+      var setPanelAside = _sAside[1];
+      // The curtain hangs from just BELOW the centre column's view tabs (对话 / 轨迹 /
+      // 上下文), not from the top of the scroll container: when those tabs live inside
+      // that container, viewport.top sits above them and the curtain would cover them.
+      // Both edges of that strip are kept: the curtain hangs from its BOTTOM line, and
+      // the curtain handle sits INSIDE the strip with its own bottom on that same line
+      // (that band is host chrome, so no conversation text can ever run under it —
+      // which is exactly what made the handle unreadable when it hung below the line).
+      // Measured when the conversation is (re)measured, not on every render —
+      // getBoundingClientRect is a layout read.
+      var _sSheetTop = react.useState(null);
+      var sheetStrip = _sSheetTop[0]; // { top, bottom } | null
+      var setSheetTop = _sSheetTop[1];
+      // The curtain handle is held in the tree for DROP_OUT_MS after the curtain starts
+      // opening, so its press-flat is actually seen (the curtain opens and would
+      // otherwise unmount it in the same commit).
+      var _sDropGone = react.useState(false);
+      var sheetHandleGone = _sDropGone[0];
+      var setSheetHandleGone = _sDropGone[1];
+      // the droplet's click may defer the curtain until its press has played (see the
+      // handle's onClick): one timer, always cancelled before being re-armed
+      var dropOpenRef = react.useRef(null);
+      react.useEffect(function () { return function () { if (dropOpenRef.current) clearTimeout(dropOpenRef.current); }; }, []);
+      react.useEffect(function () {
+        if (!sheetOpen) { setSheetHandleGone(false); return; }
+        var t = setTimeout(function () { setSheetHandleGone(true); }, DROP_OUT_MS);
+        return function () { clearTimeout(t); };
+      }, [sheetOpen]);
+      react.useEffect(function () {
+        if (!viewport) return;
+        var tabs = typeof conversationTablist === "function" ? conversationTablist() : null;
+        var next = null;
+        if (tabs && typeof tabs.getBoundingClientRect === "function") {
+          var r = tabs.getBoundingClientRect();
+          if (r && r.height > 0 && r.bottom > 0) next = { top: r.top, bottom: r.bottom };
+        }
+        setSheetTop(next);
+      }, [sheetOpen, viewport]);
+      react.useEffect(function () {
+        return function () {
+          if (sheetTimerRef.current) clearTimeout(sheetTimerRef.current);
+        };
+      }, []);
+      // The retract is driven by a CLASS on the DOM node rather than by state: a
+      // state change re-renders the whole (possibly huge) list on the very frame the
+      // animation starts, and that long task is what made the retract stutter. React
+      // only rewrites `class` when the prop changes, so a class added here survives
+      // re-renders until the curtain is actually gone.
+      var closeSheet = function () {
+        if (!sheetOpen || sheetTimerRef.current) return;
+        var el = sheetRef.current;
+        if (el && el.classList) {
+          el.classList.remove("dqt-sheet-open");
+          el.classList.add("dqt-sheet-closing");
+        }
+        // the timer sits just past the exit animation (0.3s): there is no
+        // animationend listener, so this is what actually closes the curtain
+        sheetTimerRef.current = setTimeout(function () {
+          sheetTimerRef.current = null;
+          setSheetOpen(false);
+          // the panel was open before the curtain: slide it back in instead of
+          // letting it pop into place (the reader saw that pop as a flash)
+          if (open) setPanelAside("return");
+        }, 340);
+      };
+      var openSheet = function () {
+        if (sheetOpen || panelAside) return;
+        if (sheetTimerRef.current) { clearTimeout(sheetTimerRef.current); sheetTimerRef.current = null; }
+        // reopening mid-retract: the node still carries the exit class and React
+        // would not put the enter class back on its own (that prop never changed)
+        var restoreEnterClass = function () {
+          var node = sheetRef.current;
+          if (node && node.classList) {
+            node.classList.remove("dqt-sheet-closing");
+            node.classList.add("dqt-sheet-open");
+          }
+        };
+        if (open) {
+          // The docked panel goes home FIRST — its own collapse motion, start to
+          // finish — and only then does the curtain drop. Two reasons, both seen in
+          // the browser: (1) the enter animation used to be armed at CLICK time, so
+          // by the time the curtain became visible most of its 0.46s drop was
+          // already spent and it looked like it snapped into place; (2) the panel
+          // was pulled into the sheet mid-slide, which read as it flashing away.
+          setPanelAside("tuck");
+          sheetTimerRef.current = setTimeout(function () {
+            sheetTimerRef.current = null;
+            restoreEnterClass(); // the drop animation starts HERE, with the first paint
+            setSheetOpen(true);
+            setPanelAside(null);
+          }, PANEL_TUCK_MS);
+        } else {
+          restoreEnterClass();
+          setSheetOpen(true);
+        }
+      };
+      // "return" only needs to exist for one painted frame: the panel renders at
+      // its collapsed spot, and releasing it lets the left/clip transition carry
+      // it back open. The tuck must NOT be released here — it is held until the
+      // curtain actually opens.
+      react.useEffect(function () {
+        if (panelAside !== "return") return;
+        var raf = requestAnimationFrame(function () {
+          raf = requestAnimationFrame(function () { setPanelAside(null); });
+        });
+        return function () { cancelAnimationFrame(raf); };
+      }, [panelAside]);
+
       // ---- search: header button opens a keyword box; Enter cycles through
       // matching headings and jumps to each ----
       var _s13 = react.useState(false);
@@ -1608,9 +2046,18 @@ window.__ModuleLoader__.load({
       var prevScope = _s19[0];
       var setPrevScope = _s19[1];
       var scopeTimerRef = react.useRef(null);
+      // search scope: "title" (default) / "full" (user messages + AI replies in this
+      // session) / "cross" (the HOST's full-text index across every visible session).
+      // ONE pill cycles the three, so a third scope costs no extra button.
+      var scopeLabel = function (scope) {
+        if (scope === "full") return T("search.scope.full");
+        if (scope === "cross") return T("search.scope.cross");
+        return T("search.scope.title");
+      };
       var toggleScope = function () {
+        var next = searchScope === "title" ? "full" : (searchScope === "full" ? "cross" : "title");
         setPrevScope(searchScope);
-        setSearchScope(searchScope === "title" ? "full" : "title");
+        setSearchScope(next);
         setMatchIdx(0);
         if (scopeTimerRef.current) clearTimeout(scopeTimerRef.current);
         scopeTimerRef.current = setTimeout(function () { setPrevScope(null); }, 300);
@@ -1626,6 +2073,59 @@ window.__ModuleLoader__.load({
         setMatchIdx(0);
       };
 
+      // ---- cross-session search (the host's own full-text index) --------------
+      // "cross" scope asks the HOST to search message text across every visible
+      // session. Two host facts shape the code below: one search returns at most
+      // `searchResultLimit` (20) items plus a `hasMore` flag, and an item carries
+      // only `{sessionId, snippet}` — NO seq. So a hit cannot be jumped to directly:
+      // clicking one switches to that session and re-runs the same keyword here (the
+      // pendingLocate hand-off below).
+      var _sCross = react.useState({ phase: "idle", rows: [], more: false, error: "" });
+      var cross = _sCross[0];
+      var setCross = _sCross[1];
+      var crossAbortRef = react.useRef(null);
+      var crossTimerRef = react.useRef(null);
+      var crossTitle = function (id) {
+        var sessions = hostSessions();
+        try {
+          var snap = sessions && sessions.list && typeof sessions.list.getSnapshot === "function"
+            ? sessions.list.getSnapshot() : null;
+          var rec = snap && snap.byId ? snap.byId[id] : null;
+          if (rec && typeof rec.displayTitle === "string" && rec.displayTitle !== "") return rec.displayTitle;
+        } catch (e) { /* title is decoration: the id is the fallback */ }
+        return id;
+      };
+      // Which hits may be OFFERED. The host index covers every persisted session on
+      // disk — including archived ones and sessions of workspaces this profile no
+      // longer lists — so an unfiltered list offers rows that cannot be opened. The
+      // rule below is the sidebar's own content-search rule (ui-workspace
+      // `sessionVisible` + the registry archive set): listed, not a subagent child,
+      // not archived, and never a blank session unless it is the current one.
+      var crossHitAllowed = function (id) {
+        if (typeof id !== "string" || id === "") return false;
+        var sessions = hostSessions();
+        var snap = null;
+        try {
+          snap = sessions && sessions.list && typeof sessions.list.getSnapshot === "function"
+            ? sessions.list.getSnapshot() : null;
+        } catch (e) { snap = null; }
+        var rec = snap && snap.byId ? snap.byId[id] : null;
+        if (rec === undefined || rec === null) return false; // not listed: cannot be opened
+        if (rec.origin === "subagent") return false;
+        if (snap.current === id) return true;                // the open session always works
+        if (rec.blank === true) return false;                // nothing in it to have matched
+        var archived = null;
+        try {
+          var ws = tocHost && typeof tocHost.workspaces === "function" ? tocHost.workspaces() : null;
+          var wsnap = ws && ws.list && typeof ws.list.getSnapshot === "function" ? ws.list.getSnapshot() : null;
+          archived = wsnap && Array.isArray(wsnap.archivedSessionIds) ? wsnap.archivedSessionIds : null;
+        } catch (e) { archived = null; }
+        // No workspace registry (older host): fall back to the session list's word,
+        // which is still far better than offering every indexed session on disk.
+        if (archived && archived.indexOf(id) >= 0) return false;
+        return true;
+      };
+
       // ---- preference plumbing -------------------------------------------------
       // The store is the shared source (the native Settings section writes into it);
       // the states above are the panel's LIVE copy, so a drag or a toggle never waits
@@ -1723,7 +2223,11 @@ window.__ModuleLoader__.load({
         return undefined;
       }, [searchAnim]);
       react.useEffect(function () {
-        if (searchOpen && searchRef.current) searchRef.current.focus();
+        if (!searchOpen || !searchRef.current) return;
+        // preventScroll: across the curtain the input arrives inside a column that is
+        // still animating open, and focusing it must not scroll anything
+        try { searchRef.current.focus({ preventScroll: true }); }
+        catch (e) { searchRef.current.focus(); }
       }, [searchOpen]);
       var onQueryChange = function (v) {
         setQuery(v);
@@ -2102,6 +2606,15 @@ window.__ModuleLoader__.load({
         didInitScroll.current = true;
         listRef.current.scrollTop = listRef.current.scrollHeight;
       }, [groups.length]);
+      // A live handle on the newest group list, for callbacks that outlive their
+      // render (the "did that turn actually page in?" verdict below).
+      var groupsLiveRef = react.useRef(groups);
+      groupsLiveRef.current = groups;
+      // One history-rebuild retry per session after a jump that never landed.
+      // Hooks must sit ABOVE every early return (this panel returns null for an
+      // empty conversation) or React aborts with #310.
+      var jumpRetryRef = react.useRef(false);
+      react.useEffect(function () { jumpRetryRef.current = false; }, [sessionId]);
       // The "back to the newest row" button follows the list's real geometry, and a
       // bottom can be reached WITHOUT a scroll event: older turns page in, a search
       // replaces the rows, the panel is resized, the panel is expanded/collapsed.
@@ -2208,6 +2721,9 @@ window.__ModuleLoader__.load({
       var resultRows = react.useMemo(function () {
         var fq = foldQuery(query);
         if (!fq) return [];
+        // cross-session scope lists HOST hits instead of local ones: the local list
+        // (and the in-chat highlight it drives) stays out of the way.
+        if (searchScope === "cross") return [];
         var needle = { folded: fq }; // one folded query, reused for every text
         var rows = [];
         var index = {};
@@ -2334,6 +2850,10 @@ window.__ModuleLoader__.load({
           activeSigRef.current = sig;
           setActiveGroup(actives);
           if (actives.length === 0) return;
+          // remember where the reader is (debounced): the topmost visible turn, with
+          // its start seq so a later restore can page it back in
+          var giSave = actives[0];
+          if (groups[giSave]) savePosition(groups[giSave]);
           // pause right after the reader touched the outline themselves —
           // otherwise paging older turns gets yanked back to the newest group
           if (Date.now() - outlineTouchRef.current <= 1500) return;
@@ -2377,6 +2897,9 @@ window.__ModuleLoader__.load({
       var matches = react.useMemo(function () {
         var fq = foldQuery(query);
         if (!fq) return [];
+        // cross-session scope: the host owns the searching, so there are no local
+        // matches — no n/N stepping and no keyword highlight in this conversation.
+        if (searchScope === "cross") return [];
         var needle = { folded: fq };
         var out = [];
         for (var gi = 0; gi < groups.length; gi++) {
@@ -2429,6 +2952,142 @@ window.__ModuleLoader__.load({
         }
       }
 
+      // ---- cross-session query: debounce, abort the superseded one ------------
+      // 320ms of quiet keeps a fast typist from spending the host's search budget
+      // on prefixes; the previous request is aborted, and an aborted reply is
+      // dropped (a late answer for an older query must not overwrite the new one).
+      react.useEffect(function () {
+        var q = query.trim();
+        var clearPending = function () {
+          if (crossTimerRef.current) { clearTimeout(crossTimerRef.current); crossTimerRef.current = null; }
+        };
+        if (searchScope !== "cross" || q === "") {
+          if (crossAbortRef.current) { crossAbortRef.current.abort(); crossAbortRef.current = null; }
+          clearPending();
+          setCross(function (cur) {
+            return (cur.phase === "idle" && cur.rows.length === 0) ? cur : { phase: "idle", rows: [], more: false, error: "" };
+          });
+          return;
+        }
+        var sessions = hostSessions();
+        if (!sessions || typeof sessions.search !== "function") {
+          setCross({ phase: "error", rows: [], more: false, error: T("search.cross.unavailable") });
+          return;
+        }
+        clearPending();
+        crossTimerRef.current = setTimeout(function () {
+          crossTimerRef.current = null;
+          if (crossAbortRef.current) crossAbortRef.current.abort();
+          var ctl = (typeof AbortController !== "undefined") ? new AbortController() : null;
+          crossAbortRef.current = ctl;
+          setCross({ phase: "loading", rows: [], more: false, error: "" });
+          var started;
+          try {
+            started = sessions.search(q, ctl ? ctl.signal : undefined);
+          } catch (e) {
+            setCross({ phase: "error", rows: [], more: false, error: String(e && e.message ? e.message : e) });
+            return;
+          }
+          Promise.resolve(started).then(function (result) {
+            if (ctl && ctl.signal.aborted) return;
+            if (!result || result.ok !== true) {
+              var msg = (result && result.error && result.error.message) ? String(result.error.message) : "unknown error";
+              // The deployment default is an index that is never opened, and the host
+              // says so in engineering terms. Say what it means for the reader instead,
+              // and keep the host's own words available for the "any other error" case.
+              if (/SESSION_QUERY_SEARCH_DISABLED|session search is disabled|openAt/i.test(msg)) {
+                msg = T("search.cross.disabled");
+              }
+              setCross({ phase: "error", rows: [], more: false, error: msg });
+              return;
+            }
+            var value = result.value || {};
+            var items = Array.isArray(value.items) ? value.items : [];
+            var rows = [];
+            var hidden = 0;
+            for (var i = 0; i < items.length; i++) {
+              var it = items[i];
+              if (!it || typeof it.sessionId !== "string") continue;
+              // never offer a hit the panel could not open (archived, unlisted,
+              // subagent child): the index covers every persisted session on disk
+              if (!crossHitAllowed(it.sessionId)) { hidden += 1; continue; }
+              rows.push({ sessionId: it.sessionId, snippet: typeof it.snippet === "string" ? it.snippet : "" });
+            }
+            setCross({ phase: "done", rows: rows, more: value.hasMore === true, error: "", hidden: hidden });
+          }, function (e) {
+            if (ctl && ctl.signal.aborted) return;
+            setCross({ phase: "error", rows: [], more: false, error: String(e && e.message ? e.message : e) });
+          });
+        }, 320);
+      }, [searchScope, query, langKey]);
+
+      // leaving the panel unmounts it: abort an in-flight host search
+      react.useEffect(function () {
+        return function () {
+          if (crossAbortRef.current) crossAbortRef.current.abort();
+          if (crossTimerRef.current) clearTimeout(crossTimerRef.current);
+        };
+      }, []);
+
+      // clicking a cross-session hit: switch the session, then leave the keyword for
+      // the panel that comes up (see pendingLocate) — the host hit has no seq, so the
+      // jump happens on the other side, after the same search runs there.
+      var openCrossHit = function (hitSessionId) {
+        var sessions = hostSessions();
+        if (!sessions || typeof sessions.open !== "function") {
+          showBanner(T("search.cross.unavailable"));
+          return;
+        }
+        // the list/archive set can change between the search and the click
+        if (!crossHitAllowed(hitSessionId)) {
+          showBanner(T("search.cross.goneHit"));
+          return;
+        }
+        pendingLocate = { sessionId: hitSessionId, query: query.trim(), at: Date.now() };
+        try {
+          sessions.open(hitSessionId);
+        } catch (e) {
+          pendingLocate = null;
+          showBanner(T("search.cross.error") + String(e && e.message ? e.message : e));
+          return;
+        }
+        showBanner(T("search.cross.switched"));
+      };
+
+      // the arriving side of that hand-off: prefill the keyword in full-text scope,
+      // then jump to the first row that really contains it. Best effort by design —
+      // the spot may sit in history this window has not paged in, so a grace period
+      // ends in an honest "not loaded yet" banner rather than a silent nothing.
+      var locateTimerRef = react.useRef(null);
+      react.useEffect(function () {
+        var req = pendingLocate;
+        if (!req) return;
+        if (req.sessionId !== sessionId || !req.query) return;
+        if (Date.now() - req.at > 15000) { pendingLocate = null; return; }
+        if (query !== req.query) { setQuery(req.query); setSearchScope("full"); return; }
+        if (searchScope !== "full") { setSearchScope("full"); return; }
+        if (resultRows.length === 0) {
+          if (!locateTimerRef.current) {
+            locateTimerRef.current = setTimeout(function () {
+              locateTimerRef.current = null;
+              if (pendingLocate === req) {
+                pendingLocate = null;
+                showBanner(T("search.cross.noSpot"));
+              }
+            }, 2600);
+          }
+          return;
+        }
+        if (locateTimerRef.current) { clearTimeout(locateTimerRef.current); locateTimerRef.current = null; }
+        pendingLocate = null;
+        var pick = 0;
+        for (var i = 0; i < resultRows.length; i++) {
+          var r = resultRows[i];
+          if (((r.title || "") + " " + (r.snippet || "")).indexOf(req.query) >= 0) { pick = i; break; }
+        }
+        goToRow(pick);
+      }, [sessionId, query, searchScope, resultRows]);
+
       // The result list follows the outline's convention: OLDEST hit at the top,
       // NEWEST at the bottom, and a fresh search starts scrolled to the bottom —
       // scroll UP from there to walk back through earlier hits. The newest hit is
@@ -2442,11 +3101,14 @@ window.__ModuleLoader__.load({
         if (!q) { setHint(""); return; }
         var el = listRef.current;
         if (el) el.scrollTop = el.scrollHeight;
+        // cross-session scope: the list is host hits, so neither the n/N cursor nor
+        // the "scroll up for older messages" hint applies
+        if (searchScope === "cross") { setHint(""); return; }
         if (matches.length > 0) setMatchIdx(matches.length - 1);
         // arm the "scroll up for older messages" hint: the result list only covers
         // what the window holds, and older turns are one upward scroll away
         setHint(canLoadOlder() ? "more" : "");
-      }, [query, matches.length]);
+      }, [query, matches.length, searchScope]);
 
       // keep the outline filled: after opening the panel or dragging it taller,
       // the latest page may be shorter than the list viewport, leaving dead space
@@ -2515,6 +3177,130 @@ window.__ModuleLoader__.load({
         return function () { el.removeEventListener("wheel", onWheel); };
       }, [open, crowded, groups.length]);
 
+      // ---- remember the reading position --------------------------------------
+      // Saved: the turn the reader is actually looking at (the first group crossing
+      // the conversation viewport, the same signal the rail follows), written 700ms
+      // after the scrolling stops. Restored: once per session mount, quietly — a
+      // position that can no longer be paged in is forgotten rather than announced.
+      var restoreDoneRef = react.useRef(false);
+      var restoreQuietRef = react.useRef(0);
+      var posTimerRef = react.useRef(null);
+      var rememberRef = react.useRef(true);
+      rememberRef.current = !!prefs.remember;
+      react.useEffect(function () { return function () { if (posTimerRef.current) clearTimeout(posTimerRef.current); }; }, []);
+      // `g` is the outline group the reader is looking at (its turn AND its start seq,
+      // so the position can be paged back in later, not just jumped to while loaded)
+      var savePosition = function (g) {
+        if (!rememberRef.current) return;
+        if (!g || typeof g.turn !== "number") return;
+        if (Date.now() - restoreQuietRef.current < 2500) return;   // the restore's own scrolling
+        if (posTimerRef.current) clearTimeout(posTimerRef.current);
+        posTimerRef.current = setTimeout(function () {
+          posTimerRef.current = null;
+          writeReadPos(sessionId, g.turn, g.seq);
+        }, 700);
+      };
+
+      // ---- keyboard cursor: paint + keep in view ------------------------------
+      // Hooks MUST sit above the early return below (a conditional hook aborts the
+      // whole panel with React #310); the helpers they call are defined later, which
+      // is fine because the callbacks run after the render.
+      react.useEffect(function () {
+        var el = listRef.current;
+        var rows = el && typeof el.querySelectorAll === "function"
+          ? Array.prototype.slice.call(el.querySelectorAll("[data-nav-row]")) : [];
+        if (navIdx >= rows.length) { setNavIdx(rows.length > 0 ? rows.length - 1 : -1); return; }
+        for (var i = 0; i < rows.length; i++) {
+          if (rows[i] && rows[i].classList && typeof rows[i].classList.toggle === "function") {
+            rows[i].classList.toggle("dqt-nav", i === navIdx);
+          }
+        }
+        if (navIdx >= 0 && navIdx < rows.length && el && typeof el.getBoundingClientRect === "function"
+          && typeof rows[navIdx].getBoundingClientRect === "function") {
+          var box = el.getBoundingClientRect();
+          var rr = rows[navIdx].getBoundingClientRect();
+          if (box && rr && typeof box.top === "number" && typeof rr.top === "number") {
+            var factor = zoom > 0 ? zoom : 1;
+            if (rr.top < box.top + 2) el.scrollTop -= (box.top + 2 - rr.top) / factor;
+            else if (rr.bottom > box.bottom - 2) el.scrollTop += (rr.bottom - box.bottom + 2) / factor;
+          }
+        }
+      }, [navIdx, groups, resultRows, cross, query, visibleCount, open, questionsOnly]);
+      // live region: what the reader just did (search hits / results / cursor)
+      react.useEffect(function () {
+        if (!query.trim()) { setLiveText(""); return; }
+        if (searchScope === "cross") {
+          if (cross.phase === "loading") setLiveText(T("a11y.loading"));
+          else if (cross.phase === "error") setLiveText(cross.error || T("a11y.crossEmpty"));
+          else setLiveText(cross.rows.length > 0 ? Tp("a11y.results", { n: cross.rows.length }) : T("a11y.crossEmpty"));
+          return;
+        }
+        if (matches.length > 0) setLiveText(Tp("a11y.hits", { n: (matchIdx % matches.length) + 1, total: matches.length }));
+        else setLiveText(T("search.empty"));
+      }, [query, searchScope, cross.phase, cross.rows.length, cross.error, matches.length, matchIdx, langKey]);
+
+      // ---- restore the remembered position (once per session mount) -----------
+      // Hooks must stay above the early return below. Runs after the first content
+      // arrives; a stored turn that is already the newest (or within the newest two
+      // groups) means there is nothing to restore, and a position older than
+      // READ_POS_TTL_MS is dropped instead of resumed: coming back later, the reader
+      // expects the newest messages, not an anchor from a previous sitting.
+      react.useEffect(function () {
+        if (restoreDoneRef.current) return;
+        if (groups.length === 0) return;
+        if (!chatViewActive) return;
+        restoreDoneRef.current = true;
+        if (!prefs.remember) return;
+        var saved = readPos(sessionId);
+        if (!saved) return;
+        if (typeof saved.at === "number" && Date.now() - saved.at > READ_POS_TTL_MS) {
+          clearReadPos(sessionId); // stale: open at the bottom, as if it were never saved
+          return;
+        }
+        var newest = [];
+        for (var i = Math.max(0, groups.length - 2); i < groups.length; i++) {
+          if (typeof groups[i].turn === "number") newest.push(groups[i].turn);
+        }
+        if (newest.indexOf(saved.turn) >= 0) return;
+        restoreQuietRef.current = Date.now();
+        var gi = -1;
+        for (var j = 0; j < groups.length; j++) {
+          if (groups[j].turn === saved.turn) { gi = j; break; }
+        }
+        if (gi >= 0 && !groups[gi].ghost) {
+          var g = groups[gi];
+          var key = (g.msgs && g.msgs.length > 0) ? g.msgs[0].key
+            : (g.userKey || (g.headings.length > 0 ? g.headings[0].key : ""));
+          if (key) {
+            jump(key, 0);
+            revealGroupInOutline(gi);
+            return;
+          }
+        }
+        // Not in the loaded window (or nothing jumpable in it): page it in quietly.
+        // The seq comes from the host outline — the stored entry may predate the seq
+        // being written, and loadThrough(undefined) pages nowhere, so the restore used
+        // to sit out its 8s deadline and then forget a position it could have resumed.
+        var seq = typeof saved.seq === "number" ? saved.seq : null;
+        if (seq === null) {
+          for (var k = 0; k < groups.length; k++) {
+            if (groups[k] && groups[k].turn === saved.turn && typeof groups[k].seq === "number") { seq = groups[k].seq; break; }
+          }
+        }
+        openTurn(saved.turn, seq === null ? undefined : seq, true);
+      }, [groups, prefs.remember, chatViewActive, sessionId]);
+
+      // ---- opening the sheet: land on the turn being read ----------------------
+      // Hooks stay above the early return; the helpers they call are assigned later
+      // in the render body, which is fine because this runs after the render.
+      react.useEffect(function () {
+        if (!sheetOpen) return;
+        var el = listRef.current;
+        if (el && typeof el.focus === "function") el.focus();
+        var gi = activeGroup && activeGroup.length > 0 ? activeGroup[0] : -1;
+        if (gi >= 0) revealGroupInOutline(gi);
+      }, [sheetOpen]);
+
       // ---- nothing to show without headings ----
       if (groups.length === 0) return null;
 
@@ -2522,6 +3308,21 @@ window.__ModuleLoader__.load({
       // (The scale preference leaves all of this alone: it acts on the panel's inner
       // box, so the panel itself keeps the width and height the reader dragged.)
       var dockRight = dock === "right";
+      // Keep the OPEN panel inside the window whatever the conversation area does.
+      // The area is the host's to move: its transcript width grips rewrite the
+      // column, a sidebar or another plugin's split view can shift or shrink it,
+      // and the reader can also change the window itself. A panel pushed past the
+      // edge takes its own header — and with it the only ✕ — out of reach, which
+      // is the difference between "misplaced" and "cannot be closed any more".
+      // (The collapsed panel is parked deliberately outside the area and is hidden
+      // by its own clip, so only the open position is clamped.)
+      var clampLeft = function (x) {
+        return Math.max(8, Math.min(Math.max(8, window.innerWidth - panelW - 8), x));
+      };
+      // While the panel is being handed over to (or back from) the curtain it is
+      // rendered at its COLLAPSED geometry, so the same left/clip transition that
+      // serves open/collapse also serves the handoff: no teleport, no flash.
+      var geoOpen = open && !panelAside;
       var panelLeft;
       if (dockRight) {
         // RIGHT dock: keep the panel's VISIBLE right edge pinned at the SAME
@@ -2531,15 +3332,20 @@ window.__ModuleLoader__.load({
         //         so the visible right edge stays at openRight+panelW -> the
         //         collapse shrinks toward that line and vanishes exactly there.
         var openRight = window.innerWidth - (viewport ? viewport.right + 48 : 60) - panelW;
-        panelLeft = open ? openRight : (openRight + panelW);
-      } else if (open) {
+        panelLeft = geoOpen ? clampLeft(openRight) : (openRight + panelW);
+      } else if (geoOpen) {
         // LEFT dock open (left dock is the confirmed-correct reference — untouched)
-        panelLeft = (viewport ? viewport.left + 8 : 8);
+        panelLeft = clampLeft(viewport ? viewport.left + 8 : 8);
       } else {
         panelLeft = (viewport ? viewport.left - panelW - 8 : -(panelW + 48));
       }
       var vMaxH = viewport ? Math.max(200, viewport.height - 28) : "72vh";
-      var baseTopPx = (viewport ? viewport.top + 14 : window.innerHeight * 0.12) + panelY;
+      // same reasoning vertically: the draggable offset is stored in localStorage
+      // and can outlive the layout it was chosen for
+      var baseTopPx = Math.max(8, Math.min(
+        Math.max(8, window.innerHeight - 120),
+        (viewport ? viewport.top + 14 : window.innerHeight * 0.12) + panelY
+      ));
       // the collapsed handle's vertical position (a 0..1 ratio of the conversation
       // area — 0 pins the handle to the BOTTOM, 1 to the top; 0.5 = centred, which is
       // exactly the previous fixed position)
@@ -2597,10 +3403,12 @@ window.__ModuleLoader__.load({
         var floor = Math.max(0, sp.scrollHeight - sp.clientHeight);
         return Math.max(0, Math.min(t, floor));
       };
-      var glideTo = function (el) {
-        var sp = el.closest ? el.closest("[data-conversation-scroll]") : null;
-        if (!sp) return;
-        var t0 = scrollTargetOf(el, sp);
+      // The glide machinery is target-agnostic on purpose: the target is a live
+      // function of the scrollport, so the same stick-zone lift, drift re-aim,
+      // stall watchdog and landing re-checks serve both "put this heading at the
+      // top" (jump) and "put this section's end at the visible bottom" (end jump).
+      var glideToTarget = function (sp, getTarget) {
+        var t0 = getTarget(sp);
         var floor = Math.max(0, sp.scrollHeight - sp.clientHeight);
         if (floor - sp.scrollTop <= 25 && Math.abs(t0 - sp.scrollTop) > 60) {
           sp.scrollTop = Math.max(0, floor - 26); // break the stick-to-bottom hold first
@@ -2626,7 +3434,7 @@ window.__ModuleLoader__.load({
           var ticks = 0;
           var iv = setInterval(function () {
             if (mine.done || (ticks += 1) > 5) { clearInterval(iv); return; }
-            var next = scrollTargetOf(el, sp);
+            var next = getTarget(sp);
             if (Math.abs(next - sp.scrollTop) > 2) sp.scrollTop = next;
           }, 120);
         };
@@ -2644,7 +3452,7 @@ window.__ModuleLoader__.load({
             if (mine.done) { if (glide === mine) glide = null; return; }
             var k = Math.min(1, (Date.now() - started) / dur);
             var eased = 1 - (1 - k) * (1 - k); // quick off the mark, long coast to a stop
-            var live = scrollTargetOf(el, sp); // the target's offset RIGHT NOW
+            var live = getTarget(sp); // the target's offset RIGHT NOW
             sp.scrollTop = start + (live - start) * eased;
             if (k < 1) requestAnimationFrame(frame);
             else land();
@@ -2676,7 +3484,7 @@ window.__ModuleLoader__.load({
         var stalls = 0;
         var watch = setInterval(function () {
           if (mine.done || glide !== mine || drawn) { clearInterval(watch); return; }
-          var live = scrollTargetOf(el, sp);
+          var live = getTarget(sp);
           var top = sp.scrollTop;
           if (Math.abs(live - aimed) > 40) { aim(live); lastTop = top; lastMove = Date.now(); return; }
           if (Math.abs(top - aimed) <= 2) { clearInterval(watch); land(); return; }
@@ -2690,6 +3498,12 @@ window.__ModuleLoader__.load({
         }, 120);
       };
 
+      var glideTo = function (el) {
+        var sp = el.closest ? el.closest("[data-conversation-scroll]") : null;
+        if (!sp) return;
+        glideToTarget(sp, function (s) { return scrollTargetOf(el, s); });
+      };
+
       var jump = function (key, idx) {
         var row = findRow(key);
         if (!row) return;
@@ -2701,6 +3515,84 @@ window.__ModuleLoader__.load({
         glideTo(el);
       };
 
+      // ---- jump to the END of a section ----------------------------------------
+      // Every outline row and every group header also carries a small "to the
+      // section's end" control at its far right. The landing is the boundary where
+      // that content stops: for a heading the first subsequent heading of the same
+      // or a higher level, never past the end of its own turn; for a group header
+      // the end of the turn. The boundary is set down just above the sticky
+      // composer seat (its height rides in --dsh-composer-height) so the section's
+      // tail is actually on screen instead of hidden underneath the input box.
+      // Everything shares the target-agnostic glide, so a long end jump gets the
+      // same stick-zone lift, drift re-aim and landing re-checks as a normal jump.
+      var endLimitOf = function (el, sp) {
+        var spTop = sp.getBoundingClientRect().top;
+        var elTop = el.getBoundingClientRect().top;
+        // Everything returned here is SCROLLER-relative (viewport offset + scrollTop):
+        // endTargetTop works in scroller coordinates, and mixing the two frames made
+        // the landing miss by exactly one scrollTop — measured in the browser, the
+        // section it was aiming at ended up thousands of pixels BELOW the viewport.
+        var base = sp.scrollTop - spTop;
+        var limit = null; // scroller-relative y where this entry's content stops
+        if (el.tagName && /^H[1-6]$/.test(String(el.tagName))) {
+          var lvl = Number(String(el.tagName).slice(1));
+          var hs = sp.querySelectorAll("h1, h2, h3, h4, h5, h6");
+          for (var i = 0; i < hs.length; i++) {
+            var h = hs[i];
+            if (h === el) continue;
+            if (h.getBoundingClientRect().top <= elTop + 1) continue;
+            if (Number(String(h.tagName).slice(1)) > lvl) continue; // a child, not a boundary
+            limit = h.getBoundingClientRect().top + base;
+            break;
+          }
+        }
+        var turnEl = el.closest ? el.closest("[data-chat-turn]") : null;
+        if (turnEl) {
+          var tb = turnEl.getBoundingClientRect().bottom + base;
+          if (limit === null || tb < limit) limit = tb;
+        }
+        return limit;
+      };
+      var endTargetTop = function (limit, sp) {
+        var floor = Math.max(0, sp.scrollHeight - sp.clientHeight);
+        if (limit === null) return floor; // nothing bounds it: the very end of the content
+        var seat = parseInt(getComputedStyle(sp).getPropertyValue("--dsh-composer-height"), 10) || 0;
+        var t = limit - (sp.clientHeight - seat) + 28;
+        return Math.max(0, Math.min(t, floor));
+      };
+      var endJumpRow = function (key, idx) {
+        var row = findRow(key);
+        if (!row) return;
+        var el = row;
+        if (idx !== undefined && idx !== null) {
+          var hs = row.querySelectorAll("h1, h2, h3, h4, h5, h6");
+          if (hs.length > 0) el = hs[Math.min(idx, hs.length - 1)] || row;
+        }
+        var sp = el.closest ? el.closest("[data-conversation-scroll]") : null;
+        if (!sp) return;
+        glideToTarget(sp, function (s) { return endTargetTop(endLimitOf(el, s), s); });
+      };
+      // A group header's control lands on the end of the WHOLE turn: the bottom of
+      // the turn's LAST message (the failure row for a failed turn), so the reader
+      // ends up at the bottom of the model's reply.
+      // It deliberately does NOT go through the [data-chat-turn] element. Measured in
+      // the browser: that attribute matches a small marker (0-80px tall in the
+      // sessions probed) whose bottom sits thousands of pixels away from the reply it
+      // names — the last group's marker ran 637->717 in the viewport while that
+      // group's message ran 3539->3984, so anchoring to it dropped the reader nowhere
+      // near the group they clicked.
+      var endJumpTurn = function (lastKey) {
+        var row = lastKey ? findRow(lastKey) : null;
+        if (!row) return;
+        var sp = row.closest ? row.closest("[data-conversation-scroll]") : null;
+        if (!sp) return;
+        glideToTarget(sp, function (s) {
+          // scroller-relative (+ scrollTop): re-evaluated on every tick
+          var base = row.getBoundingClientRect().bottom + s.scrollTop - s.getBoundingClientRect().top;
+          return endTargetTop(base, s);
+        });
+      };
+
       // ---- unloaded turns: page history to the turn, then land on it ----------
       // The host turn outline carries each turn's `turn/start` seq and the session
       // face's loadThrough(seq) is the documented jump loader ("page history
@@ -2748,24 +3640,123 @@ window.__ModuleLoader__.load({
       };
 
       // returns false when the host exposes no jump loader (older DSH builds)
-      var openTurn = function (turn, seq) {
+      var turnLanded = function (turn) {
+        var list = groupsLiveRef.current || [];
+        for (var i = 0; i < list.length; i++) {
+          if (list[i].turn === turn && !list[i].ghost) return true;
+        }
+        return false;
+      };
+      var openTurn = function (turn, seq, quiet) {
         var sessions = hostSessions();
         if (!sessions) {
           console.warn("[dsh-quick-toc] ctx.get(\"sessions\") returned nothing: this host has no session service, cannot open turn " + turn);
+          if (!quiet) showBanner(T("turn.loadFailed"));
           return false;
         }
         var binding = typeof sessions.binding === "function" ? sessions.binding(sessionId) : null;
         var face = binding && binding.session;
         if (!face || typeof face.loadThrough !== "function") {
           console.warn("[dsh-quick-toc] session " + String(sessionId) + " exposes no loadThrough jump loader, cannot open turn " + turn);
+          if (!quiet) showBanner(T("turn.loadFailed"));
           return false;
         }
+        // The loader silently no-ops when the host considers the window complete
+        // (`hasMore === false`) — that is DEFINITIVE evidence this turn can never be
+        // paged in, so it gets an honest banner. Every other state (session still
+        // opening, a page pull in flight) is transient: the ladder below keeps asking.
+        // A host that exposes no page state at all is asked as before.
+        //
+        // Measured in the browser: right after a session is (re)opened the face reports
+        // `openState: "loading"` WITH `hasMore: false` — the history window has simply
+        // not been read yet. Taking that as definitive dropped a perfectly good
+        // remembered position (the restore forgot it and left the reader wherever the
+        // app happened to be), so `hasMore === false` only counts once the face says the
+        // session is actually open.
+        var state = { open: face.openState, more: face.hasMore, base: face.baseSeq };
+        var sessionSettled = face.openState === undefined || face.openState === "open";
+        var cannotPage = face.hasMore === false && sessionSettled;
+        if (cannotPage) {
+          console.warn("[dsh-quick-toc] jump loader cannot page to turn " + turn + " (seq " + seq + "): openState="
+            + String(state.open) + ", hasMore=" + String(state.more) + ", baseSeq=" + String(state.base)
+            + " — the outline names more turns than this host will page in");
+        }
         setHoverCard(null);
-        Promise.resolve(face.loadThrough(seq)).then(function () {
+        // picking a row in the sheet hands the reader back to the conversation
+        if (sheetOpen) closeSheet();
+        // immediately while a plain page pull owns the busy flag (`loadingOlder`),
+        // and the caller is expected to retry once it settles. That is exactly
+        // "sometimes one click does nothing and a couple of clicks work" — the
+        // clicks that land during an in-flight page are silently discarded. So ask
+        // again on a short ladder: while the loader still says it can page, until
+        // the turn actually lands or a deadline passes.
+        var landed = false;
+        var landingIssued = false;
+        var finish = function () {
+          if (landed) return;
+          landed = true;
           landOnTurn(turn);
-        }, function (err) {
-          console.warn("[dsh-quick-toc] loadThrough failed:", err);
-        });
+        };
+        var giveUp = function () {
+          // a restore is a convenience, not a promise: it never banners, it just
+          // forgets the position so it cannot nag on every open
+          if (quiet) { clearReadPos(sessionId); return; }
+          // last resort, once per session: rebuild the history source and retry
+          if (jumpRetryRef.current) { showBanner(T("turn.loadFailed")); return; }
+          jumpRetryRef.current = true;
+          console.warn("[dsh-quick-toc] turn " + turn + " did not page in; resyncing the history window and retrying once");
+          var rebuilt;
+          try {
+            rebuilt = typeof face.resync === "function" ? face.resync() : null;
+          } catch (e) {
+            rebuilt = Promise.reject(e);
+          }
+          Promise.resolve(rebuilt).then(function () {
+            return face.loadThrough(seq);
+          }).then(function () {
+            landOnTurn(turn);
+            setTimeout(function () {
+              if (!turnLanded(turn)) showBanner(T("turn.loadFailed"));
+            }, 2500);
+          }, function (err) {
+            console.warn("[dsh-quick-toc] resync retry failed:", err);
+            showBanner(T("turn.loadFailed"));
+          });
+        };
+        if (cannotPage) {
+          if (quiet) clearReadPos(sessionId);
+          else showBanner(T("turn.noMoreHistory"));
+          return true;
+        }
+        var deadline = Date.now() + 8000;
+        var ask = function () {
+          if (turnLanded(turn)) { finish(); return; }
+          // same guard as above: a "not open yet" face is asked again rather than
+          // written off (its hasMore is still the placeholder value)
+          var settledNow = face.openState === undefined || face.openState === "open";
+          if (face.hasMore === false && settledNow) {
+            if (quiet) clearReadPos(sessionId);
+            else showBanner(T("turn.noMoreHistory"));
+            return;
+          }
+          if (Date.now() > deadline) { giveUp(); return; }
+          try {
+            Promise.resolve(face.loadThrough(seq)).then(function () {
+              if (turnLanded(turn)) { finish(); return; }
+              // the page is still arriving: let the landing helper start retrying for
+              // the row (it gives up on its own), and keep the ask-ladder running
+              if (!landingIssued) { landingIssued = true; landOnTurn(turn); }
+            }, function (err) {
+              console.warn("[dsh-quick-toc] loadThrough failed:", err);
+            });
+          } catch (e) {
+            console.warn("[dsh-quick-toc] loadThrough threw:", e);
+          }
+          setTimeout(ask, 400);
+        };
+        // first ask immediately (a click must reach the loader in the same task it
+        // happened); the retries ride the ladder
+        ask();
         return true;
       };
 
@@ -2835,14 +3826,15 @@ window.__ModuleLoader__.load({
       };
 
       // ---- circular icon button (glyph optical offset: ox/oy px) ----
-      var iconBtn = function (onClick, tip, glyph, fontSize, offset) {
+      var iconBtn = function (onClick, tip, glyph, fontSize, offset, size) {
         var ox = offset ? (offset.x || 0) : 0;
         var oy = offset ? (offset.y || 0) : 0;
+        var box = size || 24;
         return react_jsx_runtime.jsx("button", {
           onClick: onClick,
           style: {
-            width: 24,
-            height: 24,
+            width: box,
+            height: box,
             display: "flex",
             alignItems: "center",
             justifyContent: "center",
@@ -2885,8 +3877,133 @@ window.__ModuleLoader__.load({
         fuzzy: fuzzy,
         onOpenTurn: openTurn,
         hoverStart: hoverStart,
-        hoverEnd: hoverEnd
+        hoverEnd: hoverEnd,
+        // the curtain is wide: rows switch to a one-line, multi-part layout that
+        // puts the section's opening text out to the right instead of under the
+        // title (see renderItem / renderResultRow)
+        wide: sheetOpen
+      };
+
+      // ---- keyboard cursor plumbing -------------------------------------------
+      // Rows are collected from the DOM in document order, so the cursor sequence is
+      // exactly what the reader sees — one rule for the outline, the questions-only
+      // list, the in-session results and the cross-session results alike.
+      var navRows = function () {
+        var el = listRef.current;
+        if (!el || typeof el.querySelectorAll !== "function") return [];
+        var found = el.querySelectorAll("[data-nav-row]");
+        return Array.prototype.slice.call(found);
+      };
+      var markNav = function (el, on) {
+        if (!el) return;
+        if (el.classList && typeof el.classList.toggle === "function") {
+          el.classList.toggle("dqt-nav", on);
+          return;
+        }
+        var cls = String(el.className || "").split(/\s+/).filter(function (c) { return c && c !== "dqt-nav"; });
+        if (on) cls.push("dqt-nav");
+        el.className = cls.join(" ");
       };
+      var rowText = function (el) {
+        if (!el) return "";
+        var text = String(el.textContent || "").replace(/\s+/g, " ").trim();
+        return text.length > 60 ? text.slice(0, 60) + "…" : text;
+      };
+      var scrollRowIntoView = function (el, row) {
+        if (!el || !row || typeof row.getBoundingClientRect !== "function") return;
+        var box = el.getBoundingClientRect();
+        var rr = row.getBoundingClientRect();
+        if (!box || !rr || typeof box.top !== "number") return;
+        // getBoundingClientRect reports VISUAL pixels while scrollTop is layout: the
+        // panel's zoom factor divides the delta (same reasoning as zLen).
+        var factor = zoom > 0 ? zoom : 1;
+        if (rr.top < box.top + 2) el.scrollTop -= (box.top + 2 - rr.top) / factor;
+        else if (rr.bottom > box.bottom - 2) el.scrollTop += (rr.bottom - box.bottom + 2) / factor;
+      };
+      // which row is the reader looking at? (used when the cursor engages, so ↓
+      // continues from the current position instead of restarting at the top)
+      var nearestRowIndex = function (rows) {
+        var el = listRef.current;
+        if (!el || rows.length === 0) return 0;
+        var box = el.getBoundingClientRect();
+        var mid = box && typeof box.top === "number" ? (box.top + box.bottom) / 2 : 0;
+        var best = 0;
+        var bestGap = Infinity;
+        for (var i = 0; i < rows.length; i++) {
+          var rr = rows[i].getBoundingClientRect ? rows[i].getBoundingClientRect() : null;
+          if (!rr || typeof rr.top !== "number") continue;
+          var gap = Math.abs((rr.top + rr.bottom) / 2 - mid);
+          if (gap < bestGap) { bestGap = gap; best = i; }
+        }
+        return best;
+      };
+      var moveNav = function (delta) {
+        var rows = navRows();
+        if (rows.length === 0) return;
+        var next;
+        if (navIdx < 0) next = nearestRowIndex(rows);
+        else next = navIdx + delta;
+        if (next < 0) next = 0;
+        if (next > rows.length - 1) next = rows.length - 1;
+        setNavIdx(next);
+        setLiveText(rowText(rows[next]));
+      };
+      var jumpNav = function () {
+        var rows = navRows();
+        if (rows.length === 0) return;
+        var idx = navIdx < 0 ? nearestRowIndex(rows) : navIdx;
+        if (idx < 0 || idx >= rows.length) return;
+        var row = rows[idx];
+        setNavIdx(idx);
+        setLiveText(rowText(row));
+        if (row && typeof row.click === "function") row.click();
+      };
+      // Consume a key without assuming the event object is a full DOM event (the host
+      // and test harnesses can synthesize partial ones).
+      var swallow = function (e) {
+        if (!e) return;
+        if (typeof e.preventDefault === "function") e.preventDefault();
+        if (typeof e.stopPropagation === "function") e.stopPropagation();
+      };
+      var onPanelKeyDown = function (e) {
+        var target = e.target;
+        var tag = target && target.tagName ? String(target.tagName).toUpperCase() : "";
+        // the search box owns its own keys (it stops propagation for the ones it uses)
+        if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT" || (target && target.isContentEditable)) return;
+        if (e.altKey || e.ctrlKey || e.metaKey) return;
+        var key = e.key;
+        if (key === "ArrowDown" || key === "ArrowUp") {
+          swallow(e);
+          moveNav(key === "ArrowDown" ? 1 : -1);
+          return;
+        }
+        if (key === "Home" || key === "End") {
+          var rows = navRows();
+          if (rows.length === 0) return;
+          swallow(e);
+          var idx = key === "Home" ? 0 : rows.length - 1;
+          setNavIdx(idx);
+          setLiveText(rowText(rows[idx]));
+          return;
+        }
+        if (key === "Enter") {
+          swallow(e);
+          jumpNav();
+          return;
+        }
+        if (key === "Escape") {
+          if (sheetOpen) { swallow(e); closeSheet(); return; }
+          if (!open) return;
+          swallow(e);
+          setNavIdx(-1);
+          setOpen(false);
+        }
+      };
+      // keep the painted cursor on the row the index points at, and keep that row in
+      // view. Runs whenever the row set itself changes (page-in, new results, a mode
+      // switch) so the cursor never survives onto a different row. (The effect itself
+      // lives above the early return, with the other hooks.)
+
       // Transient banner pinned to the bottom of the panel (the panel is
       // position:fixed, so this anchors to the list's lower edge without joining
       // the list's scroll flow). pointerEvents:none keeps it from eating clicks.
@@ -2928,9 +4045,13 @@ window.__ModuleLoader__.load({
       // while `zoom` itself does not animate: leaving `left` in the transition on that
       // one render would let the panel slide across the screen. It lands on exactly the
       // same visual spot either way, so that render simply skips the transition.
-      var slide = open ? "0.6s " + EASE : "0.28s " + EASE;
+      // The tuck is a departure even though `open` is still true, so it has to move
+      // at the CLOSING speed: with the opening 0.6s curve the panel was still
+      // travelling when the curtain took over, which looked like it flashed away.
+      var panelAway = !open || panelAside === "tuck";
+      var slide = panelAway ? "0.28s " + EASE : "0.6s " + EASE;
       var panelTransition = (zoomJustChanged ? "" : "left " + slide + ", ")
-        + "clip-path " + slide + ", opacity " + (open ? "0.45s ease" : "0.14s ease 0.26s");
+        + "clip-path " + slide + ", opacity " + (panelAway ? "0.14s ease 0.26s" : "0.45s ease");
 
       // clip the panel at the dock edge while collapsed, so sliding away looks
       // like being covered by the sidebar (the sidebar stays untouched):
@@ -2939,7 +4060,7 @@ window.__ModuleLoader__.load({
       // LEFT dock keeps its original clip (collapse left). RIGHT dock clips the
       // LEFT side so the panel closes toward its right (dock) edge in place.
       var panelClip = "inset(0 0 0 0px)";
-      if (!open) {
+      if (!geoOpen) {
         if (dockRight) {
           // mirror of LEFT: clip the RIGHT side (panel flies right, shrinking from its right)
           panelClip = "inset(0 " + zLen(panelW) + " 0 0)";
@@ -2955,277 +4076,415 @@ window.__ModuleLoader__.load({
       // renderGroups) instead of from fading everything else away.
       var panelOpacity = open && chatViewActive ? (hovered ? 1 : 0.72) : 0;
 
-      var panelEl = react_jsx_runtime.jsx("div", {
-        ref: panelRootRef,
-        style: {
-          position: "fixed",
-          top: zLen(baseTopPx),
-          left: zLen(panelLeft),
-          width: zLen(panelW),
-          maxHeight: zLen(vMaxH),
-          height: panelH > 0 ? zLen(panelH) : undefined,
-          zoom: zoom === 1 ? undefined : zoom,
-          display: "flex",
-          flexDirection: "column",
-          background: C.panelBg,
-          border: "none",
-          borderRadius: 12,
-          zIndex: Z_BASE,
-          overflow: "hidden",
-          color: C.text,
-          opacity: panelOpacity,
-          clipPath: panelClip,
-          // inner shadow only (no outer): theme-aware (white bevel in dark mode,
-          // soft shade in light) — outer shadow would be clipped by the collapse
-          // clip-path and the panel edges.
-          boxShadow: innerShadow(),
-          // A view switch swaps in a short, delay-free opacity fade; the dock and
-          // collapse animations keep their own (slower) timings.
-          transition: viewFading ? "opacity 0.3s ease" : panelTransition,
-          pointerEvents: chatViewActive ? "auto" : "none"
-        },
-        onMouseEnter: function () { setHovered(true); },
-        onMouseLeave: function () { setHovered(false); },
-        onClickCapture: function (e) {
-          // jump handled in the capture phase (bubble-phase handlers are unreliable here)
-          var t = e.target;
-          var item = (t && t.closest) ? t.closest("[data-jump-key]") : null;
-          if (item && item.dataset && item.dataset.jumpKey) {
-            e.preventDefault();
-            e.stopPropagation();
-            var idx = item.dataset.jumpIdx !== undefined ? Number(item.dataset.jumpIdx) : 0;
-            jump(item.dataset.jumpKey, idx);
-          }
-        },
-        children: [
-          // top block: small grip bar on top + header row below (whole block draggable)
-          react_jsx_runtime.jsx("div", {
-            style: {
-              flex: "none",
-              cursor: "grab",
-              userSelect: "none"
-            },
-            title: T("handle.dragY"),
-            onPointerDown: onHandleDown,
-            onMouseEnter: function () { handleBright(true); },
-            onMouseLeave: function () { handleBright(false); },
-            children: [
+      // ---- toolbar buttons -----------------------------------------------------
+      // ONE instance of each, placed either in the docked header row or in the
+      // curtain's own chrome. On the curtain they are larger (that surface has the
+      // room), and the dock / curtain / collapse controls are not built at all —
+      // they mean nothing on a panel that already spans the conversation.
+      var tbSize = sheetOpen ? 32 : 24;
+      var tbIcon = sheetOpen ? 18 : 14;
+      var tbIconLg = sheetOpen ? 20 : 15;
+      var toolBtn = function (tool, className, onClick, title, active, disabled, svg, extra) {
+        var props = {
+          className: className,
+          onClick: onClick,
+          title: title,
+          "data-tool": tool,
+          style: {
+            width: tbSize,
+            height: tbSize,
+            padding: 0,
+            border: "none",
+            borderRadius: "50%",
+            cornerShape: "round",
+            flex: "none",
+            display: "flex",
+            alignItems: "center",
+            justifyContent: "center",
+            cursor: disabled ? "default" : "pointer",
+            opacity: disabled ? 0.45 : 1,
+            // open (or still animating shut) uses the SAME tint as every other
+            // "on" control, so the toolbar reads consistently in both layouts
+            background: active ? C.chip : "var(--dsw-alias-interactive-bg-hover, rgba(128,128,128,0.16))",
+            color: active ? C.accent : C.muted,
+            transition: "background 0.15s ease, color 0.15s ease, opacity 0.2s ease"
+          },
+          onMouseEnter: function (e) {
+            if (disabled) return;
+            e.currentTarget.style.background = "var(--dsw-alias-interactive-bg-active, rgba(79,140,255,0.24))";
+            e.currentTarget.style.color = "var(--dsw-alias-brand-primary, #4f8cff)";
+          },
+          onMouseLeave: function (e) {
+            e.currentTarget.style.background = active ? C.chip : "var(--dsw-alias-interactive-bg-hover, rgba(128,128,128,0.16))";
+            e.currentTarget.style.color = active ? C.accent : C.muted;
+          },
+          children: svg
+        };
+        // always present (false, not undefined): the toolbar reads it to decide the
+        // resting cursor/opacity, and the tests assert the false case explicitly
+        props.disabled = !!disabled;
+        if (extra) {
+          for (var k in extra) {
+            if (Object.prototype.hasOwnProperty.call(extra, k)) props[k] = extra[k];
+          }
+        }
+        return react_jsx_runtime.jsx("button", props);
+      };
+      // heading-level filter: a round icon button that pops down the H1–H6 picker.
+      // Icon: three lines of decreasing width = outline levels.
+      var levelsBtnEl = toolBtn("levels", "dqt-levels-btn",
+        function () { if (questionsOnly) return; levelsOpen ? closeLevels() : setLevelsOpen(true); },
+        questionsOnly ? T("levels.offInQuestions") : T("levels.tip"),
+        (levelsOpen || levelsClosing), questionsOnly,
+        react_jsx_runtime.jsx("svg", {
+          width: tbIcon,
+          height: tbIcon,
+          viewBox: "0 0 14 14",
+          fill: "none",
+          stroke: "currentColor",
+          strokeWidth: 1.8,
+          strokeLinecap: "round",
+          style: { display: "block" },
+          children: [
+            react_jsx_runtime.jsx("line", { x1: 1.5, y1: 3, x2: 12.5, y2: 3 }),
+            react_jsx_runtime.jsx("line", { x1: 1.5, y1: 7, x2: 9, y2: 7 }),
+            react_jsx_runtime.jsx("line", { x1: 1.5, y1: 11, x2: 5.5, y2: 11 })
+          ]
+        })
+      );
+      // questions-only toggle: icon = a speech bubble (the prompt), which is exactly
+      // what that view keeps
+      var questionsBtnEl = toolBtn("questions", "dqt-questions-btn", toggleQuestions,
+        questionsOnly ? T("view.questions.tipOn") : T("view.questions.tipOff"),
+        questionsOnly, false,
+        react_jsx_runtime.jsx("svg", {
+          width: tbIcon,
+          height: tbIcon,
+          viewBox: "0 0 14 14",
+          fill: "none",
+          stroke: "currentColor",
+          strokeWidth: 1.8,
+          strokeLinecap: "round",
+          strokeLinejoin: "round",
+          style: { display: "block" },
+          children: [
+            react_jsx_runtime.jsx("rect", { x: 1.6, y: 2.4, width: 10.8, height: 7.2, rx: 1.6 }),
+            react_jsx_runtime.jsx("path", { d: "M4.6 9.6v2.6l2.8-2.6" })
+          ]
+        }),
+        { "data-questions": questionsOnly ? "on" : "off" }
+      );
+      // magnifier (SVG, matches the other buttons' style)
+      var searchBtnEl = toolBtn("search", "dqt-search-btn",
+        function () { searchOpen ? closeSearch() : openSearch(); },
+        T("search.open"), searchOpen, false,
+        react_jsx_runtime.jsx("svg", {
+          width: tbIconLg,
+          height: tbIconLg,
+          viewBox: "0 0 24 24",
+          // overflow visible: the stroke may extend past the
+          // viewBox without being clipped at the svg boundary
+          style: { display: "block", transform: "translate(-1px, -1px)", overflow: "visible" },
+          fill: "none",
+          stroke: "currentColor",
+          strokeWidth: 3.6,
+          strokeLinecap: "round",
+          children: [
+            react_jsx_runtime.jsx("circle", { cx: 11, cy: 11, r: 7 }),
+            react_jsx_runtime.jsx("line", { x1: 21, y1: 21, x2: 16, y2: 16 })
+          ]
+        })
+      );
+      // the curtain's way out: the SAME thick SVG cross as the docked header's
+      // collapse button, scaled with the rest of the curtain's buttons
+      var sheetCloseBtnEl = toolBtn("close", "dqt-sheet-close-btn", closeSheet, T("sheet.close"), false, false,
+        react_jsx_runtime.jsx("svg", {
+          width: tbIconLg,
+          height: tbIconLg,
+          viewBox: "0 0 24 24",
+          style: { display: "block", transform: "translate(1px, 0px)", overflow: "visible" },
+          fill: "none",
+          stroke: "currentColor",
+          strokeWidth: 3.4,
+          strokeLinecap: "round",
+          children: [
+            // cross lines span 5..19, intersection (12,12) centered
+            react_jsx_runtime.jsx("line", { x1: 5, y1: 5, x2: 19, y2: 19 }),
+            react_jsx_runtime.jsx("line", { x1: 19, y1: 5, x2: 5, y2: 19 })
+          ]
+        })
+      );
+      // heading-level picker: pops down from the round toolbar button. It is anchored
+      // to the toolbar itself on the curtain (no overflow-clipped row there) and to
+      // the panel box in the docked layout (the header row scrolls sideways, so a
+      // child of it would be clipped). Open/close animate from the button's center;
+      // the animation lives in the injected stylesheet (classes, not inline
+      // animation) so React re-renders never restart or cancel it.
+      var buildLevelsPop = function (inSheet) {
+        // on the curtain the six levels are ONE spread-out row (there is room);
+        // in the narrow docked panel they have to wrap, and they are capped by the
+        // panel's own width rather than by the shrink-to-fit toolbar wrapper
+        var popW = inSheet ? "min(336px, 74vw)" : undefined;
+        return react_jsx_runtime.jsx("div", {
+          className: "dqt-levels-pop" + (levelsClosing ? " dqt-levels-pop-closing" : ""),
+          style: {
+            position: "absolute",
+            top: inSheet ? "calc(100% + 8px)" : 40,
+            left: inSheet ? 0 : 10,
+            zIndex: 30,
+            display: "flex",
+            alignItems: "center",
+            flexWrap: inSheet ? "nowrap" : "wrap",
+            gap: 4,
+            padding: 8,
+            background: C.panelBg,
+            border: "1px solid " + C.panelBorder,
+            borderRadius: 10,
+            cornerShape: "round",
+            boxShadow: "0 6px 20px rgba(0, 0, 0, 0.28), 0 2px 6px rgba(0, 0, 0, 0.18)",
+            width: popW,
+            maxWidth: inSheet ? popW : "calc(100% - 20px)",
+            // the button's center sits 12px (dock) / 16px (curtain) inside the popup
+            transformOrigin: (inSheet ? tbSize / 2 : 12) + "px top"
+          },
+          children: [1, 2, 3, 4, 5, 6].map(function (lv) {
+            var active = !!levelSet[lv];
+            return react_jsx_runtime.jsx("button", {
+              onClick: function () { toggleLevel(lv); },
+              title: active ? T("levels.hide") + lv : T("levels.show") + lv,
+              style: {
+                height: inSheet ? 32 : 22,
+                flex: inSheet ? "1 1 0" : "0 0 auto",
+                minWidth: 0,
+                padding: inSheet ? 0 : "0 7px",
+                border: "none",
+                borderRadius: 6,
+                cornerShape: "round",
+                cursor: "pointer",
+                fontSize: inSheet ? 14.5 : 11,
+                lineHeight: (inSheet ? 32 : 22) + "px",
+                fontFamily: "inherit",
+                background: active
+                  ? C.chip
+                  : "var(--dsw-alias-interactive-bg-hover, rgba(128,128,128,0.14))",
+                color: active ? C.accent : C.muted,
+                fontWeight: active ? 600 : 400
+              },
+              children: "H" + lv
+            }, "lv" + lv);
+          })
+        });
+      };
+      var levelsPopDockEl = (!sheetOpen && (levelsOpen || levelsClosing)) ? buildLevelsPop(false) : null;
+      var levelsPopSheetEl = (sheetOpen && (levelsOpen || levelsClosing)) ? buildLevelsPop(true) : null;
+      // dock toggle: the triangle tips toward the side it will move TO
+      var dockBtnEl = iconBtn(toggleDock, dockRight ? T("handle.dockLeft") : T("handle.dockRight"), dockRight ? "◀" : "▶", 12, dockRight ? { x: -1, y: -1 } : { x: 1, y: -1 });
+      // the curtain button: a surface with an arrow rising out of it
+      var sheetBtnEl = react_jsx_runtime.jsx("button", {
+        className: "dqt-sheet-btn",
+        onClick: openSheet,
+        title: T("sheet.open"),
+        style: {
+          width: 24,
+          height: 24,
+          padding: 0,
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          borderRadius: "50%",
+          cornerShape: "round",
+          border: "none",
+          flex: "none",
+          cursor: "pointer",
+          background: "var(--dsw-alias-interactive-bg-hover, rgba(128,128,128,0.16))",
+          color: C.muted,
+          transition: "background 0.15s ease, color 0.15s ease, opacity 0.2s ease"
+        },
+        onMouseEnter: function (e) {
+          e.currentTarget.style.background = "var(--dsw-alias-interactive-bg-active, rgba(79,140,255,0.24))";
+          e.currentTarget.style.color = "var(--dsw-alias-brand-primary, #4f8cff)";
+        },
+        onMouseLeave: function (e) {
+          e.currentTarget.style.background = "var(--dsw-alias-interactive-bg-hover, rgba(128,128,128,0.16))";
+          e.currentTarget.style.color = C.muted;
+        },
+        children: react_jsx_runtime.jsx("svg", {
+          width: 14,
+          height: 14,
+          viewBox: "0 0 14 14",
+          fill: "none",
+          stroke: "currentColor",
+          strokeWidth: 1.8,
+          strokeLinecap: "round",
+          strokeLinejoin: "round",
+          style: { display: "block" },
+          children: [
+            react_jsx_runtime.jsx("rect", { x: 1.6, y: 3.2, width: 10.8, height: 9.2, rx: 1.6 }),
+            react_jsx_runtime.jsx("path", { d: "M7 9.6V5.6M4.9 7.7L7 5.6l2.1 2.1" })
+          ]
+        })
+      });
+      // collapse (docked panel only): thick SVG cross, nudged slightly down
+      var headerCloseBtnEl = react_jsx_runtime.jsx("button", {
+        onClick: function () { setOpen(false); },
+        title: T("handle.collapse"),
+        style: {
+          width: 24,
+          height: 24,
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          borderRadius: "50%",
+          cornerShape: "round",
+          background: "var(--dsw-alias-interactive-bg-hover, rgba(128,128,128,0.16))",
+          border: "none",
+          color: C.muted,
+          cursor: "pointer"
+        },
+        onMouseEnter: function (e) {
+          e.currentTarget.style.background = "var(--dsw-alias-interactive-bg-active, rgba(79,140,255,0.24))";
+          e.currentTarget.style.color = "var(--dsw-alias-brand-primary, #4f8cff)";
+        },
+        onMouseLeave: function (e) {
+          e.currentTarget.style.background = "var(--dsw-alias-interactive-bg-hover, rgba(128,128,128,0.16))";
+          e.currentTarget.style.color = C.muted;
+        },
+        children: react_jsx_runtime.jsx("svg", {
+          width: 15,
+          height: 15,
+          viewBox: "0 0 24 24",
+          style: { display: "block", transform: "translate(1px, 0px)", overflow: "visible" },
+          fill: "none",
+          stroke: "currentColor",
+          strokeWidth: 3.4,
+          strokeLinecap: "round",
+          children: [
+            // cross lines span 5..19, intersection (12,12) centered
+            react_jsx_runtime.jsx("line", { x1: 5, y1: 5, x2: 19, y2: 19 }),
+            react_jsx_runtime.jsx("line", { x1: 19, y1: 5, x2: 5, y2: 19 })
+          ]
+        })
+      });
+
+      // ---- docked header: grip bar on top + the header row (whole block draggable)
+      var dockHeaderEl = react_jsx_runtime.jsx("div", {
+        style: {
+          flex: "none",
+          cursor: "grab",
+          userSelect: "none"
+        },
+        title: T("handle.dragY"),
+        onPointerDown: onHandleDown,
+        onMouseEnter: function () { handleBright(true); },
+        onMouseLeave: function () { handleBright(false); },
+        children: [
+          react_jsx_runtime.jsx("div", {
+            ref: handleRef,
+            style: {
+              width: 56,
+              maxWidth: "calc(100% - 12px)",
+              height: 5,
+              borderRadius: 999,
+              cornerShape: "round",
+              background: "var(--dsw-alias-border-l2, rgba(128,128,128,0.55))",
+              // no slack left in the header -> the grab hint fades away
+              opacity: crowded ? 0 : 0.35,
+              transition: "opacity 0.2s ease",
+              margin: "5px auto 2px"
+            }
+          }),
+          react_jsx_runtime.jsx("div", {
+            ref: headerRef,
+            className: "dqt-header",
+            style: {
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "space-between",
+              padding: "1px 10px 5px",
+              borderBottom: "1px solid " + C.panelBorder,
+              fontSize: 13,
+              fontWeight: 600,
+              gap: 6,
+              // the controls keep their size and stay on ONE line; when the row
+              // runs out of room it scrolls sideways (wheel) instead of wrapping or
+              // overlapping, and the flexible spacer below collapses first
+              flexWrap: "nowrap",
+              overflowX: "auto",
+              overflowY: "hidden",
+              scrollbarWidth: "none"
+            },
+            children: [
+              // LEFT pair: the heading-level filter and the dock toggle take the
+              // left end — so the header reads two controls per side (search +
+              // collapse sit at the other end).
               react_jsx_runtime.jsx("div", {
-                ref: handleRef,
-                style: {
-                  width: 56,
-                  maxWidth: "calc(100% - 12px)",
-                  height: 5,
-                  borderRadius: 999,
-                  cornerShape: "round",
-                  background: "var(--dsw-alias-border-l2, rgba(128,128,128,0.55))",
-                  // no slack left in the header -> the grab hint fades away
-                  opacity: crowded ? 0 : 0.35,
-                  transition: "opacity 0.2s ease",
-                  margin: "5px auto 2px"
-                }
+                style: { display: "flex", alignItems: "center", gap: 6, flex: "none" },
+                children: [levelsBtnEl, questionsBtnEl, dockBtnEl]
               }),
+              // spacer: nothing here, it just pins the two pairs to the two ends —
+              // and it is the first thing to give way when the panel narrows
+              react_jsx_runtime.jsx("div", { style: { flex: "1 1 auto", minWidth: 0 } }),
+              // RIGHT pair: search + curtain + collapse
               react_jsx_runtime.jsx("div", {
-                ref: headerRef,
-                className: "dqt-header",
-                style: {
-                  display: "flex",
-                  alignItems: "center",
-                  justifyContent: "space-between",
-                  padding: "1px 10px 5px",
-                  borderBottom: "1px solid " + C.panelBorder,
-                  fontSize: 13,
-                  fontWeight: 600,
-                  gap: 6,
-                  // the four controls keep their size and stay on ONE line; when the row
-                  // runs out of room it scrolls sideways (wheel) instead of wrapping or
-                  // overlapping, and the flexible spacer below collapses first
-                  flexWrap: "nowrap",
-                  overflowX: "auto",
-                  overflowY: "hidden",
-                  scrollbarWidth: "none"
-                },
-                children: [
-                  // LEFT pair: the heading-level filter and the dock toggle take the
-                  // left end — so the header reads two controls per side (search +
-                  // collapse sit at the other end).
-                  react_jsx_runtime.jsx("div", {
-                    style: { display: "flex", alignItems: "center", gap: 6, flex: "none" },
-                    children: [
-                      // heading-level filter: a round icon button that pops down the
-                      // H1–H6 picker. Icon: three lines of decreasing width = outline
-                      // levels. Hover behaviour matches the magnifier: background +
-                      // icon tint change; the resting look never shifts when open.
-                      react_jsx_runtime.jsx("button", {
-                        className: "dqt-levels-btn",
-                        onClick: function () { levelsOpen ? closeLevels() : setLevelsOpen(true); },
-                        title: T("levels.tip"),
-                        style: {
-                          width: 24,
-                          height: 24,
-                          padding: 0,
-                          border: "none",
-                          borderRadius: "50%",
-                          cornerShape: "round",
-                          cursor: "pointer",
-                          flex: "none",
-                          display: "flex",
-                          alignItems: "center",
-                          justifyContent: "center",
-                          // open (or still animating shut) uses the SAME tint as every
-                          // other "on" control, so the header reads consistently
-                          background: (levelsOpen || levelsClosing) ? C.chip : "var(--dsw-alias-interactive-bg-hover, rgba(128,128,128,0.16))",
-                          color: (levelsOpen || levelsClosing) ? C.accent : C.muted,
-                          transition: "background 0.15s ease, color 0.15s ease"
-                        },
-                        onMouseEnter: function (e) {
-                          e.currentTarget.style.background = "var(--dsw-alias-interactive-bg-active, rgba(79,140,255,0.24))";
-                          e.currentTarget.style.color = "var(--dsw-alias-brand-primary, #4f8cff)";
-                        },
-                        onMouseLeave: function (e) {
-                          e.currentTarget.style.background = (levelsOpen || levelsClosing) ? C.chip : "var(--dsw-alias-interactive-bg-hover, rgba(128,128,128,0.16))";
-                          e.currentTarget.style.color = (levelsOpen || levelsClosing) ? C.accent : C.muted;
-                        },
-                        children: react_jsx_runtime.jsx("svg", {
-                          width: 14,
-                          height: 14,
-                          viewBox: "0 0 14 14",
-                          fill: "none",
-                          stroke: "currentColor",
-                          strokeWidth: 1.8,
-                          strokeLinecap: "round",
-                          style: { display: "block" },
-                          children: [
-                            react_jsx_runtime.jsx("line", { x1: 1.5, y1: 3, x2: 12.5, y2: 3 }),
-                            react_jsx_runtime.jsx("line", { x1: 1.5, y1: 7, x2: 9, y2: 7 }),
-                            react_jsx_runtime.jsx("line", { x1: 1.5, y1: 11, x2: 5.5, y2: 11 })
-                          ]
-                        })
-                      }),
-                      // dock toggle: the triangle tips toward the side it will move TO
-                      iconBtn(toggleDock, dockRight ? T("handle.dockLeft") : T("handle.dockRight"), dockRight ? "◀" : "▶", 12, dockRight ? { x: -1, y: -1 } : { x: 1, y: -1 })
-                    ]
-                  }),
-                  // spacer: nothing here, it just pins the two pairs to the two ends —
-                  // and it is the first thing to give way when the panel narrows
-                  react_jsx_runtime.jsx("div", { style: { flex: "1 1 auto", minWidth: 0 } }),
-                  // RIGHT pair: search + collapse
-                  react_jsx_runtime.jsx("div", {
-                    style: { display: "flex", alignItems: "center", gap: 6, flex: "none" },
-                    children: [
-                      // magnifier button (SVG, matches the other buttons' style)
-                      react_jsx_runtime.jsx("button", {
-                        onClick: function () { searchOpen ? closeSearch() : openSearch(); },
-                        title: T("search.open"),
-                        style: {
-                          width: 24,
-                          height: 24,
-                          display: "flex",
-                          alignItems: "center",
-                          justifyContent: "center",
-                          borderRadius: "50%",
-                          cornerShape: "round",
-                          background: searchOpen ? C.chip : "var(--dsw-alias-interactive-bg-hover, rgba(128,128,128,0.16))",
-                          border: "none",
-                          color: searchOpen ? C.accent : C.muted,
-                          cursor: "pointer"
-                        },
-                        onMouseEnter: function (e) {
-                          e.currentTarget.style.background = "var(--dsw-alias-interactive-bg-active, rgba(79,140,255,0.24))";
-                          e.currentTarget.style.color = "var(--dsw-alias-brand-primary, #4f8cff)";
-                        },
-                        onMouseLeave: function (e) {
-                          e.currentTarget.style.background = searchOpen ? C.chip : "var(--dsw-alias-interactive-bg-hover, rgba(128,128,128,0.16))";
-                          e.currentTarget.style.color = searchOpen ? C.accent : C.muted;
-                        },
-                        children: react_jsx_runtime.jsx("svg", {
-                          width: 15,
-                          height: 15,
-                          viewBox: "0 0 24 24",
-                          // overflow visible: the stroke may extend past the
-                          // viewBox without being clipped at the svg boundary
-                          style: { display: "block", transform: "translate(-1px, -1px)", overflow: "visible" },
-                          fill: "none",
-                          stroke: "currentColor",
-                          strokeWidth: 3.6,
-                          strokeLinecap: "round",
-                          children: [
-                            react_jsx_runtime.jsx("circle", { cx: 11, cy: 11, r: 7 }),
-                            react_jsx_runtime.jsx("line", { x1: 21, y1: 21, x2: 16, y2: 16 })
-                          ]
-                        })
-                      }),
-                      // close: thick SVG cross, nudged slightly down
-                      react_jsx_runtime.jsx("button", {
-                        onClick: function () { setOpen(false); },
-                        title: T("handle.collapse"),
-                        style: {
-                          width: 24,
-                          height: 24,
-                          display: "flex",
-                          alignItems: "center",
-                          justifyContent: "center",
-                          borderRadius: "50%",
-                          cornerShape: "round",
-                          background: "var(--dsw-alias-interactive-bg-hover, rgba(128,128,128,0.16))",
-                          border: "none",
-                          color: C.muted,
-                          cursor: "pointer"
-                        },
-                        onMouseEnter: function (e) {
-                          e.currentTarget.style.background = "var(--dsw-alias-interactive-bg-active, rgba(79,140,255,0.24))";
-                          e.currentTarget.style.color = "var(--dsw-alias-brand-primary, #4f8cff)";
-                        },
-                        onMouseLeave: function (e) {
-                          e.currentTarget.style.background = "var(--dsw-alias-interactive-bg-hover, rgba(128,128,128,0.16))";
-                          e.currentTarget.style.color = C.muted;
-                        },
-                        children: react_jsx_runtime.jsx("svg", {
-                          width: 15,
-                          height: 15,
-                          viewBox: "0 0 24 24",
-                          style: { display: "block", transform: "translate(1px, 0px)", overflow: "visible" },
-                          fill: "none",
-                          stroke: "currentColor",
-                          strokeWidth: 3.4,
-                          strokeLinecap: "round",
-                          children: [
-                            // cross lines span 5..19, intersection (12,12) centered
-                            react_jsx_runtime.jsx("line", { x1: 5, y1: 5, x2: 19, y2: 19 }),
-                            react_jsx_runtime.jsx("line", { x1: 19, y1: 5, x2: 5, y2: 19 })
-                          ]
-                        })
-                      })
-                    ]
-                  })
-                ]
+                style: { display: "flex", alignItems: "center", gap: 6, flex: "none" },
+                children: [searchBtnEl, sheetBtnEl, headerCloseBtnEl]
               })
             ]
+          })
+        ]
+      });
+
+      // ---- curtain chrome: the controls that still apply here (the level filter,
+      // questions-only, search) plus the way out. There is no title — the surface is
+      // self-evident — and no hint text: ✕ and Esc are the obvious exits. The dock /
+      // curtain / collapse buttons are absent on purpose: there is no docked panel to
+      // move and no second curtain to open.
+      var sheetChromeEl = react_jsx_runtime.jsx("div", {
+        className: "dqt-sheet-chrome",
+        title: T("sheet.noDrag"),
+        style: {
+          flex: "none",
+          display: "flex",
+          alignItems: "center",
+          gap: 10,
+          padding: "7px 12px",
+          borderBottom: "1px solid " + C.panelBorder
+        },
+        children: [
+          react_jsx_runtime.jsx("div", {
+            style: { position: "relative", display: "flex", alignItems: "center", gap: 8, flex: "none" },
+            children: [levelsBtnEl, questionsBtnEl, levelsPopSheetEl]
           }),
-          // search input row: outer grid row animates 0fr<->1fr so the row
-          // collapses/expands to its EXACT natural height (no max-height
-          // overshoot stutter); the outline below moves smoothly with it
-          (searchOpen || searchAnim === "out") ? react_jsx_runtime.jsx("div", {
+          react_jsx_runtime.jsx("div", { style: { flex: "1 1 auto", minWidth: 0 } }),
+          searchBtnEl,
+          sheetCloseBtnEl
+        ]
+      });
+
+      // ---- search row: the input plus the scope pill, the fuzzy switch and the
+      // match counter. In the docked layout it is a row under the header; on the
+      // curtain it is the head of the search column on the right.
+      var searchRowEl = (searchOpen || searchAnim === "out") ? react_jsx_runtime.jsx("div", {
+        style: {
+          display: "grid",
+          gridTemplateRows: (searchAnim === "enter" || searchAnim === "out") ? "0fr" : "1fr",
+          transition: "grid-template-rows 0.2s " + EASE,
+          flex: "none"
+        },
+        children: react_jsx_runtime.jsx("div", {
+          style: { overflow: "hidden", minHeight: 0 },
+          children: react_jsx_runtime.jsx("div", {
             style: {
-              display: "grid",
-              gridTemplateRows: (searchAnim === "enter" || searchAnim === "out") ? "0fr" : "1fr",
-              transition: "grid-template-rows 0.2s " + EASE,
-              flex: "none"
+              display: "flex",
+              alignItems: "center",
+              gap: sheetOpen ? 6 : 4,
+              padding: sheetOpen ? "4px 10px 8px" : "2px 8px 4px",
+              borderBottom: "1px solid " + C.panelBorder,
+              opacity: (searchAnim === "enter" || searchAnim === "out") ? 0 : 1,
+              transform: (searchAnim === "enter" || searchAnim === "out") ? "translateY(-6px)" : "none",
+              transition: "opacity 0.2s ease, transform 0.2s ease"
             },
-            children: react_jsx_runtime.jsx("div", {
-              style: { overflow: "hidden", minHeight: 0 },
-              children: react_jsx_runtime.jsx("div", {
-                style: {
-                  display: "flex",
-                  alignItems: "center",
-                  gap: 4,
-                  padding: "2px 8px 4px",
-                  borderBottom: "1px solid " + C.panelBorder,
-                  opacity: (searchAnim === "enter" || searchAnim === "out") ? 0 : 1,
-                  transform: (searchAnim === "enter" || searchAnim === "out") ? "translateY(-6px)" : "none",
-                  transition: "opacity 0.2s ease, transform 0.2s ease"
-                },
-                children: [
+            children: [
               // input with a custom animated placeholder: the box stays static,
               // only the placeholder text fades when the scope switches
               react_jsx_runtime.jsx("div", {
@@ -3238,7 +4497,7 @@ window.__ModuleLoader__.load({
                   background: "var(--dsw-alias-interactive-bg-hover, rgba(128,128,128,0.14))",
                   borderRadius: 999,
                   cornerShape: "round",
-                  padding: "6px 12px"
+                  padding: sheetOpen ? "8px 14px" : "6px 12px"
                 },
                 children: [
                   react_jsx_runtime.jsx("input", {
@@ -3246,8 +4505,12 @@ window.__ModuleLoader__.load({
                     value: query,
                     onChange: function (e) { onQueryChange(e.target.value); },
                     onKeyDown: function (e) {
-                      if (e.key === "Enter") { goToMatch(matchIdx + 1); e.preventDefault(); }
-                      if (e.key === "Escape") { closeSearch(); }
+                      // ↑/↓ step the in-session matches, exactly like Enter does
+                      // (arrows only mean something while a query is typed)
+                      if (e.key === "ArrowDown") { goToMatch(matchIdx + 1); swallow(e); return; }
+                      if (e.key === "ArrowUp") { goToMatch(matchIdx - 1); swallow(e); return; }
+                      if (e.key === "Enter") { goToMatch(matchIdx + 1); swallow(e); return; }
+                      if (e.key === "Escape") { closeSearch(); swallow(e); }
                     },
                     style: {
                       flex: 1,
@@ -3256,7 +4519,7 @@ window.__ModuleLoader__.load({
                       background: "transparent",
                       border: "none",
                       outline: "none",
-                      fontSize: 13,
+                      fontSize: sheetOpen ? 16 : 13,
                       color: C.text,
                       padding: 0
                     }
@@ -3264,9 +4527,9 @@ window.__ModuleLoader__.load({
                   (!query) ? react_jsx_runtime.jsx("span", {
                     style: {
                       position: "absolute",
-                      left: 12,
+                      left: sheetOpen ? 14 : 12,
                       pointerEvents: "none",
-                      fontSize: 13,
+                      fontSize: sheetOpen ? 16 : 13,
                       color: "var(--dsw-alias-label-tertiary, rgba(128,128,128,0.7))"
                     },
                     children: [
@@ -3277,21 +4540,21 @@ window.__ModuleLoader__.load({
                           react_jsx_runtime.jsx("span", {
                             key: searchScope,
                             style: { display: "inline-block", animation: "dqt-fade-in 0.25s linear" },
-                            children: searchScope === "title" ? T("search.scope.title") : T("search.scope.full")
+                            children: scopeLabel(searchScope)
                           }),
                           (prevScope && prevScope !== searchScope) ? react_jsx_runtime.jsx("span", {
                             key: "old-" + prevScope,
                             style: { position: "absolute", left: 0, top: 0, opacity: 0, animation: "dqt-fade-out 0.25s linear forwards" },
-                            children: prevScope === "title" ? T("search.scope.title") : T("search.scope.full")
+                            children: scopeLabel(prevScope)
                           }) : null
                         ]
                       }),
                       T("search.tail")
                     ]
-                  }) : null,
+                  }) : null
                 ]
               }),
-              searching ? react_jsx_runtime.jsx("span", {
+              (searching || (searchScope === "cross" && cross.phase === "loading")) ? react_jsx_runtime.jsx("span", {
                 style: { width: 13, height: 13, flex: "none", display: "flex", alignItems: "center", justifyContent: "center" },
                 children: react_jsx_runtime.jsx("svg", {
                   width: 12,
@@ -3309,25 +4572,30 @@ window.__ModuleLoader__.load({
                 })
               }) : react_jsx_runtime.jsx("span", {
                 style: { fontSize: 11, color: C.muted, flex: "none", minWidth: 30, textAlign: "center" },
-                children: matches.length > 0 ? ((matchIdx % matches.length) + 1) + "/" + matches.length : ""
+                children: searchScope === "cross"
+                  ? (cross.phase === "done" && cross.rows.length > 0 ? String(cross.rows.length) + (cross.more ? "+" : "") : "")
+                  : (matches.length > 0 ? ((matchIdx % matches.length) + 1) + "/" + matches.length : "")
               }),
-              // scope toggle: 标题 <-> 全文 (round pill; background fades,
-              // label text cross-fades old->new)
+              // scope toggle: 标题 -> 全文 -> 会话 (ONE round pill cycling the three
+              // scopes; background fades, label text cross-fades old->new, so a third
+              // scope costs no extra button)
               react_jsx_runtime.jsx("button", {
                 onClick: toggleScope,
-                title: searchScope === "title" ? T("search.scope.tipTitle") : T("search.scope.tipFull"),
+                "data-scope": searchScope,
+                title: searchScope === "title" ? T("search.scope.tipTitle")
+                  : (searchScope === "full" ? T("search.scope.tipFull") : T("search.scope.tipCross")),
                 style: {
                   flex: "none",
-                  width: 34,
-                  height: 34,
+                  width: sheetOpen ? 40 : 34,
+                  height: sheetOpen ? 40 : 34,
                   display: "flex",
                   alignItems: "center",
                   justifyContent: "center",
                   borderRadius: "50%",
                   cornerShape: "round",
-                  fontSize: 11,
-                  color: searchScope === "full" ? "var(--dsw-alias-brand-primary, #4f8cff)" : C.muted,
-                  background: searchScope === "full" ? C.chip : "var(--dsw-alias-interactive-bg-hover, rgba(128,128,128,0.14))",
+                  fontSize: sheetOpen ? 13 : 11,
+                  color: searchScope !== "title" ? "var(--dsw-alias-brand-primary, #4f8cff)" : C.muted,
+                  background: searchScope !== "title" ? C.chip : "var(--dsw-alias-interactive-bg-hover, rgba(128,128,128,0.14))",
                   border: "none",
                   cursor: "pointer",
                   whiteSpace: "nowrap",
@@ -3339,91 +4607,272 @@ window.__ModuleLoader__.load({
                     react_jsx_runtime.jsx("span", {
                       key: searchScope,
                       style: { animation: "dqt-fade-in 0.25s linear", display: "block" },
-                      children: searchScope === "title" ? T("search.scope.title") : T("search.scope.full")
+                      children: scopeLabel(searchScope)
                     }),
                     (prevScope && prevScope !== searchScope) ? react_jsx_runtime.jsx("span", {
                       key: "old-" + prevScope,
                       style: { position: "absolute", opacity: 0, animation: "dqt-fade-out 0.25s linear forwards", display: "block" },
-                      children: prevScope === "title" ? T("search.scope.title") : T("search.scope.full")
+                      children: scopeLabel(prevScope)
                     }) : null
                   ]
                 })
               }),
               // fuzzy switch: an independent toggle beside the scope pill (its label
-              // is the same either way, so only the colour carries the state)
+              // is the same either way, so only the colour carries the state). It means
+              // nothing in cross-session scope — the HOST searches literal phrases —
+              // so there it is disabled and its tip says exactly that.
               react_jsx_runtime.jsx("button", {
                 onClick: toggleFuzzy,
-                title: fuzzy ? T("search.fuzzy.tipOn") : T("search.fuzzy.tipOff"),
+                disabled: searchScope === "cross",
+                title: searchScope === "cross" ? T("search.cross.note") : (fuzzy ? T("search.fuzzy.tipOn") : T("search.fuzzy.tipOff")),
                 "data-fuzzy": fuzzy ? "on" : "off",
                 style: {
                   flex: "none",
-                  width: 34,
-                  height: 34,
+                  width: sheetOpen ? 40 : 34,
+                  height: sheetOpen ? 40 : 34,
                   display: "flex",
                   alignItems: "center",
                   justifyContent: "center",
                   borderRadius: "50%",
                   cornerShape: "round",
-                  fontSize: 11,
+                  fontSize: sheetOpen ? 13 : 11,
                   color: fuzzy ? "var(--dsw-alias-brand-primary, #4f8cff)" : C.muted,
                   background: fuzzy ? C.chip : "var(--dsw-alias-interactive-bg-hover, rgba(128,128,128,0.14))",
                   border: "none",
-                  cursor: "pointer",
+                  cursor: searchScope === "cross" ? "default" : "pointer",
+                  opacity: searchScope === "cross" ? 0.45 : 1,
                   whiteSpace: "nowrap",
-                  transition: "background 0.25s ease, color 0.25s ease"
+                  transition: "background 0.25s ease, color 0.25s ease, opacity 0.25s ease"
                 },
                 children: T("search.fuzzy")
               })
-                ]
-              })
-            })
-          }) : null,
-          // outline list (paged: newest first, scroll to the top loads older);
-          // the scrollbar follows the dock side (rtl flips it to the left)
-          react_jsx_runtime.jsx("div", {
-            ref: listRef,
-            className: "dqt-list",
-            style: {
-              overflowY: "auto",
-              // NO top padding: a sticky child is confined to its containing
-              // block, so a padded scroll container would hold the pinned group
-              // header that many pixels below the toolbar (a visible gap). Spacing
-              // between groups comes from the per-group divider instead.
-              padding: "0 8px 6px",
-              flex: "1 1 auto",
-              minHeight: 0,
-              direction: dockRight ? "ltr" : "rtl"
-            },
-            onScroll: onListScroll,
-            onWheel: onListWheel,
-            children: react_jsx_runtime.jsx("div", {
-              style: { direction: "ltr" },
-              children: query.trim()
-                ? [
-                  react_jsx_runtime.jsx("div", {
-                    key: "results",
-                    children: renderResults(resultRows, query.trim(), C, goToRow, activeResultRow, renderExtra)
-                  }),
-                  // older history is one upward scroll away — say so until the
-                  // reader actually scrolls up (then the hint has done its job)
-                  hint ? react_jsx_runtime.jsx("div", {
-                    key: "hint",
-                    style: {
-                      display: "flex",
-                      alignItems: "center",
-                      justifyContent: "center",
-                      padding: "10px 6px 4px",
-                      fontSize: 11,
-                      color: C.muted,
-                      opacity: 0.85,
-                      textAlign: "center"
-                    },
-                    children: hint === "oldest" ? T("search.hintOldest") : T("search.hintMore")
-                  }) : null
-                ]
-                : renderGroups(shownGroups, shownTrees, jump, C, Math.max(0, groups.length - visibleCount), activeGroup, renderExtra)
+            ]
+          })
+        })
+      }) : null;
+
+      // ---- list content: the outline, or the search results ---------------------
+      // Built once and placed either inside the single docked list, or split across
+      // the curtain's two columns (outline left, results right).
+      var resultsEl = query.trim()
+        ? (searchScope === "cross"
+          ? react_jsx_runtime.jsx("div", {
+            key: "cross",
+            children: renderCrossResults(cross, query.trim(), C, crossTitle, openCrossHit)
+          })
+          : react_jsx_runtime.jsx("div", {
+            key: "results",
+            children: renderResults(resultRows, query.trim(), C, goToRow, activeResultRow, renderExtra)
+          }))
+        : null;
+      // older history is one upward scroll away — say so until the reader actually
+      // scrolls up (then the hint has done its job)
+      var hintEl = hint ? react_jsx_runtime.jsx("div", {
+        key: "hint",
+        style: {
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          padding: "10px 6px 4px",
+          fontSize: 11,
+          color: C.muted,
+          opacity: 0.85,
+          textAlign: "center"
+        },
+        children: hint === "oldest" ? T("search.hintOldest") : T("search.hintMore")
+      }) : null;
+      var outlineEl = renderGroups(shownGroups, shownTrees, jump, C, Math.max(0, groups.length - visibleCount), activeGroup,
+        questionsOnly ? Object.assign({}, renderExtra, { questionsOnly: true }) : renderExtra);
+      // The curtain keeps the outline in the middle of the surface (its own column,
+      // centred with room to spare at both sides) and pushes the search in from the
+      // right; the docked panel keeps its original "results replace the list".
+      var listChildren = sheetOpen
+        ? [outlineEl, hintEl]
+        : (resultsEl ? [resultsEl, hintEl] : outlineEl);
+      var listEl = react_jsx_runtime.jsx("div", {
+        ref: listRef,
+        className: "dqt-list",
+        // focusable so the arrow keys can drive the cursor; the panel root handles
+        // the same keys, so either focus target works
+        tabIndex: 0,
+        role: "group",
+        "aria-label": T("a11y.list"),
+        style: {
+          overflowY: "auto",
+          // NO top padding: a sticky child is confined to its containing
+          // block, so a padded scroll container would hold the pinned group
+          // header that many pixels below the toolbar (a visible gap). Spacing
+          // between groups comes from the per-group divider instead.
+          padding: sheetOpen ? "0 20px 8px" : "0 8px 6px",
+          flex: "1 1 auto",
+          minHeight: 0,
+          // across the curtain the list does not touch the edges: it is a centred
+          // column with room at both sides, which is also what makes it slide left
+          // when the search column is pushed in
+          width: sheetOpen ? "100%" : undefined,
+          maxWidth: sheetOpen ? "90%" : undefined,
+          margin: sheetOpen ? "0 auto" : undefined,
+          // the 20px side padding sits INSIDE the 90% (content-box would make the
+          // rendered column 90% + 40px, i.e. ~93% of the curtain)
+          boxSizing: sheetOpen ? "border-box" : undefined,
+          // the scrollbar follows the dock side in the narrow panel; across the
+          // curtain it sits on the list's right edge
+          direction: (sheetOpen || dockRight) ? "ltr" : "rtl"
+        },
+        onScroll: onListScroll,
+        onWheel: onListWheel,
+        children: react_jsx_runtime.jsx("div", {
+          // the two-phase cross-fade of the questions-only switch rides on this
+          // wrapper (classes, never inline animation: React rewrites inline styles
+          // every render and would restart or drop the animation)
+          className: "dqt-list-body"
+            + (listFade === "out" ? " dqt-mode-out" : (listFade === "in" ? " dqt-mode-in" : "")),
+          style: { direction: "ltr" },
+          children: listChildren
+        })
+      });
+      // ---- curtain search column: pushed in from the right edge -----------------
+      // The panel's own search box and its two buttons, then the hits below them.
+      // Only the column's WIDTH animates (0 <-> 360) so the outline is pushed left
+      // instead of jumped; an inner box keeps the full width so the content never
+      // squashes while the column narrows, and the column is always mounted while the
+      // curtain is up so both directions animate.
+      var sheetColW = (searchOpen || searchAnim === "out") ? SHEET_SEARCH_W : 0;
+      var sheetSearchColEl = sheetOpen ? react_jsx_runtime.jsx("div", {
+        className: "dqt-sheet-search",
+        "data-sheet-search": sheetColW > 0 ? "on" : undefined,
+        style: {
+          flex: "none",
+          width: sheetColW,
+          overflow: "hidden",
+          minHeight: 0,
+          borderLeft: sheetColW > 0 ? "1px solid " + C.panelBorder : "none",
+          transition: "width 0.24s " + EASE + ", border-color 0.24s " + EASE
+        },
+        children: react_jsx_runtime.jsx("div", {
+          style: { width: SHEET_SEARCH_W, height: "100%", display: "flex", flexDirection: "column", minHeight: 0 },
+          children: [
+            searchRowEl,
+            // empty until something is typed — no placeholder note in the way
+            react_jsx_runtime.jsx("div", {
+              className: "dqt-sheet-results",
+              style: { flex: "1 1 auto", minHeight: 0, overflowY: "auto", padding: "0 8px 8px", direction: "ltr" },
+              children: resultsEl
             })
-          }),
+          ]
+        })
+      }) : null;
+      // the outline and the search column share one row in BOTH layouts, so the list
+      // is never moved between parents when the curtain opens or closes
+      var bodyRowEl = react_jsx_runtime.jsx("div", {
+        className: "dqt-body-row",
+        style: { flex: "1 1 auto", minHeight: 0, display: "flex", flexDirection: "row", alignItems: "stretch" },
+        children: [listEl, sheetSearchColEl]
+      });
+      var panelEl = react_jsx_runtime.jsx("div", {
+        ref: panelRootRef,
+        // the panel takes focus on any click inside it (except into a text field), so
+        // ↑/↓/Enter/Esc keep working right after a mouse interaction instead of only
+        // when the user tabs into the widget first
+        tabIndex: -1,
+        onKeyDown: onPanelKeyDown,
+        onMouseDown: function (e) {
+          var t = e.target;
+          var tag = t && t.tagName ? String(t.tagName).toUpperCase() : "";
+          if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT" || (t && t.isContentEditable)) return;
+          var root = panelRootRef.current;
+          if (root && typeof root.focus === "function") root.focus();
+        },
+        style: sheetOpen ? {
+          // inside the sheet the panel IS the content: the wrapper owns position,
+          // size and the drop-in animation, and the content renders at 100% (the
+          // panel-scale preference is a docked-panel setting, not a sheet one)
+          position: "relative",
+          width: "100%",
+          flex: "1 1 auto",
+          minHeight: 0,
+          display: "flex",
+          flexDirection: "column",
+          background: C.panelBg,
+          border: "none",
+          borderRadius: 0,
+          zIndex: Z_PANEL,
+          overflow: "hidden",
+          color: C.text,
+          opacity: 1,
+          pointerEvents: chatViewActive ? "auto" : "none"
+        } : {
+          position: "fixed",
+          top: zLen(baseTopPx),
+          left: zLen(panelLeft),
+          width: zLen(panelW),
+          maxHeight: zLen(vMaxH),
+          height: panelH > 0 ? zLen(panelH) : undefined,
+          zoom: zoom === 1 ? undefined : zoom,
+          display: "flex",
+          flexDirection: "column",
+          background: C.panelBg,
+          border: "none",
+          borderRadius: 12,
+          zIndex: Z_PANEL,
+          overflow: "hidden",
+          color: C.text,
+          opacity: panelOpacity,
+          clipPath: panelClip,
+          // inner shadow only (no outer): theme-aware (white bevel in dark mode,
+          // soft shade in light) — outer shadow would be clipped by the collapse
+          // clip-path and the panel edges.
+          boxShadow: innerShadow(),
+          // A view switch swaps in a short, delay-free opacity fade; the dock and
+          // collapse animations keep their own (slower) timings.
+          transition: viewFading ? "opacity 0.3s ease" : panelTransition,
+          // held back while the edge handle slips home (see edgeLeaving): the panel is
+          // already at its open geometry here, only the animation waits
+          transitionDelay: edgeLeaving ? EDGE_OUT_MS + "ms" : undefined,
+          pointerEvents: chatViewActive ? "auto" : "none"
+        },
+        onMouseEnter: function () { setHovered(true); },
+        onMouseLeave: function () { setHovered(false); },
+        onClickCapture: function (e) {
+          // jump handled in the capture phase (bubble-phase handlers are unreliable here)
+          var t = e.target;
+          // the "to the section's end" control sits INSIDE a jumpable row, and the
+          // row's own jump would otherwise fire first (capture runs top-down), so
+          // this branch is checked first and takes the event entirely
+          var endBtn = (t && t.closest) ? t.closest("[data-dqt-end]") : null;
+          if (endBtn && endBtn.dataset) {
+            e.preventDefault();
+            e.stopPropagation();
+            if (endBtn.dataset.endTurn !== undefined) {
+              endJumpTurn(endBtn.dataset.endKey);
+            } else {
+              endJumpRow(endBtn.dataset.endKey, endBtn.dataset.endIdx !== undefined ? Number(endBtn.dataset.endIdx) : 0);
+            }
+            // same hand-back rule as picking a row: the curtain closes
+            if (sheetOpen) closeSheet();
+            return;
+          }
+          var item = (t && t.closest) ? t.closest("[data-jump-key]") : null;
+          if (item && item.dataset && item.dataset.jumpKey) {
+            e.preventDefault();
+            e.stopPropagation();
+            var idx = item.dataset.jumpIdx !== undefined ? Number(item.dataset.jumpIdx) : 0;
+            jump(item.dataset.jumpKey, idx);
+            // a curtain hands you back to the conversation once you picked a row
+            if (sheetOpen) closeSheet();
+            return;
+          }
+          // ANY other row (group header, in-session result, cross-session hit)
+          // carries its own click handler and keeps it — no stopPropagation here —
+          // but picking a row still hands the reader back to the conversation
+          if (sheetOpen && t && t.closest && t.closest("[data-nav-row]")) closeSheet();
+        },
+        children: [
+          sheetOpen ? sheetChromeEl : dockHeaderEl,
+          // the docked panel keeps its search band under the header; across the
+          // curtain the same row lives at the top of the pushed-in search column
+          sheetOpen ? null : searchRowEl,
+          bodyRowEl,
           // "back to the newest row": floats over the list's lower-right corner and
           // fades in the moment the newest turns fall below the fold. Kept MOUNTED
           // and toggled by opacity/pointer-events — an unmounted button has nothing
@@ -3446,8 +4895,9 @@ window.__ModuleLoader__.load({
             },
             style: {
               position: "absolute",
-              // clear of the resize handle in the very corner (16x16)
-              right: 18,
+              // clear of the resize handle in the very corner (16x16); across the
+              // curtain it also clears the pushed-in search column
+              right: (sheetOpen && sheetColW > 0 ? SHEET_SEARCH_W : 0) + 18,
               bottom: 12,
               width: 26,
               height: 26,
@@ -3490,10 +4940,19 @@ window.__ModuleLoader__.load({
             })
           }),
           toastEl,
+          // Polite live region: match stepping, result counts and cursor moves land
+          // here. Visually hidden (`.dqt-sr`) — it exists for assistive tech only.
+          react_jsx_runtime.jsx("span", {
+            className: "dqt-sr",
+            role: "status",
+            "aria-live": "polite",
+            "aria-atomic": "true",
+            children: liveText
+          }),
           // resize handles (right edge: width, bottom edge: height)
           // Their grab strips keep their SCREEN thickness under the scale factor:
           // they are part of the panel's box, not of its magnified content.
-          react_jsx_runtime.jsx("div", {
+          sheetOpen ? null : react_jsx_runtime.jsx("div", {
             style: {
               position: "absolute",
               top: 0,
@@ -3507,7 +4966,7 @@ window.__ModuleLoader__.load({
             onPointerDown: onResizeWDown,
             title: T("resize.w")
           }),
-          react_jsx_runtime.jsx("div", {
+          sheetOpen ? null : react_jsx_runtime.jsx("div", {
             style: {
               position: "absolute",
               left: 0,
@@ -3521,8 +4980,8 @@ window.__ModuleLoader__.load({
             onPointerDown: onResizeHDown,
             title: T("resize.h")
           }),
-          // corner handle: resize width AND height at once
-          react_jsx_runtime.jsx("div", {
+          // corner handle: resize width AND height at once (dock-only too)
+          sheetOpen ? null : react_jsx_runtime.jsx("div", {
             style: {
               position: "absolute",
               right: 0,
@@ -3536,88 +4995,54 @@ window.__ModuleLoader__.load({
             onPointerDown: onResizeCornerDown,
             title: T("resize.wh")
           }),
-          // heading-level picker: pops down from the round header button and its
-          // LEFT edge lines up with that button (the button now sits at the left end
-          // of the header, so 10px is exactly the header's own left padding).
-          // Open/close animate from the button's center: the animation lives in
-          // the injected stylesheet (classes, not inline animation) so React
-          // re-renders never restart or cancel it — an inline `animation` set on
-          // every render made the entrance invisible and the exit never play.
-          (levelsOpen || levelsClosing) ? react_jsx_runtime.jsx("div", {
-            className: "dqt-levels-pop" + (levelsClosing ? " dqt-levels-pop-closing" : ""),
-            style: {
-              position: "absolute",
-              top: 40,
-              left: 10,
-              zIndex: 30,
-              display: "flex",
-              alignItems: "center",
-              flexWrap: "wrap",
-              gap: 4,
-              padding: 8,
-              background: C.panelBg,
-              border: "1px solid " + C.panelBorder,
-              borderRadius: 10,
-              cornerShape: "round",
-              boxShadow: "0 6px 20px rgba(0, 0, 0, 0.28), 0 2px 6px rgba(0, 0, 0, 0.18)",
-              maxWidth: "calc(100% - 20px)",
-              // the button's center sits 12px inside the popup's left edge
-              transformOrigin: "12px top"
-            },
-            children: [1, 2, 3, 4, 5, 6].map(function (lv) {
-              var active = !!levelSet[lv];
-              return react_jsx_runtime.jsx("button", {
-                onClick: function () { toggleLevel(lv); },
-                title: active ? T("levels.hide") + lv : T("levels.show") + lv,
-                style: {
-                  height: 22,
-                  padding: "0 7px",
-                  border: "none",
-                  borderRadius: 6,
-                  cornerShape: "round",
-                  cursor: "pointer",
-                  fontSize: 11,
-                  lineHeight: "22px",
-                  fontFamily: "inherit",
-                  background: active
-                    ? C.chip
-                    : "var(--dsw-alias-interactive-bg-hover, rgba(128,128,128,0.14))",
-                  color: active ? C.accent : C.muted,
-                  fontWeight: active ? 600 : 400
-                },
-                children: "H" + lv
-              }, "lv" + lv);
-            })
-          }) : null
+          levelsPopDockEl
         ]
       });
 
-      // ---- edge collapse handle: fades+pops in after the panel fully slides away ----
-      var edgeEl = !open ? react_jsx_runtime.jsx("div", {
+      // ---- edge collapse handle ------------------------------------------------
+      // It emerges from BEHIND the conversation area's edge and slips back into it, the
+      // same vocabulary the docked panel uses when it collapses: the box is parked
+      // EDGE_W outside the line and clipped at it, so the 12px pill is progressively
+      // revealed as it slides out. A plain fade-in-place made it read as appearing and
+      // vanishing ON the divider line. `open` also drives it (fade + slide home) and
+      // `edgeGone` keeps the element in the tree until that motion has played.
+      var EDGE_W = 26;
+      var edgeShown = !open && handleShown && chatViewActive;
+      var edgeLineLeft = viewport ? viewport.left : 0;
+      var edgeLineRight = viewport ? viewport.right + 52 : 60;   // clear of the milestone rail
+      var edgeEl = (!open || !edgeGone) ? react_jsx_runtime.jsx("div", {
         style: {
           position: "fixed",
-          width: 26,
+          width: EDGE_W,
           height: 92,
           display: "flex",
           alignItems: "center",
           justifyContent: "center",
           cursor: "pointer",
-          zIndex: Z_BASE,
+          zIndex: Z_HANDLE,
           // the ratio counts from the BOTTOM (0% = bottom, 100% = top) — at 0.5 this
-          // is the same centred spot the handle always had
-          top: (viewport
-            ? viewport.top + (viewport.height - 92) * handleFromTop
-            : (window.innerHeight - 92) * handleFromTop) + "px",
-          transform: handleShown ? "translateX(0)" : (dockRight ? "translateX(16px)" : "translateX(-16px)"),
-          opacity: chatViewActive ? 1 : 0,
-          pointerEvents: chatViewActive ? "auto" : "none",
-          transition: "transform 0.4s " + EASE + ", opacity 0.26s ease",
+          // is the same centred spot the handle always had. The 100% end still lands
+          // exactly on the area's top edge; only the far end is floored, because the
+          // handle is the ONLY way back to a collapsed panel and may never be pushed
+          // off the bottom by a stored rect that is one layout generation behind.
+          top: Math.max(0, Math.min(Math.max(0, window.innerHeight - 100),
+            (viewport
+              ? viewport.top + (viewport.height - 92) * handleFromTop
+              : (window.innerHeight - 92) * handleFromTop))) + "px",
+          // clipped at the line it hides behind: parked EDGE_W further out, the whole
+          // box falls inside the clipped strip, so it is invisible without a fade
+          clipPath: dockRight
+            ? (edgeShown ? "inset(0 0 0 0)" : "inset(0 " + EDGE_W + "px 0 0)")
+            : (edgeShown ? "inset(0 0 0 0)" : "inset(0 0 0 " + EDGE_W + "px)"),
+          opacity: (chatViewActive && !open) ? 1 : 0,
+          pointerEvents: edgeShown ? "auto" : "none",
+          transition: "left 0.22s " + EASE + ", right 0.22s " + EASE + ", clip-path 0.22s " + EASE + ", opacity 0.18s ease",
           ...(dockRight
-            ? { right: viewport ? viewport.right + 52 : 60 }   // clear of the milestone rail
-            : { left: viewport ? viewport.left : 0 })
+            ? { right: edgeShown ? edgeLineRight : edgeLineRight - EDGE_W }
+            : { left: edgeShown ? edgeLineLeft : edgeLineLeft - EDGE_W })
         },
         title: T("handle.expand"),
-        onClick: function () { setOpen(true); },
+        onClick: function () { openFromEdge(); },
         onMouseEnter: function () { if (edgeRef.current) edgeRef.current.style.opacity = "1"; },
         onMouseLeave: function () { if (edgeRef.current) edgeRef.current.style.opacity = "0.5"; },
         children: react_jsx_runtime.jsx("div", {
@@ -3651,6 +5076,111 @@ window.__ModuleLoader__.load({
         })
       }) : null;
 
+      // where the curtain hangs from: just under the view tabs, with a floor so the
+      // tabs can never eat the whole surface
+      var convTopPx = viewport ? viewport.top : 0;
+      var sheetTopPx = viewport
+        ? Math.max(convTopPx, Math.min(sheetStrip ? sheetStrip.bottom : convTopPx, convTopPx + viewport.height - 160))
+        : 0;
+      // The handle sits INSIDE the tab strip, bottom edge on that same line, so no
+      // conversation text can ever run under it. The strip measured 25px tall on this
+      // build, so the hit box fits the band instead of the other way round (a fixed
+      // 26px box poked 3px below the line, straight back into the text it was moved
+      // away from); the 12px pill inside is bottom-aligned, so the visible control
+      // rests ON the line. Falls back to hanging below the line if the strip was never
+      // measured.
+      var HANDLE_BOX_MAX = 26;
+      var stripH = sheetStrip ? Math.max(0, sheetStrip.bottom - sheetStrip.top) : 0;
+      var handleH = sheetStrip ? Math.max(16, Math.min(HANDLE_BOX_MAX, stripH)) : HANDLE_BOX_MAX;
+      var handleTopPx = sheetStrip ? sheetStrip.bottom - handleH : sheetTopPx;
+
+      // ---- curtain handle resting on the view tab strip's line -----------------
+      // A droplet held to the line by surface tension rather than a floating pill: the
+      // silhouette flares out into two concave fillets that meet the strip's lower line
+      // tangentially, and the little triangle says "this drops down". Laid out so its
+      // base sits exactly ON that line (the svg's own bottom edge), centred on the
+      // conversation area — the band above the line is host chrome and never carries
+      // transcript text, which is what made the old handle unreadable.
+      // 140 wide and only 13.5 tall: the reader asked for a wider, flatter droplet
+      // (it started at 92, then 120).
+      var DROP_W = 140;
+      var topHandleEl = (!sheetOpen || !sheetHandleGone) && chatViewActive ? react_jsx_runtime.jsx("div", {
+        className: "dqt-sheet-handle",
+        "data-sheet-handle": "on",
+        style: {
+          position: "fixed",
+          width: DROP_W,
+          height: handleH,
+          display: "flex",
+          alignItems: "flex-end",
+          justifyContent: "center",
+          boxSizing: "border-box",
+          cursor: "pointer",
+          zIndex: Z_HANDLE,
+          top: handleTopPx,
+          transformOrigin: "50% 100%",
+          // The press is SLOW FIRST, THEN FAST, and it is the pop keyframe below read
+          // backwards: `cubic-bezier(0.75, 0, 1, 0.45)` mirrors exactly onto the pop's
+          // `cubic-bezier(0, 0.55, 0.25, 1)`, so the two directions are one motion and
+          // its rewind rather than two lookalike eases. Over the 200ms: 86% of the clock
+          // buys the first 40% of the squash, and the last 40% lands inside ~11ms. The
+          // fade is held back past the press so the squash is never hidden behind it.
+          opacity: sheetOpen ? 0 : 1,
+          transition: "transform 0.2s cubic-bezier(0.75, 0, 1, 0.45), opacity 0.12s ease 0.2s",
+          // centred on the conversation area, and clamped like the side handle: it is
+          // the only entry point to the curtain, so it stays inside the window even
+          // if the stored area rect is one layout generation behind
+          left: Math.max(8, Math.min(Math.max(8, window.innerWidth - DROP_W - 8),
+            viewport
+              ? viewport.left + (Math.max(320, window.innerWidth - viewport.left - viewport.right) - DROP_W) / 2
+              : (window.innerWidth - DROP_W) / 2)) + "px"
+        },
+        title: T("sheet.openHandle"),
+        onClick: function () {
+          var el = sheetHandleRef.current;
+          if (el && el.parentElement && el.parentElement.style) el.parentElement.style.transform = "scaleY(0.12)";
+          setSheetHandleGone(false);
+          // The press has to be SEEN before the curtain takes the stage. With the panel
+          // open it already is: the panel's own 300ms tuck comes first. Collapsed, the
+          // curtain used to drop on this very frame and cover the droplet (z 16 over
+          // 12), which is why the press "had no animation" — so here the curtain waits
+          // for the press to play out.
+          if (open) openSheet();
+          else {
+            if (dropOpenRef.current) clearTimeout(dropOpenRef.current);
+            dropOpenRef.current = setTimeout(function () {
+              dropOpenRef.current = null;
+              openSheet();
+            }, DROP_OUT_MS);
+          }
+        },
+        onMouseEnter: function () { if (sheetHandleRef.current) sheetHandleRef.current.style.opacity = "1"; },
+        onMouseLeave: function () { if (sheetHandleRef.current) sheetHandleRef.current.style.opacity = "0.5"; },
+        children: react_jsx_runtime.jsx("svg", {
+          ref: sheetHandleRef,
+          width: DROP_W,
+          height: 17,
+          viewBox: "0 0 140 17",
+          // flush with the box's bottom edge, i.e. exactly on the strip's line
+          style: { display: "block", opacity: 0.5, transition: "opacity 0.25s ease", cursor: "pointer" },
+          children: [
+            react_jsx_runtime.jsx("path", {
+              // base from x=8 to x=132 (124px), dome up at y=3.5, both sides flaring
+              // into concave fillets that become horizontal where they touch the line
+              d: "M8 17 Q30 17 42 9 C50 4.5 58 3.5 70 3.5 C82 3.5 90 4.5 98 9 Q110 17 132 17 Z",
+              fill: "var(--dsw-alias-border-l2, rgba(160,160,160,0.55))"
+            }, "drop"),
+            react_jsx_runtime.jsx("path", {
+              // the side handle's own triangle, turned a quarter turn and taken down a
+              // shade — 14 x 4.5 against its 5.5 x 16 — so it reads as the same
+              // affordance without crowding the smaller droplet it sits in
+              d: "M63 8.5 L77 8.5 L70 13 Z",
+              fill: "var(--dsw-alias-label-secondary, #9aa0ab)"
+            }, "tip")
+          ]
+        })
+      }) : null;
+
       // ---- hover preview card ------------------------------------------------
       // Rendered INSIDE the body portal (position: fixed) so the outline's own
       // scroll container can never clip it, and pointer-events: none so it can
@@ -3699,22 +5229,179 @@ window.__ModuleLoader__.load({
             color: C.text,
             border: "1px solid " + C.panelBorder,
             boxShadow: "0 8px 24px rgba(0,0,0,0.28)",
-            zIndex: Z_BASE + 1,
+            // above the panel and the curtain — it is a sibling of both in this
+            // portal, and both sit below it in the layer band we claim
+            zIndex: Z_HOVER,
             pointerEvents: "none"
           },
           children: cardChildren
         }, "hover-card");
       }
 
+      // ---- the curtain shell ---------------------------------------------------
+      // TWO boxes: an outer clip box that sits at the anchor line with the curtain's
+      // own size, and the curtain inside it, which flies down from above that line
+      // (translateY -100% -> 0) and back up on the way out. The clip is what makes it
+      // emerge from under the view tabs — like the docked panel emerging from behind
+      // the sidebar — so the surface is never seen above the line it hangs from.
+      // The outer box never unmounts: while the curtain is down it is a zero-size,
+      // non-clipping pass-through, so the panel (and the whole list DOM) is never
+      // moved or rebuilt when the curtain opens or closes.
+      var sheetUp = sheetOpen && chatViewActive;
+      var sheetShellEl = react_jsx_runtime.jsx("div", {
+        key: "sheet-shell",
+        className: "dqt-sheet-clip",
+        "data-sheet-shell": sheetUp ? "on" : undefined,
+        style: sheetUp ? {
+          position: "fixed",
+          // hangs from just below the 对话/轨迹/上下文 strip
+          top: sheetTopPx,
+          left: viewport ? viewport.left : 0,
+          width: viewport ? Math.max(320, window.innerWidth - viewport.left - viewport.right) : "100%",
+          // a curtain over the conversation, not the whole screen: the composer and
+          // the newest message stay reachable below it. The height is measured from
+          // the conversation box (not from the curtain's own top) so hanging it below
+          // the tabs does not push its bottom edge down over the composer.
+          height: viewport
+            ? Math.max(240, Math.min(760, (viewport.height - Math.max(0, sheetTopPx - viewport.top)) * 0.82))
+            : "70vh",
+          overflow: "hidden",
+          zIndex: Z_SHEET
+        } : {
+          // Nothing while it is down — and in particular no border: a 1px border on a
+          // zero-size box is still a 2px border box, and with the wrapper's overflow
+          // visible that added 2px to the DOCUMENT's scrollable overflow. That raised a
+          // page scrollbar while the curtain was down, so opening it dropped the
+          // scrollbar and widened the whole app by ~8px — which is exactly the small
+          // rightward shift of the conversation the reader saw. A fixed, zero-size,
+          // borderless box contributes nothing, and the fixed-positioned docked panel
+          // inside still resolves against the viewport and is not clipped by it.
+          //
+          // It DOES have to carry the panel's own layer though: a fixed-position
+          // element creates a stacking context even at `z-index: auto`, so with the
+          // shell at auto the docked panel inside it could never paint at its own
+          // z-index — it sat below every positive-z-index element of the app. The
+          // transcript width grips (z 8, a 40px full-height column just outside the
+          // text column) won the hit test INSIDE the open panel: the cursor turned
+          // into col-resize over the outline and a press there resized the
+          // conversation instead of using the panel. Probed in a real browser with
+          // elementFromPoint plus a temporary marker of the same z-index:
+          //   shell auto -> at the grip's own column the hit was the grip
+          //   shell 14   -> the hit is the outline row, and a 13 marker no longer
+          //                 covers the panel while a 15 marker still does
+          zIndex: Z_PANEL,
+          position: "fixed",
+          top: 0,
+          left: 0,
+          width: 0,
+          height: 0,
+          overflow: "visible"
+        },
+        children: react_jsx_runtime.jsx("div", {
+          ref: sheetRef,
+          className: sheetUp ? "dqt-sheet dqt-sheet-open" : "dqt-sheet-idle",
+          "data-sheet": sheetUp ? "on" : undefined,
+          style: {
+            width: sheetUp ? "100%" : 0,
+            height: sheetUp ? "100%" : 0,
+            display: "flex",
+            flexDirection: "column",
+            background: C.panelBg,
+            color: C.text,
+            border: sheetUp ? "1px solid " + C.panelBorder : "none",
+            // square where it meets the top edge, since the curtain hangs from there;
+            // no dimming layer and no drop shadow either — the conversation below
+            // stays legible and usable, and the curtain announces itself by flying
+            borderRadius: "0 0 12px 12px",
+            overflow: "hidden"
+          },
+          children: panelEl
+        })
+      });
+
       return react_dom.createPortal(
-        react_jsx_runtime.jsx(ErrorBoundary, { children: [panelEl, edgeEl, hoverEl] }),
+        react_jsx_runtime.jsx(ErrorBoundary, {
+          children: [sheetShellEl, edgeEl, topHandleEl, hoverEl]
+        }),
         document.body
       );
     }
 
+    // the "to the section's end" control that every jumpable row (outline entries
+    // and group headers, docked and curtain alike) carries at its far right. It
+    // stays hidden until the row is hovered — the row's own mouseenter/leave
+    // reveal it — and the click is handled once, in the panel's capture phase,
+    // so the row's jump-to-start can never fire alongside it.
+    function renderEndBtn(C, key, idx, turn) {
+      // These markers are not decoration: the row's hover handler looks for
+      // [data-dqt-end] to reveal the control, and the panel's capture phase looks
+      // for it to route the click to the end jump instead of the row's own
+      // jump-to-start. They are deliberately NOT data-jump-key: that attribute
+      // belongs to the rows themselves, and two kinds of element claiming it made
+      // every "find the row" query ambiguous.
+      var attrs = { "data-dqt-end": "1" };
+      if (key) attrs["data-end-key"] = key;
+      if (idx !== undefined && idx !== null) attrs["data-end-idx"] = String(idx);
+      if (turn !== undefined && turn !== null) attrs["data-end-turn"] = String(turn);
+      return react_jsx_runtime.jsx("button", Object.assign({
+        type: "button",
+        tabIndex: -1,
+        title: T("row.end"),
+        onMouseEnter: function (e) {
+          e.currentTarget.style.background = C.hover;
+          e.currentTarget.style.color = C.text;
+        },
+        onMouseLeave: function (e) {
+          e.currentTarget.style.background = "transparent";
+          e.currentTarget.style.color = C.muted;
+        },
+        style: {
+          position: "absolute",
+          right: 4,
+          top: "50%",
+          transform: "translateY(-50%)",
+          width: 20,
+          height: 20,
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          padding: 0,
+          border: "none",
+          borderRadius: 999,
+          cornerShape: "round",
+          background: "transparent",
+          color: C.muted,
+          // hover-only: the row raises this to 1 and the transition fades it in
+          // and out, so the control never appears or vanishes with a snap
+          opacity: 0,
+          cursor: "pointer",
+          transition: "opacity 0.22s ease, background 0.18s ease, color 0.18s ease"
+        },
+        children: react_jsx_runtime.jsx("svg", {
+          width: 12,
+          height: 12,
+          viewBox: "0 0 12 12",
+          style: { display: "block" },
+          children: react_jsx_runtime.jsx("path", {
+            // an arrow down onto a floor line: "go to where this section stops"
+            d: "M6 1.5V8M2.8 5.2 6 8.4l3.2-3.2M2 11h8",
+            fill: "none",
+            stroke: "currentColor",
+            strokeWidth: 1.5,
+            strokeLinecap: "round",
+            strokeLinejoin: "round"
+          })
+        })
+      }, attrs), "end-" + (key || "") + "-" + (idx !== undefined && idx !== null ? idx : turn));
+    }
+
     function renderItem(n, depth, jump, C, uid, extra) {
       var hasChildren = !!(n.children && n.children.length);
       var path = extra && extra.paths ? extra.paths[headingId(n)] : null;
+      // Wide (curtain) rows put the same information on ONE line: an H-level chip,
+      // the title, and the section's opening text out to the right — the space the
+      // docked panel does not have. The narrow panel keeps title-over-subtitle.
+      var wide = !!(extra && extra.wide);
       var hoverInfo = {
         title: n.title,
         sub: n.sub || "",
@@ -3722,57 +5409,124 @@ window.__ModuleLoader__.load({
         meta: [n.time, path ? path.path : ""].filter(Boolean).join("  ·  "),
         ghost: false
       };
-      var rows = [
-        react_jsx_runtime.jsx("div", {
-          style: { display: "flex", alignItems: "center", gap: 2, minWidth: 0 },
-          children: react_jsx_runtime.jsx("span", {
-            style: { minWidth: 0, overflow: "hidden", textOverflow: "ellipsis" },
-            children: n.title
-          })
-        }, uid + "-l")
-      ];
-      // Subtitle = the section's first sentence. This is what makes two headings
-      // with the SAME text distinguishable without hovering ("which one is this?").
-      if (n.sub) {
-        rows.push(react_jsx_runtime.jsx("div", {
-          style: {
-            fontSize: 10,
-            lineHeight: "13px",
-            color: C.muted,
-            opacity: 0.75,
-            whiteSpace: "nowrap",
-            overflow: "hidden",
-            textOverflow: "ellipsis"
-          },
-          children: n.sub
-        }, uid + "-s"));
+      var rows;
+      if (wide) {
+        var context = n.preview || n.sub || "";
+        rows = [react_jsx_runtime.jsx("div", {
+          style: { display: "flex", alignItems: "baseline", gap: 8, minWidth: 0 },
+          children: [
+            react_jsx_runtime.jsx("span", {
+              style: { flex: "none", width: 22, fontSize: 11.5, fontWeight: 600, letterSpacing: 0.2, color: C.muted, opacity: 0.65 },
+              children: "H" + n.level
+            }, uid + "-lv"),
+            react_jsx_runtime.jsx("span", {
+              style: { flex: "0 1 auto", minWidth: 0, overflow: "hidden", textOverflow: "ellipsis" },
+              children: n.title
+            }),
+            // basis 0 + grow: the small text only ever takes the space the title
+            // leaves over, so a long title is never squeezed by its own context
+            context ? react_jsx_runtime.jsx("span", {
+              style: {
+                flex: "1 1 0",
+                minWidth: 0,
+                fontSize: 13,
+                color: C.muted,
+                opacity: 0.68,
+                textAlign: "right",
+                overflow: "hidden",
+                textOverflow: "ellipsis"
+              },
+              children: context
+            }) : null
+          ]
+        }, uid + "-l")];
+      } else {
+        rows = [
+          react_jsx_runtime.jsx("div", {
+            style: { display: "flex", alignItems: "center", gap: 2, minWidth: 0 },
+            children: react_jsx_runtime.jsx("span", {
+              style: { minWidth: 0, overflow: "hidden", textOverflow: "ellipsis" },
+              children: n.title
+            })
+          }, uid + "-l")
+        ];
+        // Subtitle = the section's first sentence. This is what makes two headings
+        // with the SAME text distinguishable without hovering ("which one is this?").
+        if (n.sub) {
+          rows.push(react_jsx_runtime.jsx("div", {
+            style: {
+              fontSize: 10,
+              lineHeight: "13px",
+              color: C.muted,
+              opacity: 0.75,
+              whiteSpace: "nowrap",
+              overflow: "hidden",
+              textOverflow: "ellipsis"
+            },
+            children: n.sub
+          }, uid + "-s"));
+        }
       }
+      // the section's own "jump to its end" control, revealed while the row is
+      // hovered; the reserved right padding keeps the title/subtitle/context
+      // clear of it so nothing ever runs underneath the button
+      rows.push(renderEndBtn(C, n.key, n.idx));
+      // The hover highlight is its own layer rather than the row's own background:
+      // the row box runs to its right edge, which is exactly where the end control's
+      // round backdrop appears, so the two boxes used to sit flush against each other
+      // (and on a long row the highlight ran underneath the button). This layer stops
+      // END_ZONE short of that edge, leaving a clear gap.
+      rows.unshift(react_jsx_runtime.jsx("div", {
+        "data-dqt-hl": "1",
+        style: {
+          position: "absolute",
+          left: 0,
+          top: 0,
+          bottom: 0,
+          right: END_ZONE,
+          borderRadius: 6,
+          background: "transparent",
+          transition: "background 0.15s ease",
+          pointerEvents: "none"
+        }
+      }, uid + "-hl"));
       return react_jsx_runtime.jsx(
         "div",
         {
           onClick: function () { jump(n.key, n.idx); },
           onMouseEnter: function (e) {
-            e.currentTarget.style.background = C.hover;
+            var hl = e.currentTarget.querySelector("[data-dqt-hl]");
+            if (hl) hl.style.background = C.hover;
+            var b = e.currentTarget.querySelector("[data-dqt-end]");
+            if (b) b.style.opacity = "1";
             if (extra && extra.hoverStart) extra.hoverStart(hoverInfo, e.currentTarget);
           },
           onMouseLeave: function (e) {
-            e.currentTarget.style.background = "transparent";
+            var hl = e.currentTarget.querySelector("[data-dqt-hl]");
+            if (hl) hl.style.background = "transparent";
+            var b = e.currentTarget.querySelector("[data-dqt-end]");
+            if (b) b.style.opacity = "0";
             if (extra && extra.hoverEnd) extra.hoverEnd();
           },
           "data-jump-key": n.key,
           "data-jump-idx": n.idx !== undefined ? String(n.idx) : "0",
+          // keyboard navigation walks the ORDER of these rows inside the list
+          "data-nav-row": "1",
           style: {
             // no fixed height: a row grows by one line when it has a subtitle
+            // (narrow layout) — in wide mode it is one line by construction
             display: "block",
-            padding: "2px 6px",
-            paddingLeft: (hasChildren ? 2 : 6) + (n.level - 1) * 12,
+            position: "relative",
+            padding: wide ? "4px 8px" : "2px 6px",
+            paddingRight: END_ZONE,
+            paddingLeft: (hasChildren ? (wide ? 4 : 2) : (wide ? 8 : 6)) + (n.level - 1) * (wide ? 16 : 12),
             margin: "1px 0",
             borderRadius: 6,
             cursor: "pointer",
-            fontSize: n.level <= 2 ? 13 : 12,
+            fontSize: n.level <= 2 ? (wide ? 16.5 : 13) : (wide ? 15.5 : 12),
             color: n.level <= 2 ? C.text : C.muted,
             fontWeight: n.level <= 2 ? 600 : 400,
-            lineHeight: "18px",
+            lineHeight: wide ? "26px" : "18px",
             whiteSpace: "nowrap",
             overflow: "hidden"
           },
@@ -3813,43 +5567,84 @@ window.__ModuleLoader__.load({
 
     function renderResultRow(r, i, q, C, onRow, isActive, extra) {
       var fuzzy = !!(extra && extra.fuzzy);
+      // the curtain's rows are wide: title, snippet and meta share ONE line (title
+      // left, context middle-right, meta far right) instead of stacking three
+      // half-empty lines. The docked panel keeps the stacked form.
+      var wide = !!(extra && extra.wide);
       var meta = [];
       if (r.ghost) meta.push(T("turn.unloaded"));
       if (r.failed) meta.push(T("turn.failed"));
       if (r.time) meta.push(r.time);
       if (r.path) meta.push(r.path);
       if (r.count > 1) meta.push("×" + r.count);
-      var children = [
-        react_jsx_runtime.jsx("div", {
-          style: {
-            fontSize: 12,
-            fontWeight: r.level > 0 && r.level <= 2 ? 600 : 400,
-            color: r.level > 0 ? C.text : C.muted,
-            whiteSpace: "nowrap",
-            overflow: "hidden",
-            textOverflow: "ellipsis"
-          },
-          children: hitSpans(r.title, q, fuzzy)
-        }, "t" + i)
-      ];
-      if (r.snippet) {
-        children.push(react_jsx_runtime.jsx("div", {
-          style: {
-            fontSize: 11,
-            color: C.muted,
-            marginTop: 1,
-            whiteSpace: "nowrap",
-            overflow: "hidden",
-            textOverflow: "ellipsis"
-          },
-          children: hitSpans(r.snippet, q, fuzzy)
-        }, "s" + i));
-      }
-      if (meta.length) {
-        children.push(react_jsx_runtime.jsx("div", {
-          style: { fontSize: 10, color: C.muted, opacity: 0.8, marginTop: 1, whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis" },
-          children: meta.join("  ·  ")
-        }, "m" + i));
+      var children;
+      if (wide) {
+        children = [
+          react_jsx_runtime.jsx("span", {
+            style: {
+              flex: "0 1 auto",
+              minWidth: 0,
+              fontSize: 15.5,
+              fontWeight: r.level > 0 && r.level <= 2 ? 600 : 400,
+              color: r.level > 0 ? C.text : C.muted,
+              whiteSpace: "nowrap",
+              overflow: "hidden",
+              textOverflow: "ellipsis"
+            },
+            children: hitSpans(r.title, q, fuzzy)
+          }, "t" + i),
+          r.snippet ? react_jsx_runtime.jsx("span", {
+            style: {
+              flex: "1 1 0",
+              minWidth: 0,
+              fontSize: 13,
+              color: C.muted,
+              opacity: 0.85,
+              textAlign: "right",
+              whiteSpace: "nowrap",
+              overflow: "hidden",
+              textOverflow: "ellipsis"
+            },
+            children: hitSpans(r.snippet, q, fuzzy)
+          }, "s" + i) : null,
+          meta.length ? react_jsx_runtime.jsx("span", {
+            style: { flex: "none", fontSize: 12, color: C.muted, opacity: 0.7, whiteSpace: "nowrap" },
+            children: meta.join("  ·  ")
+          }, "m" + i) : null
+        ];
+      } else {
+        children = [
+          react_jsx_runtime.jsx("div", {
+            style: {
+              fontSize: 12,
+              fontWeight: r.level > 0 && r.level <= 2 ? 600 : 400,
+              color: r.level > 0 ? C.text : C.muted,
+              whiteSpace: "nowrap",
+              overflow: "hidden",
+              textOverflow: "ellipsis"
+            },
+            children: hitSpans(r.title, q, fuzzy)
+          }, "t" + i)
+        ];
+        if (r.snippet) {
+          children.push(react_jsx_runtime.jsx("div", {
+            style: {
+              fontSize: 11,
+              color: C.muted,
+              marginTop: 1,
+              whiteSpace: "nowrap",
+              overflow: "hidden",
+              textOverflow: "ellipsis"
+            },
+            children: hitSpans(r.snippet, q, fuzzy)
+          }, "s" + i));
+        }
+        if (meta.length) {
+          children.push(react_jsx_runtime.jsx("div", {
+            style: { fontSize: 10, color: C.muted, opacity: 0.8, marginTop: 1, whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis" },
+            children: meta.join("  ·  ")
+          }, "m" + i));
+        }
       }
       return react_jsx_runtime.jsx("div", {
         // clicking a row makes that hit the CURRENT one: it highlights the
@@ -3873,13 +5668,18 @@ window.__ModuleLoader__.load({
           if (extra && extra.hoverEnd) extra.hoverEnd();
         },
         "data-result-idx": i,
+        "data-nav-row": "1",
         title: r.path || r.title,
         style: {
-          padding: "4px 6px",
+          padding: wide ? "6px 10px" : "4px 6px",
           margin: "1px 0",
           borderRadius: 6,
           cursor: "pointer",
           minWidth: 0,
+          // wide: one line, three parts — level chip / title, context, meta
+          display: wide ? "flex" : "block",
+          alignItems: wide ? "baseline" : undefined,
+          gap: wide ? 10 : undefined,
           background: isActive ? C.chip : "transparent",
           transition: "background 0.15s ease"
         },
@@ -3901,13 +5701,86 @@ window.__ModuleLoader__.load({
       return out;
     }
 
+    // cross-session list: the HOST's index over the other sessions. One row per hit —
+    // the hit session's title, the host's bounded snippet, and the scope note — and
+    // clicking a row hands that session to openCrossHit. No hover card here: the
+    // panel has no section text for a session it has not loaded.
+    function renderCrossResults(cross, q, C, titleOf, onOpen) {
+      var line = function (text, key, color, size) {
+        return react_jsx_runtime.jsx("div", {
+          style: {
+            padding: "10px 8px",
+            fontSize: size || 12,
+            color: color || C.muted,
+            textAlign: "center",
+            lineHeight: 1.5,
+            overflowWrap: "anywhere"
+          },
+          children: text
+        }, key);
+      };
+      var out = [
+        react_jsx_runtime.jsx("div", {
+          key: "cross-note",
+          style: { padding: "2px 8px 6px", fontSize: 10, color: C.muted, opacity: 0.8, lineHeight: 1.45 },
+          children: T("search.cross.note")
+        })
+      ];
+      if (cross.phase === "loading") {
+        out.push(line(T("search.cross.loading"), "cross-loading"));
+        return out;
+      }
+      if (cross.phase === "error") {
+        out.push(line(T("search.cross.error") + cross.error, "cross-error", C.error || C.muted));
+        return out;
+      }
+      if (!cross.rows || cross.rows.length === 0) {
+        out.push(line(T("search.cross.empty"), "cross-empty"));
+        if (cross.hidden > 0) {
+          out.push(line(Tp("search.cross.hidden", { n: cross.hidden }), "cross-hidden", C.muted, 10));
+        }
+        return out;
+      }
+      var rows = cross.rows;
+      var open = function (i) { onOpen(rows[i].sessionId); };
+      for (var i = 0; i < rows.length; i++) {
+        out.push(renderResultRow({
+          title: titleOf(rows[i].sessionId),
+          snippet: rows[i].snippet,
+          level: 0,
+          path: "",
+          time: "",
+          count: 1
+        }, i, q, C, open, false, null));
+      }
+      if (cross.more) {
+        out.push(react_jsx_runtime.jsx("div", {
+          key: "cross-more",
+          style: { padding: "8px 8px 2px", fontSize: 10, color: C.muted, opacity: 0.8, textAlign: "center" },
+          children: T("search.cross.more")
+        }));
+      }
+      // Hits the panel refuses to offer (archived / unlisted / subagent) are counted,
+      // not silently dropped: "why is my hit missing" must have an answer on screen.
+      if (cross.hidden > 0) {
+        out.push(line(Tp("search.cross.hidden", { n: cross.hidden }), "cross-hidden", C.muted, 10));
+      }
+      return out;
+    }
+
     // a group's header (the time row): clicking it jumps to the TOP OF THE
     // MODEL'S REPLY for that turn — the first assistant step — which also makes
     // heading-less turns jumpable, since they only have this row.
     // Implemented as a function (not an inline closure in a loop) so each
     // header captures its own (g, gi) — the var-in-loop closure bug would
     // otherwise make every header jump to the last group.
-    function renderGroupHeader(g, gi, jump, C, isActive) {
+    function renderGroupHeader(g, gi, jump, C, isActive, extra) {
+      // questions-only view and the wide curtain both give the header more room: it
+      // grows (11px -> 14px, 18px -> 24px) and its prompt stops being a footnote
+      // (0.75 -> 0.92 opacity on the body colour). The current-turn box is untouched
+      // either way, and every header in a given view still shares ONE style.
+      var big = !!(extra && (extra.questionsOnly || extra.wide));
+      var wideBand = !!(extra && extra.wide && !extra.questionsOnly);
       // a turn that ended in a failure has no reply to land on: its terminal row IS
       // the interesting position, so the header lands there (and says so in the tip)
       var replyKey = (g.msgs && g.msgs.length > 0) ? g.msgs[0].key : (g.failure ? g.failure.key : "");
@@ -3919,14 +5792,32 @@ window.__ModuleLoader__.load({
         if (g.userKey && findRow(g.userKey)) { jump(g.userKey); return; }
         if (g.headings.length > 0) jump(g.headings[0].key, g.headings[0].idx);
       };
+      // the group's own "jump to its end": the turn's last row (the failure row for
+      // a failed turn, else the last reply). Revealed while the header is hovered.
+      var lastKey = (g.msgs && g.msgs.length > 0) ? g.msgs[g.msgs.length - 1].key
+        : (g.failure ? g.failure.key : "");
       return react_jsx_runtime.jsx("div", {
+        onMouseEnter: function (e) {
+          var b = e.currentTarget.querySelector("[data-dqt-end]");
+          if (b) b.style.opacity = "1";
+        },
+        onMouseLeave: function (e) {
+          var b = e.currentTarget.querySelector("[data-dqt-end]");
+          if (b) b.style.opacity = "0";
+        },
         style: {
           // ONE row geometry for every group header, whether or not the turn has
           // headings: same box, same 18px rhythm, same left inset, so the time
           // column of a heading-less turn lines up with all the others. Only the
           // type emphasis differs (weight + colour, see the label below).
-          padding: "1px 4px 2px",
-          height: 18,
+          padding: big ? (wideBand ? "3px 4px 4px" : "2px 4px 3px") : "1px 4px 2px",
+          // the label is capped by this, not by a maxWidth guess: the row reserves the
+          // end control's zone, so a long prompt's hover box ends END_ZONE from the row
+          // edge — a real gap before the button's round backdrop, which sits 24px in.
+          // (With `max-width: calc(100% - 32px)` the percentage resolved somewhere else
+          // and a forced-long header still came within 2px of the circle.)
+          paddingRight: END_ZONE,
+          height: big ? (wideBand ? 24 : 22) : 18,
           display: "flex",
           alignItems: "center",
           minWidth: 0,
@@ -3957,6 +5848,7 @@ window.__ModuleLoader__.load({
           react_jsx_runtime.jsx("span", {
           onClick: jumpToTurn,
           title: (g.msgs && g.msgs.length > 0) ? T("turn.jumpReply") : (g.failure ? T("turn.jumpFailed") : T("turn.jumpTurn")),
+          "data-nav-row": "1",
           onMouseEnter: function (e) { e.currentTarget.style.background = C.hover; },
           onMouseLeave: function (e) { e.currentTarget.style.background = "transparent"; },
           style: {
@@ -3966,11 +5858,11 @@ window.__ModuleLoader__.load({
             // with the rest of the list (same size, weight, colour, opacity). The only
             // thing that marks a group is the shared "current group" tint, which lives
             // on the group box — never on the label.
-            fontSize: 11,
+            fontSize: big ? (wideBand ? 14 : 12.5) : 11,
             fontWeight: 400,
-            color: C.muted,
+            color: big ? C.text : C.muted,
             cursor: "pointer",
-            padding: "1px 5px",
+            padding: big ? "1px 5px" : "1px 5px",
             borderRadius: 4,
             background: "transparent",
             transition: "background 0.15s ease",
@@ -3978,6 +5870,8 @@ window.__ModuleLoader__.load({
             alignItems: "center",
             gap: 5,
             minWidth: 0,
+            // the row's paddingRight already reserves the end control's zone, so the
+            // label simply fills what is left: its hover box can never reach the circle
             maxWidth: "100%",
             overflow: "hidden"
           },
@@ -3986,7 +5880,7 @@ window.__ModuleLoader__.load({
             g.userText ? react_jsx_runtime.jsx("span", {
               style: {
                 fontWeight: 400,
-                opacity: 0.75,
+                opacity: big ? 0.92 : 0.75,
                 overflow: "hidden",
                 textOverflow: "ellipsis",
                 whiteSpace: "nowrap",
@@ -3995,7 +5889,8 @@ window.__ModuleLoader__.load({
               children: g.userText
             }) : null
           ]
-        })
+        }),
+          renderEndBtn(C, lastKey, undefined, g.turn)
         ]
       }, "g-h-" + gi);
     }
@@ -4040,6 +5935,7 @@ window.__ModuleLoader__.load({
         },
         "data-group-idx": gi,
         "data-ghost-turn": g.turn,
+        "data-nav-row": "1",
         title: T("turn.loadTip"),
         style: {
           padding: "3px 6px",
@@ -4131,8 +6027,10 @@ window.__ModuleLoader__.load({
           // every group gets the SAME header, whether or not this turn produced any
           // markdown headings — a heading-less turn is just a group with no rows, not
           // a second kind of entry (`rows` only decides what gets listed below it)
-          items.push(renderGroupHeader(g, gi, jump, C, isActive));
-          items.push(renderNodes(rows, 0, jump, C, "g" + gi, extra));
+          items.push(renderGroupHeader(g, gi, jump, C, isActive, extra));
+          // questions-only reading: the header IS the content, so its rows are left out
+          // entirely (the header itself grows and brightens for that job)
+          if (!extra.questionsOnly) items.push(renderNodes(rows, 0, jump, C, "g" + gi, extra));
           // the failure is the turn's LAST event, so its row sits under the rows
           if (g.failure) items.push(renderFailureRow(g, gi, jump, C));
         }
@@ -4358,6 +6256,7 @@ window.__ModuleLoader__.load({
         field("handle", T("settings.handle"), T("settings.handle.tip"), handleControl, false),
         field("fuzzy", T("settings.fuzzy"), "", onoff(prefs.fuzzy, function (v) { commit({ fuzzy: v }); }), true),
         field("hover", T("settings.hover"), "", onoff(prefs.hover, function (v) { commit({ hover: v }); }), true),
+        field("remember", T("settings.remember"), T("settings.remember.tip"), onoff(prefs.remember, function (v) { commit({ remember: v }); }), true),
         field("debug", T("settings.debug"), T("settings.debug.tip"), onoff(prefs.debug, function (v) { commit({ debug: v }); }), true, true)
       ];
       return react_jsx_runtime.jsxs("li", {
@@ -4459,6 +6358,16 @@ window.__ModuleLoader__.load({
           } catch (e) {
             return null;
           }
+        },
+        // The workspace registry owns the archive set the sidebar filters with
+        // (list.getSnapshot().archivedSessionIds). Cross-session hits are filtered
+        // by the SAME rule, so a hit the sidebar would hide is never offered here.
+        workspaces: function () {
+          try {
+            return typeof ctx.get === "function" ? (ctx.get("workspaces") || null) : null;
+          } catch (e) {
+            return null;
+          }
         }
       };
 
@@ -4534,6 +6443,43 @@ window.__ModuleLoader__.load({
         "@keyframes dqt-toast-out{from{opacity:1;transform:none}to{opacity:0;transform:none}}" +
         ".dqt-toast{animation:dqt-toast-in 0.2s cubic-bezier(0.22, 0.9, 0.3, 1) both}" +
         ".dqt-toast-closing{animation:dqt-toast-out 0.42s linear both}" +
+        // questions-only switch: fade the list out, swap the mode while it is
+        // invisible, fade it back in (the two lists never blend mid-swap)
+        ".dqt-mode-out{animation:dqt-fade-out 0.15s linear both}" +
+        ".dqt-mode-in{animation:dqt-fade-in 0.26s cubic-bezier(0.22, 0.9, 0.3, 1) both}" +
+        // the curtain FLIES DOWN from above the line it hangs from and flies back up
+        // on the way out — the same vocabulary as the docked panel sliding in from its
+        // edge. The clip box it lives in (see the portal) is what keeps it from being
+        // seen above that line, so it reads as emerging from under the view tabs.
+        "@keyframes dqt-sheet-in{from{transform:translateY(-100%)}to{transform:translateY(0)}}" +
+        "@keyframes dqt-sheet-out{from{transform:translateY(0)}to{transform:translateY(-100%)}}" +
+        ".dqt-sheet-open{animation:dqt-sheet-in 0.46s cubic-bezier(0.22, 0.9, 0.3, 1) both;will-change:transform}" +
+        ".dqt-sheet-closing{animation:dqt-sheet-out 0.3s cubic-bezier(0.4, 0, 1, 1) both;pointer-events:none;will-change:transform}" +
+        "@media (prefers-reduced-motion: reduce){.dqt-sheet-open,.dqt-sheet-closing{animation:none}}" +
+        // The curtain handle is a droplet resting on the view-tab strip's lower line:
+        // its silhouette flares into two concave fillets at the line (surface tension,
+        // not a detached pill). It grows out of the line when it appears — after a
+        // retract as much as on first paint — and the click squeezes it flat against
+        // the line before the curtain takes over (see the element's own transform).
+        "@keyframes dqt-handle-pop{from{transform:scaleY(0.06)}to{transform:scaleY(1)}}" +
+        ".dqt-sheet-handle{transform-origin:50% 100%}" +
+        // coming back it is the press read backwards: FAST OUT OF THE LINE — 74% of the
+        // easing is done 30ms in — and then the rest settles over the remaining 170ms.
+        // `cubic-bezier(0, 0.55, 0.25, 1)` is exactly `cubic-bezier(0.75, 0, 1, 0.45)`
+        // mirrored, which is the curve the press uses.
+        ".dqt-sheet-handle>svg{animation:dqt-handle-pop 0.2s cubic-bezier(0, 0.55, 0.25, 1) both;transform-origin:50% 100%}" +
+        "@media (prefers-reduced-motion: reduce){.dqt-sheet-handle>svg{animation:none}}" +
+        // keyboard cursor: an INSET outline plus a whisper of fill, so it never
+        // reflows the row and stays distinct from the reading position's blue box
+        // (which keeps the 3px left accent bar and the pastel fill)
+        ".dqt-nav{box-shadow:inset 0 0 0 1px var(--dsw-alias-brand-primary, #4f8cff);background:rgba(79,140,255,0.10);border-radius:6px}" +
+        ".dqt-nav:focus{outline:none}" +
+        // the list itself never draws a focus ring — the cursor row is the indicator
+        ".dqt-list:focus-visible{outline:none}" +
+        // screen-reader-only live region
+        ".dqt-sr{position:absolute;width:1px;height:1px;margin:-1px;padding:0;overflow:hidden;clip:rect(0 0 0 0);clip-path:inset(50%);white-space:nowrap;border:0}" +
+        // the fade is decoration: a reader who asked for less motion gets the swap
+        "@media (prefers-reduced-motion: reduce){.dqt-mode-out,.dqt-mode-in{animation:none}}" +
         // exit: starts moving immediately (fast attack), so the dismiss feels snappy
         ".dqt-levels-pop-closing{animation:dqt-pop-out 0.14s cubic-bezier(0.2, 0.9, 0.3, 1) both;will-change:transform,opacity}" +
         // Hide the native scrollbar entirely (no arrow buttons, no grey bar) —