dsh-sessions-manager 3.7.6 → 3.7.7

package/lib/index.js

@@ -2039,7 +2039,7 @@ function emptyScanCandidate(sizeBytes) {
 }
 
 // src/index.js
-var BUILD_STAMP = true ? "3.7.6+68c2ab69" : "dev";
+var BUILD_STAMP = true ? "3.7.7+89abb735" : "dev";
 var name = "dsh-sessions-manager";
 var inject = ["webServer", "workspaceRegistry", "sessionPersistence", "sessionQuery", "storageDomain"];
 var MAX_TITLE = 80;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-sessions-manager",
   "description": "DSH 设置面板会话管理器：归档 / 恢复 / 彻底删除 / 移动到其他工作区，带工作区标签与会话日期；统一「会话管理」面板。Session manager for the DeepSeek Harness settings panel — archive / restore / permanently delete / move sessions across workspaces, with workspace tags & session dates in one unified panel.",
-  "version": "3.7.6",
+  "version": "3.7.7",
   "type": "module",
   "main": "lib/index.js",
   "exports": {

package/src/client/index.jsx

@@ -11,7 +11,7 @@
  */
 
 import React, { useEffect, useMemo, useRef, useState } from 'react'
-import { applyTagFilter, canDropOnWorkspace, dotStateFor, effectiveTitleOf, filterShapeFromSaved, filterSnapshotOf, foldBranches, foldSubagents, noticeToastPlan, openSubagentToast, pathTail, sessionForNodes, shortId, starredOf, tagDeleteConfirm, titleBackfillDecision, toastDurationFor, workspaceForNodes } from './logic.js'
+import { aliveSessionCount, applyTagFilter, canDropOnWorkspace, countRenderedVisible, dotStateFor, effectiveTitleOf, filterShapeFromSaved, filterSnapshotOf, foldBranches, foldSubagents, noticeToastPlan, openSubagentToast, overflowPlan, pathTail, remainingRows, sessionForNodes, shortId, starredOf, tagDeleteConfirm, titleBackfillDecision, toastDurationFor, workspaceForNodes } from './logic.js'
 
 export const inject = ['slots']
 
@@ -2726,6 +2726,24 @@ function dsmTeardownSidebarAug() {
   for (const sel of selectors) {
     try { document.querySelectorAll(sel).forEach((el) => el.remove()) } catch (e) { /* best-effort */ }
   }
+  try {
+    // issue #16：被隐藏的会话行与展开按钮在卸载时还原——adapter 停用（上游
+    // 改版）或插件停用后，不能把「看不见的会话」留在官方侧栏上。
+    document.querySelectorAll('[data-dsm-hidden]').forEach((row) => {
+      row.style.display = ''
+      row.removeAttribute('data-dsm-hidden')
+    })
+    document.querySelectorAll('[data-dsm-overflow-hidden], [data-dsm-overflow-base]').forEach((btn) => {
+      // 文案可能被我们改写过：dataset 里存着上游原文，卸载时连文案一起还原。
+      const base = btn.getAttribute('data-dsm-overflow-base')
+      if (base != null && btn.textContent !== base) btn.textContent = base
+      btn.style.display = ''
+      btn.removeAttribute('data-dsm-overflow-hidden')
+      btn.removeAttribute('data-dsm-overflow-base')
+      btn.removeAttribute('data-dsm-overflow-write')
+      btn.removeAttribute('data-dsm-overflow-ver')
+    })
+  } catch (e) { /* best-effort */ }
   try {
     document.querySelectorAll('[data-dsm-group-hidden]').forEach((owner) => {
       owner.style.display = owner.dataset.dsmPrevDisplay || ''
@@ -2770,11 +2788,26 @@ function createSidebarAdapter() {
     }
     return out
   }
+  // 只取 `group` 的静默识别：命中即停，**不参与 miss 预算**。展开计数的
+  // workspace 行识别属非关键路径（拿不到就保持上游原文案），不能让它的落空
+  // 把整套侧栏增强熔断；命中即返也省掉继续上溯整条 fiber 链。
+  const recognizeGroupQuiet = (row) => {
+    if (disabled || !row || typeof row !== 'object') return null
+    let f = findFiber(row)
+    let guard = 0
+    while (f && guard++ < 300) {
+      const props = f.memoizedProps
+      if (props && props.group && typeof props.group === 'object') return props.group
+      f = f.return
+    }
+    return null
+  }
   return {
     version: SIDEBAR_ADAPTER_VERSION,
     get disabled() { return disabled },
     findFiber,
     recognize,
+    recognizeGroupQuiet,
   }
 }
 const sidebarAdapter = createSidebarAdapter()
@@ -3060,6 +3093,25 @@ function installSidebarSessionMenuAug() {
 function installSidebarStatusDots() {
   if (typeof document === 'undefined') return
   const DOT = 'data-dsm-dot'
+  // issue #16：被插件隐藏的行打标记；展开计数的扣减统计靠它（数据层不可用时兜底）。
+  const DSM_HIDDEN_ATTR = 'data-dsm-hidden'
+  // 空分组：整组被我们藏起时打在**分组容器**上的标记（见 dsmSyncEmptyGroups）。
+  const GROUP_UNIT_ATTR = 'data-dsm-group-hidden'
+  // 展开按钮上的数据集：上游原文（基线）、上次写入值、口径版本、是否被我们藏起。
+  const DSM_OVERFLOW_BASE = 'data-dsm-overflow-base'
+  const DSM_OVERFLOW_WRITE = 'data-dsm-overflow-write'
+  const DSM_OVERFLOW_VER = 'data-dsm-overflow-ver'
+  const DSM_OVERFLOW_HIDDEN = 'data-dsm-overflow-hidden'
+  let overflowDebugged = false
+  const debugOverflowOnce = (msg) => {
+    if (overflowDebugged) return
+    overflowDebugged = true
+    try { console.debug('[dsh-sessions-manager] 展开计数：' + msg) } catch (e) { /* 控制台不可用 */ }
+  }
+  // 展开按钮的文案基线 / 上次写入值存在 dataset（而非 WeakMap）：HMR / 插件
+  // 重装后新闭包里 WeakMap 是空的，会把「已扣减的文案」再当上游原文扣一次；
+  // dataset 跟随节点存活，卸载时还能据此还原原文案。data-dsm-* 不在
+  // MutationObserver 的 attributeFilter 里，不会自触发重绘。
   if (!document.querySelector('style[data-dsm=aug]')) {
     const s = document.createElement('style')
     s.dataset.dsm = 'aug'
@@ -3093,37 +3145,250 @@ function installSidebarStatusDots() {
   // 行；官方（重命名等）改写文本后所有权移交，绝不覆盖 DSH Core 的实时更新。
   const titleBaselines = new WeakMap()
   // 空分组兜底：DSH 会把「日志已不在原处」的会话重新归到「未分组」组里（删
-  // 除后最明显）。我们把行隐藏了，但空组标题会留下来——所以组内所有行都被
-  // 隐藏时，把整个分组（含它的标题行）一起隐藏；组内重新出现可见行时自动
-  // 还原。只在「组内确实有行」时才判定，避免把正在加载的空组误藏。
-  // 原 display 记在 owner 的 dataset 上（见下方 dsmSyncEmptyGroups）。
-  function dsmSyncEmptyGroups() {
-    let groups = null
-    try { groups = document.querySelectorAll('[role="group"]') } catch (e) { return }
-    if (!groups || !groups.length) return
-    groups.forEach((g) => {
-      const items = g.querySelectorAll('[role="treeitem"]')
-      if (!items.length) return
-      let visible = 0
-      items.forEach((it) => { if (it.style.display !== 'none') visible++ })
-      // ARIA tree：group 通常嵌在它的标题 treeitem 里，藏标题即藏整组。
-      // 原 display 存进 dataset（而非 WeakMap）：清场/还原函数无法遍历
-      // WeakMap，dataset 让「谁被我们藏过、原来是什么」随时可查可还原。
-      const owner = g.closest('[role="treeitem"]') || g
-      if (visible === 0) {
-        if (!owner.hasAttribute('data-dsm-group-hidden')) {
-          owner.dataset.dsmPrevDisplay = owner.style.display || ''
-          owner.setAttribute('data-dsm-group-hidden', '')
-        }
-        if (owner.style.display !== 'none') owner.style.display = 'none'
-      } else if (owner.hasAttribute('data-dsm-group-hidden')) {
-        const prev = owner.dataset.dsmPrevDisplay || ''
-        if (owner.style.display !== prev) owner.style.display = prev
-        owner.removeAttribute('data-dsm-group-hidden')
-        delete owner.dataset.dsmPrevDisplay
+  // 除后最明显）。我们把行隐藏了，但空组标题会留下来——所以组内没有**可能
+  // 出现**的会话时，把整个分组容器一起隐藏；重新出现时自动还原。
+  //
+  // 容器定位：各版本的顶层分组容器都没有稳定的 role/class —— `role="group"`
+  // 从 0.1.7 到 0.2.1 只出现在**子分组**容器上（一个包着整段子分组的 div），
+  // 顶层分组是无 role 的普通 div（`groupSection`）。所以以
+  // `data-row-key="workspace:*"`（0.1.7 起稳定）为锚点，取它的父元素当容器：
+  // 本组的会话行与展开按钮都是这个容器的子节点。
+  //
+  // 判定走数据层（与展开计数同一口径）：只有 group.sessions 里「非空白、且
+  // 不在回收站/墓碑/空白集合」的条数确实为 0 才藏。只看 DOM 会把「上游折叠
+  // 后还没渲染出来的可见会话」误判成空组，连标题带展开按钮一起藏掉——那些
+  // 会话就再也点不到了。
+  //
+  // 原 display 记在容器的 dataset 上（而不是 WeakMap）：还原路径无法遍历
+  // WeakMap，dataset 让「谁被我们藏过、原来是什么」随时可查可还原。
+  const setGroupHidden = (scope, hidden) => {
+    if (hidden) {
+      if (!scope.hasAttribute(GROUP_UNIT_ATTR)) {
+        scope.dataset.dsmPrevDisplay = scope.style.display || ''
+        scope.setAttribute(GROUP_UNIT_ATTR, '')
       }
+      if (scope.style.display !== 'none') scope.style.display = 'none'
+      return
+    }
+    if (!scope.hasAttribute(GROUP_UNIT_ATTR)) return
+    const prev = scope.dataset.dsmPrevDisplay || ''
+    if (scope.style.display !== prev) scope.style.display = prev
+    scope.removeAttribute(GROUP_UNIT_ATTR)
+    delete scope.dataset.dsmPrevDisplay
+  }
+  // 元素自身到 stopAt（不含）之间有没有被藏起来。只看我们自己的两处标记与
+  // style.display：不碰 getComputedStyle（每帧调用的代价太高）。
+  const isShownWithin = (el, stopAt) => {
+    let node = el
+    while (node && node !== stopAt) {
+      if (node.style && node.style.display === 'none') return false
+      if (node.hasAttribute && (node.hasAttribute(GROUP_UNIT_ATTR) || node.hasAttribute(DSM_HIDDEN_ATTR))) return false
+      node = node.parentElement
+    }
+    return true
+  }
+  function dsmSyncEmptyGroups(purgedNow) {
+    let rows = null
+    try { rows = document.querySelectorAll('[role="treeitem"][data-row-key^="workspace:"]') } catch (e) { return }
+    if (!rows || !rows.length) return
+    const purged = purgedNow instanceof Set ? purgedNow : new Set()
+    // 被插件藏起来的 id 集合只在真的需要判定时建一次（绝大多数帧用不到）。
+    let hiddenIds = null
+    const hiddenIdSet = () => {
+      if (hiddenIds) return hiddenIds
+      hiddenIds = new Set()
+      if (dsmTrashIds) for (const id of dsmTrashIds) hiddenIds.add(id)
+      for (const id of purged) hiddenIds.add(id)
+      for (const [id, info] of dsmLineage.entries()) if (info && info.empty) hiddenIds.add(id)
+      return hiddenIds
+    }
+    rows.forEach((row) => {
+      try {
+        const scope = row.parentElement
+        if (!scope || scope === document.body) return
+        // 容器必须是无 role 的普通元素（顶层分组）。子分组容器 role="group"
+        // 里装的是整段子分组，不能当组容器用——拿它当容器会把整段子分组藏掉。
+        if (typeof scope.getAttribute !== 'function' || scope.getAttribute('role')) return
+        // 组内还有没被我们藏起来的会话行 → 绝不藏（也顺手还原）。
+        let rendered = 0
+        for (const el of scope.children) {
+          if (el === row || !el.getAttribute) continue
+          if (el.getAttribute('role') !== 'treeitem') continue
+          if (!(el.getAttribute('data-row-key') || '').startsWith('session:')) continue
+          if (el.hasAttribute(DSM_HIDDEN_ATTR)) continue
+          rendered++
+        }
+        if (rendered > 0) { setGroupHidden(scope, false); return }
+        // 容器里可能还挂着子分组（上游把嵌套工作区渲染在 role="group" 的
+        // div 里）。只要还有子分组对用户可见，就绝不能藏父容器——那会把整
+        // 段子分组一起带走。
+        for (const nested of scope.querySelectorAll('[data-row-key^="workspace:"]')) {
+          if (nested === row) continue
+          if (!isShownWithin(nested, scope)) continue
+          setGroupHidden(scope, false)
+          return
+        }
+        // 渲染行全被我们藏了（或一行都没渲染）：只有数据层能证明「真空」才藏。
+        // 拿不到 group.sessions / 数组为空 = 不知道 → 按非空处理，保持显示。
+        const group = sidebarAdapter.recognizeGroupQuiet(row)
+        const sessions = group && Array.isArray(group.sessions) ? group.sessions : null
+        setGroupHidden(scope, aliveSessionCount(sessions, hiddenIdSet()) === 0)
+      } catch (e) { /* 单组失败不影响其它组 */ }
     })
   }
+  // issue #16：「展开其余 N 个会话」的 N 是上游按数据层算的（0.2.0-rc.2 叫
+  // collapsedSessionRows，0.2.1-rc.2 改叫 watermarkRows），它看不到插件用
+  // display:none 藏起来的回收站/空白行，于是 N 虚高；点开只是把更多已隐藏行
+  // 塞进 DOM，画面不动，很像「会话丢了」。
+  //
+  // 只改**文案与显隐**，不碰上游的展开状态机（watermark / 点击行为），也不改
+  // 任何行自身的可见性判定。
+  //
+  // 口径（F1）：上游 N 是「水位线之外未渲染的行数」，和「整组被插件藏起来的
+  // 行数」不重叠，相减会重复扣减、点开一次就翻负，把仍有可见行的按钮藏掉
+  // （上游只有这一个展开入口 → 会话不可达）。这里改用
+  //   还能出现几行 = 本组可见总数（非 blank、且不会被插件藏）- 已渲染可见行数
+  // 空白行两边都排除（F2）：上游 watermarkRows 里 `if (session.blank) return true`
+  // —— 空白行永远保留、从不计入 N。
+  //
+  // 数据层拿不到 group.sessions 时**什么都不改**（F6）：DOM 兜底在数学上不成立，
+  // 写一个看起来合理却会算错的数比不改更糟。
+  const OVERFLOW_SIGS = new WeakMap()
+  // 签名只看「便宜且能反映变化」的量：本组已渲染可见会话行（数量 + 首尾 id）、
+  // 按钮自身文案与显隐、三个集合的大小。流式输出时 paint 每帧都跑，但侧栏结构
+  // 绝大多数帧没变 —— 命中签名就直接跳过 fiber 走链（F4）。
+  const overflowSignature = (scope, btn, purgedNow) => {
+    let n = 0
+    let firstKey = ''
+    let lastKey = ''
+    for (const el of scope.children) {
+      if (el === btn || !el.getAttribute) continue
+      const k = el.getAttribute('data-row-key') || ''
+      if (!k.startsWith('session:')) continue
+      if (el.hasAttribute(DSM_HIDDEN_ATTR)) continue
+      n++
+      if (!firstKey) firstKey = k
+      lastKey = k
+    }
+    return n + '|' + firstKey + '|' + lastKey + '|' + (btn.textContent || '') + '|' + (btn.style.display || '') +
+      '|' + (dsmTrashIds ? dsmTrashIds.size : -1) + '|' + purgedNow.size + '|' + dsmLineage.size
+  }
+  function dsmSyncOverflowLabels(purgedNow) {
+    let buttons = null
+    try { buttons = document.querySelectorAll('[data-row-key^="overflow:"]') } catch (e) { return }
+    if (!buttons || !buttons.length) return
+    try {
+      buttons.forEach((btn) => {
+        // 工作区标题行与本组的会话行同属一个 groupSection（上游 renderGroup 的
+        // 直接子节点；子分组在另一个 role=group 容器里）→ 只按直接子节点找，
+        // 不再做全文档属性前缀扫描。
+        const scope = btn.parentElement
+        if (!scope || !scope.children) return
+        const sig = overflowSignature(scope, btn, purgedNow)
+        if (OVERFLOW_SIGS.get(btn) === sig) return
+        const key = (btn.getAttribute('data-row-key') || '').slice('overflow:'.length)
+        let wsRow = null
+        for (const el of scope.children) {
+          if (el.getAttribute && el.getAttribute('data-row-key') === 'workspace:' + key) { wsRow = el; break }
+        }
+        const group = wsRow ? sidebarAdapter.recognizeGroupQuiet(wsRow) : null
+        const nodes = group && Array.isArray(group.sessions) ? group.sessions : null
+        if (!nodes) {
+          // 数据层不可用：还原成上游原文案并放开按钮，绝不猜数字。
+          restoreOverflowButton(btn)
+          OVERFLOW_SIGS.set(btn, overflowSignature(scope, btn, purgedNow))
+          return
+        }
+        // 本组「上游会列出、且不会被插件藏起来」的会话集合。
+        const ids = new Set()
+        for (const node of nodes) {
+          if (!node || node.blank) continue
+          const id = node.id != null ? String(node.id) : ''
+          if (!id) continue
+          if ((dsmTrashIds && dsmTrashIds.has(id)) || purgedNow.has(id)) continue
+          const li = dsmLineage.get(id)
+          if (li && li.empty) continue
+          ids.add(id)
+        }
+        // 已渲染进 DOM 的可见行：只认本组直接子节点里不在隐藏标记中的会话行。
+        // 用 `data-dsm-hidden` 而非 style.display 判定——上游折叠父级时行自身
+        // 的 display 仍是空串，按 style 判会把看不见的行算成已渲染。
+        const rendered = []
+        for (const el of scope.children) {
+          if (el === btn || !el.getAttribute) continue
+          if (el.getAttribute('role') !== 'treeitem') continue
+          const k = el.getAttribute('data-row-key') || ''
+          if (!k.startsWith('session:')) continue
+          rendered.push({ id: k.slice('session:'.length), pluginHidden: el.hasAttribute(DSM_HIDDEN_ATTR) })
+        }
+        // 空集/口径不匹配的保护：数据层说「一条都没有」但 DOM 里明明有会话行，
+        // 说明 group.sessions 的语义变了（懒加载、上游又换了过滤条件）。此时按
+        // 未知处理，绝不能算出 0 把按钮藏掉 —— 那是把可见会话变成不可达。
+        if (!nodes.length || (!ids.size && rendered.length)) {
+          restoreOverflowButton(btn)
+          OVERFLOW_SIGS.set(btn, overflowSignature(scope, btn, purgedNow))
+          return
+        }
+        const renderedVisible = countRenderedVisible(rendered, ids)
+        const more = remainingRows(ids.size, renderedVisible)
+        applyOverflowPlan(btn, more, '可见 ' + ids.size + ' / 已渲染 ' + renderedVisible)
+        OVERFLOW_SIGS.set(btn, overflowSignature(scope, btn, purgedNow))
+      })
+    } catch (e) {
+      // 非关键路径：失败就保持上游原样，不影响本次 paint 的其它注入（F5）。
+      try { console.debug('[dsh-sessions-manager] 展开计数校准跳过：' + (e && e.message)) } catch (e2) {}
+    }
+  }
+  // 把计划落到按钮上：文案基线 / 上次写入值 / 口径版本都记在 dataset
+  // （F8：跨版本残留的旧基线不会延续到下个版本），HMR 重装后也不会二次处理。
+  function applyOverflowPlan(btn, more, detail) {
+    const raw = btn.textContent || ''
+    const ver = String(SIDEBAR_ADAPTER_VERSION)
+    const fresh = btn.getAttribute(DSM_OVERFLOW_VER) === ver
+    const last = fresh ? btn.getAttribute(DSM_OVERFLOW_WRITE) : null
+    let baseline = fresh ? btn.getAttribute(DSM_OVERFLOW_BASE) : null
+    // 首次见到，或上游重渲染换了文案（含点击展开后的新 N）→ 以当前文案为新基准。
+    if (baseline == null || raw !== last) baseline = raw
+    btn.setAttribute(DSM_OVERFLOW_BASE, baseline)
+    btn.setAttribute(DSM_OVERFLOW_VER, ver)
+    // F3：上游 N 藏在基线文案里。若我们算出的「还能出现几行」反而比上游 N 大，
+    // 说明数据层与 DOM 的口径已经不一致（上游改了 group.sessions 的过滤语义、
+    // 或将来插件改用官方归档 API）——收敛回上游 N 并留一条 debug，把「静默
+    // 失效」变成可观测。注意必须用**基线**里的 N：当前文案可能是我们写过的值。
+    const bm = baseline.match(/(\d[\d,]*)/)
+    const upstream = bm ? Number(bm[1].replace(/,/g, '')) : null
+    if (more != null && upstream != null && upstream > 0 && more > upstream) {
+      more = upstream
+      debugOverflowOnce((detail || '') + '，超过上游计数 ' + upstream + '，已按上游计数收敛')
+    }
+    const plan = overflowPlan(baseline, more)
+    if (plan.hide) {
+      if (btn.style.display !== 'none') btn.style.display = 'none'
+      if (!btn.hasAttribute(DSM_OVERFLOW_HIDDEN)) btn.setAttribute(DSM_OVERFLOW_HIDDEN, '')
+      btn.setAttribute(DSM_OVERFLOW_WRITE, baseline)
+      return
+    }
+    if (btn.hasAttribute(DSM_OVERFLOW_HIDDEN)) {
+      btn.style.display = ''
+      btn.removeAttribute(DSM_OVERFLOW_HIDDEN)
+    }
+    if (plan.changed) {
+      // 同值不写：写入会触发 characterData 观察 → 重绘，必须保持幂等。
+      if (btn.textContent !== plan.text) btn.textContent = plan.text
+      btn.setAttribute(DSM_OVERFLOW_WRITE, plan.text)
+    } else {
+      if (btn.textContent !== baseline) btn.textContent = baseline
+      btn.setAttribute(DSM_OVERFLOW_WRITE, baseline)
+    }
+  }
+  function restoreOverflowButton(btn) {
+    const verbatim = btn.getAttribute(DSM_OVERFLOW_BASE)
+    if (verbatim != null && btn.textContent !== verbatim) btn.textContent = verbatim
+    if (btn.hasAttribute(DSM_OVERFLOW_HIDDEN)) {
+      btn.style.display = ''
+      btn.removeAttribute(DSM_OVERFLOW_HIDDEN)
+    }
+  }
   const paint = () => {
     if (sidebarAdapter.disabled) return
     // Recompute the active session on every paint so the active row is never
@@ -3169,6 +3434,10 @@ function installSidebarStatusDots() {
       const purged = purgedNow
       if ((dsmTrashIds && dsmTrashIds.has(id)) || purged.has(id)) {
         if (row.style.display !== 'none') row.style.display = 'none'
+        // issue #16：标记「这一行是插件隐藏的」，供展开计数扣减使用（数据层
+        // 拿不到 group.sessions 时也能按 DOM 兜底统计）。属性不进 observer 的
+        // attributeFilter，不会自触发重绘。
+        if (row.getAttribute(DSM_HIDDEN_ATTR) !== 'trash') row.setAttribute(DSM_HIDDEN_ATTR, 'trash')
         const d = row.querySelector('[' + DOT + ']'); if (d) d.remove()
         dsmDropSubList(row, id)
         return
@@ -3201,11 +3470,15 @@ function installSidebarStatusDots() {
       }
       if (hideLineage) {
         if (row.style.display !== 'none') row.style.display = 'none'
+        if (row.getAttribute(DSM_HIDDEN_ATTR) !== 'empty') row.setAttribute(DSM_HIDDEN_ATTR, 'empty')
         const d = row.querySelector('[' + DOT + ']'); if (d) d.remove()
         dsmDropSubList(row, id)
         return
       }
       if (row.style.display === 'none') row.style.display = ''
+      // 行重新可见（已从回收站恢复 / 空白状态消失）：摘掉隐藏标记，展开计数
+      // 立刻把这一条还回「可展开」的数量里。
+      if (row.hasAttribute(DSM_HIDDEN_ATTR)) row.removeAttribute(DSM_HIDDEN_ATTR)
       if (!isEmpty && li && li.parentSession && li.origin !== 'subagent') {
         // fork 分支行：绿「⑂ 分支」chip，点击滚动并高亮父会话行。
         // v3.6.2 #3：chip 每次 paint 幂等同步（存在才不建，但 tooltip/父 id
@@ -3341,7 +3614,9 @@ function installSidebarStatusDots() {
       }
       dot.style.background = color
     })
-    dsmSyncEmptyGroups()
+    dsmSyncEmptyGroups(purgedNow)
+    // issue #16：等隐藏标记落定后再校准展开计数（数据层优先，DOM 标记兜底）。
+    dsmSyncOverflowLabels(purgedNow)
   }
   dsmRepaintDots = paint
   const paintToast = (msg, kind) => {

package/src/client/logic.js

@@ -462,3 +462,96 @@ export function filterShapeFromSaved(item) {
   if (tag === '' && f.tag !== '') degraded.push('tag')
   return { view, workspace, sort, tag, degraded }
 }
+
+// issue #16：侧栏「展开其余 N 个会话」的 N 由上游按**数据层**计算
+// （0.2.0-rc.2 `collapsedSessionRows` → 0.2.1-rc.2 `watermarkRows`），
+// 看不到插件用 display:none 隐藏的回收站/空白行，于是数字虚高；点展开只是
+// 把更多已隐藏行塞进 DOM，可见行数不变——按钮在动、画面不动，容易被误读成
+// 「会话丢了」。
+//
+// 注意**不能**用「N − 本组被插件隐藏的条数」：上游的 N 数是「水位线之外
+// 还没渲染的行」，隐藏数数的是「整组被藏起来的行」，两个口径不重叠——被藏的
+// 行可能就在已渲染窗口内，减它属重复扣减，点开一次就翻负，进而把仍有可见行
+// 的按钮藏掉（上游只有这一个展开入口 → 会话不可达）。
+//
+// 正确口径由 `remainingRows` 给出：还能出现几行 = 本组可见总数 − 已渲染的
+// 可见行数；`overflowPlan` 只负责把它写进文案、并决定是否藏按钮。
+export function remainingRows(visibleTotal, renderedVisible) {
+  // Number(null) === 0：null / undefined 必须当作「不知道」，不能当成 0。
+  if (visibleTotal == null || visibleTotal === '') return null
+  const total = Number(visibleTotal)
+  if (!Number.isFinite(total)) return null
+  const shown = Number(renderedVisible)
+  const shownCount = Number.isFinite(shown) ? Math.max(0, Math.floor(shown)) : 0
+  return Math.max(0, Math.max(0, Math.floor(total)) - shownCount)
+}
+
+// 本组已渲染的可见会话行数。`rows` 是直接子节点里会话行的描述
+// （{ id, pluginHidden }），`visibleIds` 是「上游会列出且插件不会藏」的 id 集合。
+// 插件隐藏的行（回收站 / 空白）与不在集合里的行（空白会话 / 上游过滤口径差异）
+// 都不计入 —— 与 `remainingRows` 的「可见总数」保持同一口径。
+export function countRenderedVisible(rows, visibleIds) {
+  if (!Array.isArray(rows) || !visibleIds || typeof visibleIds.has !== 'function') return 0
+  let n = 0
+  for (const row of rows) {
+    if (!row || row.pluginHidden) continue
+    if (row.id && visibleIds.has(row.id)) n++
+  }
+  return n
+}
+
+// 空分组判定：`group.sessions` 里「还会出现在侧栏」的条数。
+// - 空白会话不计：上游 `watermarkRows` 里 `if (session.blank) return true`，
+//   空白行永远保留、从不计入可展开数；插件也一律把它藏起来。
+// - `hiddenIds` = 回收站 / 墓碑 / 空白血缘的行 id（与展开计数同一份口径）。
+// - 返回 null 表示**不知道**（拿不到数据层，或该组还没加载出会话）：调用方
+//   必须按「非空」处理——宁可留一个空标题，也不能把仍有会话的组藏掉。
+export function aliveSessionCount(sessions, hiddenIds) {
+  if (!Array.isArray(sessions) || !sessions.length) return null
+  let alive = 0
+  let seen = 0
+  for (const node of sessions) {
+    if (!node || node.id == null) continue
+    const id = String(node.id)
+    if (!id) continue
+    seen++
+    if (node.blank) continue
+    if (hiddenIds && typeof hiddenIds.has === 'function' && hiddenIds.has(id)) continue
+    alive++
+  }
+  // 一条带 id 的都没有 = 结构不认识（不是「组空」），照未知处理。
+  return seen === 0 ? null : alive
+}
+
+// 把「还能出现几行」落到展开按钮上：
+// - `more` 未知（拿不到数据层）→ 一律不动作。DOM 兜底在数学上不成立
+//   （窗口内/外的隐藏数口径不同），宁可不改也不写一个看起来合理却会算错的数；
+// - 文案没有数字（展开态的「收起」、或上游改成纯图标）→ 不改也不藏。无法确认
+//   是不是计数文案时保持沉默；
+// - 只替换第一个数字（各语言文案都把计数放在数字位，如「展开其余 12 个会话」
+//   /「Show 12 more」），支持千分位写法；
+// - `more === 0` 才藏按钮：此时确实一行都不会再出现，留着只会让人反复点。
+export function overflowPlan(text, more) {
+  const raw = typeof text === 'string' ? text : ''
+  const unknown = more == null || !Number.isFinite(Number(more))
+  const remaining = unknown ? 0 : Math.max(0, Math.floor(Number(more)))
+  const m = raw.match(/(\d[\d,]*)/)
+  const base = m ? Number(m[1].replace(/,/g, '')) : null
+  if (base === null || unknown) {
+    return { text: raw, hide: false, base, more: unknown ? null : remaining, changed: false }
+  }
+  if (remaining === 0) {
+    // base<=0 是上游没给出可信计数（理论上不会出现）：不据此隐藏，避免误判。
+    return { text: raw, hide: base > 0, base, more: 0, changed: false }
+  }
+  if (remaining === base) {
+    return { text: raw, hide: false, base, more: remaining, changed: false }
+  }
+  return {
+    text: raw.slice(0, m.index) + String(remaining) + raw.slice(m.index + m[1].length),
+    hide: false,
+    base,
+    more: remaining,
+    changed: true,
+  }
+}