dsh-quick-toc 0.5.0 → 0.5.1

package/CHANGELOG.en.md

@@ -2,6 +2,24 @@
 
 All notable changes to **dsh-quick-toc** are documented here. Chinese version: [CHANGELOG.md](CHANGELOG.md).
 
+## [0.5.1] - 2026-09-13
+
+### Added
+- **"Back to the newest row" button**: a round button in the outline list's lower-right corner. It fades in whenever the list is not at its bottom and fades out once it is; clicking scrolls the outline back to the newest entry (smooth for a short distance, instant when the list is far up).
+- **Turn stamps carry the day**: the time shown in group headers, search result rows and hover cards is no longer a bare `HH:MM` — yesterday reads `昨天 15:04`, the day before `前天 15:04`, anything older `25-09-11 15:04` (two-digit year; decided by calendar day, not a 24-hour difference).
+- **Failures are reported**: a turn that produced no reply at all (request timeout, upstream error) now shows a `请求失败` row under its group header with the host's own error text; clicking it jumps to that error in the conversation, and the error text is searchable in full-text scope (its result row is tagged 请求失败).
+
+### Changed
+- **The header now holds two buttons per side**: the heading-level filter and the dock toggle on the left, search and collapse on the right, with a spacer pinning the pairs to the two ends; the three-bar identity mark on the left is gone.
+- **The level filter popup is left-aligned with its button** (it used to be right-aligned).
+- **The mount diagnostic is silent by default**: the console no longer prints `[dsh-quick-toc] panel mounted …`. To diagnose, run `localStorage.setItem("dsh-quick-toc.debug", "1")` and reload — the line then reports `turnOutline` and the jump loader's stage-by-stage state, while normal use stays quiet.
+- **Long jumps land instantly**: a jump across a long history no longer "stops halfway" (short jumps still glide smoothly); after landing it re-checks for ~0.6s, which corrects a target that moved while content was mounting.
+
+### Fixed
+- **Failed or aborted turns were mislabelled 未加载**: those turns have no model reply, so they carried neither a time nor headings and were re-listed as unloaded turns. A loaded user message now counts as "this turn is loaded", failures additionally show their error row, and a user-aborted turn simply shows as a heading-less turn.
+- **Scrolling the outline up to load older messages bounced the transcript back to the newest turn**, so paging up never got anywhere: the host force-scrolls to the bottom whenever a scroll is not attributed to the reader while it still believes the reader sits at the bottom, and a page-in triggered from the outline matches exactly that condition. The plugin now lifts the transcript just off the bottom stick zone before clicking the host's "load earlier", so the page-in keeps its place.
+- **A heading-less turn's group header was formatted unlike every other header**: it used to be enlarged (12px / 600 / primary colour), which made it read as a different kind of entry. All group headers now share one style (11px, secondary colour, one row box); a heading-less turn is simply a group with no rows under its header.
+
 ## [0.5.0] - 2026-09-12
 
 ### Added

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 **dsh-quick-toc** 的重要变更都记录在这里。英文版见 [CHANGELOG.en.md](CHANGELOG.en.md)。
 
+## [0.5.1] - 2026-09-13
+
+### 新增
+- **「回到底部」浮动按钮**：大纲列表右下角的圆形按钮。列表不在底部时渐显，滚到底后渐隐；点击把大纲滚回最新一条（近距离平滑滚动，长距离即时到位）。
+- **回合时间带日期**：组头、搜索结果行与悬停卡片里的时间不再只有 `HH:MM`——昨天显示 `昨天 15:04`，前天显示 `前天 15:04`，更早显示 `25-09-11 15:04`（年份取后两位；按自然日判定，不是按 24 小时差）。
+- **失败回合的报错**：请求超时、上游报错这类没有产出任何回复的回合，现在在组头下方显示一行 `请求失败` 与宿主提供的报错原文；点击跳到对话中该报错的位置，报错原文同样能被全文搜索命中（结果行带「请求失败」标记）。
+
+### 变更
+- **标题栏改为一边两个按钮**：左侧「层级筛选 + 停靠切换」，右侧「搜索 + 收起」，中间留白把两组顶到两端；并去掉左侧的三条杠装饰标识。
+- **层级筛选弹层改为左对齐按钮**（此前在按钮右侧对齐）。
+- **挂载诊断日志默认静默**：控制台不再打印 `[dsh-quick-toc] panel mounted …`。需要排查时先执行 `localStorage.setItem("dsh-quick-toc.debug", "1")` 再刷新即可看到该行（`turnOutline` 与跳转加载器的分阶段状态），正常使用不再有噪音。
+- **长距离跳转改为即时定位**：跨越很长历史的跳转不再"滚到一半停下"（近距离仍是平滑滚动），落地后还有约 0.6 秒的校验，用于纠正内容高度在飞行途中变化的情况。
+
+### 修复
+- **失败或中止的回合被误标成「未加载」**：这类回合没有模型回复，既没有时间也没有标题，被当成尚未加载的回合重新列了一遍。现在"该回合的用户消息已加载"本身就是已加载的依据，失败回合另加报错行；被用户中止的回合按普通无标题回合显示。
+- **从大纲往上翻加载更早消息时，对话区会被弹回最新一条**，越翻越回到底部：宿主在"这次滚动不是读者发起、且它仍认为读者停在底部"时会强制滚回底部，而从大纲触发的翻页恰好命中该条件。现在点击宿主的「加载更早」之前会先把对话区抬离贴底区，翻页保持原位。
+- **无标题回合的组头与其它组头格式不一致**：它此前被整体放大（12px / 600 / 正文色），与常规组头并列时像另一种条目。现在所有组头共用同一套样式（11px、次要色、同一行盒），无标题回合只是"组头下面没有行"。
+
 ## [0.5.0] - 2026-09-12
 
 ### 新增

package/README.en.md

