dsh-auto-collapse 0.1.4 → 0.1.5

package/README.en.md

@@ -46,9 +46,10 @@ Restart the DSH web service (or trigger plugin HMR), then hard-refresh the page
 ```
 src/fold.ts       core: FoldController (state machine) + findBlocks (block recognition) + collapse/expand logic
 src/client.ts     browser entry (plugin registration)
-src/index.ts      host half
-build.mjs         esbuild build (the client registration id lives in the banner)
-deploy.mjs        safe deploy: validate → back up → replace → verified restart → hash check/rollback
+src/index.ts      host half (host-side entry)
+build.mjs         build script (generates lib/client.js, lib/index.js, and lib/types/*)
+tsconfig.build.json TypeScript declaration build configuration
+deploy.mjs        safe deploy: validate → back up → replace → verified restart → hash check/rollback; Windows uses PowerShell, Linux/macOS use lsof + ps
 cordis.patch.yml  profile tree mounting
 test/             fake-DOM contract, race, session-switch, and 40-order permutation regressions
 ```
@@ -67,7 +68,7 @@ Runs TypeScript checking, a fresh build, and the complete regression suite.
 npm run deploy
 ```
 
-Validates the plugin/DSH package identities and the process listening on port 3080, then creates a timestamped backup, replaces the bundle, restarts DSH, and verifies the served hash. Failures restore the old bundle. Override defaults with `DSH_AUTO_COLLAPSE_LIB`, `DSH_DIR`, `DSH_WEB_PORT`, and `DSH_LOG_DIR`.
+Validates the plugin/DSH package identities and the process listening on port 3080, then creates a timestamped backup, replaces the bundle, restarts DSH, and verifies the served hash. Failures restore the old bundle. Windows, Linux, and macOS are supported; Unix systems locate DSH from `npm root -g` by default and use `HOME` for the profile path. Linux/macOS require `lsof`. Override defaults with `DSH_AUTO_COLLAPSE_LIB`, `DSH_DIR`, `DSH_WEB_PORT`, and `DSH_LOG_DIR`.
 
 ### Publishing a new version
 

package/README.md

@@ -47,9 +47,10 @@ dsh plugin --profile web add "github:a179-sanae/dsh-auto-collapse#main"
 ```
 src/fold.ts       核心：FoldController（状态机）+ findBlocks（块识别）+ 折叠/展开逻辑
 src/client.ts     浏览器端入口（注册插件）
-src/index.ts      host half
-build.mjs         esbuild 构建（lib/client.js 的注册 id 在 banner 里）
-deploy.mjs        安全部署：校验 → 备份 → 替换 → 身份核验重启 → 哈希验证/回滚（DSH web 输出持久化到 ~/.dsh/logs/web.{out,err}.log）
+src/index.ts      host half（宿主端，Host half）
+build.mjs         构建脚本（Build script）：生成 lib/client.js、lib/index.js 与 lib/types/*
+tsconfig.build.json TypeScript 声明构建配置（Declaration build config）
+deploy.mjs        安全部署（Safe deploy）：校验 → 备份 → 替换 → 身份核验重启 → 哈希验证/回滚（DSH web 输出持久化到 ~/.dsh/logs/web.{out,err}.log）；Windows 使用 PowerShell，Linux/macOS 使用 lsof + ps
 cordis.patch.yml  profile 树挂载
 test/             fake DOM 契约、竞态、会话切换与 40 组乱序排列回归
 ```
@@ -68,7 +69,7 @@ npm run check
 npm run deploy
 ```
 
-脚本先核验插件/DSH 包名和 3080 监听进程身份，再做时间戳备份、替换、重启与服务端哈希验证；失败自动恢复旧 bundle。可用 `DSH_AUTO_COLLAPSE_LIB`、`DSH_DIR`、`DSH_WEB_PORT`、`DSH_LOG_DIR` 覆盖默认路径。
+脚本先核验插件/DSH 包名和 3080 监听进程身份，再做时间戳备份、替换、重启与服务端哈希验证；失败自动恢复旧 bundle。支持 Windows、Linux 和 macOS；Unix 系统默认从 `npm root -g` 定位 DSH 包，并使用 `HOME` 定位 profile。Linux/macOS 需要安装 `lsof`。可用 `DSH_AUTO_COLLAPSE_LIB`、`DSH_DIR`、`DSH_WEB_PORT`、`DSH_LOG_DIR` 覆盖默认路径。
 
 ### 发布新版本
 

package/lib/client.js

@@ -38,6 +38,9 @@ var __dshcfBundle = (() => {
   var DEFAULT_STATUS_TEXT = "Deep sleeping...";
   var ANIM_DURATION_MS = 180;
   var ANIM_EASING = "ease-out";
+  var DISPLAY_OWNED_PROP = "--dshcf-display-owned";
+  var AUDIT_TICK_MS = 1e3;
+  var STICK_BOTTOM_THRESHOLD_PX = 24;
   var TOOL_LABELS = {
     bash: "Bash",
     pwsh: "Pwsh",
@@ -343,8 +346,16 @@ var __dshcfBundle = (() => {
 }
 `;
   var FoldController = class {
-    constructor(statusTextProvider2) {
+    constructor(statusTextProvider2, options) {
       this.observer = null;
+      /** 防止同一个控制器重复注册 observer、定时器和可见性监听。 */
+      this.started = false;
+      /** body 尚未创建时等待 DOMContentLoaded，再补一次启动。 */
+      this.waitingForBody = false;
+      this.onDomContentLoaded = () => {
+        this.waitingForBody = false;
+        this.start();
+      };
       this.raf = 0;
       this.timer = 0;
       this.disposed = false;
