dsh-quick-toc 0.3.3 → 0.4.1

package/CHANGELOG.en.md

@@ -2,6 +2,33 @@
 
 All notable changes to **dsh-quick-toc** are documented here. Chinese version: [CHANGELOG.md](CHANGELOG.md).
 
+## [0.4.0] - 2026-09-11
+
+### Added
+- **Search result list**: while a query is present the outline becomes a result list — one row per match, showing the matched heading or message with the keyword highlighted, its heading path, the turn time and a repeat count (plus a context snippet in full-text scope). Rows are chronological with the **newest hit at the bottom**, a fresh search starts at the newest hit and you scroll up to reach earlier ones; **clicking a row** makes that hit current, i.e. the same path as Enter stepping — it highlights the keyword in the conversation and scrolls there. `n/N` Enter-stepping is kept.
+- **Sticky group headers**: while scrolling the outline, the header of the turn you are inside stays pinned to the top of the panel, flush against the toolbar above it.
+- **Collapsible level-filter row**: the **层级 (levels)** button at the left of the magnifier hides/shows the `1`–`6` row (the choice is remembered; the filter keeps applying while it is hidden).
+- **Position breadcrumb**: the top of the panel shows the path of the section you are reading; click it to jump there. The rule is "the deepest heading above the viewport's middle line" — the section that fills most of the screen — and since a jump also lands above that line, the breadcrumb still shows the same heading after you click it.
+- **Heading level filter**: the `1`–`6` chips at the top of the panel are independent switches, so any combination works (e.g. H1 and H3 with H2 hidden) and the choice is remembered; switching off the last remaining level restores all six.
+
+### Changed
+- **Performance**: heading parsing and text extraction are now cached per node, so a streaming update only re-processes the node that changed instead of the whole history; the cache drops nodes that left the conversation, keeping it bounded.
+- The turn header (the time row) now jumps to the **start of that turn's model reply** (it used to jump to the user message).
+- **Compatibility**: verified against and declared for DSH **0.1.5-rc.1 and 0.1.5-rc.2** (`engines.dsh` keeps its floor of `>=0.1.5-rc.1`). The host interface is identical in both — the session-scoped slot `conversation.input.overlay`, the `useChat` hook from `dsh-client-ui-chat` and the client-module seed table were all checked against the installed bundles.
+- `countOccurrences` now guards an empty needle (an empty query made `indexOf` spin in place — an infinite loop; every current call site is guarded, so this is hardening).
+
+### Fixed
+- The outline did not jump to the newest turn when content first appeared: that effect's dependency array was written above the `groups` declaration, so it always evaluated to `0` during render and the effect only ever ran on mount. The effect now sits below `groups` and depends on `groups.length`.
+- Dragging the top bar to move the panel persisted the position from **before** the drag (the closure kept the value captured at pointer-down), so the panel jumped back to its old spot after a reload. It now stores the position the drag ended at.
+- When the same keyword occurred more than once inside one text node, the in-chat highlight wrapped only the FIRST occurrence there, so the later one was neither tinted nor eligible to be marked as the current hit — stepping to it found no current mark and degraded to a plain scroll with no distinct highlight. Every occurrence inside each text node is now wrapped in order, so the in-conversation hit order lines up with `n/N`.
+- `# comment` / `## example` lines inside a ``` fenced code block were treated as headings and leaked into the outline: they have no element to jump to, and they shifted the index of the real headings after them so those jumped to the wrong place. Heading parsing now skips fenced blocks (``` and ~~~, info strings, longer closing fences, up to 3 spaces of indentation).
+
+## [0.4.1] - 2026-09-12
+
+### Changed
+- **Heading levels are now a popup**: a round icon button in the header (three lines of decreasing width, hover feedback matching the magnifier) scales the H1–H6 picker out of the **button's center**, right-aligned with an outer shadow; closing shrinks it back into the button with a fade. The picker no longer occupies its own row, the chips are labelled H1–H6, and their selected tint matches the title / full-text toggle.
+- Removed the "you are here" breadcrumb row introduced in 0.4.0 (it felt unnecessary in use).
+
 ## [0.3.3] - 2026-09-10
 
 ### Added

package/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 **dsh-quick-toc** 的重要变更都记录在这里。英文版见 [CHANGELOG.en.md](CHANGELOG.en.md)。
 
+## [0.4.0] - 2026-09-11
+
+### 新增
+- **搜索结果列表**：有搜索词时大纲切换为结果列表，逐条列出命中（标题关键字高亮、层级路径、回合时间、重复次数，全文模式附上下文片段）。列表按时间排列、**最新的命中在底部**，开始搜索时自动定位到最新命中，向上滚回看更早的命中；点击任一行会把该命中设为当前命中——和回车逐处跳同一条路径，会在对话里高亮并滚过去；`n/N` 回车逐处跳保留
+- **组头吸顶**：滚动大纲时，当前所在回合的组头固定在面板顶部，并与上方工具条紧贴
+- **层级筛选行可收起**：标题栏放大镜左边的 **层级** 按钮收起/展开 `1`–`6` 那一行（选择会记住；收起后筛选设置仍然生效）
+- **位置面包屑**：面板顶部显示你正在读的章节路径，点击可跳到该标题。判定规则是"视口中线之上最深的标题"（画面里占得最多的那一节）；跳转落点也在中线之上，所以点完后面包屑显示的仍是同一个标题
+- **标题层级筛选**：面板顶部 `1`–`6` 芯片是各自独立的开关，可任意组合（例如只留 H1 与 H3、关掉中间的 H2），选择会记住；把最后一个亮着的层级也关掉时自动恢复显示全部六级
+
+### 变更
+- **性能**：标题解析与文本提取改为按节点缓存——流式更新只重算真正变化的节点，不再每次重算整段历史；缓存会清理已离开会话的节点，保持有界
+- 回合组头（时间那一行）点击改为跳到**该回合模型回答的开头**（原来跳到用户消息位置）
+- **兼容性**：在 DSH **0.1.5-rc.1 与 0.1.5-rc.2** 上验证并声明兼容（`engines.dsh` 下限仍为 `>=0.1.5-rc.1`）。两版的宿主接口一致——会话级槽位 `conversation.input.overlay`、`dsh-client-ui-chat` 的 `useChat` hook 与客户端模块 seed 表都经实测核对相同。
+- `countOccurrences` 增加空查询守卫（空查询会让 `indexOf` 原地打转导致死循环；现有调用点都有守卫，此举为加固）
+
+### 修复
+- 大纲首次载入内容时没有自动定位到最新回合：该副作用的依赖数组写在 `groups` 声明之前，渲染时读到的永远是 `0`，导致副作用只在挂载时执行一次。已把副作用移到 `groups` 之后并直接依赖 `groups.length`。
+- 拖动顶部横条调整面板垂直位置后，记录的仍是**拖动前**的位置（写入的是拖动开始时闭包里的旧值），刷新后面板跳回原位。现在写入拖动结束时的实际位置。
+- 同一段文本里同一关键字出现多次时，对话内高亮只包住**该文本节点里的第一处**：第二处既不染色，也无法被标成"当前命中"，于是跳到第二处时找不到当前标记，退化成"只滚动、没有高亮"。现在每个文本节点内的所有出现都会依次包住，对话内命中序号与 `n/N` 完全对齐。
+- ``` 围栏代码块里的 `# 注释` / `## 示例` 会被当成标题混进大纲（既没有可跳转的目标，又会让它后面那些真标题的序号错位、跳到错误位置）。现在解析标题时会跳过围栏代码块（支持 ``` 与 ~~~、带 info string 的开栏、更长的闭栏、最多 3 空格缩进）。
+
+## [0.4.1] - 2026-09-12
+
+### 变更
+- **层级筛选改为弹出选择**：标题栏新增圆形图标按钮（三条递减横线，悬停反馈与放大镜一致），点击后从**按钮中心**放大弹出 H1–H6 选择层（靠右、带外阴影），收回时缩回按钮并渐隐，不再单独占一行；选择芯片标注 H1–H6，选中态配色与搜索的"标题 / 全文"切换一致
+- 移除面板顶部的"当前位置"面包屑行（0.4.0 新增，使用中显得多余）
+
 ## [0.3.3] - 2026-09-10
 
 ### 新增