@@ -8,6 +8,8 @@ A conversation TOC plugin for [DeepSeek Harness](https://github.com/deepseek-ai/
 
 - **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
 - **Whole-session coverage** — turns the conversation window has not loaded are listed too (tagged 未加载, with previews); clicking one loads that turn and jumps to it
+- **Failures are reported** — a turn with no reply at all (request timeout, upstream error) shows `请求失败` plus the host's error text, and clicking it jumps to that error in the conversation
+- **Turn stamps carry the day** — yesterday reads `昨天 15:04`, the day before `前天 15:04`, anything older `25-09-11 15:04`, so times never blur together in a session spanning days
 - **Row subtitles** — under each heading, the first sentence of that section, so identically-titled headings can be told apart
 - **Hover previews** — hovering a heading row shows the section's opening, the turn time and the heading path
 - **Search** — title / full-text scopes; click any result row to locate and highlight that hit, `n/N` Enter stepping, Esc to close
@@ -17,6 +19,7 @@ A conversation TOC plugin for [DeepSeek Harness](https://github.com/deepseek-ai/
 - **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 a closed blue box while you scroll the conversation; the outline follows on its own
 - **Jumping** — click a heading to jump to its position in the conversation
+- **Back to the newest row** — after paging far up, a floating button in the list's lower-right corner returns to the newest entry in one click (it appears when the list is not at its bottom and disappears once it is)
 - **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; scrolling up both expands the index and loads older conversation
 - **Edge hints** — a brief hint at the bottom of the panel when you keep scrolling past the first or the last entry
@@ -28,13 +31,14 @@ A conversation TOC plugin for [DeepSeek Harness](https://github.com/deepseek-ai/
 
 | Plugin | Supported DSH |
 | --- | --- |
-| **0.5.0** (latest) | 0.1.5-rc.1, 0.1.5-rc.2 |
+| **0.5.1** (latest) | 0.1.5-rc.1, 0.1.5-rc.2 |
+| 0.5.0 | 0.1.5-rc.1, 0.1.5-rc.2 |
 | 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 |
 
-`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. 0.5.0 was tested on **0.1.5-rc.2**, and the host interfaces it newly relies on (the `turnOutline` projection, the session-scoped `useProjection`, the client `sessions` service and its `loadThrough` jump loader) were checked one by one against the installed **0.1.5-rc.1** bundles, so both are declared. 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`.
+`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. 0.5.1 was tested on **0.1.5-rc.2**, and the host interfaces it relies on — the `turnOutline` projection, the session-scoped `useProjection`, the client `sessions` service and its `loadThrough` jump loader (since 0.5.0), and the `turn-error` node used for failed turns (since 0.5.1) — were checked one by one against the installed **0.1.5-rc.1** bundles, so both are declared. 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
 
@@ -60,15 +64,26 @@ After installing, restart DSH and open the Web UI. The panel starts collapsed; c
 
 ## Usage
 
-- **Jumping**: click an outline heading or a group header to jump to it; entries tagged 未加载 load that turn first
+- **Jumping**: click an outline heading or a group header to jump to it; entries tagged 未加载 load that turn first, and a failed turn's error row jumps to that error in the conversation
 - **Search**: open the box with the magnifier, click a result to locate and highlight it, Enter to step through matches, Esc to close
 - **Search tolerance**: full-width/half-width, case and whitespace differences match automatically; for looser matching turn on the "fuzzy" switch next to the search box
 - **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 (it both expands the index and loads older conversation)
+- **Back to the newest row**: after paging far up, click the floating button in the list's lower-right corner
 - **Reading position**: scroll the conversation and the turn you are reading is boxed in blue; the outline follows
 
+## Diagnostics
+
+Mounting the panel prints **nothing** by default. To check the host facilities, run this once in the browser console:
+
+```
+localStorage.setItem("dsh-quick-toc.debug", "1")
+```
+
+then reload: the console shows one line, `[dsh-quick-toc] panel mounted · turnOutline=… · jumpLoader=…`. A missing `turnOutline` means the host has no such projection, and the staged `jumpLoader` wording (`no-sessions-service` / `no-binding-api` / `no-binding-for-session` / `no-loadThrough` / `binding-threw`) pinpoints which link of the jump bridge is broken. Turn it off again with `localStorage.removeItem("dsh-quick-toc.debug")`.
+
 ## Development
 
 - `lib/client.js` — all UI logic (browser side)
@@ -76,6 +91,7 @@ After installing, restart DSH and open the Web UI. The panel starts collapsed; c
 - `cordis.patch.yml` — loader patch (official DSH bundle format)
 - The panel registers into the session-scoped `conversation.input.overlay` slot so it receives session-scoped hooks (`useChat`, `useSession`, `sessionId`, …), and renders itself through `createPortal` into `document.body` as a fixed floating dock; conversation data comes from `props.useChat` (`ChatSnapshot.order` and `nodes`; node shape: `kind: user/assistant-step`, `location.turn`, `data.blocks`)
 - The "unloaded turn" capability needs two host facilities: the `turnOutline` projection (the whole-session turn index, each entry carrying its `turn/start` seq) and the turn-jump loader (the client `sessions` service's `binding(sessionId).session.loadThrough(seq)`, reached through the client ctx's declaration-free `ctx.get("sessions")` lookup). Each degrades on its own: without the projection the outline lists loaded turns only, without the loader unloaded entries are shown but not jumped to, and nothing else in the panel is affected.
+- The failure row reads the host's `turn-error` conversation node (published when `turn/end` carries an `error` reason, with `message` and an optional `code`); on a host without that node the row is simply absent and nothing else changes.
 - Changes to `lib/client.js` show up after a page refresh (client modules are served under a content hash and DSH's client HMR pushes reloads); restart DSH only if that does not take
 
 ## License

package/README.md

@@ -8,6 +8,8 @@
 
 - **按回合分组** —— 每条用户消息 + 其后续 AI 回复为一组，组头显示回合时间与首行预览，点击跳到该回合模型回答的开头
 - **覆盖整段会话** —— 未加载进对话窗口的回合也在列表里（带「未加载」标记与预览）；点击即加载该回合并跳过去
+- **失败回合的报错** —— 请求超时 / 上游报错这类没有回复的回合显示 `请求失败` 与报错原文，点击跳到对话中的报错位置
+- **回合时间带日期** —— 昨天 `昨天 15:04`、前天 `前天 15:04`、更早 `25-09-11 15:04`，跨天的会话里时间不再重影
 - **标题行副标题** —— 每行标题下方显示该节正文的第一句，同名标题一眼可辨
 - **悬停预览** —— 悬停标题行显示该节开头、回合时间与层级路径
 - **搜索** —— 标题 / 全文两种范围，结果列表点击定位并高亮，`n/N` 回车逐处跳，Esc 关闭
@@ -17,6 +19,7 @@
 - **层级筛选** —— 标题栏的圆形层级按钮弹出 H1–H6 开关，任意组合显示
 - **自动跟随** —— 滚动对话时正在阅读的回合自动点亮（封闭蓝框），大纲自动跟随
 - **跳转** —— 点击标题跳到对话中该标题的位置；面板与对话双向定位
+- **回到底部** —— 往上翻远之后，列表右下角的浮动按钮一步回到最新一条（不在底部时出现、到底后消失）
 - **可停靠、可缩放** —— 拖顶部横条移动，◀ / ▶ 切换左右停靠，拖边缘调宽高，收起后成为边缘把手；位置与尺寸会被记住
 - **分页** —— 默认显示最近的若干组，向上滚动既展开索引也加载更早的对话
 - **边界提示** —— 滚到最早或最新再继续滚动时，面板底部短暂提示
@@ -28,13 +31,14 @@
 
 | 插件版本 | 支持的 DSH 版本 |
 | --- | --- |
-| **0.5.0**（最新） | 0.1.5-rc.1、0.1.5-rc.2 |
+| **0.5.1**（最新） | 0.1.5-rc.1、0.1.5-rc.2 |
+| 0.5.0 | 0.1.5-rc.1、0.1.5-rc.2 |
 | 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 |
 
-`engines.dsh` 下限为 **0.1.5-rc.1**（`>=`，该版本起插件改用会话级槽位注入的宿主接口）。0.5.0 在 **0.1.5-rc.2** 上实测通过；它新依赖的宿主接口（`turnOutline` 投影、会话级槽位的 `useProjection`、客户端 `sessions` 服务与 `loadThrough` 跳转加载器）已在 **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.5.1 在 **0.1.5-rc.2** 上实测通过；它依赖的宿主接口——`turnOutline` 投影、会话级槽位的 `useProjection`、客户端 `sessions` 服务与 `loadThrough` 跳转加载器（0.5.0 起）、以及失败回合所用的 `turn-error` 节点（0.5.1 起）——已在 **0.1.5-rc.1** 的安装包中逐个核对存在，因此两版都声明兼容。更早或更新的 DSH 版本未经验证，不作声明；在更早的 DSH 上可安装的最新插件版本是 **0.3.2**。安装或更新时，DSH 市场会依据 `package.json` 中的 `engines.dsh`、`dsh.compatibility.dshReleases` 与 `peerDependencies` 做宿主兼容预检。
 
 ## 安装
 
@@ -60,15 +64,26 @@ dsh plugin --profile web add <插件目录路径>
 
 ## 使用
 
-- **跳转**：点击大纲标题或组头跳到对应位置；带「未加载」标记的条目会先把该回合加载进来再跳
+- **跳转**：点击大纲标题或组头跳到对应位置；带「未加载」标记的条目会先把该回合加载进来再跳；失败回合点报错行跳到对话中的报错位置
 - **搜索**：放大镜打开搜索框，输入后点结果定位并高亮，回车逐处跳，Esc 关闭
 - **搜索容错**：全角/半角、大小写、空格差异会自动匹配；需要更宽松时点搜索框右侧的「模糊」开关
 - **层级筛选**：点标题栏的圆形层级按钮弹出 H1–H6 开关，选择显示的层级
 - **移动与停靠**：拖顶部横条移动，◀ / ▶ 切换左右停靠
 - **调整大小**：拖右边缘、下边缘或右下角
 - **加载更早**：在大纲中向上滚动（既展开索引，也加载更早的对话）
+- **回到底部**：翻远了之后点列表右下角的浮动按钮回到最新一条
 - **阅读位置**：滚动对话，正在阅读的回合会以蓝框标出；大纲会自动跟随
 
+## 诊断
+
+面板挂载时默认**不打印**任何日志。需要排查宿主能力时，在浏览器控制台执行一次：
+
+```
+localStorage.setItem("dsh-quick-toc.debug", "1")
+```
+
+再刷新页面，控制台会出现一行 `[dsh-quick-toc] panel mounted · turnOutline=… · jumpLoader=…`：`turnOutline` 缺失说明宿主没有该投影，`jumpLoader` 的分阶段措辞（`no-sessions-service` / `no-binding-api` / `no-binding-for-session` / `no-loadThrough` / `binding-threw`）可直接定位跳转桥断在哪一环。用完执行 `localStorage.removeItem("dsh-quick-toc.debug")` 关掉。
+
 ## 开发
 
 - `lib/client.js` —— 全部 UI 逻辑（浏览器端）
@@ -76,6 +91,7 @@ dsh plugin --profile web add <插件目录路径>
 - `cordis.patch.yml` —— loader patch（符合官方 bundle 规范）
 - 面板注册进会话级 `conversation.input.overlay` 槽以取得会话级 hook（`useChat`、`useSession`、`sessionId` 等），面板本体通过 `createPortal` 渲染到 `document.body` 成为固定浮层；对话数据来自 `props.useChat`（`ChatSnapshot.order` 与 `nodes`，节点形状：`kind: user/assistant-step`、`location.turn`、`data.blocks`）
 - 「未加载回合」能力依赖宿主的两样东西：`turnOutline` 投影（整段会话的回合索引，每条含 `turn/start` 的 seq）与会话跳转加载器（客户端 `sessions` 服务的 `binding(sessionId).session.loadThrough(seq)`，通过客户端 ctx 的 `ctx.get("sessions")` 免声明查找取得）。两者各自独立降级：没有投影时只列已加载回合，没有加载器时未加载条目只展示、不跳转，面板其余功能不受影响。
+- 失败回合的报错行读的是宿主的 `turn-error` 会话节点（宿主在 `turn/end` 的原因为 `error` 时发布，含 `message` 与可选的 `code`）；宿主不提供该节点时只是不显示这一行，其余功能不受影响。
 - 修改 `lib/client.js` 后刷新页面即可看到变化（客户端模块按内容哈希发版，DSH 的客户端 HMR 也会推送重载）；若未生效再重启 DSH
 
 ## License

package/lib/client.js

@@ -52,11 +52,16 @@ window.__ModuleLoader__.load({
         "search.hintMore": "向上滚动可加载更早的消息",
         "search.hintOldest": "已经是最早的消息",
         "hint.bottom": "已经到底了",
+        "outline.bottom": "回到底部",
         "turn.jumpReply": "跳转到该回合的模型回答开头",
         "turn.jumpTurn": "跳转到该回合开头",
         "turn.loading": "正在加载这个回合…",
         "turn.unloaded": "未加载",
         "turn.loadTip": "点击加载这个回合并跳转过去",
+        "turn.failed": "请求失败",
+        "turn.jumpFailed": "跳转到该回合的报错位置",
+        "time.yesterday": "昨天",
+        "time.beforeYesterday": "前天",
         "preview.truncated": "预览由宿主提供，可能被截断",
         "resize.w": "拖拽调整宽度",
         "resize.h": "拖拽调整高度",
@@ -592,6 +597,9 @@ window.__ModuleLoader__.load({
       text: "var(--dsw-alias-label-primary, #e8eaee)",
       muted: "var(--dsw-alias-label-secondary, #9aa0ab)",
       accent: "var(--dsw-alias-brand-primary, #4f8cff)",
+      // terminal turn failures (a reply that never arrived) get the host's own
+      // error colour, so the outline speaks the same language as the transcript
+      error: "var(--dsw-alias-state-error-primary, #e5534b)",
       hover: "var(--dsw-alias-interactive-bg-hover, rgba(255, 255, 255, 0.08))",
       // ONE source for every "this control is on / this button is open / this match
       // is current" tint, so the panel cannot drift into five near-identical blues.
@@ -952,6 +960,41 @@ window.__ModuleLoader__.load({
       var lastScrollTopRef = react.useRef(0);
       var lastHostClickRef = react.useRef(0); // throttle for the "load earlier" click
 
+      // ---- "back to the newest row" button ------------------------------------
+      // The list can be scrolled far up into history (that is the whole point of
+      // paging), and the newest turns are then a long scroll away. The button
+      // appears whenever the list is NOT parked at its bottom and disappears once it
+      // is. `atBottomRef` mirrors the state so the scroll handler can tell "changed"
+      // from "same value" without depending on a stale render closure.
+      var _sAtBottom = react.useState(true);
+      var atBottom = _sAtBottom[0];
+      var setAtBottom = _sAtBottom[1];
+      var atBottomRef = react.useRef(true);
+      // a few px of slack: scrollTop is fractional and sub-pixel remainders are
+      // normal at the end of a smooth scroll
+      var syncAtBottom = function (el) {
+        if (!el) return;
+        var max = el.scrollHeight - el.clientHeight;
+        var next = max <= 4 || el.scrollTop >= max - 4;
+        if (next !== atBottomRef.current) {
+          atBottomRef.current = next;
+          setAtBottom(next);
+        }
+      };
+      var scrollToBottom = function (e) {
+        if (e && e.stopPropagation) e.stopPropagation();
+        outlineTouchRef.current = Date.now();
+        hoverEnd();
+        var el = listRef.current;
+        if (!el) return;
+        // optimistic: the list is on its way to the newest row, so the button starts
+        // fading at once; if the user interrupts the scroll the handler brings it back
+        atBottomRef.current = true;
+        setAtBottom(true);
+        if (typeof el.scrollTo === "function") el.scrollTo({ top: el.scrollHeight, behavior: "smooth" });
+        else el.scrollTop = el.scrollHeight;
+      };
+
       // ---- "scroll up to load earlier messages" hint (search mode) -----------
       // Armed by a search when older history is still reachable; dismissed the
       // moment the reader scrolls up (which is when the older page starts loading,
@@ -1163,9 +1206,26 @@ window.__ModuleLoader__.load({
           }
           return false;
         };
+        var liftOffBottom = function () {
+          // DSH re-pins the transcript to the newest message whenever it sees a
+          // scroll it does not attribute to the reader while it still believes the
+          // reader is at the bottom (`toBottom`). Paging history in from the OUTLINE
+          // is exactly that case: the prepend compensation DSH applies is a
+          // programmatic scroll, `atBottomRef` was never cleared (the reader never
+          // touched the transcript), so the page-in is immediately undone and the
+          // whole view — and with it the outline's follow — snaps back to the newest
+          // turn. Nudging the transcript just past DSH's 25px stick zone first makes
+          // that scroll read as a reader movement, so the page-in keeps its place.
+          // (Same trick `glideTo` uses so a jump is not yanked back.)
+          var sp = document.querySelector("[data-conversation-scroll]");
+          if (!sp) return;
+          var floor = Math.max(0, sp.scrollHeight - sp.clientHeight);
+          if (floor - sp.scrollTop <= 25) sp.scrollTop = Math.max(0, floor - 26);
+        };
         var viaHost = function () {
           var btn = findLoadOlderButton();
           if (!btn || btn.disabled) return false;
+          liftOffBottom();
           btn.click();
           // once the conversation loads more, expand the outline window too
           setTimeout(function () {
@@ -1240,6 +1300,7 @@ window.__ModuleLoader__.load({
       var onListScroll = function (e) {
         outlineTouchRef.current = Date.now();
         var el = e.currentTarget;
+        syncAtBottom(el);
         var upward = el.scrollTop < lastScrollTopRef.current - 2;
         if (upward) {
           if (hint === "more") setHint("");
@@ -1332,24 +1393,39 @@ window.__ModuleLoader__.load({
         window.addEventListener("pointerup", up);
       };
 
-      // ---- node timestamp -> HH:MM (handles ms / s epochs / ISO strings) ----
-      var fmtTime = function (t) {
-        if (t === undefined || t === null) return "";
+      // ---- node timestamp -> Date (handles ms / s epochs / ISO strings) ----
+      var toDate = function (t) {
+        if (t === undefined || t === null) return null;
         if (typeof t === "string") {
           var d0 = new Date(t);
-          if (isNaN(d0.getTime())) return "";
-          var hh0 = ("0" + d0.getHours()).slice(-2);
-          var mm0 = ("0" + d0.getMinutes()).slice(-2);
-          return hh0 + ":" + mm0;
+          return isNaN(d0.getTime()) ? null : d0;
         }
         var n = Number(t);
-        if (!isFinite(n) || n <= 0) return "";
+        if (!isFinite(n) || n <= 0) return null;
         if (n < 1e12) n = n * 1000; // epoch seconds -> ms
         var d = new Date(n);
-        if (isNaN(d.getTime())) return "";
-        var hh = ("0" + d.getHours()).slice(-2);
-        var mm = ("0" + d.getMinutes()).slice(-2);
-        return hh + ":" + mm;
+        return isNaN(d.getTime()) ? null : d;
+      };
+      var pad2 = function (n) { return ("0" + n).slice(-2); };
+      // ---- node timestamp -> HH:MM ----
+      var fmtTime = function (t) {
+        var d = toDate(t);
+        return d ? pad2(d.getHours()) + ":" + pad2(d.getMinutes()) : "";
+      };
+
+      // ---- turn stamp: the clock alone is ambiguous in a session that spans days,
+      // so today stays "HH:MM", yesterday and the day before get a word, and anything
+      // older gets its date as YY-MM-DD (weekday-free, sortable, short).
+      var startOfDay = function (d) { return new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime(); };
+      var fmtStamp = function (t) {
+        var d = toDate(t);
+        if (!d) return "";
+        var clock = pad2(d.getHours()) + ":" + pad2(d.getMinutes());
+        var days = Math.round((startOfDay(new Date()) - startOfDay(d)) / 86400000);
+        if (days <= 0) return clock; // today (a future skew also reads as today)
+        if (days === 1) return T("time.yesterday") + " " + clock;
+        if (days === 2) return T("time.beforeYesterday") + " " + clock;
+        return pad2(d.getFullYear() % 100) + "-" + pad2(d.getMonth() + 1) + "-" + pad2(d.getDate()) + " " + clock;
       };
 
       // ---- best-effort node time across common field names ----
@@ -1357,7 +1433,7 @@ window.__ModuleLoader__.load({
         var d = node && node.data;
         if (!d) return "";
         var t = d.time !== undefined ? d.time : (d.createdAt !== undefined ? d.createdAt : d.timestamp);
-        return fmtTime(t);
+        return fmtStamp(t);
       };
 
       // ---- group headings by conversation turn (node.location.turn) ----
@@ -1370,12 +1446,18 @@ window.__ModuleLoader__.load({
         var turnUserFull = {};
         if (!order || !nodes) return result;
         var seen = {};
+        // A turn's group is anchored by EVERY node that belongs to it — the user
+        // message, its assistant steps, and the terminal `turn-error` the host
+        // publishes when a request never produced a reply. Without the error node a
+        // timed-out turn had no time and no headings, so it was dropped here and the
+        // host outline re-listed it as "未加载" even though it was fully loaded.
+        var anchorKind = function (kind) { return kind === "user" || kind === "assistant-step" || kind === "turn-error"; };
         // 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++) {
           var k0 = order[i];
           var n0 = nodes.get(k0);
-          if (!n0 || (n0.kind !== "user" && n0.kind !== "assistant-step")) continue;
+          if (!n0 || !anchorKind(n0.kind)) continue;
           var l0 = n0.location;
           var tid0 = l0 && (l0.kind === "turn" || l0.kind === "step") && l0.turn ? l0.turn.turn : null;
           if (tid0 === null) continue;
@@ -1389,11 +1471,12 @@ window.__ModuleLoader__.load({
           var t0 = getNodeTime(n0);
           if (t0) turnTimes[tid0] = t0;
         }
-        // second pass: group assistant headings + full reply texts by turn
+        // second pass: group assistant headings + full reply texts by turn, and
+        // record a turn's terminal failure so the outline can say WHY it is empty
         for (var j = 0; j < order.length; j++) {
           var key = order[j];
           var node = nodes.get(key);
-          if (!node || node.kind !== "assistant-step") continue;
+          if (!node || !anchorKind(node.kind)) continue;
           var loc = node.location;
           var turnId = loc && (loc.kind === "turn" || loc.kind === "step") && loc.turn ? loc.turn.turn : null;
           var sameGroup = current !== null && current.turn === turnId;
@@ -1404,12 +1487,26 @@ window.__ModuleLoader__.load({
               userKey: turnId !== null ? (turnUserKey[turnId] || "") : "",
               userText: turnId !== null ? (turnUserText[turnId] || "") : "",
               userFull: turnId !== null ? (turnUserFull[turnId] || "") : "",
+              failure: null,
               msgs: [],
               headings: []
             };
             result.push(current);
           }
           seen[key] = true;
+          if (node.kind === "turn-error") {
+            // the host's terminal failure row: the turn ended without a reply, so
+            // the outline shows the reason instead of pretending it is unloaded
+            if (current.failure === null) {
+              current.failure = {
+                key: key,
+                message: (node.data && node.data.message) || "",
+                code: (node.data && node.data.code) || ""
+              };
+            }
+            continue;
+          }
+          if (node.kind !== "assistant-step") continue;
           var info = nodeInfo(key, node);
           current.msgs.push({ key: key, text: info.text });
           for (var k = 0; k < info.headings.length; k++) {
@@ -1424,9 +1521,11 @@ window.__ModuleLoader__.load({
           }
         }
         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)
-        var ready = result.filter(function (g) { return g.headings.length > 0 || g.time !== ""; });
+        // keep a turn when it has headings, a time, a loaded prompt or a failure —
+        // turns without headings still get a standalone time entry (click to jump)
+        var ready = result.filter(function (g) {
+          return g.headings.length > 0 || g.time !== "" || g.userKey !== "" || g.failure !== null;
+        });
         if (outlineTurns === null) return ready;
         // ---- merge the whole-log turn index ---------------------------------
         // Loaded groups keep their order (a group whose node carries no turn
@@ -1452,6 +1551,7 @@ window.__ModuleLoader__.load({
             userKey: "",
             userText: entry.prompt,
             userFull: "",
+            failure: null,
             msgs: [],
             headings: [],
             preview: entry.response
@@ -1469,12 +1569,26 @@ window.__ModuleLoader__.load({
         didInitScroll.current = true;
         listRef.current.scrollTop = listRef.current.scrollHeight;
       }, [groups.length]);
-      // one-line diagnostic so the loaded build AND the host capabilities it can
-      // actually reach are identifiable from the browser console
+      // 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.
+      // Also must stay below `groups` (deps arrays read the vars eagerly).
+      react.useEffect(function () {
+        syncAtBottom(listRef.current);
+      }, [groups.length, query, visibleCount, panelW, panelH, open]);
+      // Mount diagnostic: the host capabilities this panel actually reached
+      // (whole-log turn index + jump loader). SILENT by default — a normal console
+      // should stay clean — and switched on with
+      //   localStorage.setItem("dsh-quick-toc.debug", "1")
+      // plus a reload. Kept because it is the fastest way to tell "the host has no
+      // turnOutline projection" apart from "the jump-loader bridge is broken".
       var mountLogRef = react.useRef(false);
       react.useEffect(function () {
         if (mountLogRef.current) return;
         mountLogRef.current = true;
+        var debug = false;
+        try { debug = localStorage.getItem("dsh-quick-toc.debug") === "1"; } catch (e) { debug = false; }
+        if (!debug) return;
         console.log("[dsh-quick-toc] panel mounted · turnOutline=" +
           (outlineTurns ? outlineTurns.length + " turns" : "unavailable") +
           " · jumpLoader=" + jumpLoaderState());
@@ -1506,6 +1620,7 @@ window.__ModuleLoader__.load({
           var g = groups[i];
           if (g.ghost) continue; // no loaded rows to match
           if (g.userKey) m[g.userKey] = i;
+          if (g.failure) m[g.failure.key] = i;
           for (var j = 0; j < g.headings.length; j++) {
             m[g.headings[j].key] = i;
           }
@@ -1604,6 +1719,18 @@ window.__ModuleLoader__.load({
                 level: 0, path: "", time: g.time, snippet: snippetAround(msg.text, fq, 36, fuzzy)
               }, nm);
             }
+            // a failed turn's provider message is searchable too — "timed out" must
+            // find the turns it killed
+            if (g.failure && g.failure.message) {
+              var nf = countOccurrences(g.failure.message, needle, fuzzy);
+              if (nf > 0) {
+                push({
+                  gi: gi, key: g.failure.key, idx: undefined, title: previewText(g.failure.message, 40),
+                  level: 0, path: "", time: g.time, failed: true,
+                  snippet: snippetAround(g.failure.message, fq, 36, fuzzy)
+                }, nf);
+              }
+            }
           }
         }
         return rows;
@@ -1831,21 +1958,45 @@ window.__ModuleLoader__.load({
         if (handleRef.current) handleRef.current.style.opacity = on ? "1" : "0.35";
       };
 
-      // ---- jump: smooth glide to the exact heading element. When glued to the
-      // bottom, lift just past DSH's 25px stick-to-bottom threshold first so
-      // the glide is not yanked back. ----
+      // ---- jump: glide to the exact heading element ---------------------------
+      // A SMOOTH scroll is only trustworthy while the paged conversation keeps its
+      // geometry. A LONG jump travels through the whole window, and the host mounts
+      // and drops turns along the way, so the target's offset moves mid-flight and
+      // the animation lands short ("it scrolled halfway and stopped"). Long jumps
+      // therefore position INSTANTLY and then re-check for a short while (the same
+      // "instant, never smooth" rule the outline's own follow uses), while nearby
+      // headings keep the glide. When glued to the bottom, lift just past DSH's 25px
+      // stick-to-bottom threshold first so the landing is not yanked back.
+      var scrollTargetOf = function (el, sp) {
+        var t = el.getBoundingClientRect().top - sp.getBoundingClientRect().top + sp.scrollTop - 20;
+        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) {
           el.scrollIntoView({ behavior: "smooth", block: "start" });
           return;
         }
-        var t = el.getBoundingClientRect().top - sp.getBoundingClientRect().top + sp.scrollTop - 20;
+        var t = scrollTargetOf(el, sp);
         var floor = Math.max(0, sp.scrollHeight - sp.clientHeight);
         if (floor - sp.scrollTop <= 25 && Math.abs(t - sp.scrollTop) > 60) {
           sp.scrollTop = Math.max(0, floor - 26);
         }
-        sp.scrollTo({ top: t, behavior: "smooth" });
+        if (Math.abs(t - sp.scrollTop) <= sp.clientHeight * 1.5) {
+          sp.scrollTo({ top: t, behavior: "smooth" });
+          return;
+        }
+        // long jump: land now, then keep the landing honest for ~0.6s while the host
+        // finishes measuring the window it just re-paged
+        sp.scrollTop = t;
+        var ticks = 0;
+        var settle = setInterval(function () {
+          ticks++;
+          var next = scrollTargetOf(el, sp);
+          if (Math.abs(next - sp.scrollTop) > 2) sp.scrollTop = next;
+          if (ticks >= 5) clearInterval(settle);
+        }, 120);
       };
 
       var jump = function (key, idx) {
@@ -2192,30 +2343,16 @@ window.__ModuleLoader__.load({
                   gap: 6
                 },
                 children: [
-                  // three-bar outline mark (long / medium / short) — no title text
-                  react_jsx_runtime.jsx("div", {
-                    style: { display: "flex", alignItems: "center", color: C.muted, flex: "none" },
-                    title: T("panel.title"),
-                    children: react_jsx_runtime.jsx("svg", {
-                      width: 18,
-                      height: 14,
-                      viewBox: "0 0 18 14",
-                      style: { display: "block" },
-                      children: [
-                        react_jsx_runtime.jsx("line", { x1: 0, y1: 2, x2: 18, y2: 2, stroke: "currentColor", strokeWidth: 2, strokeLinecap: "round" }),
-                        react_jsx_runtime.jsx("line", { x1: 0, y1: 7, x2: 12, y2: 7, stroke: "currentColor", strokeWidth: 2, strokeLinecap: "round" }),
-                        react_jsx_runtime.jsx("line", { x1: 0, y1: 12, x2: 6, y2: 12, stroke: "currentColor", strokeWidth: 2, strokeLinecap: "round" })
-                      ]
-                    })
-                  }),
+                  // 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 (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.
+                      // 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); },
@@ -2262,6 +2399,16 @@ window.__ModuleLoader__.load({
                           ]
                         })
                       }),
+                      // 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
+                  react_jsx_runtime.jsx("div", { style: { flex: "1 1 auto" } }),
+                  // 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(); },
@@ -2304,8 +2451,6 @@ window.__ModuleLoader__.load({
                           ]
                         })
                       }),
-                      // triangle tips toward the side it will move TO: shift slightly up + toward the tip
-                      iconBtn(toggleDock, dockRight ? T("handle.dockLeft") : T("handle.dockRight"), dockRight ? "◀" : "▶", 12, dockRight ? { x: -1, y: -1 } : { x: 1, y: -1 }),
                       // close: thick SVG cross, nudged slightly down
                       react_jsx_runtime.jsx("button", {
                         onClick: function () { setOpen(false); },
@@ -2575,6 +2720,71 @@ window.__ModuleLoader__.load({
                 : renderGroups(shownGroups, shownTrees, jump, C, Math.max(0, groups.length - visibleCount), activeGroup, renderExtra)
             })
           }),
+          // "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
+          // to animate, and (like the level picker) its animation must not depend on
+          // inline keyframes that every re-render rewrites.
+          react_jsx_runtime.jsx("button", {
+            onClick: scrollToBottom,
+            className: "dqt-bottom-btn",
+            "data-at-bottom": atBottom ? "on" : "off",
+            title: T("outline.bottom"),
+            tabIndex: atBottom ? -1 : 0,
+            "aria-hidden": atBottom ? "true" : undefined,
+            onMouseEnter: function (e) {
+              e.currentTarget.style.color = C.accent;
+              e.currentTarget.style.borderColor = C.groupEdgeSoft;
+            },
+            onMouseLeave: function (e) {
+              e.currentTarget.style.color = C.text;
+              e.currentTarget.style.borderColor = C.panelBorder;
+            },
+            style: {
+              position: "absolute",
+              // clear of the resize handle in the very corner (16x16)
+              right: 18,
+              bottom: 12,
+              width: 26,
+              height: 26,
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "center",
+              padding: 0,
+              // OPAQUE surface + outline + lift, the same vocabulary as the hover card:
+              // a translucent chip disappeared into the rows behind it (and the panel's
+              // own idle transparency multiplied it away). The surface is the host's
+              // RAISED menu colour, not the panel background — a fill identical to the
+              // panel it sits on reads as "no fill" and the button looks see-through.
+              background: "var(--dsw-specific-menu, rgba(44, 49, 60, 0.99))",
+              border: "1px solid " + C.panelBorder,
+              borderRadius: "50%",
+              cornerShape: "round",
+              color: C.text,
+              cursor: "pointer",
+              zIndex: 6,
+              boxShadow: "0 3px 10px rgba(0, 0, 0, 0.30)",
+              opacity: atBottom ? 0 : 1,
+              transform: atBottom ? "translateY(6px)" : "translateY(0)",
+              pointerEvents: atBottom ? "none" : "auto",
+              transition: "opacity 0.22s ease, transform 0.22s ease, background 0.18s ease, color 0.18s ease, border-color 0.18s ease"
+            },
+            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("polyline", { points: "3.5,4.5 7,8 10.5,4.5" }),
+                react_jsx_runtime.jsx("line", { x1: 3.5, y1: 11, x2: 10.5, y2: 11 })
+              ]
+            })
+          }),
           toastEl,
           // resize handles (right edge: width, bottom edge: height)
           react_jsx_runtime.jsx("div", {
@@ -2620,8 +2830,9 @@ window.__ModuleLoader__.load({
             onPointerDown: onResizeCornerDown,
             title: T("resize.wh")
           }),
-          // heading-level picker: pops down from the round header button,
-          // right-aligned, with an outer shadow so it reads as a floating layer.
+          // 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
@@ -2631,7 +2842,7 @@ window.__ModuleLoader__.load({
             style: {
               position: "absolute",
               top: 40,
-              right: 8,
+              left: 10,
               zIndex: 30,
               display: "flex",
               alignItems: "center",
@@ -2643,8 +2854,9 @@ window.__ModuleLoader__.load({
               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"
+              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];
@@ -2893,6 +3105,7 @@ window.__ModuleLoader__.load({
       var fuzzy = !!(extra && extra.fuzzy);
       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);
@@ -2984,8 +3197,10 @@ window.__ModuleLoader__.load({
     // 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, headingless) {
-      var replyKey = (g.msgs && g.msgs.length > 0) ? g.msgs[0].key : "";
+    function renderGroupHeader(g, gi, jump, C, isActive) {
+      // 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 : "");
       var jumpToTurn = function (e) {
         e.stopPropagation();
         // prefer the model's reply; fall back to the user message, then to the
@@ -2996,8 +3211,12 @@ window.__ModuleLoader__.load({
       };
       return react_jsx_runtime.jsx("div", {
         style: {
-          padding: headingless ? "3px 4px" : "1px 4px 2px",
-          height: headingless ? undefined : 18,
+          // 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,
           display: "flex",
           alignItems: "center",
           minWidth: 0,
@@ -3027,19 +3246,21 @@ window.__ModuleLoader__.load({
           }, "g-h-tint-" + gi),
           react_jsx_runtime.jsx("span", {
           onClick: jumpToTurn,
-          title: replyKey ? T("turn.jumpReply") : T("turn.jumpTurn"),
+          title: (g.msgs && g.msgs.length > 0) ? T("turn.jumpReply") : (g.failure ? T("turn.jumpFailed") : T("turn.jumpTurn")),
           onMouseEnter: function (e) { e.currentTarget.style.background = C.hover; },
           onMouseLeave: function (e) { e.currentTarget.style.background = "transparent"; },
           style: {
-            // A turn with no headings has ONLY this row, so it carries the whole
-            // entry: readable size, weight and colour. No extra pill background —
-            // the "current group" tint belongs to the group, so headed and
-            // heading-less turns look the same when they are being read.
-            fontSize: headingless ? 12 : 11,
-            fontWeight: headingless ? 600 : 400,
-            color: headingless ? C.text : C.muted,
+            // ONE style for every group header, heading-less turns included: a turn
+            // whose reply has no markdown headings is not a different kind of entry,
+            // it is simply a group with no rows under its header, and it must line up
+            // 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,
+            fontWeight: 400,
+            color: C.muted,
             cursor: "pointer",
-            padding: headingless ? "2px 6px" : "1px 5px",
+            padding: "1px 5px",
             borderRadius: 4,
             background: "transparent",
             transition: "background 0.15s ease",
@@ -3054,8 +3275,8 @@ window.__ModuleLoader__.load({
             react_jsx_runtime.jsx("span", { style: { fontWeight: 600, flex: "none" }, children: g.time || " " }),
             g.userText ? react_jsx_runtime.jsx("span", {
               style: {
-                fontWeight: headingless ? 500 : 400,
-                opacity: headingless ? 0.95 : 0.75,
+                fontWeight: 400,
+                opacity: 0.75,
                 overflow: "hidden",
                 textOverflow: "ellipsis",
                 whiteSpace: "nowrap",
@@ -3123,6 +3344,55 @@ window.__ModuleLoader__.load({
       }, "g-ghost-" + gi);
     }
 
+    // A turn that ended in a terminal failure (the host's `turn-error` row): the
+    // outline lists it as a normal turn and adds this row, so a turn whose request
+    // never came back reads as "请求失败 · <provider message>" instead of "未加载"
+    // and never silently disappears from the outline.
+    function renderFailureRow(g, gi, jump, C) {
+      var f = g.failure;
+      var message = f.message || f.code || "";
+      var open = function (e) {
+        e.stopPropagation();
+        if (findRow(f.key)) jump(f.key);
+        else if (g.userKey && findRow(g.userKey)) jump(g.userKey);
+      };
+      return react_jsx_runtime.jsx("div", {
+        onClick: open,
+        title: message || T("turn.failed"),
+        "data-turn-failure": g.turn === null || g.turn === undefined ? String(gi) : String(g.turn),
+        style: {
+          display: "flex",
+          alignItems: "center",
+          gap: 5,
+          minWidth: 0,
+          padding: "1px 6px",
+          margin: "1px 0",
+          borderRadius: 6,
+          cursor: "pointer",
+          transition: "background 0.15s ease"
+        },
+        onMouseEnter: function (e) { e.currentTarget.style.background = C.hover; },
+        onMouseLeave: function (e) { e.currentTarget.style.background = "transparent"; },
+        children: [
+          react_jsx_runtime.jsx("span", {
+            style: { fontSize: 10, fontWeight: 600, flex: "none", color: C.error, border: "1px solid " + C.error, borderRadius: 4, padding: "0 4px" },
+            children: T("turn.failed")
+          }),
+          message ? react_jsx_runtime.jsx("span", {
+            style: {
+              fontSize: 11,
+              color: C.muted,
+              overflow: "hidden",
+              textOverflow: "ellipsis",
+              whiteSpace: "nowrap",
+              minWidth: 0
+            },
+            children: message
+          }) : null
+        ]
+      }, "g-fail-" + gi);
+    }
+
     // render each conversation turn as its own block: solid divider + time header
     // offset = global group index of the first rendered group (stable React keys)
     // activeIdx = array of groups being read (full opacity); others are dimmed
@@ -3148,14 +3418,20 @@ window.__ModuleLoader__.load({
         if (g.ghost) {
           items.push(renderGhostGroup(g, gi, C, extra));
         } else {
-          items.push(renderGroupHeader(g, gi, jump, C, isActive, !rows || rows.length === 0));
+          // 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));
+          // 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));
         }
-        // Inactive groups used to fade to 0.6, which — multiplied by the panel's own
-        // idle opacity — turned the whole list into grey. 0.85 keeps every row
-        // readable, and "the group being read" is marked by a CLOSED tinted box
-        // (fill + outline + accent bar) instead, which stays visible on top of any
-        // panel transparency and no longer looks cut off on the right.
+        // The group being read stays at full opacity and every other group is dimmed
+        // to 0.85 — enough to mark the reading position without turning the list grey
+        // (0.6 did, and multiplied by the panel's own idle transparency it made the
+        // outline barely readable). The current group ALSO gets the closed tinted box
+        // below (fill + outline + accent bar), which stays visible on top of any
+        // panel transparency and never looks cut off on the right.
         var dim = !isActive && !g.ghost;
         out.push(react_jsx_runtime.jsx("div", {
           "data-group-idx": gi,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-quick-toc",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Conversation TOC for DeepSeek Harness (DSH): turn-grouped Markdown outline covering the whole session (unloaded turns included), title/full-text search with an optional fuzzy switch, hover previews, in-chat match highlighting, heading-level filter and reading-position auto-follow",
   "type": "module",
   "main": "lib/index.js",