@@ -372,7 +383,9 @@ var __dshcfBundle = (() => {
       /** 插件改写 display 前的精确原值；受控集合用于分类漂移和 stop() 恢复。 */
       this.originalDisplay = /* @__PURE__ */ new WeakMap();
       this.controlledDisplay = /* @__PURE__ */ new Set();
-      /** 被改写为状态提示词的原生状态文本，卸载时按节点恢复。 */
+      /** 元素 → 插件最后确保的 display 值：恢复前与当前内联值比对，漂移即视为
+       * 外部介入（镜像 turnStatusTexts 的 original/written 双快照守卫，issue #11）。 */
+      this.writtenDisplay = /* @__PURE__ */ new WeakMap();
       /** 被改写为状态提示词的原生状态文本：original = 宿主原文（卸载还原用），
        * written = 插件最后一次写入的值（仅当节点仍等于它时才还原，避免覆盖
        * 宿主在插件写入之后的状态更新）。 */
@@ -390,14 +403,39 @@ var __dshcfBundle = (() => {
       /** segment 点击时只让点击前已存在的 block 播放 reveal；流式中新出现的
        * 临时分裂块直接显示，避免分类收敛时留下半透明 stale chip。 */
       this.animatableSegmentBlocks = /* @__PURE__ */ new Map();
+      /** 外部变更对账定时器句柄（自重排 setTimeout 链，见 armAuditLoop）。 */
+      this.auditTimer = 0;
+      /** 上一轮 pass 记录的关键元素内联 display，用于 audit 轻量检测漂移。
+       * audit 只读这份快照，不在页面稳定时重新执行完整 pass。 */
+      this.auditDisplays = /* @__PURE__ */ new Map();
+      /** 自上次 pass 以来 flow 子树发生过结构变化（childList）或正文判定翻转：
+       * 为 true 时 pass 重建分块快照，否则复用 currentBlocks——characterData/
+       * attributes 批次（流式文本、data-state 翻转）不改变块结构，跳过全量
+       * querySelectorAll 重扫（issue #14：长会话下每轮重扫造成主线程卡顿）。 */
+      this.structureDirty = true;
+      /** 滚动稳定化（issue #14）：flow 最近的滚动容器缓存（按 flow 身份失效）。 */
+      this.scrollContainer = null;
+      this.scrollContainerFlow = null;
+      /** 回到前台立即补一轮对账；后台 tab 由 document.hidden 门控跳过。 */
+      this.onVisibilityChange = () => {
+        if (typeof document === "undefined" || document.hidden !== true) this.schedule();
+      };
       this.statusTextProvider = statusTextProvider2 ?? (() => DEFAULT_STATUS_TEXT);
+      this.auditIntervalMs = options?.auditIntervalMs ?? AUDIT_TICK_MS;
     }
     /** 设置变更后重跑一轮，让状态提示词立即生效。 */
     refresh() {
       this.schedule();
     }
     start() {
-      if (this.disposed) return;
+      if (this.disposed || this.started || this.waitingForBody) return;
+      if (typeof document === "undefined") return;
+      if (document.body === null) {
+        if (typeof document.addEventListener !== "function") return;
+        this.waitingForBody = true;
+        document.addEventListener("DOMContentLoaded", this.onDomContentLoaded, { once: true });
+        return;
+      }
       injectStyle();
       try {
         this.observer = new MutationObserver((records) => {
@@ -417,16 +455,86 @@ var __dshcfBundle = (() => {
           // 不会自激。
           characterData: true
         });
+        this.started = true;
+        this.armAuditLoop();
         this.schedule();
       } catch (error) {
+        this.observer?.disconnect();
+        this.observer = null;
+        this.started = false;
         this.reportError(error);
         throw error;
       }
     }
+    /** 外部显示变更对账循环（issue #11 Bug B）：外部对宿主行的 style 写入不产生
+     * observer record（style 不在 attributeFilter 内，监听会因插件自身直写 style
+     * 自激），改用低频轻量对账兜底——发现漂移后才由 pass 收敛；
+     * 后台 tab 由 document.hidden 门控跳过，回前台由 visibilitychange 立即补一轮。
+     * 用自重排 setTimeout 链而非 setInterval：与 schedule 的兜底定时器同源，
+     * 测试桩 clearTimers 后链条自然熄灭。 */
+    armAuditLoop() {
+      if (typeof document !== "undefined" && typeof document.addEventListener === "function") {
+        document.addEventListener("visibilitychange", this.onVisibilityChange);
+      }
+      this.rearmAudit();
+    }
+    rearmAudit() {
+      if (this.disposed || this.auditTimer !== 0) return;
+      this.auditTimer = setTimeout(() => {
+        this.auditTimer = 0;
+        if (this.disposed) return;
+        if (typeof document !== "undefined" && document.hidden === true) {
+          this.rearmAudit();
+          return;
+        }
+        this.audit();
+        this.rearmAudit();
+      }, this.auditIntervalMs);
+    }
+    /** 低成本显示状态对账：只有发现外部漂移时才启动完整 pass。
+     *
+     * 外部 style.display 写入不会产生当前 observer 的 attribute 记录，
+     * 因此仍保留 audit；但稳定页面不应每秒重扫整个 flow。快照只覆盖
+     * flow 顶层行、插件控制中的宿主行和插件自有展示行，避免引入布局读取。 */
+    audit() {
+      if (this.disposed) return;
+      const flow = this.flow;
+      if (flow === null || !flow.isConnected) {
+        if (flow !== null) this.schedule();
+        return;
+      }
+      const current = this.collectAuditDisplays(flow);
+      if (current.size !== this.auditDisplays.size) {
+        this.schedule();
+        return;
+      }
+      for (const [el, display] of current) {
+        if (this.auditDisplays.get(el) !== display) {
+          this.schedule();
+          return;
+        }
+        if (this.controlledDisplay.has(el) && this.displayForeign(el)) {
+          this.schedule();
+          return;
+        }
+      }
+    }
     stop() {
       this.disposed = true;
+      this.started = false;
+      this.waitingForBody = false;
+      if (typeof document !== "undefined" && typeof document.removeEventListener === "function") {
+        document.removeEventListener("DOMContentLoaded", this.onDomContentLoaded);
+      }
       if (this.raf !== 0) cancelAnimationFrame(this.raf);
       if (this.timer !== 0) clearTimeout(this.timer);
+      if (this.auditTimer !== 0) {
+        clearTimeout(this.auditTimer);
+        this.auditTimer = 0;
+      }
+      if (typeof document !== "undefined" && typeof document.removeEventListener === "function") {
+        document.removeEventListener("visibilitychange", this.onVisibilityChange);
+      }
       this.observer?.disconnect();
       this.switchFlow(null);
       removeStyle();
@@ -434,29 +542,50 @@ var __dshcfBundle = (() => {
     /** body 级 observer 只负责发现 flow 替换；已有 flow 外的文本变化不再触发全量扫描。 */
     shouldSchedule(records) {
       if (records.length === 0 || this.flow === null || !this.flow.isConnected) return true;
-      return records.some((record) => nodeWithin(record.target, this.flow) || nodeWithin(this.flow, record.target));
+      return records.some((record) => this.isRelevantMutation(record));
+    }
+    /** 判断 mutation 是否会影响宿主 flow；插件自有节点的回写直接忽略，
+     * 避免“pass 插入 chip → observer 再开一轮 pass”的自激循环。 */
+    isRelevantMutation(record) {
+      const flow = this.flow;
+      if (flow === null || !flow.isConnected) return true;
+      if (!nodeWithin(record.target, flow) && !nodeWithin(flow, record.target)) return false;
+      if (record.type === "characterData" && record.target instanceof Text && this.turnStatusTexts.has(record.target)) {
+        return false;
+      }
+      const changed = [
+        ...Array.from(record.addedNodes ?? []),
+        ...Array.from(record.removedNodes ?? [])
+      ];
+      if (changed.length > 0 && changed.every(isPluginOwnedNode)) return false;
+      if (changed.length === 0 && isPluginOwnedNode(record.target)) return false;
+      return true;
     }
     /** 记录本批 mutation 命中的 flow 顶层消息，供正文判定缓存定向失效。
-     * 从 record.target 沿 parentNode 走到 flow 的直接子级即所属消息；
-     * 归属不到单一顶层消息（flow 直挂层结构变化、flow 外节点、文本直接
-     * 子节点）时全量失效——保守正确且罕见。 */
+     * 从 record.target 沿 parentNode 走到 flow 的直接子级即所属消息。
+     * 失效粒度（issue #14）：只有 childList 使分块快照失效；flow 直挂层的
+     * 插件节点/文本节点与 flow 外的混批记录不影响任何消息的正文判定，跳过
+     * 而非全量失效——旧逻辑把它们全部放大成 O(全会话) 的 TreeWalker 重扫，
+     * 长会话流式期间每帧如此。空批次仍保守全量失效（测试桩的调度通知）。 */
     markDirty(records) {
       const flow = this.flow;
       if (flow === null || !flow.isConnected) return;
       if (records.length === 0) {
         this.bodyTextCache = /* @__PURE__ */ new WeakMap();
         this.dirtyMessages.clear();
+        this.structureDirty = true;
         return;
       }
-      for (const record of records) {
-        let current = record.target;
-        while (current !== null && current.parentNode !== flow) current = current.parentNode;
-        if (!(current instanceof HTMLElement)) {
-          this.bodyTextCache = /* @__PURE__ */ new WeakMap();
-          this.dirtyMessages.clear();
-          return;
+      for (const record of records.filter((record2) => this.isRelevantMutation(record2))) {
+        if (record.type === "childList") this.structureDirty = true;
+        if (record.target === flow) {
+          for (const node of record.addedNodes ?? []) {
+            if (node instanceof HTMLElement) this.dirtyMessages.add(node);
+          }
+          continue;
         }
-        this.dirtyMessages.add(current);
+        const owner = flowChildOwner(record.target, flow);
+        if (owner !== null) this.dirtyMessages.add(owner);
       }
     }
     schedule() {
@@ -510,12 +639,20 @@ var __dshcfBundle = (() => {
       if (nextFlow !== this.flow) this.switchFlow(nextFlow);
       const flow = this.flow;
       if (flow === null) return;
-      for (const el of this.dirtyMessages) this.bodyTextCache.delete(el);
+      let bodyFlipped = false;
+      for (const el of this.dirtyMessages) {
+        const prev = this.bodyTextCache.get(el);
+        this.bodyTextCache.delete(el);
+        if (prev !== void 0 && this.hasBodyCached(el) !== prev) bodyFlipped = true;
+      }
       this.dirtyMessages.clear();
-      const blocks = findBlocks(flow, (el) => this.hasBodyCached(el));
+      const rebuildBlocks = this.structureDirty || bodyFlipped || this.currentBlocks.size === 0;
+      this.structureDirty = false;
+      const blocks = rebuildBlocks ? findBlocks(flow, (el) => this.hasBodyCached(el)) : [...this.currentBlocks.values()];
       this.currentBlocks = new Map(blocks.map((block) => [block.key, block]));
       const segments = buildSegments(flow, blocks, (el) => this.hasBodyCached(el));
       const liveSegmentKeys = new Set(segments.map((segment) => segment.key));
+      const scrollAnchor = this.captureScrollAnchor(flow);
       for (const segment of segments) {
         if (!segment.running) continue;
         if (this.completedOnce.has(segment.key)) {
@@ -584,6 +721,7 @@ var __dshcfBundle = (() => {
       this.cleanupStaleChips(seenBlocks);
       this.restoreUnusedDisplays(desiredHidden);
       for (const state of this.segmentStates.values()) this.placeProcessedRow(flow, state);
+      this.stabilizeScrollAfterFold(scrollAnchor);
       for (const key of [...this.runningSince.keys()]) {
         if (!liveSegmentKeys.has(key)) this.runningSince.delete(key);
       }
@@ -602,6 +740,51 @@ var __dshcfBundle = (() => {
       } else {
         replaceTurnStatus(flow, this.turnStatusTexts, statusText);
       }
+      this.captureAuditDisplays(flow);
+    }
+    /** flow 最近的滚动容器（issue #14 滚动稳定化的测量基准）：沿父链找第一个
+     * overflow-y 为 auto/scroll 且实际可滚动的祖先。结果按 flow 身份缓存；
+     * 找不到时不缓存（内容增长后祖先可能变为可滚动），每 pass 重探的代价
+     * 只是几次 clean-layout 的 computed style / scrollHeight 读取。 */
+    findScrollContainer(flow) {
+      if (this.scrollContainerFlow === flow && this.scrollContainer !== null && this.scrollContainer.isConnected) {
+        return this.scrollContainer;
+      }
+      let node = flow.parentElement;
+      while (node !== null) {
+        if (typeof getComputedStyle === "function") {
+          const oy = getComputedStyle(node).overflowY;
+          if ((oy === "auto" || oy === "scroll") && node.scrollHeight > node.clientHeight) break;
+        }
+        node = node.parentElement;
+      }
+      if (node === null) return null;
+      this.scrollContainer = node;
+      this.scrollContainerFlow = flow;
+      return node;
+    }
+    /** 几何写入前捕捉贴底意图（issue #14）：视口距底 ≤ 上游 FOLLOW_THRESHOLD
+     * 时返回锚点，stabilizeScrollAfterFold 在写入后同帧钉回底部。远离底部
+     * （用户正在滚动浏览）时不干预——视口上方的高度变化由浏览器 scroll
+     * anchoring 补偿，视口下方的折叠不可见，插件再写 scrollTop 只会加入
+     * 上游吸底回写的拉锯。 */
+    captureScrollAnchor(flow) {
+      const scroller = this.findScrollContainer(flow);
+      if (scroller === null) return null;
+      const dist = scroller.scrollHeight - scroller.scrollTop - scroller.clientHeight;
+      return dist <= STICK_BOTTOM_THRESHOLD_PX ? { el: scroller } : null;
+    }
+    /** 几何写入后把贴底视口钉回底部：折叠让 scrollHeight 缩小时若不在此帧
+     * 补写 scrollTop，宿主 ChatView 要到下一帧 ResizeObserver 才吸底回写，
+     * 中间的空档让触控板惯性滚动乘虚而入，反复折叠时表现为上下抽搐（用户
+     * 实测：长会话滚到底部附近无法稳定定位）。同一帧内钉回后，宿主的吸底
+     * 回写成为幂等 no-op，不再是第二个 scrollTop 写入方。 */
+    stabilizeScrollAfterFold(anchor) {
+      if (anchor === null) return;
+      const el = anchor.el;
+      if (!el.isConnected) return;
+      const dist = el.scrollHeight - el.scrollTop - el.clientHeight;
+      if (dist > STICK_BOTTOM_THRESHOLD_PX) el.scrollTop = el.scrollHeight - el.clientHeight;
     }
     /** flow 元素变化即视为会话切换：完整恢复旧 flow，再从新 DOM 重建。 */
     switchFlow(next) {
@@ -624,6 +807,8 @@ var __dshcfBundle = (() => {
       this.completedOnce.clear();
       this.bodyTextCache = /* @__PURE__ */ new WeakMap();
       this.dirtyMessages.clear();
+      this.auditDisplays.clear();
+      this.structureDirty = true;
       this.restoreAllDisplays();
       restoreTurnStatus(this.turnStatusTexts);
       this.flow = next;
@@ -1062,6 +1247,22 @@ var __dshcfBundle = (() => {
     unpinChipMargin(chip) {
       if (chip.style.marginBottom !== "") chip.style.marginBottom = "";
     }
+    /** 外部介入检测（issue #11 Bug A）：当前内联值 ≠ 插件最后确保值，或所有权
+     * 哨兵被 style 整体改写抹除。返回 true 时调用方放弃本次写回并交还账本——
+     * 属性级改写由值比对捕获，整体改写（cssText / setAttribute('style')）由
+     * 哨兵缺失捕获，两层合起来覆盖外部介入的两种形态。 */
+    displayForeign(el) {
+      const written = this.writtenDisplay.get(el);
+      if (written === void 0) return false;
+      return el.style.getPropertyValue(DISPLAY_OWNED_PROP) === "" || el.style.display !== written;
+    }
+    /** 清空单个元素的显示账本（三账本 + 所有权哨兵）。 */
+    releaseDisplayLedger(el) {
+      this.originalDisplay.delete(el);
+      this.writtenDisplay.delete(el);
+      this.controlledDisplay.delete(el);
+      el.style.removeProperty(DISPLAY_OWNED_PROP);
+    }
     /** 返回 true 表示启动了渐隐动画（调用方可据此决定内部元素的处置）。
      * settle 在渐隐自然结束时调用（onfinish 链；反向取消不触发）。 */
     hideElement(el, desired, animate = false, settle) {
@@ -1073,7 +1274,11 @@ var __dshcfBundle = (() => {
       }
       if (!this.originalDisplay.has(el) && !isDisplayed(el)) return false;
       if (this.hasAnimatingAncestor(el)) return false;
-      if (!this.originalDisplay.has(el)) this.originalDisplay.set(el, el.style.display);
+      if (!this.originalDisplay.has(el) || this.displayForeign(el)) {
+        this.originalDisplay.set(el, el.style.display);
+        this.writtenDisplay.set(el, el.style.display);
+        el.style.setProperty(DISPLAY_OWNED_PROP, "1");
+      }
       this.controlledDisplay.add(el);
       if (el.style.display === "none") return false;
       if (animate && this.canAnimate(el)) {
@@ -1081,6 +1286,7 @@ var __dshcfBundle = (() => {
         return true;
       }
       el.style.display = "none";
+      this.writtenDisplay.set(el, "none");
       return false;
     }
     restoreElement(el, animate = false) {
@@ -1090,14 +1296,18 @@ var __dshcfBundle = (() => {
         this.cancelPendingSync(el);
       }
       if (!this.originalDisplay.has(el)) return;
+      if (this.displayForeign(el)) {
+        this.releaseDisplayLedger(el);
+        return;
+      }
       const original = this.originalDisplay.get(el);
       if (!animate || !this.canAnimate(el) || this.hasAnimatingAncestor(el)) {
         if (el.style.display !== original) el.style.display = original;
-        this.originalDisplay.delete(el);
-        this.controlledDisplay.delete(el);
+        this.releaseDisplayLedger(el);
         return;
       }
       if (el.style.display !== original) el.style.display = original;
+      this.writtenDisplay.set(el, original);
       this.startReveal(el);
     }
     /** 是否可动画：WAAPI 特性检测 + reduced-motion 门控（均做 typeof 防桩缺失）。 */
@@ -1122,8 +1332,7 @@ var __dshcfBundle = (() => {
       anim.onfinish = () => {
         if (this.pendingAnims.get(el) !== record) return;
         this.pendingAnims.delete(el);
-        this.originalDisplay.delete(el);
-        this.controlledDisplay.delete(el);
+        this.releaseDisplayLedger(el);
         this.schedule();
       };
       anim.oncancel = () => {
@@ -1174,7 +1383,14 @@ var __dshcfBundle = (() => {
       anim.onfinish = () => {
         if (this.pendingAnims.get(el) !== record) return;
         this.pendingAnims.delete(el);
+        if (this.displayForeign(el)) {
+          this.releaseDisplayLedger(el);
+          this.schedule();
+          anim.cancel();
+          return;
+        }
         if (el.style.display !== "none") el.style.display = "none";
+        this.writtenDisplay.set(el, "none");
         settle?.();
         anim.cancel();
         this.schedule();
@@ -1204,10 +1420,31 @@ var __dshcfBundle = (() => {
         if (!desired.has(el)) this.restoreElement(el);
       }
     }
+    /** 收集 audit 需要观察的 display 集合；只读取内联样式，不触发布局计算。 */
+    collectAuditDisplays(flow) {
+      const nodes = new Set(flowItems(flow));
+      for (const el of this.controlledDisplay) {
+        if (el.isConnected && nodeWithin(el, flow)) nodes.add(el);
+      }
+      for (const { chip } of this.chips.values()) {
+        if (chip.isConnected && nodeWithin(chip, flow)) nodes.add(chip);
+      }
+      for (const row of this.mergedThinks.values()) {
+        if (row.isConnected && nodeWithin(row, flow)) nodes.add(row);
+      }
+      const displays = /* @__PURE__ */ new Map();
+      for (const el of nodes) displays.set(el, el.style.display);
+      return displays;
+    }
+    /** 在完整 pass 完成后保存 display 基线，供下一次轻量 audit 比对。 */
+    captureAuditDisplays(flow) {
+      this.auditDisplays = this.collectAuditDisplays(flow);
+    }
     restoreAllDisplays() {
       for (const el of [...this.controlledDisplay]) this.restoreElement(el);
       this.controlledDisplay.clear();
       this.originalDisplay = /* @__PURE__ */ new WeakMap();
+      this.writtenDisplay = /* @__PURE__ */ new WeakMap();
     }
   };
   function createSpan(cls) {
@@ -1410,6 +1647,15 @@ var __dshcfBundle = (() => {
     }
     return false;
   }
+  function isPluginOwnedNode(node) {
+    const element = node.nodeType === 1 ? node : node.parentElement;
+    return element !== null && element !== void 0 && element.closest(".dshcf-chip, .dshcf-processed, .dshcf-merged-think, .dshcf-merged-body") !== null;
+  }
+  function flowChildOwner(node, flow) {
+    let current = node;
+    while (current !== null && current.parentNode !== flow) current = current.parentNode;
+    return current instanceof HTMLElement ? current : null;
+  }
   function flowItems(flow) {
     return [...flow.children].filter((el) => el instanceof HTMLElement && !el.classList.contains("dshcf-processed") && !el.classList.contains("dshcf-flow-chip"));
   }
@@ -1799,8 +2045,16 @@ var __dshcfBundle = (() => {
   function isThinkRow(row) {
     return row.matches('[data-variant="think"]') && !row.hasAttribute("data-tool");
   }
+  var turnDurationCache = /* @__PURE__ */ new WeakMap();
   function parseTurnDuration(boundary) {
     const text = boundary.textContent ?? "";
+    const cached = turnDurationCache.get(boundary);
+    if (cached !== void 0 && cached.text === text) return cached.duration;
+    const duration = parseTurnDurationText(boundary, text);
+    turnDurationCache.set(boundary, { text, duration });
+    return duration;
+  }
+  function parseTurnDurationText(boundary, text) {
     const m = text.match(/用时\s*(\d+)分(\d+)秒|用时\s*(\d+)秒/);
     if (m !== null) {
       if (m[1] !== void 0 && m[2] !== void 0) return Number(m[1]) * 6e4 + Number(m[2]) * 1e3;
@@ -2132,14 +2386,16 @@ var __dshcfBundle = (() => {
 
   // src/client.ts
   var name = "dsh-auto-collapse";
-  var inject = ["slots", "settingsScope"];
+  var inject = [];
   function apply(ctx) {
     ctx.effect(() => {
-      const scope = ctx.settingsScope?.bind({ namespace: AUTO_COLLAPSE_NS });
+      const settingsScope = ctx.get?.("settingsScope");
+      const slots = ctx.get?.("slots");
+      const scope = settingsScope?.bind({ namespace: AUTO_COLLAPSE_NS });
       const controller = new FoldController(statusTextProvider(scope));
       controller.start();
       const offScope = scope?.subscribe(() => controller.refresh());
-      const offSettings = ctx.slots === void 0 || scope === void 0 ? void 0 : setupSettingsCard(ctx, scope);
+      const offSettings = slots === void 0 || scope === void 0 ? void 0 : setupSettingsCard({ slots }, scope);
       return () => {
         offScope?.();
         offSettings?.();

package/lib/index.js

@@ -1,32 +1,27 @@
-/**
- * dsh-auto-collapse — node half（构建产物，与 src/index.ts 对应）。
- *
- * Host 侧除了让插件出现在宿主插件树之外，还注册一个 `dsh-auto-collapse`
- * settings 命名空间，供浏览器端“插件配置 → 状态提示词”卡片读写。
- * 浏览器端 bundle 由 dsh.client 声明 + exports["./client"] 提供。
- */
-import z from '@deepseek-ai/schemastery'
-import { installSettingsSection, settingsNamespace } from '@deepseek-ai/dsh-settings'
-
-export const name = 'dsh-auto-collapse'
-export const inject = []
-
-const DEFAULT_STATUS_TEXT = 'Deep sleeping...'
-const AUTO_COLLAPSE_SETTINGS_NAMESPACE = settingsNamespace('dsh-auto-collapse')
-const AUTO_COLLAPSE_SETTINGS_SCHEMA = z.object({
-  statusText: z.string().default(DEFAULT_STATUS_TEXT),
-})
-
-export function apply(ctx, config = {}) {
-  let current = () => ({ statusText: config.statusText ?? DEFAULT_STATUS_TEXT })
-  installSettingsSection(ctx, AUTO_COLLAPSE_SETTINGS_NAMESPACE, AUTO_COLLAPSE_SETTINGS_SCHEMA, {
-    statusText: config.statusText ?? DEFAULT_STATUS_TEXT,
-  }, {
-    setSource: (source) => {
-      current = source
-    },
-    onChange: () => {
-      void current
-    },
-  })
-}
+import z from "@deepseek-ai/schemastery";
+import { installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
+const name = "dsh-auto-collapse";
+const inject = [];
+const DEFAULT_STATUS_TEXT = "Deep sleeping...";
+const AUTO_COLLAPSE_SETTINGS_NAMESPACE = settingsNamespace("dsh-auto-collapse");
+const AUTO_COLLAPSE_SETTINGS_SCHEMA = z.object({
+  statusText: z.string().default(DEFAULT_STATUS_TEXT)
+});
+function apply(ctx, config = {}) {
+  let current = () => ({ statusText: config.statusText ?? DEFAULT_STATUS_TEXT });
+  installSettingsSection(ctx, AUTO_COLLAPSE_SETTINGS_NAMESPACE, AUTO_COLLAPSE_SETTINGS_SCHEMA, {
+    statusText: config.statusText ?? DEFAULT_STATUS_TEXT
+  }, {
+    setSource: (source) => {
+      current = source;
+    },
+    onChange: () => {
+      void current;
+    }
+  });
+}
+export {
+  apply,
+  inject,
+  name
+};

package/lib/types/client.d.ts

@@ -0,0 +1,13 @@
+export declare const name = "dsh-auto-collapse";
+/**
+ * 不声明必需服务：slots/settingsScope 只是可选增强能力，不能阻止核心折叠
+ * 插件启动。运行时通过 ctx.get() 读取，服务不存在时仅跳过设置卡片与配置订阅。
+ */
+export declare const inject: string[];
+/** 客户端根上下文的最小结构化类型（仅用 cordis 标准 effect，无运行时依赖）。 */
+export interface FoldClientCtx {
+    effect(fn: () => unknown, label?: string): unknown;
+    /** Cordis 动态客户端上下文提供的可选服务查询。 */
+    get?<T>(name: string): T | undefined;
+}
+export declare function apply(ctx: FoldClientCtx): void;

package/lib/types/fold.d.ts

@@ -0,0 +1,264 @@
+/**
+ * FoldController —— dsh-auto-collapse 的核心。
+ *
+ * 把会话流（[data-chat-flow]）里的“非正文 display”折叠成内联的一行，
+ * 折叠行实时显示**当前正在进行的工作**（与 Codex 对齐）：
+ *
+ *   - 块里有运行中的工具调用 → 标题 = "Running" + 工具名（Bash/Read/
+ *     Search…，读 data-tool），摘要 = 正在执行的命令/路径/查询（读工具
+ *     卡片的 summary 行）；标题与摘要带平滑呼吸动画（Pulse）。
+ *   - 块里正在思考（think running）→ 标题 = "Thinking"，摘要 = 思考的
+ *     最新一行（读 [data-follow-end]，官方 ReasoningRow 的实时摘要锚点）。
+ *   - 全部完成 → 标题 = 类型总结（编辑了文件 / 运行了命令 / 已思考 /
+ *     上下文注入），摘要清空；出错 → 红色，中断 → 琥珀。
+ *
+ * 另外把官方 ChatView 尾部的运行状态行文字 "Deep diving..." 替换为
+ * 可配置的状态提示词（默认 "Deep sleeping..."；流光特效在 CSS 上，
+ * 替换文本节点不影响）。React 重渲染会恢复原文，pass() 每轮自愈改回。
+ * 设置为空时不替换，等价于恢复官方 "Deep diving..."。
+ *
+ * 点击一行展开，再点收起；折叠态下若有行被选中（详情联动）自动展开。
+ *
+ * 折叠规则（沿用 dsh-web-archive 验证过的算法）：每个回合合成一块——
+ * 某条消息的 Think 推理组与其后紧跟的工具组合并成一块（只有 think 或
+ * 只有工具组时各自成块），在块宿主**原位**插入 chip；带正文文本的消息
+ * 断开合并。结构保持 文本a - [折叠块] - 文本b - 文本c。
+ *
+ * 与 React 的关系：chip 插入 React 管理的 flow 子树内，但只做前置插入与
+ * style.display 切换（React 的 vdom diff 不会感知也不会清除 CSSOM 上的
+ * 手动样式）；MutationObserver 每轮把结构变化合并到一次
+ * requestAnimationFrame 里重放（自愈：React 重渲染、切换会话、流式新
+ * 卡片都会自动跟上）。
+ *
+ * 零核心改动：不修改任何 slot 注册，不依赖任何 client 服务。
+ */
+export declare class FoldController {
+    private observer;
+    /** 防止同一个控制器重复注册 observer、定时器和可见性监听。 */
+    private started;
+    /** body 尚未创建时等待 DOMContentLoaded，再补一次启动。 */
+    private waitingForBody;
+    private readonly onDomContentLoaded;
+    private raf;
+    private timer;
+    private disposed;
+    private lastPassError;
+    private flow;
+    /** 稳定 block key → 当前 React 渲染中的 chip/host。 */
+    private chips;
+    private currentBlocks;
+    private blockExpanded;
+    /** host → 三级合并思考行（展开二级后连续思考合并显示为一个三级行）。 */
+    private mergedThinks;
+    /** 合并思考行的展开状态（true = 显示合并内容块）。 */
+    private mergedExpanded;
+    /** 合并内容缓存（首次从原生行读取后保存，pass 重建内容块时不再重新展开原生行）。 */
+    private mergedBodyTexts;
+    /** 合并行标题缓存（原生行展开态提取不到摘要时保持首次标题，不丢成“思考”）。 */
+    private mergedTitles;
+    /** 稳定 segment key → 一级折叠行与展开状态。 */
+    private segmentStates;
+    /** segment 首次观察到 running 的时间，用于没有官方时长的实时回合。 */
+    private runningSince;
+    /** 曾完成过的 segment key：段恢复运行时据此重开本地计时，防止重新结算
+     * 的本地时长吞掉完成间隙。 */
+    private completedOnce;
+    /** 插件改写 display 前的精确原值；受控集合用于分类漂移和 stop() 恢复。 */
+    private originalDisplay;
+    private controlledDisplay;
+    /** 元素 → 插件最后确保的 display 值：恢复前与当前内联值比对，漂移即视为
+     * 外部介入（镜像 turnStatusTexts 的 original/written 双快照守卫，issue #11）。 */
+    private writtenDisplay;
+    /** 被改写为状态提示词的原生状态文本：original = 宿主原文（卸载还原用），
+     * written = 插件最后一次写入的值（仅当节点仍等于它时才还原，避免覆盖
+     * 宿主在插件写入之后的状态更新）。 */
+    private turnStatusTexts;
+    /** 当前状态提示词读取器；返回空串时插件不替换状态行。 */
+    private statusTextProvider;
+    /** 正文判定缓存（消息元素 → 有无正文）：流式期间只有被 mutation 命中的
+     * 消息失效重算，历史消息跨 pass 复用，避免每帧全量 TreeWalker。 */
+    private bodyTextCache;
+    /** 自上次 pass 以来子树发生变化的 flow 顶层消息；pass 开头统一失效。 */
+    private dirtyMessages;
+    /** 在途显示动画（元素 → 记录）：冲突仲裁、记账对齐与生命周期清理的依据。
+     * 用 Map 不用 WeakMap——switchFlow/stop 需要遍历全量 cancel。 */
+    private pendingAnims;
+    /** 手势点击的一次性可动画 block key；segment 级点击另保留中间正文的门控。 */
+    private animatableKeys;
+    /** segment 点击时只让点击前已存在的 block 播放 reveal；流式中新出现的
+     * 临时分裂块直接显示，避免分类收敛时留下半透明 stale chip。 */
+    private animatableSegmentBlocks;
+    /** 外部变更对账定时器句柄（自重排 setTimeout 链，见 armAuditLoop）。 */
+    private auditTimer;
+    /** 上一轮 pass 记录的关键元素内联 display，用于 audit 轻量检测漂移。
+     * audit 只读这份快照，不在页面稳定时重新执行完整 pass。 */
+    private auditDisplays;
+    /** 自上次 pass 以来 flow 子树发生过结构变化（childList）或正文判定翻转：
+     * 为 true 时 pass 重建分块快照，否则复用 currentBlocks——characterData/
+     * attributes 批次（流式文本、data-state 翻转）不改变块结构，跳过全量
+     * querySelectorAll 重扫（issue #14：长会话下每轮重扫造成主线程卡顿）。 */
+    private structureDirty;
+    /** 滚动稳定化（issue #14）：flow 最近的滚动容器缓存（按 flow 身份失效）。 */
+    private scrollContainer;
+    private scrollContainerFlow;
+    /** 回到前台立即补一轮对账；后台 tab 由 document.hidden 门控跳过。 */
+    private readonly onVisibilityChange;
+    constructor(statusTextProvider?: () => string | undefined, options?: {
+        auditIntervalMs?: number;
+    });
+    private readonly auditIntervalMs;
+    /** 设置变更后重跑一轮，让状态提示词立即生效。 */
+    refresh(): void;
+    start(): void;
+    /** 外部显示变更对账循环（issue #11 Bug B）：外部对宿主行的 style 写入不产生
+     * observer record（style 不在 attributeFilter 内，监听会因插件自身直写 style
+     * 自激），改用低频轻量对账兜底——发现漂移后才由 pass 收敛；
+     * 后台 tab 由 document.hidden 门控跳过，回前台由 visibilitychange 立即补一轮。
+     * 用自重排 setTimeout 链而非 setInterval：与 schedule 的兜底定时器同源，
+     * 测试桩 clearTimers 后链条自然熄灭。 */
+    private armAuditLoop;
+    private rearmAudit;
+    /** 低成本显示状态对账：只有发现外部漂移时才启动完整 pass。
+     *
+     * 外部 style.display 写入不会产生当前 observer 的 attribute 记录，
+     * 因此仍保留 audit；但稳定页面不应每秒重扫整个 flow。快照只覆盖
+     * flow 顶层行、插件控制中的宿主行和插件自有展示行，避免引入布局读取。 */
+    private audit;
+    stop(): void;
+    /** body 级 observer 只负责发现 flow 替换；已有 flow 外的文本变化不再触发全量扫描。 */
+    private shouldSchedule;
+    /** 判断 mutation 是否会影响宿主 flow；插件自有节点的回写直接忽略，
+     * 避免“pass 插入 chip → observer 再开一轮 pass”的自激循环。 */
+    private isRelevantMutation;
+    /** 记录本批 mutation 命中的 flow 顶层消息，供正文判定缓存定向失效。
+     * 从 record.target 沿 parentNode 走到 flow 的直接子级即所属消息。
+     * 失效粒度（issue #14）：只有 childList 使分块快照失效；flow 直挂层的
+     * 插件节点/文本节点与 flow 外的混批记录不影响任何消息的正文判定，跳过
+     * 而非全量失效——旧逻辑把它们全部放大成 O(全会话) 的 TreeWalker 重扫，
+     * 长会话流式期间每帧如此。空批次仍保守全量失效（测试桩的调度通知）。 */
+    private markDirty;
+    private schedule;
+    /** 异步 observer 异常不能静默杀死协调器；保留非可视诊断并允许后续 mutation 重试。 */
+    private runPass;
+    private reportError;
+    /** 一轮重放：重算堆积 → 应用折叠/展开 → 摆放并更新 chip → 替换状态行。 */
+    private pass;
+    /** flow 最近的滚动容器（issue #14 滚动稳定化的测量基准）：沿父链找第一个
+     * overflow-y 为 auto/scroll 且实际可滚动的祖先。结果按 flow 身份缓存；
+     * 找不到时不缓存（内容增长后祖先可能变为可滚动），每 pass 重探的代价
+     * 只是几次 clean-layout 的 computed style / scrollHeight 读取。 */
+    private findScrollContainer;
+    /** 几何写入前捕捉贴底意图（issue #14）：视口距底 ≤ 上游 FOLLOW_THRESHOLD
+     * 时返回锚点，stabilizeScrollAfterFold 在写入后同帧钉回底部。远离底部
+     * （用户正在滚动浏览）时不干预——视口上方的高度变化由浏览器 scroll
+     * anchoring 补偿，视口下方的折叠不可见，插件再写 scrollTop 只会加入
+     * 上游吸底回写的拉锯。 */
+    private captureScrollAnchor;
+    /** 几何写入后把贴底视口钉回底部：折叠让 scrollHeight 缩小时若不在此帧
+     * 补写 scrollTop，宿主 ChatView 要到下一帧 ResizeObserver 才吸底回写，
+     * 中间的空档让触控板惯性滚动乘虚而入，反复折叠时表现为上下抽搐（用户
+     * 实测：长会话滚到底部附近无法稳定定位）。同一帧内钉回后，宿主的吸底
+     * 回写成为幂等 no-op，不再是第二个 scrollTop 写入方。 */
+    private stabilizeScrollAfterFold;
+    /** flow 元素变化即视为会话切换：完整恢复旧 flow，再从新 DOM 重建。 */
+    private switchFlow;
+    private createProcessedRow;
+    private syncProcessedRow;
+    private placeProcessedRow;
+    private reconcileBlock;
+    private ensureChip;
+    private suppressBlock;
+    private retainDisplayControl;
+    private cleanupStaleChips;
+    /** 连续思考合并行：插在第一个思考行前，标题用第一行思考内容；
+     * 点击切换显示/隐藏全部原始思考行。 */
+    private syncMergedThink;
+    /** 展开合并行：直接读各思考行文本合成内容块（不依赖原生行展开：
+     * 程序化 click 不触发 React 展开，且后台 tab 的 rAF 不执行）。
+     * 返回是否成功——思考行已不可读（parts 为空）时返回 false，调用方
+     * 据此保持收起态，避免展开状态与内容块脱节。 */
+    private expandMergedBody;
+    /** 创建/更新合并内容块（缓存优先，不重新展开原生行）。
+     * 返回内容块与其是否为本次新建（新建才走展开动画）。 */
+    private ensureMergedBody;
+    /** 清理合并 think 行（v12）：状态 map 立即清除；DOM 在手势动画路径下
+     * 渐隐后移除（settle 回调），其余路径瞬删。渐隐中途被反向取消时元素
+     * 保留，由后续 pass 的 syncMergedThink 重建/复用。
+     * settle 透传给每个渐隐目标的移除回调之后（chip 间距钉住的结算探测点，
+     * AI 评审 P0：merged 行渐隐不走 block.rows，必须纳入同一钉住体系）。 */
+    private releaseMergedThink;
+    /** merged-body 展开高度动画（机制样板：插件全资 DOM）。
+     * 关键帧含 marginBottom 0→16px——其 CSS 有常量 margin-bottom:16px，
+     * 高度从 0 起步时这 16px 会先占位产生小跳变。fill:'forwards' 托住终态，
+     * onfinish 清内联后 cancel 释放，无闪烁窗口。收起由 collapseMergedBody
+     * 做镜像高度卷下（同款账本与身份守卫），开合对称。 */
+    private revealMergedBody;
+    /** 收起合并行：内容块高度卷下后移除——镜像 revealMergedBody 的唯一几何动画，
+     * 开合对称。插件全资静态文本 DOM、无 React 协调竞争，可安全做几何收起
+     * （与 seat 级拒绝盲卷的场景不同：那里是 React 混杂多卡片）。
+     * reduced-motion / 无 WAAPI / 零高度降级为同步 remove()。 */
+    private collapseMergedBody;
+    /** 当前宿主内的思考行（现取，React 重渲染后引用仍然有效）。 */
+    private currentThinkRows;
+    /** 移除合并思考行（二级收起 / 一级收起时），恢复行由 applyRows 控制。
+     * 合并内容块（btn 的兄弟节点）一并移除，避免宿主展开后残留文本。 */
+    private removeMergedThink;
+    /** 正文判定（带缓存）：同一消息子树未变时直接复用上次结果。失效由
+     * markDirty（mutation 定向）与 switchFlow（整体重置）驱动；缓存的是
+     * 纯文本/媒体存在性判定，与 display 状态无关，插件自身的显隐切换
+     * 不会产生脏数据。 */
+    private hasBodyCached;
+    /** 本块是否有在途收起渐隐（rows/containers/merged 行/body 任一）。
+     * 基于 pendingAnims 账本无状态判定：onfinish/oncancel 都会即时清账，
+     * 取消路径天然解锁（计数器/最后注册者会卡死）。merged 行渐隐时已被
+     * releaseMergedThink 摘出 mergedThinks，按 DOM 类名现查。 */
+    private hasPendingCollapse;
+    /** 钉住 chip 与首行的 16px 间距（收起 fade 期间；内联优先于 aria=false 的 0）。
+     * flow-chip（context 等 before-mounted）豁免：其间距由宿主 row-gap 16px
+     * 提供、自身 CSS 恒 0，钉住 16px 会叠加成 32px（真机实测：收起上下文
+     * 注入时二级与三级间距瞬间扩大）。
+     */
+    private pinChipMargin;
+    /** 解除钉住（aria=true 的 16px 或 aria=false 的 0 由 CSS 接管）。 */
+    private unpinChipMargin;
+    /** 外部介入检测（issue #11 Bug A）：当前内联值 ≠ 插件最后确保值，或所有权
+     * 哨兵被 style 整体改写抹除。返回 true 时调用方放弃本次写回并交还账本——
+     * 属性级改写由值比对捕获，整体改写（cssText / setAttribute('style')）由
+     * 哨兵缺失捕获，两层合起来覆盖外部介入的两种形态。 */
+    private displayForeign;
+    /** 清空单个元素的显示账本（三账本 + 所有权哨兵）。 */
+    private releaseDisplayLedger;
+    /** 返回 true 表示启动了渐隐动画（调用方可据此决定内部元素的处置）。
+     * settle 在渐隐自然结束时调用（onfinish 链；反向取消不触发）。 */
+    private hideElement;
+    private restoreElement;
+    /** 是否可动画：WAAPI 特性检测 + reduced-motion 门控（均做 typeof 防桩缺失）。 */
+    private canAnimate;
+    /** 展开方向淡入（opacity + 4px 微位移）：无高度分量、零布局读取。
+     * onfinish 按终态可见对齐账本（双删除）并 schedule() 幂等重同步；
+     * oncancel 只做身份守卫删除——取消方的终态写入自己负责。 */
+    private startReveal;
+    /** 同步取消在途动画并清账：收起动画需同时清锁高内联（height/overflow/
+     * marginBottom），否则取消方写完终态后元素仍被锁高裁剪一帧以上。 */
+    private cancelPendingSync;
+    private clearCollapseLock;
+    /** 祖先 seat 在途动画检测：沿 parentNode 走到 flow，任一祖先在 pendingAnims
+     * 即视为在途。分层规则——同一视觉变化只动画一层。 */
+    private hasAnimatingAncestor;
+    /** 收起方向渐隐动画（v11 定稿）：镜像 reveal 的 opacity + 4px 微位移，
+     * 淡完 onfinish 写 display:none 并保持双条目（镜像 hideElement 终态契约）。
+     * fill:'forwards' 占位到终态写入后释放；无几何锁、无 gap 补偿。 */
+    private startFadeCollapse;
+    /** 轻量视觉 reveal（opacity + 4px 微位移）：用于插件全资元素的即时显示
+     * 路径——chip（一级展开时出现）与 merged-think 行（二级展开时出现）。
+     * 这些元素的 display 完全由插件直写、无 React 协调竞争，因此不入
+     * pendingAnims 账本、无仲裁；收起同为直写 display:none，无 fill 的在途
+     * 动画残留在隐藏元素上自然失效。门控沿用 animate 布尔（手势路径才调）。 */
+    private revealVisual;
+    private restoreUnusedDisplays;
+    /** 收集 audit 需要观察的 display 集合；只读取内联样式，不触发布局计算。 */
+    private collectAuditDisplays;
+    /** 在完整 pass 完成后保存 display 基线，供下一次轻量 audit 比对。 */
+    private captureAuditDisplays;
+    private restoreAllDisplays;
+}

package/lib/types/index.d.ts

@@ -1,22 +1,11 @@
-/**
- * dsh-auto-collapse — host half 类型声明。
- *
- * 注册 `dsh-auto-collapse` settings 命名空间，供浏览器端插件配置卡片读写；
- * 浏览器端 bundle 通过 package.json 的 dsh.client 声明 + exports["./client"]
- * 被 dsh web 的 client-modules 服务发现并注入页面。
- */
-
-/** Host 插件名。 */
-export declare const name: 'dsh-auto-collapse'
-
-/** Host 侧不注入额外服务。 */
-export declare const inject: string[]
-
-/** 插件配置。 */
-export interface Config {
-  /** 自定义状态提示词；留空恢复官方 "Deep diving..."。 */
-  statusText?: string
-}
-
-/** Host 插件体：注册设置命名空间。 */
-export declare function apply(ctx: unknown, config?: Config): void
+/** Host 插件名。 */
+export declare const name = "dsh-auto-collapse";
+/** Host 侧不注入额外服务；settings 是可选的运行能力，由 installSettingsSection 惰性接入。 */
+export declare const inject: string[];
+/** 插件配置。 */
+export interface Config {
+    /** 自定义状态提示词；留空恢复官方 "Deep diving..."。 */
+    statusText?: string;
+}
+/** Host 插件体：注册设置命名空间。 */
+export declare function apply(ctx: unknown, config?: Config): void;

package/lib/types/settings.d.ts

@@ -0,0 +1,41 @@
+/**
+ * dsh-auto-collapse — 插件配置卡片。
+ *
+ * 在 DSH Web 设置 → 插件 → 插件配置 中追加“状态提示词”卡片，编辑
+ * dsh-auto-collapse 的 settings 命名空间。卡片只做暂存与保存，不改动
+ * 业务逻辑；运行时文字替换由 FoldController 读取同一 scope 后实时生效。
+ */
+/** settings 命名空间。Host 侧与客户端侧使用同一个值才能配对出现。 */
+export declare const AUTO_COLLAPSE_NS = "dsh-auto-collapse";
+/** 默认状态提示词。 */
+export declare const DEFAULT_STATUS_TEXT = "Deep sleeping...";
+/** 客户端 settings scope 的最小结构化类型。 */
+export interface SettingsScopeLike {
+    getSnapshot(): {
+        status: 'loading' | 'ready' | 'unavailable';
+        value?: Record<string, unknown>;
+        base?: Record<string, unknown>;
+        user?: Record<string, unknown>;
+        writable: boolean;
+    };
+    subscribe(listener: () => void): () => void;
+    set(field: string, value: unknown): Promise<void>;
+    unset(field: string): Promise<void>;
+}
+/** 客户端 slots 服务的最小结构化类型。 */
+export interface SlotsLike {
+    inject(key: string, callback: () => unknown): () => void;
+    register(options: {
+        name: string;
+        key: string;
+        inject: () => unknown;
+    }, renderer: (props: {
+        scope: SettingsScopeLike;
+    }) => unknown): unknown;
+}
+/** 从绑定的 settings scope 构造实时状态提示词读取器。 */
+export declare function statusTextProvider(scope: SettingsScopeLike | undefined): () => string | undefined;
+/** 向 DSH 插件配置页注册“状态提示词”卡片。 */
+export declare function setupSettingsCard(ctx: {
+    slots: SlotsLike;
+}, scope: SettingsScopeLike): () => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-auto-collapse",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "DeepSeek Harness Web 客户端插件：把会话里的工具卡片与 Think 推理块折叠成一行，折叠态实时显示当前正在进行的工作（工具名 + 正在执行的命令/参数、或思考内容），运行中带流光动画；点击展开/收起。让界面只保留模型说的话。",
   "type": "module",
   "main": "lib/index.js",
@@ -11,7 +11,7 @@
       "default": "./lib/index.js"
     },
     "./client": {
-      "types": "./lib/types/client/index.d.ts",
+      "types": "./lib/types/client.d.ts",
       "default": "./lib/client.js"
     },
     "./package.json": "./package.json"

package/lib/types/client/index.d.ts

@@ -1,16 +0,0 @@
-/**
- * dsh-auto-collapse — browser half 类型声明。
- *
- * 折叠会话里的工具卡片与 Think 推理块；把官方 "Deep diving..." 运行状态行
- * 替换为可配置的状态提示词（默认 "Deep sleeping..."，为空时不替换）。
- * 同时注册 DSH 设置 → 插件 → 插件配置的“状态提示词”卡片。
- */
-
-/** 客户端根上下文的最小结构化类型（仅用 cordis 标准 effect，运行时通过 slot 注册配置卡片）。 */
-export interface FoldClientCtx {
-  effect(fn: () => unknown, label?: string): unknown
-}
-
-export declare const name: string
-export declare const inject: string[]
-export declare function apply(ctx: FoldClientCtx): void