package/README.en.md

@@ -6,26 +6,29 @@ A conversation TOC plugin for [DeepSeek Harness](https://github.com/deepseek-ai/
 
 ## Features
 
-- **Turn-grouped outline** — each user message plus its following AI replies form one group; the group header shows the turn's end time and a first-line preview, and clicking it jumps to the start of the turn
-- **Keyword search** — the magnifier in the panel header opens a search box; press **Enter** to jump to the next match (wrapping), **Esc** to close, with an `n/N` match counter
-- **Search scope toggle** — the **title / full-text** button in the search box switches between searching heading titles only and also searching user messages plus AI reply text
-- **In-chat highlighting** — matched keywords are highlighted in the conversation; the current match is highlighted distinctly and scrolled into the upper part of the viewport; every occurrence inside a message counts toward `n/N`
-- **Auto-follow highlighting** — while scrolling the conversation, the turns visible in the viewport light up in the outline (several at once) and the rest dim; the outline loads and scrolls so the group being read stays visible
-- **Jumping** — click a heading to jump to its position in the conversation, or click a group header's time/preview to jump to the start of that turn
-- **Dockable and resizable** — drag the top bar to move the panel, use ◀ / ▶ to dock it left or right, drag an edge or corner to resize, and collapse it into an edge handle (click it to expand); the panel's position and size are remembered
-- **Paging and loading older** — the most recent groups show first; scrolling up inside the outline loads older groups
-- **Markdown-aware titles** — inline markup in headings (`**bold**`, `*italic*`, `` `code` ``, `[links](url)`, `~~strike~~`) is stripped before display
-- **Chat view only** — when the center column switches to another view (trajectory, context, …), the panel and its edge handle fade out
-- The panel hides itself when the conversation has no headings; it adapts to the dark and light themes (the inner-shadow card follows the theme)
+- **Turn-grouped outline** — each user message plus its following AI replies form one group; the group header shows the turn's time and a first-line preview, and clicking it jumps to the start of that turn's model reply
+- **Search** — the magnifier in the panel header opens a search box: title / full-text scopes, click any result row to locate and highlight that hit, `n/N` Enter stepping, Esc to close
+- **In-chat highlighting** — matched keywords are highlighted in the conversation; the current match is highlighted distinctly
+- **Sticky group headers** — while scrolling the outline, the current turn's header stays pinned at the top of the panel
+- **Heading level filter** — the round levels button in the header pops down H1–H6 switches for any combination
+- **Auto-follow** — the turn being read lights up in the outline while you scroll the conversation; the outline loads and follows on its own
+- **Jumping** — click a heading to jump to its position in the conversation
+- **Dockable and resizable** — drag the top bar to move the panel, ◀ / ▶ to dock left or right, drag an edge to resize, and collapse it into an edge handle; position and size are remembered
+- **Paging** — the most recent groups show first; scroll up to load older turns
+- **Markdown-aware** — inline markup in headings is stripped; `#` lines inside fenced code blocks are not headings
+- **Theme-aware** — adapts to dark and light themes; visible on the chat view only and fades out elsewhere
+- The panel hides itself when the conversation has neither headings nor readable times
 
 ## Compatibility
 
 | Plugin | Supported DSH |
 | --- | --- |
-| **0.3.3** (latest) | 0.1.5-rc.1 |
-| 0.3.2 | ≥ 0.1.2-rc.1 |
+| **0.4.1** (latest) | 0.1.5-rc.1, 0.1.5-rc.2 |
+| 0.4.0 | 0.1.5-rc.1, 0.1.5-rc.2 |
+| 0.3.3 | 0.1.5-rc.1 |
+| 0.3.0 – 0.3.2 | ≥ 0.1.2-rc.1 |
 
-The latest version has only been verified against **DSH 0.1.5-rc.1**, so that is the only version it declares; older DSH versions are unverified and therefore not claimed. On an older DSH, the newest usable plugin version is **0.3.2**. On install or update, the DSH market pre-flights host compatibility from `engines.dsh`, `dsh.compatibility.dshReleases` and `peerDependencies` in `package.json`.
+`engines.dsh` has a floor of **0.1.5-rc.1** (`>=`): from that release on, the plugin uses the host's session-scoped slot injection. Since 0.4.0 the plugin has been verified against **0.1.5-rc.1 and 0.1.5-rc.2** and declares exactly those; older or newer DSH versions are unverified and therefore not claimed. On an older DSH, the newest usable plugin version is **0.3.2**. On install or update, the DSH market pre-flights host compatibility from `engines.dsh`, `dsh.compatibility.dshReleases` and `peerDependencies` in `package.json`.
 
 ## Install
 
@@ -51,11 +54,12 @@ After installing, restart DSH and open the Web UI. The panel starts collapsed; c
 
 ## Usage
 
-- **Jumping**: click a heading in the outline to jump to its position; click a group header's time or first-line preview to jump to the start of that turn
-- **Search**: click the magnifier in the header to open the search box, type a keyword and press Enter to step through matches (`n/N` shows the current position and the total); press Esc or the magnifier again to close it; use the **title / full-text** button to change the search scope
-- **Moving and docking**: drag the top bar to move the panel; use ◀ / ▶ to switch between left and right docking
-- **Resizing**: drag the right edge for width, the bottom edge for height, or the bottom-right corner for both
-- **Loading older turns**: scroll up inside the outline to load older groups; when the conversation itself offers a "load older messages" button, the outline also triggers it on reaching the top
+- **Jumping**: click an outline heading or a group header to jump to it
+- **Search**: open the box with the magnifier, click a result to locate and highlight it, Enter to step through matches, Esc to close
+- **Level filter**: click the round levels button in the header to pop down the H1–H6 switches
+- **Moving and docking**: drag the top bar to move, ◀ / ▶ to switch sides
+- **Resizing**: drag the right edge, bottom edge or bottom-right corner
+- **Loading older turns**: scroll up inside the outline
 
 ## Development
 

package/README.md

@@ -6,26 +6,29 @@
 
 ## 功能
 
-- **按回合分组** —— 每条用户消息 + 其后续 AI 回复为一组；组头显示该组最后一条消息的结束时间，并附带该回合首行预览，点击可跳到回合开头
-- **关键字搜索** —— 标题栏放大镜打开搜索框；输入后按 **回车** 跳到下一处命中（循环），按 **Esc** 关闭；命中计数以 `n/N` 显示
-- **搜索范围切换** —— 搜索框内的 **标题 / 全文** 按钮切换范围：仅标题，或同时搜索用户消息与 AI 回复正文
-- **对话内高亮** —— 命中的关键字在对话中高亮，当前命中单独标亮并滚动到视口上部；同一条消息中的多次命中都会计入 `n/N`
-- **自动跟随高亮** —— 滚动对话时，视口内可见的回合在大纲中自动点亮（可同时点亮多组），其余组变暗；大纲自动加载并滚动，使正在阅读的组保持可见
-- **跳转** —— 点击标题跳到对话中该标题所在位置；点击组头的时间或预览跳到该回合开头
-- **可停靠、可缩放** —— 拖顶部横条移动，按 ◀ / ▶ 切换左右停靠，拖边缘或角部调整宽高，收起后成为边缘把手（点击展开）；面板位置与尺寸会被记住
-- **分页与加载更早** —— 默认显示最近的若干组；在大纲中向上滚动（或滚动到顶部）会加载更早的组
-- **Markdown 清理** —— 标题中的行内标记（`**加粗**`、`*斜体*`、`` `代码` ``、`[链接](url)`、`~~删除线~~`）会被剥离后显示
-- **仅对话视图显示** —— 中间列切到轨迹、上下文等其他视图时，面板与边缘把手渐隐
-- 对话中没有标题时面板自动隐藏；适配深色与浅色主题（内阴影质感随主题切换）
+- **按回合分组** —— 每条用户消息 + 其后续 AI 回复为一组，组头显示回合时间与首行预览，点击跳到该回合模型回答的开头
+- **搜索** —— 标题栏放大镜打开搜索框：标题 / 全文两种范围，结果列表点击任一条定位并高亮，`n/N` 回车逐处跳，Esc 关闭
+- **对话内高亮** —— 命中的关键字在对话中高亮，当前命中单独标亮
+- **组头吸顶** —— 滚动大纲时，当前回合的组头固定在面板顶部
+- **层级筛选** —— 标题栏的圆形层级按钮弹出 H1–H6 开关，任意组合显示
+- **自动跟随** —— 滚动对话时正在阅读的回合在大纲中自动点亮，其余变暗；大纲自动加载并跟随
+- **跳转** —— 点击标题跳到对话中该标题的位置；面板与对话双向定位
+- **可停靠、可缩放** —— 拖顶部横条移动，◀ / ▶ 切换左右停靠，拖边缘调宽高，收起后成为边缘把手；位置与尺寸会被记住
+- **分页** —— 默认显示最近的若干组，向上滚动加载更早的回合
+- **Markdown 感知** —— 标题中的行内标记会被剥离；围栏代码块里的 `#` 行不算标题
+- **主题适配** —— 深色 / 浅色主题自适应；仅对话视图显示，切到其他视图渐隐
+- 对话中没有标题也没有可识别时间时面板自动隐藏
 
 ## 兼容性
 
 | 插件版本 | 支持的 DSH 版本 |
 | --- | --- |
-| **0.3.3**（最新） | 0.1.5-rc.1 |
-| 0.3.2 | ≥ 0.1.2-rc.1 |
+| **0.4.1**（最新） | 0.1.5-rc.1、0.1.5-rc.2 |
+| 0.4.0 | 0.1.5-rc.1、0.1.5-rc.2 |
+| 0.3.3 | 0.1.5-rc.1 |
+| 0.3.0 – 0.3.2 | ≥ 0.1.2-rc.1 |
 
-最新版目前只在 **DSH 0.1.5-rc.1** 上验证过，因此仅声明该版本兼容；更早的 DSH 版本未经验证，不作声明。使用更早版本 DSH 时，可用的最新插件版本是 **0.3.2**。安装或更新时，DSH 市场会依据 `package.json` 中的 `engines.dsh`、`dsh.compatibility.dshReleases` 与 `peerDependencies` 做宿主兼容预检。
+`engines.dsh` 下限为 **0.1.5-rc.1**（`>=`，该版本起插件改用会话级槽位注入的宿主接口）；0.4.0 起在 **0.1.5-rc.1 与 0.1.5-rc.2** 上验证过并声明兼容，更早或更新的 DSH 版本未经验证，不作声明。在更早的 DSH 上，可安装的最新插件版本是 **0.3.2**。安装或更新时，DSH 市场会依据 `package.json` 中的 `engines.dsh`、`dsh.compatibility.dshReleases` 与 `peerDependencies` 做宿主兼容预检。
 
 ## 安装
 
@@ -51,11 +54,12 @@ dsh plugin --profile web add <插件目录路径>
 
 ## 使用
 
-- **跳转**：点击大纲标题跳到该标题所在位置；点击组头的时间或首行预览跳到该回合开头
-- **搜索**：点击标题栏的放大镜展开搜索框，输入关键字后按回车逐处跳转（`n/N` 显示当前位置与命中总数），按 Esc 或再次点击放大镜关闭；用 **标题 / 全文** 按钮切换搜索范围
-- **移动与停靠**：拖顶部横条移动面板，按 ◀ / ▶ 在左右之间切换停靠
-- **调整大小**：拖右边缘调宽度、拖下边缘调高度、拖右下角同时调整
-- **加载更早**：在大纲中向上滚动即可加载更早的回合；对话本身有"加载更早消息"按钮时，大纲滚到顶部也会触发它
+- **跳转**：点击大纲标题或组头跳到对应位置
+- **搜索**：放大镜打开搜索框，输入后点结果定位并高亮，回车逐处跳，Esc 关闭
+- **层级筛选**：点标题栏的圆形层级按钮弹出 H1–H6 开关，选择显示的层级
+- **移动与停靠**：拖顶部横条移动，◀ / ▶ 切换左右停靠
+- **调整大小**：拖右边缘、下边缘或右下角
+- **加载更早**：在大纲中向上滚动
 
 ## 开发
 

package/lib/client.js

@@ -78,12 +78,28 @@ window.__ModuleLoader__.load({
       return first;
     }
 
+    // Headings are collected line by line so FENCED CODE BLOCKS can be skipped:
+    // a "```" block that documents markdown (or shows a shell comment like
+    // "# install") contains lines that look like headings but are code — they
+    // must not become outline entries (they have no element to jump to, and they
+    // shifted the index of the real headings).
     function parseHeadings(text) {
       var items = [];
-      var re = /^(#{1,6})\s+(.+?)\s*#*\s*$/gm;
-      var m;
-      while ((m = re.exec(text)) !== null) {
-        items.push({ level: m[1].length, title: cleanTitle(m[2].trim()) });
+      if (!text) return items;
+      var lines = text.split("\n");
+      var fence = null; // { char, len } while inside a fenced code block
+      for (var i = 0; i < lines.length; i++) {
+        var line = lines[i];
+        var fm = line.match(/^ {0,3}(`{3,}|~{3,})(.*)$/);
+        if (fence !== null) {
+          // a closing fence uses the same character, is at least as long and has
+          // no info string after it
+          if (fm && fm[1].charAt(0) === fence.char && fm[1].length >= fence.len && fm[2].trim() === "") fence = null;
+          continue;
+        }
+        if (fm) { fence = { char: fm[1].charAt(0), len: fm[1].length }; continue; }
+        var m = line.match(/^(#{1,6})\s+(.+?)\s*#*\s*$/);
+        if (m !== null) items.push({ level: m[1].length, title: cleanTitle(m[2].trim()) });
       }
       return items;
     }
@@ -101,6 +117,74 @@ window.__ModuleLoader__.load({
       return root.children;
     }
 
+    // ---- per-node extraction cache ----
+    // The conversation store keeps the same node objects for unchanged messages,
+    // so a streaming update only re-joins/re-parses the node that actually
+    // changed instead of every message in the history.
+    var EMPTY_HEADINGS = [];
+    var nodeInfoCache = new Map();
+    function nodeInfo(key, node) {
+      var isUser = node.kind === "user";
+      var blocks = node.data ? node.data.blocks : undefined;
+      var cached = nodeInfoCache.get(key);
+      if (cached !== undefined &&
+        (cached.node === node || (blocks !== undefined && cached.blocks === blocks && cached.user === isUser))) {
+        return cached;
+      }
+      var text = isUser ? extractUserText(node) : extractReplyText(node);
+      var info = {
+        node: node,
+        blocks: blocks,
+        user: isUser,
+        text: text,
+        headings: node.kind === "assistant-step" ? parseHeadings(text) : EMPTY_HEADINGS
+      };
+      nodeInfoCache.set(key, info);
+      return info;
+    }
+    // Drop cache records whose node left the conversation (bounded growth).
+    function pruneNodeInfo(seen) {
+      if (nodeInfoCache.size <= 200) return;
+      nodeInfoCache.forEach(function (value, key) {
+        if (!seen[key]) nodeInfoCache.delete(key);
+      });
+    }
+
+    // stable id for one heading occurrence (a message can hold several)
+    function headingId(h) {
+      return h.key + "#" + h.idx;
+    }
+
+    // Split `text` into runs around case-insensitive occurrences of `q`, so the
+    // caller can render the hits distinctly. Returns [{ text, hit }, ...].
+    function highlightParts(text, q) {
+      var parts = [];
+      if (!text) return parts;
+      if (!q) return [{ text: text, hit: false }];
+      var lower = text.toLowerCase();
+      var from = 0;
+      for (;;) {
+        var at = lower.indexOf(q, from);
+        if (at === -1) break;
+        if (at > from) parts.push({ text: text.slice(from, at), hit: false });
+        parts.push({ text: text.slice(at, at + q.length), hit: true });
+        from = at + q.length;
+      }
+      if (from < text.length) parts.push({ text: text.slice(from), hit: false });
+      return parts;
+    }
+
+    // A one-line window around the first hit of `q` in `text` (for search results).
+    function snippetAround(text, q, span) {
+      if (!text) return "";
+      var flat = text.replace(/\s+/g, " ").trim();
+      var at = flat.toLowerCase().indexOf(q);
+      if (at === -1) return previewText(flat, span * 2);
+      var start = Math.max(0, at - span);
+      var end = Math.min(flat.length, at + q.length + span);
+      return (start > 0 ? "…" : "") + flat.slice(start, end) + (end < flat.length ? "…" : "");
+    }
+
     // strict lookup: exact dataset match or CSS-escaped selector only —
     // no fuzzy contains matching (avoids landing on the wrong row);
     // hidden rows (zero rect, e.g. duplicate/hidden copies) are skipped
@@ -145,6 +229,10 @@ window.__ModuleLoader__.load({
 
     // count every occurrence of q (case-insensitive) inside text
     function countOccurrences(text, q) {
+      // an empty needle would make indexOf return 0 forever and freeze the tab;
+      // every caller passes a trimmed non-empty query today, but the guard keeps
+      // a future call site from hanging the UI.
+      if (!text || !q) return 0;
       var lower = text.toLowerCase();
       var count = 0;
       var idx = 0;
@@ -245,26 +333,36 @@ window.__ModuleLoader__.load({
         var text = node.nodeValue;
         if (!text) continue;
         var lower = text.toLowerCase();
-        var idx = lower.indexOf(q);
-        if (idx < 0) continue;
+        if (lower.indexOf(q) < 0) continue;
         var frag = document.createDocumentFragment();
-        var before = text.slice(0, idx);
-        if (before) frag.appendChild(document.createTextNode(before));
-        var mark = document.createElement("span");
-        if (occ === currentOcc) {
-          mark.className = "dqt-current";
-          mark.style.background = "rgba(79,140,255,0.55)";
-          mark.style.boxShadow = "0 0 0 1px rgba(79,140,255,0.85)";
-        } else {
-          mark.style.background = "rgba(79,140,255,0.32)";
+        // EVERY occurrence inside this text node must be wrapped, in order: the
+        // caller addresses hits by their global index (`occ`), which is counted
+        // over the message text. Wrapping only the first one per text node made
+        // a second hit on the same line un-markable, so stepping to it found no
+        // `.dqt-current` and fell back to a plain scroll with no highlight.
+        var from = 0;
+        var idx = lower.indexOf(q, from);
+        while (idx !== -1) {
+          var before = text.slice(from, idx);
+          if (before) frag.appendChild(document.createTextNode(before));
+          var mark = document.createElement("span");
+          if (occ === currentOcc) {
+            mark.className = "dqt-current";
+            mark.style.background = "rgba(79,140,255,0.55)";
+            mark.style.boxShadow = "0 0 0 1px rgba(79,140,255,0.85)";
+          } else {
+            mark.style.background = "rgba(79,140,255,0.32)";
+          }
+          mark.style.borderRadius = "2px";
+          mark.style.color = "inherit";
+          mark.textContent = text.slice(idx, idx + q.length);
+          frag.appendChild(mark);
+          highlightSpans.push(mark);
+          occ++;
+          from = idx + q.length;
+          idx = lower.indexOf(q, from);
         }
-        mark.style.borderRadius = "2px";
-        mark.style.color = "inherit";
-        mark.textContent = text.slice(idx, idx + q.length);
-        frag.appendChild(mark);
-        highlightSpans.push(mark);
-        occ++;
-        var after = text.slice(idx + q.length);
+        var after = text.slice(from);
         if (after) frag.appendChild(document.createTextNode(after));
         node.parentNode.replaceChild(frag, node);
       }
@@ -475,6 +573,88 @@ window.__ModuleLoader__.load({
       var panelH = _s8[0];
       var setPanelH = _s8[1];
 
+      // ---- heading level filter (persisted) ----
+      // An arbitrary SET of levels, not a "show up to N" prefix: every chip is an
+      // independent on/off switch, so H1 + H3 without H2 is a valid view. Turning
+      // the last remaining level off restores all six (the panel is never empty).
+      var LEVELS_KEY = "dsh-quick-toc.levels.v1";
+      var OLD_MAX_LEVEL_KEY = "dsh-quick-toc.maxLevel.v1";
+      var ALL_LEVELS = [1, 2, 3, 4, 5, 6];
+      var _sLv = react.useState(function () {
+        try {
+          var raw = localStorage.getItem(LEVELS_KEY);
+          if (raw !== null) {
+            var arr = JSON.parse(raw);
+            if (Array.isArray(arr)) {
+              var kept = ALL_LEVELS.filter(function (lv) { return arr.indexOf(lv) !== -1; });
+              if (kept.length > 0) return kept;
+            }
+          }
+          // migrate the "show up to N" value written by earlier builds
+          var v = Number(localStorage.getItem(OLD_MAX_LEVEL_KEY));
+          if (isFinite(v) && v >= 1 && v <= 6) {
+            return ALL_LEVELS.filter(function (lv) { return lv <= v; });
+          }
+        } catch (e) {}
+        return ALL_LEVELS.slice();
+      });
+      var levels = _sLv[0];
+      var setLevels = _sLv[1];
+      var levelSet = react.useMemo(function () {
+        var m = {};
+        for (var i = 0; i < levels.length; i++) m[levels[i]] = true;
+        return m;
+      }, [levels]);
+      var toggleLevel = function (lv) {
+        var next;
+        if (levelSet[lv]) {
+          next = levels.filter(function (x) { return x !== lv; });
+          if (next.length === 0) next = ALL_LEVELS.slice(); // never leave the panel empty
+        } else {
+          next = ALL_LEVELS.filter(function (x) { return x === lv || levelSet[x]; });
+        }
+        setLevels(next);
+        try { localStorage.setItem(LEVELS_KEY, JSON.stringify(next)); } catch (e) {}
+      };
+
+      // ---- heading-level picker popup (transient): opens from the round button
+      // next to the search button; closes on an outside pointerdown. Closing
+      // plays a short shrink-back animation before unmounting. ----
+      var _sLo = react.useState(false);
+      var levelsOpen = _sLo[0];
+      var setLevelsOpen = _sLo[1];
+      var _sLc = react.useState(false);
+      var levelsClosing = _sLc[0];
+      var setLevelsClosing = _sLc[1];
+      var closeLevels = function () {
+        if (!levelsOpen || levelsClosing) return;
+        setLevelsClosing(true);
+        // unmount when the exit animation actually finishes (fallback timer in
+        // case animationend never fires, e.g. display:none ancestors)
+        var popped = document.querySelector(".dqt-levels-pop");
+        var done = false;
+        var finish = function () {
+          if (done) return;
+          done = true;
+          if (popped && popped.removeEventListener) popped.removeEventListener("animationend", finish);
+          setLevelsOpen(false);
+          setLevelsClosing(false);
+        };
+        if (popped && popped.addEventListener) popped.addEventListener("animationend", finish);
+        setTimeout(finish, 220);
+      };
+      react.useEffect(function () {
+        if (!levelsOpen) return;
+        var close = function (e) {
+          var t = e.target;
+          if (t && t.closest && (t.closest(".dqt-levels-pop") || t.closest(".dqt-levels-btn"))) return;
+          closeLevels();
+        };
+        document.addEventListener("pointerdown", close);
+        return function () { document.removeEventListener("pointerdown", close); };
+      }, [levelsOpen, levelsClosing]);
+
+
       // ---- pagination: show the latest N groups; scrolling to the top loads older ----
       var PAGE_SIZE = 6;
       var _s9 = react.useState(PAGE_SIZE);
@@ -593,13 +773,6 @@ window.__ModuleLoader__.load({
       var setActiveGroup = _s10[1];
       var activeSigRef = react.useRef("");
 
-      // first time content appears, scroll the list to the bottom (newest)
-      react.useEffect(function () {
-        if (didInitScroll.current || !listRef.current || !groups || groups.length === 0) return;
-        didInitScroll.current = true;
-        listRef.current.scrollTop = listRef.current.scrollHeight;
-      }, [groups ? groups.length : 0]);
-
       // load older outline groups; when everything is loaded, click the
       // conversation's own "load older" button so older turns keep appearing
       var loadOlderOutline = function (el) {
@@ -760,6 +933,7 @@ window.__ModuleLoader__.load({
         var turnUserText = {};
         var turnUserFull = {};
         if (!order || !nodes) return result;
+        var seen = {};
         // first pass: per-turn time — the LAST message of the turn wins (end time);
         // also remember each turn's user message key + first-line preview + full text
         for (var i = 0; i < order.length; i++) {
@@ -769,10 +943,12 @@ window.__ModuleLoader__.load({
           var l0 = n0.location;
           var tid0 = l0 && (l0.kind === "turn" || l0.kind === "step") && l0.turn ? l0.turn.turn : null;
           if (tid0 === null) continue;
+          seen[k0] = true;
+          var info0 = nodeInfo(k0, n0);
           if (n0.kind === "user" && turnUserKey[tid0] === undefined) {
             turnUserKey[tid0] = k0;
-            turnUserText[tid0] = previewText(extractUserText(n0), 30);
-            turnUserFull[tid0] = extractUserText(n0);
+            turnUserText[tid0] = previewText(info0.text, 30);
+            turnUserFull[tid0] = info0.text;
           }
           var t0 = getNodeTime(n0);
           if (t0) turnTimes[tid0] = t0;
@@ -797,22 +973,37 @@ window.__ModuleLoader__.load({
             };
             result.push(current);
           }
-          var text = extractReplyText(node);
-          current.msgs.push({ key: key, text: text });
-          var parsed = parseHeadings(text);
-          var hIdx = 0;
-          for (var k = 0; k < parsed.length; k++) {
-            current.headings.push({ level: parsed[k].level, title: parsed[k].title, key: key, idx: hIdx });
-            hIdx++;
+          seen[key] = true;
+          var info = nodeInfo(key, node);
+          current.msgs.push({ key: key, text: info.text });
+          for (var k = 0; k < info.headings.length; k++) {
+            current.headings.push({ level: info.headings[k].level, title: info.headings[k].title, key: key, idx: k });
           }
         }
+        pruneNodeInfo(seen);
         // keep a turn when it has headings OR a time — turns without headings
         // still get a standalone time entry in the outline (click to jump)
         return result.filter(function (g) { return g.headings.length > 0 || g.time !== ""; });
       }, [order, nodes]);
+      // first time content appears, scroll the list to the bottom (newest).
+      // NOTE: must stay BELOW the `groups` memo — a deps array is evaluated
+      // during render, so reading `groups` before that `var` is assigned would
+      // freeze the deps at 0 and the effect would only ever run on mount.
+      react.useEffect(function () {
+        if (didInitScroll.current || !listRef.current || groups.length === 0) return;
+        didInitScroll.current = true;
+        listRef.current.scrollTop = listRef.current.scrollHeight;
+      }, [groups.length]);
       var groupTrees = react.useMemo(function () {
-        return groups.map(function (g) { return buildTree(g.headings); });
-      }, [groups]);
+        return groups.map(function (g) {
+          if (levels.length === 6) return buildTree(g.headings);
+          var kept = [];
+          for (var i = 0; i < g.headings.length; i++) {
+            if (levelSet[g.headings[i].level]) kept.push(g.headings[i]);
+          }
+          return buildTree(kept);
+        });
+      }, [groups, levels, levelSet]);
       // pagination slice: the latest `visibleCount` groups
       var shownGroups = groups.slice(Math.max(0, groups.length - visibleCount));
       var shownTrees = groupTrees.slice(groupTrees.length - shownGroups.length);
@@ -828,6 +1019,79 @@ window.__ModuleLoader__.load({
         }
         return m;
       }, [groups]);
+
+      // ancestor path of every heading occurrence (used by the search result rows):
+      // id -> { path, title, level, gi }
+      var headingPaths = react.useMemo(function () {
+        var byId = {};
+        var lastTitle = {};
+        for (var gi = 0; gi < groups.length; gi++) {
+          var g = groups[gi];
+          for (var j = 0; j < g.headings.length; j++) {
+            var h = g.headings[j];
+            for (var deeper = h.level + 1; deeper <= 6; deeper++) lastTitle[deeper] = undefined;
+            var parts = [];
+            for (var up = 1; up < h.level; up++) {
+              if (lastTitle[up]) parts.push(lastTitle[up]);
+            }
+            parts.push(h.title);
+            byId[headingId(h)] = { path: parts.join(" › "), title: h.title, level: h.level, gi: gi };
+            lastTitle[h.level] = h.title;
+          }
+        }
+        return byId;
+      }, [groups]);
+
+      // search result rows: one row per matched heading/message (with an
+      // occurrence count), carrying its heading path, turn time and a snippet.
+      var resultRows = react.useMemo(function () {
+        var q = query.trim().toLowerCase();
+        if (!q) return [];
+        var rows = [];
+        var index = {};
+        var push = function (row, n) {
+          var id = row.key + "#" + (row.idx === undefined ? "-" : row.idx);
+          var known = index[id];
+          if (known !== undefined) { known.count += n; return; }
+          row.count = n;
+          index[id] = row;
+          rows.push(row);
+        };
+        for (var gi = 0; gi < groups.length; gi++) {
+          var g = groups[gi];
+          for (var j = 0; j < g.headings.length; j++) {
+            var h = g.headings[j];
+            var nh = countOccurrences(h.title, q);
+            if (nh > 0) {
+              var hp = headingPaths[headingId(h)];
+              push({
+                gi: gi, key: h.key, idx: h.idx, title: h.title, level: h.level,
+                path: hp ? hp.path : "", time: g.time, snippet: ""
+              }, nh);
+            }
+          }
+          if (searchScope === "full") {
+            var nu = g.userKey && g.userFull ? countOccurrences(g.userFull, q) : 0;
+            if (nu > 0) {
+              push({
+                gi: gi, key: g.userKey, idx: undefined, title: previewText(g.userFull, 40),
+                level: 0, path: "", time: g.time, snippet: snippetAround(g.userFull, q, 36)
+              }, nu);
+            }
+            for (var m = 0; m < g.msgs.length; m++) {
+              var msg = g.msgs[m];
+              if (!msg.text) continue;
+              var nm = countOccurrences(msg.text, q);
+              if (nm === 0) continue;
+              push({
+                gi: gi, key: msg.key, idx: undefined, title: previewText(msg.text, 40),
+                level: 0, path: "", time: g.time, snippet: snippetAround(msg.text, q, 36)
+              }, nm);
+            }
+          }
+        }
+        return rows;
+      }, [groups, query, searchScope, headingPaths]);
       react.useEffect(function () {
         var sp = document.querySelector("[data-conversation-scroll]");
         if (!sp) return;
@@ -918,6 +1182,46 @@ window.__ModuleLoader__.load({
         return out;
       }, [groups, query, searchScope]);
 
+      // which result row holds the current (n/N) occurrence (needs `matches`)
+      var activeResultRow = -1;
+      if (resultRows.length > 0 && matches.length > 0) {
+        var acc = 0;
+        var target = matchIdx % matches.length;
+        for (var ri = 0; ri < resultRows.length; ri++) {
+          acc += resultRows[ri].count;
+          if (target < acc) { activeResultRow = ri; break; }
+        }
+      }
+
+      // 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
+      // also made the current one, so the highlighted row is the one on screen
+      // (otherwise n/N points at a row that is off-view).
+      var searchPosRef = react.useRef("");
+      react.useEffect(function () {
+        var q = query.trim();
+        if (searchPosRef.current === q) return;
+        searchPosRef.current = q;
+        if (!q) return;
+        var el = listRef.current;
+        if (el) el.scrollTop = el.scrollHeight;
+        if (matches.length > 0) setMatchIdx(matches.length - 1);
+      }, [query, matches.length]);
+
+      // keep the current row in view while stepping with Enter
+      react.useEffect(function () {
+        if (!query.trim() || activeResultRow < 0) return;
+        var el = listRef.current;
+        if (!el || !el.querySelector) return;
+        var node = el.querySelector('[data-result-idx="' + activeResultRow + '"]');
+        if (!node) return;
+        var er = node.getBoundingClientRect();
+        var lr2 = el.getBoundingClientRect();
+        if (er.top < lr2.top + 2) el.scrollTop += er.top - lr2.top - 2;
+        else if (er.bottom > lr2.bottom - 2) el.scrollTop += er.bottom - lr2.bottom + 2;
+      }, [activeResultRow, query]);
+
       // ---- nothing to show without headings ----
       if (groups.length === 0) return null;
 
@@ -949,15 +1253,19 @@ window.__ModuleLoader__.load({
         if (e.button !== 0) return;
         var startY = e.clientY;
         var origY = panelY;
+        var lastY = panelY;
         var move = function (ev) {
           var next = origY + (ev.clientY - startY);
           next = Math.max(-(viewport ? viewport.top : 0), Math.min(window.innerHeight - 90, next));
+          lastY = next;
           setPanelY(next);
         };
         var up = function () {
           window.removeEventListener("pointermove", move);
           window.removeEventListener("pointerup", up);
-          try { localStorage.setItem(PANEL_Y_KEY, String(panelY)); } catch (e2) {}
+          // persist the DRAGGED value: `panelY` here is the value captured when
+          // the drag started (the state setter has not re-rendered this closure)
+          try { localStorage.setItem(PANEL_Y_KEY, String(lastY)); } catch (e2) {}
         };
         window.addEventListener("pointermove", move);
         window.addEventListener("pointerup", up);
@@ -1033,6 +1341,15 @@ window.__ModuleLoader__.load({
         }, 150);
       };
 
+      // clicking result row `i` = make its FIRST occurrence the current match, so
+      // it highlights + scrolls exactly like Enter stepping does (rows are deduped
+      // one-per-message, so row i starts at the sum of the previous rows' counts)
+      var goToRow = function (i) {
+        var start = 0;
+        for (var k = 0; k < i && k < resultRows.length; k++) start += resultRows[k].count;
+        goToMatch(start);
+      };
+
       // ---- circular icon button (glyph optical offset: ox/oy px) ----
       var iconBtn = function (onClick, tip, glyph, fontSize, offset) {
         var ox = offset ? (offset.x || 0) : 0;
@@ -1201,6 +1518,55 @@ window.__ModuleLoader__.load({
                   react_jsx_runtime.jsx("div", {
                     style: { display: "flex", alignItems: "center", gap: 6, flex: "none" },
                     children: [
+                      // heading-level filter: a round icon button (directly left
+                      // of the search 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: "标题层级筛选",
+                        style: {
+                          width: 24,
+                          height: 24,
+                          padding: 0,
+                          border: "none",
+                          borderRadius: "50%",
+                          cornerShape: "round",
+                          cursor: "pointer",
+                          flex: "none",
+                          display: "flex",
+                          alignItems: "center",
+                          justifyContent: "center",
+                          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"
+                        },
+                        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",
+                          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 })
+                          ]
+                        })
+                      }),
                       // magnifier button (SVG, matches the other buttons' style)
                       react_jsx_runtime.jsx("button", {
                         onClick: function () { searchOpen ? closeSearch() : openSearch(); },
@@ -1450,7 +1816,11 @@ window.__ModuleLoader__.load({
             className: "dqt-list",
             style: {
               overflowY: "auto",
-              padding: "6px 8px",
+              // 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"
@@ -1459,7 +1829,9 @@ window.__ModuleLoader__.load({
             onWheel: onListWheel,
             children: react_jsx_runtime.jsx("div", {
               style: { direction: "ltr" },
-              children: renderGroups(shownGroups, shownTrees, jump, C, Math.max(0, groups.length - visibleCount), activeGroup)
+              children: query.trim()
+                ? renderResults(resultRows, query.trim().toLowerCase(), C, goToRow, activeResultRow)
+                : renderGroups(shownGroups, shownTrees, jump, C, Math.max(0, groups.length - visibleCount), activeGroup)
             })
           }),
           // resize handles (right edge: width, bottom edge: height)
@@ -1505,7 +1877,58 @@ window.__ModuleLoader__.load({
             },
             onPointerDown: onResizeCornerDown,
             title: "拖拽同时调整宽高"
-          })
+          }),
+          // heading-level picker: pops down from the round header button,
+          // right-aligned, with an outer shadow so it reads as a floating layer.
+          // 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,
+              right: 8,
+              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% - 16px)",
+              transformOrigin: "calc(50% + 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 ? "隐藏 H" + lv : "显示 H" + lv,
+                style: {
+                  height: 22,
+                  padding: "0 7px",
+                  border: "none",
+                  borderRadius: 6,
+                  cornerShape: "round",
+                  cursor: "pointer",
+                  fontSize: 11,
+                  lineHeight: "22px",
+                  fontFamily: "inherit",
+                  background: active
+                    ? "rgba(79,140,255,0.18)"
+                    : "var(--dsw-alias-interactive-bg-hover, rgba(128,128,128,0.14))",
+                  color: active ? "var(--dsw-alias-brand-primary, #4f8cff)" : C.muted,
+                  fontWeight: active ? 600 : 400
+                },
+                children: "H" + lv
+              }, "lv" + lv);
+            })
+          }) : null
         ]
       });
 
@@ -1571,6 +1994,12 @@ window.__ModuleLoader__.load({
     }
 
     function renderItem(n, depth, jump, C, uid) {
+      var hasChildren = !!(n.children && n.children.length);
+      var parts = [];
+      parts.push(react_jsx_runtime.jsx("span", {
+        style: { minWidth: 0, overflow: "hidden", textOverflow: "ellipsis" },
+        children: n.title
+      }, uid + "-l"));
       return react_jsx_runtime.jsx(
         "div",
         {
@@ -1578,8 +2007,11 @@ window.__ModuleLoader__.load({
           "data-jump-key": n.key,
           "data-jump-idx": n.idx !== undefined ? String(n.idx) : "0",
           style: {
+            display: "flex",
+            alignItems: "center",
+            gap: 2,
             padding: "2px 6px",
-            paddingLeft: 8 + (n.level - 1) * 12,
+            paddingLeft: (hasChildren ? 2 : 6) + (n.level - 1) * 12,
             margin: "1px 0",
             borderRadius: 6,
             cursor: "pointer",
@@ -1589,13 +2021,12 @@ window.__ModuleLoader__.load({
             lineHeight: "18px",
             height: 22,
             whiteSpace: "nowrap",
-            overflow: "hidden",
-            textOverflow: "ellipsis"
+            overflow: "hidden"
           },
           onMouseEnter: function (e) { e.currentTarget.style.background = C.hover; },
           onMouseLeave: function (e) { e.currentTarget.style.background = "transparent"; },
           title: n.title,
-          children: n.title
+          children: parts
         },
         uid + "-" + n.level + "-" + (n.key || "")
       );
@@ -1613,23 +2044,130 @@ window.__ModuleLoader__.load({
       return out;
     }
 
-    // a group's header: clicking the time jumps to that turn's start.
+    // ---- search results view ----
+    // While a query is present the list shows every matched heading/message
+    // (grouped per message, with an occurrence count) instead of the outline, so
+    // search is "see them all, then jump" rather than stepping blindly.
+    function hitSpans(text, q) {
+      var parts = highlightParts(text, q);
+      return parts.map(function (p, i) {
+        return p.hit
+          ? react_jsx_runtime.jsx("span", {
+            style: { background: "rgba(255,196,0,0.32)", borderRadius: 2, color: "inherit" },
+            children: p.text
+          }, "hp" + i)
+          : p.text;
+      });
+    }
+
+    function renderResultRow(r, i, q, C, onRow, isActive) {
+      var meta = [];
+      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)
+        }, "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)
+        }, "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
+        // keyword in the conversation and scrolls there, exactly like Enter
+        // stepping — a row that only scrolled (no highlight) was the old bug
+        onClick: function () { onRow(i); },
+        "data-result-idx": i,
+        onMouseEnter: function (e) { e.currentTarget.style.background = C.hover; },
+        onMouseLeave: function (e) { e.currentTarget.style.background = isActive ? "rgba(79,140,255,0.16)" : "transparent"; },
+        title: r.path || r.title,
+        style: {
+          padding: "4px 6px",
+          margin: "1px 0",
+          borderRadius: 6,
+          cursor: "pointer",
+          minWidth: 0,
+          background: isActive ? "rgba(79,140,255,0.16)" : "transparent",
+          transition: "background 0.15s ease"
+        },
+        children: children
+      }, "res-" + i);
+    }
+
+    function renderResults(rows, q, C, onRow, activeRow) {
+      if (!rows || rows.length === 0) {
+        return react_jsx_runtime.jsx("div", {
+          style: { padding: "12px 8px", fontSize: 12, color: C.muted, textAlign: "center" },
+          children: "没有匹配"
+        });
+      }
+      var out = [];
+      for (var i = 0; i < rows.length; i++) {
+        out.push(renderResultRow(rows[i], i, q, C, onRow, i === activeRow));
+      }
+      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) {
+      var replyKey = (g.msgs && g.msgs.length > 0) ? g.msgs[0].key : "";
+      var targetKey = replyKey || g.userKey;
       var jumpToTurn = function (e) {
         e.stopPropagation();
-        if (!g.userKey) return;
-        var r0 = findRowStrict(g.userKey);
-        if (r0) jump(g.userKey);
-        else if (g.headings.length > 0) jump(g.headings[0].key, g.headings[0].idx);
+        // prefer the model's reply; fall back to the user message, then to the
+        // turn's first heading, so the row always does something useful
+        if (replyKey && findRow(replyKey)) { jump(replyKey); return; }
+        if (g.userKey && findRow(g.userKey)) { jump(g.userKey); return; }
+        if (g.headings.length > 0) jump(g.headings[0].key, g.headings[0].idx);
       };
       return react_jsx_runtime.jsx("div", {
-        style: { padding: "1px 4px 2px", height: 18, display: "flex", alignItems: "center", minWidth: 0 },
+        style: {
+          padding: "1px 4px 2px",
+          height: 18,
+          display: "flex",
+          alignItems: "center",
+          minWidth: 0,
+          // sticky: while you scroll the outline, the header of the group you are
+          // inside stays pinned at the top (background must be opaque to cover
+          // the rows scrolling underneath).
+          position: "sticky",
+          top: 0,
+          zIndex: 2,
+          background: C.panelBg
+        },
         children: react_jsx_runtime.jsx("span", {
           onClick: jumpToTurn,
-          title: g.userKey ? "跳转到该回合开头" : "",
+          title: replyKey ? "跳转到该回合的模型回答开头" : "跳转到该回合开头",
           onMouseEnter: function (e) { e.currentTarget.style.background = C.hover; },
           onMouseLeave: function (e) { e.currentTarget.style.background = "transparent"; },
           style: {
@@ -1725,6 +2263,12 @@ window.__ModuleLoader__.load({
       var s = document.createElement("style");
       s.id = "dsh-quick-toc-css";
       s.textContent = "@keyframes dqt-spin{to{transform:rotate(360deg)}}@keyframes dqt-fade-in{from{opacity:0}to{opacity:1}}@keyframes dqt-fade-out{from{opacity:1}to{opacity:0}}" +
+        "@keyframes dqt-pop-in{from{opacity:0;transform:scale(0.7)}to{opacity:1;transform:scale(1)}}@keyframes dqt-pop-out{from{opacity:1;transform:scale(1)}to{opacity:0;transform:scale(0.7)}}" +
+        // the level picker's enter/exit animations live here as classes so React
+        // re-renders (which rewrite inline styles) cannot restart or cancel them
+        ".dqt-levels-pop{animation:dqt-pop-in 0.22s cubic-bezier(0.22, 0.9, 0.3, 1) both;will-change:transform,opacity}" +
+        // 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) —
         // custom webkit scrollbar styling was not reliably suppressing the
         // default arrows, so a hidden native bar + the panel's inner shadow gives

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-quick-toc",
-  "version": "0.3.3",
-  "description": "Conversation TOC for DeepSeek Harness (DSH): turn-grouped Markdown heading outline with keyword search (title/full-text scope), in-chat match highlighting, auto-follow and smooth jump navigation",
+  "version": "0.4.1",
+  "description": "Conversation TOC for DeepSeek Harness (DSH): turn-grouped Markdown heading outline with keyword search (title/full-text scope), in-chat match highlighting, per-level heading filtering, auto-follow and smooth jump navigation",
   "type": "module",
   "main": "lib/index.js",
   "files": [
@@ -35,7 +35,8 @@
     },
     "compatibility": {
       "dshReleases": {
-        "0.1.5-rc.1": "compatible"
+        "0.1.5-rc.1": "compatible",
+        "0.1.5-rc.2": "compatible"
       }
     }
   },