dsh-toolfold 0.1.7 → 0.1.8

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 所有显著变更将记录于此。格式基于 [Keep a Changelog](https://keepachangelog.com/zh-CN/1.1.0/)，版本号遵循 [语义化版本](https://semver.org/lang/zh-CN/)。
 
+## [0.1.8] - 2026-08-28
+
+### Fixed
+- 修复运行时收起"先动一下再突然收起"：当模型产生大量工具调用、且它们是最新信息时，run 在收起动画期间仍在增长。旧实现（自 0.1.3 起）假定行集合固定：折叠条点击闭包持有的是创建时的旧 run 快照，动画只覆盖原始行，随后按旧行数计时的完成定时器把整个增长后的 run 一次性合并，新流入的行瞬间消失。现点击改为操作当前 run（`bar._ccxRun`）而非创建时快照；`syncBars` 将动画期间新增的行折入同一瀑布（`extendCollapse`：rise 类 + 高度收缩 + 各自 stagger）并重排完成定时器（`armCollapseFinish`），最后一行动画结束才应用合并。（`lib/client.js`, `lib/dynamic-body.js`）
+
+### Changed
+- npm 发布工作流增加 OIDC 权限（`id-token: write`、`contents: read`），发布改用 OIDC 身份认证（移除 `NODE_AUTH_TOKEN` 环境变量），并禁用 `package-manager-cache`。
+- `package.json` 增加 `repository` 字段指向 GitHub 仓库。
+- 重构 README：重组章节（安装、快速开始、默认行为、功能、设置、性能、限制），新增"默认行为 – 首次使用"说明（为什么思考会消失、为什么调用默认分组，以及快速修复指引），补充安装方法与徽章，并同步翻译为 `README.en.md`。
+
 ## [0.1.7] - 2026-08-26
 
 ### Fixed
@@ -54,6 +64,7 @@
 - 首个可用版本：连续 `tool-call` 折叠为最后一条的单行摘要 + “已折叠 N 个工具调用”，支持 `durMs / keepThink / splitThink / stats` 四项设置（DSH `settings` 服务 → `~/.dsh/settings.yaml`，回退到 Host 路由与 `localStorage`）与瀑布动画。
 - `toolfold` 远端包与一键安装、设置双半通信（Host `GET/POST /api/dsh-toolfold/settings` + Client 桥）。
 
+[0.1.8]: https://github.com/Minecraftbe/dsh-toolfold/compare/v0.1.7...v0.1.8
 [0.1.7]: https://github.com/Minecraftbe/dsh-toolfold/compare/v0.1.6...v0.1.7
 [0.1.6]: https://github.com/Minecraftbe/dsh-toolfold/compare/v0.1.5...v0.1.6
 [0.1.5]: https://github.com/Minecraftbe/dsh-toolfold/compare/v0.1.4...v0.1.5

package/README.en.md

@@ -1,136 +1,174 @@
 # dsh-toolfold · Tool Call Folding
 
-> A DSH Web GUI plugin delivering a **Codex-like folding experience**: runs of consecutive
-> **tool calls** fold into a single compact bar showing a one-line summary of the **last call** —
-> click to expand/collapse. It replaces no built-in renderer, and uninstalling restores the UI
-> completely.
-
-![Folding demo](assets/demo-fold.gif)
-<!-- 🖼️ IMAGE SLOT: assets/demo-fold.gif — record 6–10s: a run of tool calls auto-folds into one bar → click to expand (cards waterfall down) → click to collapse (cards rise, heights shrink), 16:9, ≤2MB -->
-
-## Highlights
-
-- **Runs of tool calls fold into one bar**: consecutive tool calls collapse into a single bar
-  showing the **last call's** one-line summary, labelled "已折叠 N 个工具调用 · 点击展开"
-  (N folded calls · click to expand);
-- **Thinking separates call groups (default on)**: settled think blocks SPLIT the calls around
-  them into independent bars — calls before and after a completed think never merge into one bar;
-  turn it off to restore the original fold, where thinking folds WITH the surrounding tool group;
-- **Thinking hidden by default, keepable**: settled think blocks are hidden outright by default;
-  with "保留思考" enabled they never disappear — shown between the folded bars in split mode, or
-  **re-inserted in their original order** between the calls on expand in merge mode;
-- **In-progress thinking stays visible**: streaming think blocks render as their own row until
-  they complete, then follow the "split thinking" setting;
-- **Spring waterfall animations**: cards cascade down on expand (spring overshoot) and rise with a
-  synchronized height shrink on collapse — content below follows continuously, no end snap;
-  disabled automatically under `prefers-reduced-motion`;
-- **Bottom-pinned expand**: expanding near the bottom pins the bar's viewport position, so the
-  chat's auto-scroll never shoves it off the top of the screen;
-- **Near-zero performance cost**: no page-wide observer, zero work while content streams, and
-  everything pauses when the tab is hidden — measured ≈0.03% of one core while idle
-  (see [Performance](#performance)).
-
-![Expand / collapse animation](assets/expand-collapse.gif)
-<!-- 🖼️ IMAGE SLOT: assets/expand-collapse.gif — close-up of one 3–4 call run expanding (waterfall + label slide) and collapsing (rise + height shrink), square or 4:3, ≤2MB -->
+[![Awesome DSH Plugin](https://awesome-dsh-plugin.com/badge.svg)](https://awesome-dsh-plugin.com)
+
+English | [中文](README.md)
+
+> A DSH Web GUI plugin that provides a **Codex‑like tool folding experience**: consecutive **tool calls** are collapsed into a single compact bar showing only a one‑line summary of the last call. Click to expand/collapse.  
+> It does not replace any built‑in renderer, and uninstallation restores the UI completely.
+
+![Demo folding effect](assets/demo-fold.gif)
+
+---
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Default Behaviour – First Use](#default-behaviour--first-use)
+- [Features](#features)
+- [Settings](#settings)
+  - [Options](#options)
+  - [Storage Location](#storage-location)
+- [Performance](#performance)
+- [Limitations & Compatibility](#limitations--compatibility)
+
+---
 
 ## Installation
 
-### One-line GitHub install
+### Recommended (via npm)
 
 ```sh
-dsh plugin --profile web add github:Minecraftbe/dsh-toolfold
+dsh plugin --profile web add dsh-toolfold
 ```
 
-### Install from source
+### Alternative Methods
 
 ```sh
+# From GitHub
+dsh plugin --profile web add github:Minecraftbe/dsh-toolfold
+
+# From source
 git clone https://github.com/Minecraftbe/dsh-toolfold.git
 dsh plugin --profile web add ./dsh-toolfold
 ```
 
-After installing, **restart dsh and refresh the browser** to activate (bundle layers are composed
-at boot). Verify the plugin reached the final config with:
+After installation, **restart dsh and refresh your browser** – the plugin will be active. You can verify that it is included in the final bundle with:
 
 ```sh
 dsh --profile web --dump-config
 ```
 
-> If an earlier version was mounted manually with a `toolfold` row in `cordis.patch.yml`,
-> remove that row before switching to this channel to avoid double-mounting.
-
-### Uninstall
+### Uninstallation
 
 ```sh
 dsh plugin --profile web remove dsh-toolfold
 ```
 
-After a restart the UI is completely restored.
+After restart, the interface returns to its original state.
+
+---
+
+## Quick Start
+
+Once installed, consecutive tool calls are automatically folded into a single bar in any DSH conversation.
+
+- **Click the fold bar** to expand or collapse the tool‑call cards (keyboard `Enter` / `Space` also work)
+- **The bar shows**: a one‑line summary of the last call plus the label “N tool calls folded · click to expand”
+
+![Expand/collapse animation](assets/expand-collapse.gif)
+
+---
+
+## Default Behaviour – First Use
+
+The plugin works immediately after installation, but you might notice two things that seem “unexpected” at first. Both are intentional defaults and can be changed easily.
+
+### ❓ Why did my thinking content disappear?
+
+**Reason**: “Keep thinking” is off by default (`keepThink: false`). Completed thinking blocks are hidden to keep the conversation cleaner.
 
-## Usage & Settings
+**How to restore**: go to `Settings → Plugins → Tool Fold` and turn on **“Keep thinking”**.
 
-Settings: **Settings → Plugins → 工具折叠** (the card matches the built-in plugin cards and follows
-the light/dark theme).
+### ❓ Why are my tool calls split into two separate fold bars?
+
+**Reason**: “Split thinking across call groups” is on by default (`splitThink: true`). The plugin treats a completed thinking block as a logical separator, folding calls before and after it independently.
+
+**How to merge them**: go to `Settings → Plugins → Tool Fold` and turn off **“Split thinking across call groups”**.
+
+> Ongoing (streaming) thinking is always visible regardless of these settings, and will only be processed according to the rules once it finishes.
+
+---
+
+## Features
+
+### Core Folding Behaviour
+
+- **Automatic folding of consecutive tool calls** – adjacent tool calls are collapsed into one bar, showing only the last call’s summary line and the number of folded items.
+- **Thinking splits call groups (enabled by default)** – a completed thinking block separates the tool calls before and after it into two independent fold bars; they are never merged across a thinking block.
+- **Thinking hidden by default, can be kept** – completed thinking is hidden to save space; when “Keep thinking” is enabled, thinking appears between fold bars (in split mode) or interpolated back between calls on expansion (in merged mode).
+- **Ongoing thinking always visible** – streaming thinking remains visible until it finishes, then follows the above rules.
+
+### Animation & Experience
+
+- **Spring‑loaded waterfall animation** – cards drop one by one on expand (with spring bounce), and on collapse they rise while heights shrink synchronously, so content below moves continuously without jumping.
+- **Sticks to the bottom without pushing out** – when expanding near the bottom, the fold bar’s viewport position is pinned so that automatic scrolling does not push it off screen.
+- **Respects system preferences** – if the system has “Reduce motion” enabled, animations are automatically disabled.
+
+### Performance & Resource Usage
+
+- **Near‑zero performance impact** – no page‑wide observers, zero engine work during streaming, and all activity is paused when the tab is hidden. Measured idle overhead is about 0.03% of a single CPU core.
+- **Optional real‑time stats** – enable “Performance stats” in the settings card to see per‑step timings and verify overhead.
+
+---
+
+## Settings
+
+Settings are found at: **Settings → Plugins → Tool Fold** (the card looks like other built‑in plugin cards and follows the light/dark theme).
 
 ![Settings card](assets/settings.png)
-<!-- 🖼️ IMAGE SLOT: assets/settings.png — screenshot of the expanded "工具折叠" card in Settings → Plugins (duration slider + keep-think toggle + stats toggle + storage-location hint), light theme, PNG/WebP ≤1MB -->
 
-| Setting | Description |
+### Options
+
+| Option | Description |
 | --- | --- |
-| **展开动画时长** (expand duration) | Per-card duration of the expand/collapse waterfall, 0–1000ms, default 240ms; 0 = instant |
-| **保留思考** (keep thinking) | Settled thinking is hidden by default; on: it never disappears — shown between the folded bars in split mode, or re-inserted in its original order between the calls on expand in merge mode |
-| **思考分隔调用组** (split call groups) | On (default): settled thinking splits the calls around it into independent bars; Off: thinking folds with the surrounding tool group (legacy behavior) |
-| **性能统计** (performance stats) | Shows the plugin's own live cost in the card (cumulative counts and ms/s for observer callbacks / engine refreshes / merge passes / safety rescans / summary clones, plus the streaming batches ignored by the zero-cost short-circuit) |
+| **Expand animation duration** | Duration of the expand/collapse animation per card (0–1000 ms, default 240 ms; 0 = instant) |
+| **Keep thinking** | Hide completed thinking by default; when enabled, thinking is shown – between fold bars in split mode, or interpolated back between calls on expansion in merged mode |
+| **Split thinking across call groups** | Enabled by default: a completed thinking block separates tool calls before and after it into independent fold bars. Disabled: thinking is folded together with the surrounding call group (legacy behaviour) |
+| **Performance stats** | Show real‑time plugin timing in the card (cumulative count and ms/s for observation callbacks, engine refresh, merge recalculation, safe rescan, summary cloning, plus the number of streaming batches short‑circuited with zero overhead) |
+
+---
 
-Interactions: click the bar to expand/collapse; `Enter` or `Space` works too.
+### Storage Location
 
-### Where settings live
+Plugin settings are persisted automatically, with the following priority:
 
-- **Installed (bundle) mode**: the DSH **settings service** persists them to
-  `~/.dsh/settings.yaml` (namespace `toolfold`) — the same document the product and other
-  plugins use, host-side, so they survive browser/device changes. The card footer shows
-  "设置保存在 DSH 主机配置". The file is editable directly:
+- **Primary (installed/bundle mode)** – stored via the DSH **settings service** in `~/.dsh/settings.yaml` (namespace `toolfold`). They follow the dsh host, so they persist across browsers/devices. You can also edit the file manually:
 
   ```yaml
   toolfold:
-    durMs: 240        # expand animation duration, 0–2000ms
-    keepThink: false  # keep settled thinking visible (between bars / on expand)
-    splitThink: true  # settled thinking splits call groups into independent bars (default true)
-    stats: false      # performance meter
+    durMs: 240        # expand animation duration 0–2000 ms
+    keepThink: false  # whether to keep completed thinking visible
+    splitThink: true  # whether to split call groups by thinking
+    stats: false      # whether to enable performance stats
   ```
 
-- **When no DSH settings service is detected** (remote browsers and other setups without the DSH
-  settings bridge): degrades to browser `localStorage` (key `dsh-toolfold.settings.v1`) and the
-  card says "仅保存在本浏览器"; the legacy key `dsh-codex-collapse.settings.v1` migrates
-  automatically on first load.
+- **Fallback (when settings service is unavailable)** – falls back to browser `localStorage` (key `dsh-toolfold.settings.v1`), so settings are only kept in that browser. The old key `dsh-codex-collapse.settings.v1` is automatically migrated on first load.
 
-![Keep-thinking comparison](assets/keep-think.gif)
-<!-- 🖼️ IMAGE SLOT: assets/keep-think.gif — same run expanded twice, "keep thinking" off vs on, showing the think block hidden vs re-inserted in order, ≤2MB -->
+The settings card shows the current storage method (“Settings saved in DSH host config” or “Saved only in this browser”).
+
+---
 
 ## Performance
 
-- **Measured on the live GUI (8s idle window)**: engine total ≈1.6–2.8ms (≈0.3ms/s, ≈0.03% of one
-  core); a 5s CPU sample in the same window shows **zero samples from the engine** — the page's long
-  tasks (141–686ms) come from page load, product rendering, and other plugins;
-- **Zero work while streaming**: text/think token mutations are short-circuited in O(1) and never
-  trigger a recompute (≈0.1–0.4µs per node);
-- **Hidden tab = literally zero**: all observers and timers disconnect on hide and re-attach with a
-  reconciliation pass on return;
-- Turn on "性能统计" to watch every cost item live inside the settings card.
-
-## Notes & Limitations
-
-- Folding works on the rendered DOM and depends on stable product markers; if the product markup
-  changes, the worst case is that folding stops applying — the chat itself is never harmed;
-- **In-progress thinking** and **AI text output** separate runs; **settled thinking** also
-  separates runs by default ("思考分隔调用组" on) — with it off, settled thinking folds with the
-  surrounding tool group instead;
-- Expanded state is remembered per session flow + node key; reopening a session with the same keys
-  restores it;
-- Settings are owned by the DSH host config (`~/.dsh/settings.yaml`); browser `localStorage` is
-  only the fallback when the host bridge is unreachable (then each browser needs its own setup);
-- Requires `MutationObserver` and `requestAnimationFrame`; without them it degrades to "fold once on
-  initial render".
+- **Measured on a real GUI page (8 s idle window)** – total engine time ~1.6–2.8 ms (~0.3 ms/s, ~0.03% single‑core); during a 5‑s CPU profile, engine functions appeared zero times.
+- **Zero work during streaming** – streaming thinking/text tokens are short‑circuited with O(1) checks and do not trigger any recalculation (~0.1–0.4 µs per node).
+- **Hidden tab = literally zero** – all observers and timers are disconnected when the tab is hidden; they are re‑attached and a single reconciliation run is performed when the tab becomes visible again.
+- Enable **“Performance stats”** in the settings card to see detailed timings for every plugin operation.
+
+---
+
+## Limitations & Compatibility
+
+- **DOM‑based** – folding relies on stable product DOM markers. If markers change, the worst case is that folding stops working – it will not break the chat.
+- **Splitting rules**:
+  - Ongoing thinking and plain text output separate tool call groups.
+  - Completed thinking also separates groups by default (when “Split thinking across call groups” is on); when off, thinking is folded together with its surrounding call group.
+- **State memory** – expand/collapse state is remembered per conversation flow and node key; re‑opening a conversation with the same key restores the state.
+- **Browser requirements** – needs `MutationObserver` and `requestAnimationFrame`. If unsupported, it falls back to “fold once on initial render”.
+- **Settings storage** – uses the DSH host config (`~/.dsh/settings.yaml`) when available; only falls back to `localStorage` when the host bridge is unreachable (in which case settings are browser‑local only).
 
 ---
 
-This project was entirely completed by dsh + deepseek v4 flash(max).
+> This project is entirely built with dsh + deepseek v4 flash(max).

package/README.md

@@ -1,56 +1,54 @@
 # dsh-toolfold · 工具调用折叠
 
-> DSH Web GUI 插件，提供**类 Codex 的工具折叠体验**：把连续的**工具调用**折叠成一条简洁的
-> 折叠条，只展示最后一个调用的一行摘要，点击即可展开/收起。
-> 不替换任何内置渲染器，卸载后界面完全恢复原样。
+[![Awesome DSH Plugin](https://awesome-dsh-plugin.com/badge.svg)](https://awesome-dsh-plugin.com)
+
+中文 | [English](README.en.md)
+
+> DSH Web GUI 插件，提供**类 Codex 的工具折叠体验**：把连续的**工具调用**折叠成一条简洁的折叠条，只展示最后一个调用的一行摘要，点击即可展开/收起。不替换任何内置渲染器，卸载后界面完全恢复原样。
 
 ![折叠效果演示](assets/demo-fold.gif)
-<!-- 🖼️ 图片位：assets/demo-fold.gif —— 建议录制 6~10s：多个工具调用自动折成一条 → 点击展开（卡片瀑布落下）→ 点击收起（卡片上行、高度收缩），16:9，≤2MB -->
-
-## 特性一览
-
-- **连续工具调用折叠为一条**：相邻的工具调用整段收起，条内直接显示**最后一个调用**的一行
-  摘要，并标注「已折叠 N 个工具调用 · 点击展开」；
-- **思考分隔调用组（默认开启）**：已完成的思考会把前后两组工具调用**隔开、各自独立折叠**，
-  不会把思考前后的调用合并成一条；关闭后恢复原折叠方式——思考并入所在工具组一起折叠；
-- **思考默认隐藏，可保留**：已完成的思考默认隐藏（不占版面）；开启「保留思考」后思考不再
-  消失——分隔模式下显示在两条折叠条之间，合并模式下展开时按**原顺序插回调用之间**；
-- **进行中的思考独立显示**：流式思考保持原样可见，完成后按「思考分隔」设置处理；
-- **弹性瀑布动画**：展开时卡片自上而下逐张落下（spring 回弹），收起时逐张上行且行高度同步收缩，
-  下方内容连续上移、结尾无跳变；系统开启「减少动态效果」时动画自动关闭；
-- **贴底不顶出**：靠近底部展开时，折叠条视口位置被钉住，不会因聊天自动滚动被顶出屏幕；
-- **接近零性能占用**：无页面级观察器、流式期间引擎零工作、标签页隐藏时全部暂停——
-  实机测量空闲开销约 0.03% 单核（详见[性能](#性能)）。
 
-![展开/收起动画](assets/expand-collapse.gif)
-<!-- 🖼️ 图片位：assets/expand-collapse.gif —— 建议：单段 3~4 个调用的展开（瀑布落下 + 标签滑左）与收起（上行 + 高度收缩）特写，正方形或 4:3，≤2MB -->
+---
 
-## 安装
+## 目录
+
+- [安装](#安装)
+- [快速上手](#快速上手)
+- [初次使用·默认行为说明](#初次使用默认行为说明)
+- [功能特性](#功能特性)
+- [设置说明](#设置说明)
+  - [设置项](#设置项)
+  - [存储位置](#存储位置)
+- [性能](#性能)
+- [限制与兼容性](#限制与兼容性)
 
+---
 
+## 安装
 
-### GitHub 一行安装
+### 推荐（通过 npm）
 
 ```sh
-dsh plugin --profile web add github:Minecraftbe/dsh-toolfold
+dsh plugin --profile web add dsh-toolfold
 ```
 
-### 从源码安装
+### 其他方式
 
 ```sh
+# 从 GitHub 安装
+dsh plugin --profile web add github:Minecraftbe/dsh-toolfold
+
+# 从源码安装
 git clone https://github.com/Minecraftbe/dsh-toolfold.git
 dsh plugin --profile web add ./dsh-toolfold
 ```
 
-装完**重启 dsh 并刷新浏览器**即可生效（bundle 层在启动时合成）。可用以下命令确认已进入
-最终配置：
+安装后**重启 dsh 并刷新浏览器**即可生效。可通过以下命令确认配置已生效：
 
 ```sh
 dsh --profile web --dump-config
 ```
 
-> 早期版本若曾在 `cordis.patch.yml` 手工加过 `toolfold` 行，先删除该行再切换，避免双挂载。
-
 ### 卸载
 
 ```sh
@@ -59,62 +57,117 @@ dsh plugin --profile web remove dsh-toolfold
 
 重启后界面完全恢复原样。
 
-## 使用与设置
+---
+
+## 快速上手
+
+安装完成后，在 DSH 对话界面中，连续的工具调用会自动折叠为一条折叠条。
+
+- **点击折叠条**：展开或收起工具调用卡片（键盘 `Enter` / `Space` 同样有效）
+- **折叠条显示**：最后一个工具调用的一行摘要 + “已折叠 N 个工具调用 · 点击展开”
+
+![展开/收起动画](assets/expand-collapse.gif)
+
+---
+
+## 初次使用·默认行为说明
+
+插件安装后立即生效，你可能首先注意到两个“异常”现象——这都是默认设置所致，可按需调整。
+
+### ❓ 思考内容怎么消失了？
+
+**原因**：默认关闭「保留思考」（`keepThink: false`），已完成的思考被折叠隐藏，目的是让界面更清爽。
 
-设置入口：**设置 → 插件 → 工具折叠**（卡片外观与内置插件卡片一致，跟随深浅主题）。
+**改回**：`设置 → 插件 → 工具折叠` → 开启「保留思考」。
+
+### ❓ 工具调用为什么被切成了两段？
+
+**原因**：默认开启「思考分隔调用组」（`splitThink: true`），插件把思考视为逻辑分界线，将前后的工具调用各自独立折叠。
+
+**改回**：`设置 → 插件 → 工具折叠` → 关闭「思考分隔调用组」。
+
+> 进行中的思考不受任何开关影响，始终保持可见，完成后再按规则处理。
+
+---
+
+## 功能特性
+
+### 核心折叠行为
+
+- **连续工具调用自动折叠**：相邻工具调用整段收起，仅显示最后一个调用的摘要行，并标注折叠数量
+- **思考分隔调用组（默认开启）**：已完成的思考会将前后两组工具调用**隔开、各自独立折叠**，不会跨思考合并
+- **思考默认隐藏，可保留**：已完成的思考默认不占用版面；开启「保留思考」后思考会出现在折叠条之间（分隔模式）或展开时插回调用之间（合并模式）
+- **进行中的思考独立显示**：流式思考始终保持可见，完成后按上述规则处理
+
+### 动画与体验
+
+- **弹性瀑布动画**：展开时卡片逐张落下（带 spring 回弹），收起时逐张上行且高度同步收缩，下方内容连续上移、无跳变
+- **贴底不顶出**：靠近底部展开时，折叠条视口位置固定，不会因自动滚动被顶出屏幕
+- **尊重系统偏好**：系统开启「减少动态效果」时，动画自动关闭
+
+### 性能与资源
+
+- **接近零性能占用**：无页面级观察器，流式期间引擎零工作，标签页隐藏时全部暂停（空闲开销约 0.03% 单核）
+- **实时性能统计**（可选）：在设置卡片内显示插件各环节耗时，便于验证开销
+
+---
+
+## 设置说明
+
+设置入口：**设置 → 插件 → 工具折叠**（卡片外观与内置插件一致，跟随深浅主题）。
 
 ![设置卡片](assets/settings.png)
-<!-- 🖼️ 图片位：assets/settings.png —— 截图建议：设置 → 插件 页内「工具折叠」卡片展开态（时长滑块 + 保留思考开关 + 性能统计开关 + 存储位置提示），浅色主题，PNG/WebP ≤1MB -->
+
+### 设置项
 
 | 设置项 | 说明 |
 | --- | --- |
-| **展开动画时长** | 展开/收起瀑布动画的单卡时长，0–1000ms，默认 240ms；0 为瞬时切换 |
-| **保留思考** | 已完成的思考默认隐藏；开启后思考保留——分隔模式下显示在两条折叠条之间，合并模式下展开时按原顺序插回调用之间 |
-| **思考分隔调用组** | 开启（默认）：已完成的思考把前后两组工具调用隔开、各自独立折叠；关闭：思考并入所在工具组一起折叠（旧行为） |
-| **性能统计** | 在卡片内实时显示插件自身耗时（观察回调/引擎刷新/合并重算/安全重扫/摘要克隆的累计次数与 ms/s，以及被零开销短路忽略的流式批次），用于验证插件开销 |
+| **展开动画时长** | 单张卡片的展开/收起动画时长（0–1000ms，默认 240ms；设为 0 为瞬时切换） |
+| **保留思考** | 默认隐藏已完成的思考；开启后思考保留（分隔模式下显示在两条折叠条之间，合并模式下展开时插回调用之间） |
+| **思考分隔调用组** | 开启（默认）：已完成的思考把前后两组工具调用隔开、各自独立折叠；关闭：思考并入所在工具组一起折叠 |
+| **性能统计** | 在卡片内实时显示插件自身耗时（观察回调/引擎刷新/合并重算/安全重扫/摘要克隆的累计次数与耗时，以及被零开销短路忽略的流式批次） |
 
-交互方式：点击折叠条展开/收起；键盘 `Enter` 或 `Space` 同样有效。
+---
+
+### 存储位置
 
-### 设置存到哪里
+插件设置会自动持久化，优先级如下：
 
-- **已安装（bundle）模式**：设置由 DSH **设置服务**持久化到
-  `~/.dsh/settings.yaml`（命名空间 `toolfold`），与产品和其他插件的设置在同一个文档里，
-  随 dsh 主机走，换浏览器/设备不丢失；卡片底部会显示「设置保存在 DSH 主机配置」。
-  也可以直接手工编辑该文件：
+- **优先（已安装模式）**：由 DSH **设置服务**写入 `~/.dsh/settings.yaml`（命名空间 `toolfold`），随主机走，换浏览器/设备不丢失。手工编辑示例：
 
   ```yaml
   toolfold:
     durMs: 240        # 展开动画时长 0–2000ms
-    keepThink: false  # 是否保留已完成的思考（显示在折叠条之间 / 展开时插回）
-    splitThink: true  # 是否让已完成的思考隔开前后两组工具调用（默认 true）
+    keepThink: false  # 是否保留已完成的思考
+    splitThink: true  # 是否让已完成的思考隔开前后两组工具调用
     stats: false      # 是否开启性能统计
   ```
 
-- **未检测到 DSH 设置服务时**（远程浏览器等未接入 DSH 设置服务的场景）：降级为浏览器
-  `localStorage`（键 `dsh-toolfold.settings.v1`），卡片会显示「仅保存在本浏览器」；
-  旧版键 `dsh-codex-collapse.settings.v1` 首次加载自动迁移。
+- **降级（无设置服务时）**：退化为浏览器 `localStorage`（键 `dsh-toolfold.settings.v1`），仅保存在当前浏览器。旧版键 `dsh-codex-collapse.settings.v1` 会在首次加载时自动迁移。
+
+设置卡片底部会显示当前使用的存储位置（“设置保存在 DSH 主机配置”或“仅保存在本浏览器”）。
 
-![保留思考对比](assets/keep-think.gif)
-<!-- 🖼️ 图片位：assets/keep-think.gif —— 建议：同一段调用分别以「保留思考 关 / 开」各演示一次展开，展示思考不显示 / 按原顺序插回，≤2MB -->
+---
 
 ## 性能
 
-- **实测（真实 GUI 页面，空闲窗口 8s）**：引擎总耗时约 1.6–2.8ms（≈0.3ms/s，约 0.03% 单核）；
-  同窗口 5s CPU 采样中引擎函数零样本，页面长任务（141–686ms）来自页面加载与产品/其他插件渲染；
-- **流式零工作**：思考/文本 token 流式变更被 O(1) 短路直接忽略，不触发任何重算（约 0.1–0.4µs/节点）；
-- **标签页隐藏 = 字面零占用**：隐藏时断开全部观察器与定时器，回到可见时重挂并补一次对账；
-- 打开「性能统计」即可在设置卡片内实时查看插件自身的每一项耗时。
+- **实测数据（真实 GUI 页面，空闲窗口 8s）**：引擎总耗时约 1.6–2.8ms（≈0.3ms/s，约 0.03% 单核）；同窗口 5s CPU 采样中引擎函数零样本。
+- **流式零工作**：思考/文本 token 流式变更被 O(1) 短路忽略，不触发任何重算（约 0.1–0.4µs/节点）。
+- **标签页隐藏 = 零占用**：隐藏时断开全部观察器与定时器，恢复可见时重挂并补一次对账。
+- 打开「性能统计」即可在设置卡片内查看各项耗时明细。
+
+---
 
-## 说明与限制
+## 限制与兼容性
 
-- 折叠基于渲染后的 DOM，依赖产品稳定标记；若产品标记变动，最坏情况是折叠停止生效，不会破坏聊天；
-- **进行中的思考**与 **AI 文字输出**会隔开工具调用；**已完成的思考**默认也会隔开（「思考分隔
-  调用组」开启时），关闭该选项后已完成的思考并入所在工具组一起折叠；
-- 展开状态按会话流 + 节点 key 记忆；会话重开且 key 相同时会恢复展开状态；
-- 设置以 DSH 主机配置（`~/.dsh/settings.yaml`）为准；仅当主机桥不可达时才退化为浏览器
-  `localStorage`（此时换浏览器/设备需重新设置）；
-- 需要浏览器支持 `MutationObserver` 与 `requestAnimationFrame`；不支持时退化为「初始渲染折叠一次」。
+- **基于 DOM 标记**：折叠依赖产品稳定的渲染标记；若标记变动，最坏情况是折叠停止生效，但不会破坏聊天。
+- **分隔规则**：
+  - 进行中的思考与 AI 文字输出会隔开工具调用
+  - 已完成的思考默认也隔开（「思考分隔调用组」开启时）；关闭后已完成的思考并入所在工具组一起折叠
+- **状态记忆**：展开状态按会话流 + 节点 key 记忆；会话重开且 key 相同时会恢复展开状态。
+- **浏览器要求**：需要支持 `MutationObserver` 与 `requestAnimationFrame`；不支持时退化为“初始渲染折叠一次”。
+- **设置存储**：以 DSH 主机配置（`~/.dsh/settings.yaml`）为准；仅当主机桥不可达时才退化为 `localStorage`（换浏览器/设备需重新设置）。
 
 ---
 
-本项目完全由 dsh + deepseek v4 flash(max) 完成。
+> 本项目完全由 dsh + deepseek v4 flash(max) 完成。

package/lib/client.js

@@ -34,6 +34,9 @@
  *     the content below the run follows upward continuously — no blank
  *     hole and no end snap. Cleanup runs exactly one step after the LAST
  *     row's animation finishes — no dead wait before the run disappears.
+ *     A run that keeps GROWING while it collapses (the model is still
+ *     streaming the newest calls into it) extends the cascade to the new
+ *     rows and re-arms the finish timer, so the tail never snaps shut.
  *     When the reader is pinned near the bottom, expanding keeps the
  *     bar's viewport position fixed (the product's sticky-bottom follow
  *     would otherwise shove the bar out of the top).
@@ -983,13 +986,20 @@ window.__ModuleLoader__.load({
         var toggle = function () {
           var set = expanded.get(flow);
           if (set === undefined || disposed) return;
-          if (set.has(run.headKey)) {
-            startCollapse(flow, run, bar);
+          // The closure `run` is the bar's creation-time snapshot; every
+          // pass refreshes bar._ccxRun with the CURRENT run. When the model
+          // streams more calls into the same run (the newest info at the
+          // bottom of the flow), collapsing the stale snapshot would animate
+          // only the original rows and then snap the rest shut — the "runs
+          // briefly, then suddenly collapses" symptom.
+          var current = bar._ccxRun !== undefined ? bar._ccxRun : run;
+          if (set.has(current.headKey)) {
+            startCollapse(flow, current, bar);
           } else {
-            set.add(run.headKey);
-            cancelCollapse(flow, run);
+            set.add(current.headKey);
+            cancelCollapse(flow, current, bar);
             pass(flow);
-            pinBar(bar, run);
+            pinBar(bar, current);
           }
         };
         bar.addEventListener('click', toggle);
@@ -1080,10 +1090,34 @@ window.__ModuleLoader__.load({
         }
         for (var j = 0; j < rows.length; j++) rows[j].classList.add(COLLAPSING_CLASS);
         animateRowShrink(rows, dur, step);
+        // Track which rows the cascade has covered: a run that keeps
+        // GROWING while it collapses (the model is still streaming the
+        // newest calls into it) extends the cascade via extendCollapse and
+        // re-arms the finish timer. Without this, rows added after the
+        // collapse began would snap shut when the timer armed for the OLD
+        // row count fires — the "runs briefly, then suddenly collapses"
+        // symptom.
+        bar._ccxCollapseRows = rows;
         // The bar flips to collapsed visuals now; the cards stay visible for
         // the rise (pass skips ccxMerged while the head key is collapsing).
         pass(flow);
+        armCollapseFinish(flow, run, bar);
+      }
+
+      /**
+       * Arm (or re-arm) the collapse-finish timer. The delay covers one
+       * full cascade — last row's stagger + rise + margin — measured from
+       * the arm moment. `cascadeCount` defaults to the full covered row
+       * set; extendCollapse passes only the NEW rows it just added, since
+       * the already-covered rows have finished animating.
+       */
+      function armCollapseFinish(flow, run, bar, cascadeCount) {
         if (bar._ccxCollapseTimer !== undefined) timers.cancel(bar._ccxCollapseTimer);
+        var rows = bar._ccxCollapseRows;
+        var dur = durMs();
+        var step = stepMs();
+        var n = cascadeCount !== undefined ? cascadeCount : rows.length;
+        var delay = Math.max(0, n - 1) * step + dur + 60;
         bar._ccxCollapseTimer = timers.after(function () {
           bar._ccxCollapseTimer = undefined;
           if (disposed || !flow.isConnected) return;
@@ -1092,21 +1126,63 @@ window.__ModuleLoader__.load({
             perNow.delete(run.headKey);
             if (perNow.size === 0) collapsing.delete(flow);
           }
-          for (var k = 0; k < rows.length; k++) {
-            rows[k].classList.remove(COLLAPSING_CLASS);
-            clearRowShrink(rows[k]);
+          var all = bar._ccxCollapseRows;
+          for (var k = 0; k < all.length; k++) {
+            all[k].classList.remove(COLLAPSING_CLASS);
+            clearRowShrink(all[k]);
           }
+          bar._ccxCollapseRows = undefined;
           pass(flow); // applies ccxMerged now
-        }, Math.max(0, rows.length - 1) * step + dur + 60);
+        }, delay);
+      }
+
+      /**
+       * A run that is mid-collapse and still GROWING (the model streams the
+       * newest tool calls into it) folds the newly added rows into the same
+       * rise/shrink cascade — with their own relative stagger, starting
+       * immediately — and re-arms the finish timer so the last new row's
+       * animation completes before the merge applies. Without this the new
+       * rows sit at full height and then snap shut with the merge.
+       */
+      function extendCollapse(flow, run, bar) {
+        var oldRows = bar._ccxCollapseRows;
+        var rows = run.rows;
+        if (oldRows === undefined || rows.length <= oldRows.length) return;
+        var dur = durMs();
+        var step = stepMs();
+        // The rows that joined the run since the cascade covered it. Diff by
+        // identity so appended, inserted, or replaced rows all join — the
+        // streaming case appends, but never assume.
+        var added = [];
+        for (var i = 0; i < rows.length; i++) {
+          if (oldRows.indexOf(rows[i]) === -1) added.push(rows[i]);
+        }
+        if (added.length === 0) return;
+        for (var j = 0; j < added.length; j++) {
+          var row = added[j];
+          row.classList.remove(FALLING_CLASS, COLLAPSING_CLASS);
+          row.style.setProperty('--ccx-i', String(j));
+          row.classList.add(COLLAPSING_CLASS);
+        }
+        animateRowShrink(added, dur, step);
+        bar._ccxCollapseRows = rows;
+        armCollapseFinish(flow, run, bar, added.length);
       }
 
       /** Abort a pending collapse (the user re-expanded mid-animation). */
-      function cancelCollapse(flow, run) {
+      function cancelCollapse(flow, run, bar) {
         var per = collapsing.get(flow);
         if (per !== undefined) {
           per.delete(run.headKey);
           if (per.size === 0) collapsing.delete(flow);
         }
+        if (bar !== undefined && bar._ccxCollapseTimer !== undefined) {
+          timers.cancel(bar._ccxCollapseTimer);
+          bar._ccxCollapseTimer = undefined;
+        }
+        if (bar !== undefined) {
+          bar._ccxCollapseRows = undefined;
+        }
         var rows = run.rows;
         for (var i = 0; i < rows.length; i++) {
           rows[i].classList.remove(COLLAPSING_CLASS);
@@ -1294,6 +1370,15 @@ window.__ModuleLoader__.load({
             registry.set(run.headKey, bar);
           }
           updateBar(bar, run);
+          // A run that is mid-collapse and still GROWING (the model is
+          // streaming the newest calls into it) extends its cascade to the
+          // newly added rows; the finish timer is re-armed by
+          // extendCollapse. Without this the new rows would sit at full
+          // height and then snap shut with the merge.
+          if (bar._ccxCollapseRows !== undefined
+            && run.rows.length > bar._ccxCollapseRows.length) {
+            extendCollapse(flow, run, bar);
+          }
           // The bar is the group HEADER: it stays before the run's first row,
           // so on expand the cards cascade downward below it. Guard against
           // re-inserting when already in place (insertBefore always mutates).

package/lib/dynamic-body.js

@@ -880,13 +880,20 @@
         var toggle = function () {
           var set = expanded.get(flow);
           if (set === undefined || disposed) return;
-          if (set.has(run.headKey)) {
-            startCollapse(flow, run, bar);
+          // The closure `run` is the bar's creation-time snapshot; every
+          // pass refreshes bar._ccxRun with the CURRENT run. When the model
+          // streams more calls into the same run (the newest info at the
+          // bottom of the flow), collapsing the stale snapshot would animate
+          // only the original rows and then snap the rest shut — the "runs
+          // briefly, then suddenly collapses" symptom.
+          var current = bar._ccxRun !== undefined ? bar._ccxRun : run;
+          if (set.has(current.headKey)) {
+            startCollapse(flow, current, bar);
           } else {
-            set.add(run.headKey);
-            cancelCollapse(flow, run);
+            set.add(current.headKey);
+            cancelCollapse(flow, current, bar);
             pass(flow);
-            pinBar(bar, run);
+            pinBar(bar, current);
           }
         };
         bar.addEventListener('click', toggle);
@@ -977,10 +984,34 @@
         }
         for (var j = 0; j < rows.length; j++) rows[j].classList.add(COLLAPSING_CLASS);
         animateRowShrink(rows, dur, step);
+        // Track which rows the cascade has covered: a run that keeps
+        // GROWING while it collapses (the model is still streaming the
+        // newest calls into it) extends the cascade via extendCollapse and
+        // re-arms the finish timer. Without this, rows added after the
+        // collapse began would snap shut when the timer armed for the OLD
+        // row count fires — the "runs briefly, then suddenly collapses"
+        // symptom.
+        bar._ccxCollapseRows = rows;
         // The bar flips to collapsed visuals now; the cards stay visible for
         // the rise (pass skips ccxMerged while the head key is collapsing).
         pass(flow);
+        armCollapseFinish(flow, run, bar);
+      }
+
+      /**
+       * Arm (or re-arm) the collapse-finish timer. The delay covers one
+       * full cascade — last row's stagger + rise + margin — measured from
+       * the arm moment. `cascadeCount` defaults to the full covered row
+       * set; extendCollapse passes only the NEW rows it just added, since
+       * the already-covered rows have finished animating.
+       */
+      function armCollapseFinish(flow, run, bar, cascadeCount) {
         if (bar._ccxCollapseTimer !== undefined) timers.cancel(bar._ccxCollapseTimer);
+        var rows = bar._ccxCollapseRows;
+        var dur = durMs();
+        var step = stepMs();
+        var n = cascadeCount !== undefined ? cascadeCount : rows.length;
+        var delay = Math.max(0, n - 1) * step + dur + 60;
         bar._ccxCollapseTimer = timers.after(function () {
           bar._ccxCollapseTimer = undefined;
           if (disposed || !flow.isConnected) return;
@@ -989,21 +1020,63 @@
             perNow.delete(run.headKey);
             if (perNow.size === 0) collapsing.delete(flow);
           }
-          for (var k = 0; k < rows.length; k++) {
-            rows[k].classList.remove(COLLAPSING_CLASS);
-            clearRowShrink(rows[k]);
+          var all = bar._ccxCollapseRows;
+          for (var k = 0; k < all.length; k++) {
+            all[k].classList.remove(COLLAPSING_CLASS);
+            clearRowShrink(all[k]);
           }
+          bar._ccxCollapseRows = undefined;
           pass(flow); // applies ccxMerged now
-        }, Math.max(0, rows.length - 1) * step + dur + 60);
+        }, delay);
+      }
+
+      /**
+       * A run that is mid-collapse and still GROWING (the model streams the
+       * newest tool calls into it) folds the newly added rows into the same
+       * rise/shrink cascade — with their own relative stagger, starting
+       * immediately — and re-arms the finish timer so the last new row's
+       * animation completes before the merge applies. Without this the new
+       * rows sit at full height and then snap shut with the merge.
+       */
+      function extendCollapse(flow, run, bar) {
+        var oldRows = bar._ccxCollapseRows;
+        var rows = run.rows;
+        if (oldRows === undefined || rows.length <= oldRows.length) return;
+        var dur = durMs();
+        var step = stepMs();
+        // The rows that joined the run since the cascade covered it. Diff by
+        // identity so appended, inserted, or replaced rows all join — the
+        // streaming case appends, but never assume.
+        var added = [];
+        for (var i = 0; i < rows.length; i++) {
+          if (oldRows.indexOf(rows[i]) === -1) added.push(rows[i]);
+        }
+        if (added.length === 0) return;
+        for (var j = 0; j < added.length; j++) {
+          var row = added[j];
+          row.classList.remove(FALLING_CLASS, COLLAPSING_CLASS);
+          row.style.setProperty('--ccx-i', String(j));
+          row.classList.add(COLLAPSING_CLASS);
+        }
+        animateRowShrink(added, dur, step);
+        bar._ccxCollapseRows = rows;
+        armCollapseFinish(flow, run, bar, added.length);
       }
 
       /** Abort a pending collapse (the user re-expanded mid-animation). */
-      function cancelCollapse(flow, run) {
+      function cancelCollapse(flow, run, bar) {
         var per = collapsing.get(flow);
         if (per !== undefined) {
           per.delete(run.headKey);
           if (per.size === 0) collapsing.delete(flow);
         }
+        if (bar !== undefined && bar._ccxCollapseTimer !== undefined) {
+          timers.cancel(bar._ccxCollapseTimer);
+          bar._ccxCollapseTimer = undefined;
+        }
+        if (bar !== undefined) {
+          bar._ccxCollapseRows = undefined;
+        }
         var rows = run.rows;
         for (var i = 0; i < rows.length; i++) {
           rows[i].classList.remove(COLLAPSING_CLASS);
@@ -1191,6 +1264,15 @@
             registry.set(run.headKey, bar);
           }
           updateBar(bar, run);
+          // A run that is mid-collapse and still GROWING (the model is
+          // streaming the newest calls into it) extends its cascade to the
+          // newly added rows; the finish timer is re-armed by
+          // extendCollapse. Without this the new rows would sit at full
+          // height and then snap shut with the merge.
+          if (bar._ccxCollapseRows !== undefined
+            && run.rows.length > bar._ccxCollapseRows.length) {
+            extendCollapse(flow, run, bar);
+          }
           // The bar is the group HEADER: it stays before the run's first row,
           // so on expand the cards cascade downward below it. Guard against
           // re-inserting when already in place (insertBefore always mutates).

package/package.json

@@ -1,7 +1,11 @@
 {
   "name": "dsh-toolfold",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "工具调用与思考的折叠显示：连续工具调用折叠为最后一个调用（可展开），已完成的思考随组折叠（可保留、展开时按原顺序显示），进行中的思考保持独立显示。",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Minecraftbe/dsh-toolfold.git"
+  },
   "type": "module",
   "main": "lib/index.js",
   "exports": {