dsh-sessions-manager 3.7.6 → 3.7.8

package/src/client/index.jsx

@@ -10,8 +10,8 @@
  * @module dsh-sessions-manager/client
  */
 
-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 React, { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import { aliveSessionCount, applyTagFilter, canDropOnWorkspace, collapsedVisibleTotal, countRenderedVisible, dotStateFor, effectiveTitleOf, filterShapeFromSaved, filterSnapshotOf, foldBranches, foldOrphanSubagents, foldSubagents, noticeToastPlan, openSubagentToast, overflowPlan, pathTail, remainingRows, sessionForNodes, shortId, starredOf, tagDeleteConfirm, titleBackfillDecision, toastDurationFor, workspaceForNodes } from './logic.js'
 
 export const inject = ['slots']
 
@@ -193,6 +193,10 @@ body[data-ds-dark-theme] .archv{color-scheme:dark}
 .dlg{width:min(420px,92vw);background:var(--dsw-alias-bg-layer-2);border:1px solid var(--dsw-alias-border-l3);border-radius:14px;padding:18px;box-shadow:0 16px 48px rgb(0 0 0/.28);display:flex;flex-direction:column;gap:12px}
 .dlg-title{font-size:15px;font-weight:650;color:var(--dsw-alias-label-primary);margin:0}
 .dlg-text{font-size:13px;line-height:1.6;color:var(--dsw-alias-label-secondary);margin:0;word-break:break-all}
+/* issue #18 第 4 条：删除确认框里的「连带子代理」勾选行。与面板其它勾选项
+   同一套视觉语言（13px / 中性标签色 / 8px 间距），不自造按钮样式。 */
+.dlg-check{display:flex;align-items:flex-start;gap:8px;font-size:13px;line-height:1.55;color:var(--dsw-alias-label-secondary);cursor:pointer}
+.dlg-check input{margin:2px 0 0;flex:none}
 .dlg-actions{display:flex;justify-content:flex-end;gap:8px;margin-top:2px}
 /* ---- T4 标签编辑/管理 sheet 与筛选保存控件（全部走 --dsw token） ---- */
 .dsm-taglist{display:flex;flex-direction:column;gap:2px;max-height:240px;overflow:auto}
@@ -499,6 +503,10 @@ function SessionPanel({ workspacesSvc }) {
   const [sortBy, setSortBy] = useState(() => ['newest', 'oldest', 'title'].includes(initialPrefs.sortBy) ? initialPrefs.sortBy : 'newest')
   const [selected, setSelected] = useState({})
   const [delTarget, setDelTarget] = useState(null)
+  // issue #18 第 4 条：删除父会话默认连带回收它的子代理（生命周期绑定），
+  // 取消勾选则保留——保留的子代理会落进「未归属子代理」卡片，仍可单独处理。
+  const [cascadeSub, setCascadeSub] = useState(true)
+  useEffect(() => { if (delTarget) setCascadeSub(true) }, [delTarget])
   const [confirmBatch, setConfirmBatch] = useState(false)
   const [batchMoveOpen, setBatchMoveOpen] = useState(false)
   const [busy, setBusy] = useState(null)
@@ -577,6 +585,9 @@ function SessionPanel({ workspacesSvc }) {
     return next
   })
   const [groupByLineage, setGroupByLineage] = useState(() => initialPrefs.groupByLineage !== false)
+  // issue #18 第 1 条：父会话不在列表里的子代理收进一张「未归属子代理」卡片，
+  // 展开态不持久化——默认收起，避免又一次把列表撑长。
+  const [openOrphans, setOpenOrphans] = useState(false)
 
   // —— T4（3.7.0）标签 + 已存筛选 ——
   // 数据源纪律：卡片 chip、编辑 sheet 勾选、管理行用量、筛选下拉，一律以本
@@ -1121,18 +1132,38 @@ function SessionPanel({ workspacesSvc }) {
   const canMove = actionCapability('relocateSession', 'move')
   const canRestoreTrash = actionCapability('restoreIndexedSession', 'restoreTrash')
 
-  const archivedList = sessions ? sessions.filter((x) => x.archived) : []
-  const activeList = sessions ? sessions.filter((x) => !x.archived) : []
-  const starredList = starredOf(sessions)
-  // issue #6 之三：空白会话单分一类。空白判定来自宿主血缘快照（sizeBytes 阈值
-  // 实测校准），与侧栏「空白」标记同源——两处永远不会各说各话。
-  const emptyList = useMemo(() => {
-    if (!sessions) return []
-    return sessions.filter((x) => { const li = lineage[String(x.sessionId)]; return !!(li && li.empty) })
-  }, [sessions, lineage])
+  // issue #18 第 1 条：子代理会话不是「一条可管理的会话」，而是父会话的下属。
+  // 先前它们以顶层行的形式混进「活动 / 全部」，一个重度的多代理工作日能攒出
+  // 上百个「(无标题)」——计数、全选、批量操作全被它们污染。这里统一判定，
+  // 表格计数与顶层行都用它排除；子代理只出现在父会话的「N 子代理」里。
+  const isSubagentItem = useCallback((item) => {
+    const li = item ? lineage[String(item.sessionId)] : null
+    return !!(li && li.origin === 'subagent')
+  }, [lineage])
+  // 列表管线仍要拿到子代理行（折叠判定要用它们挂到父会话下），所以保留一份
+  // 未过滤的集合；只有「计数 / 顶层行 / 全选」用 topOnly。
+  const { archivedAll, activeAll, starredAll, emptyAll } = useMemo(() => ({
+    archivedAll: sessions ? sessions.filter((x) => x.archived) : [],
+    activeAll: sessions ? sessions.filter((x) => !x.archived) : [],
+    starredAll: starredOf(sessions),
+    // issue #6 之三：空白会话单分一类。空白判定来自宿主血缘快照（sizeBytes 阈值
+    // 实测校准），与侧栏「空白」标记同源——两处永远不会各说各话。
+    emptyAll: sessions ? sessions.filter((x) => { const li = lineage[String(x.sessionId)]; return !!(li && li.empty) }) : [],
+  }), [sessions, lineage])
+  // 血缘分组开着时，计数只算「能作为一行被操作的会话」。平铺模式保持原样
+  // （用户显式选择与 DSH 原生一致的平铺视图）。
+  const topOnly = useCallback((arr) => (groupByLineage ? arr.filter((x) => !isSubagentItem(x)) : arr), [groupByLineage, isSubagentItem])
+  const archivedList = useMemo(() => topOnly(archivedAll), [topOnly, archivedAll])
+  const activeList = useMemo(() => topOnly(activeAll), [topOnly, activeAll])
+  const starredList = useMemo(() => topOnly(starredAll), [topOnly, starredAll])
+  const emptyList = useMemo(() => topOnly(emptyAll), [topOnly, emptyAll])
+  // 「全部」计数：血缘分组下同样只算能作为一行的会话（子代理在父行徽标里）。
+  const totalTopCount = useMemo(() => topOnly(sessions || []).length, [topOnly, sessions])
   const list = useMemo(() => {
     if (filter === 'trash') return []
-    const base = filter === 'archived' ? archivedList : filter === 'active' ? activeList : filter === 'starred' ? starredList : filter === 'empty' ? emptyList : sessions || []
+    // 注意用 *All（含子代理）：列表管线要靠它们把子代理挂到父会话下；排除子代理
+    // 发生在折叠之后的顶层行与计数（见 isSubagentItem / topOnly）。
+    const base = filter === 'archived' ? archivedAll : filter === 'active' ? activeAll : filter === 'starred' ? starredAll : filter === 'empty' ? emptyAll : sessions || []
     // T4 标签筛选（单选，v1 不追多选 AND——理由见 logic.applyTagFilter）：在
     // 搜索/工作区之前先按标签收敛；''/未就绪时谓词原样返回，行为与旧版一致。
     const tagPassed = applyTagFilter(base, tagsReady ? tagFilter : '')
@@ -1149,7 +1180,7 @@ function SessionPanel({ workspacesSvc }) {
       if (sortBy === 'title') return effectiveTitleOf(a, dsmAuthoritativeTitles).localeCompare(effectiveTitleOf(b, dsmAuthoritativeTitles), 'zh-CN')
       return Number(b.createdAt || 0) - Number(a.createdAt || 0)
     })
-  }, [sessions, filter, query, workspaceFilter, sortBy, emptyList, starredList, tagFilter, tagsReady])
+  }, [sessions, archivedAll, activeAll, starredAll, emptyAll, filter, query, workspaceFilter, sortBy, tagFilter, tagsReady])
   const selIds = Object.keys(selected).filter((k) => selected[k])
   // 「回收站」是独立视图，不共用会话列表。
   const showSessionList = filter !== 'trash'
@@ -1160,11 +1191,16 @@ function SessionPanel({ workspacesSvc }) {
   // 3.7.0 分支聚拢：先子代理折叠、后分支聚拢（foldBranches 的输入契约——顺序反了
   // 会让分支父行的子代理变孤儿弹回顶层）。链式分支拍平进同一组；缺失父出
   // 「来源：<短ID>」合成头；「一行不丢」由纯函数守恒不变量保证。
-  const { topList, kidsOf, foldedCount, branchGroupsOf, branchFolded, branchGroupCount } = useMemo(() => {
-    if (!groupByLineage) return { topList: list, kidsOf: new Map(), foldedCount: 0, branchGroupsOf: new Map(), branchFolded: 0, branchGroupCount: 0 }
+  const { topList, kidsOf, foldedCount, branchGroupsOf, branchFolded, branchGroupCount, orphanSubagents } = useMemo(() => {
+    if (!groupByLineage) return { topList: list, kidsOf: new Map(), foldedCount: 0, branchGroupsOf: new Map(), branchFolded: 0, branchGroupCount: 0, orphanSubagents: [] }
     const kids = foldSubagents(list, lineage)
     const br = foldBranches(kids.topList, lineage)
-    return { topList: br.topList, kidsOf: kids.kidsOf, foldedCount: kids.foldedCount, branchGroupsOf: br.branchGroupsOf, branchFolded: br.foldedCount, branchGroupCount: br.groupCount }
+    // issue #18 第 1 条：分支聚拢不会动子代理（branchParentOf 明确挡掉），所以
+    // 走到这里还留在顶层的子代理 = 父会话不在当前列表（已删除 / 已归档 / 被筛选）。
+    // 它们先前就地平铺成「(无标题)」行；现在收进一张「未归属子代理」卡片，
+    // 既不污染列表，也不会丢（展开仍可打开 / 归档 / 删除）。
+    const { rows, orphans } = foldOrphanSubagents(br.topList, lineage)
+    return { topList: rows, kidsOf: kids.kidsOf, foldedCount: kids.foldedCount, branchGroupsOf: br.branchGroupsOf, branchFolded: br.foldedCount, branchGroupCount: br.groupCount, orphanSubagents: orphans }
   }, [list, lineage, groupByLineage])
   // D5：query 命中折叠组内成员（或子代理）→ 渲染层强制展开——「看得见才搜得到」。
   const matchIds = useMemo(() => {
@@ -1177,6 +1213,9 @@ function SessionPanel({ workspacesSvc }) {
   }, [sessions, query])
   const kidsHit = (parentId) => !!(matchIds && (kidsOf.get(String(parentId)) || []).some((k) => matchIds.has(String(k.sessionId))))
   const branchHit = (rootId) => !!(matchIds && (branchGroupsOf.get(String(rootId)) || []).some((m) => matchIds.has(String(m.sessionId))))
+  // 搜索命中未归属子代理 → 强制展开那张卡片（「看得见才搜得到」同样适用）。
+  const orphanHit = !!(matchIds && orphanSubagents.some((k) => matchIds.has(String(k.sessionId))))
+  const orphanOpen = openOrphans || orphanHit
   const syntheticCount = groupByLineage ? topList.reduce((n, it) => n + (it && it.syntheticRoot ? 1 : 0), 0) : 0
 
   // 子代理折叠分两个部件，各自贴在它该在的位置：
@@ -1205,6 +1244,29 @@ function SessionPanel({ workspacesSvc }) {
   // 分支标记 hover 说明来源；空白标记提示去「空白」分类清理。
   // 父会话标题查找走一次性 Map（sessions 会到几百条，每卡片 find 是 O(n²)）。
   const sessionsById = useMemo(() => new Map((sessions || []).map((x) => [String(x.sessionId), x])), [sessions])
+  // issue #18 第 4 条：删除确认框里的「连同 N 个子代理」。按官方血缘字段递归数
+  // 一遍（只有对话框打开时才计算一次，列表渲染路径不承担这个成本）。
+  const delCascadeCount = useMemo(() => {
+    if (!delTarget) return 0
+    const childMap = new Map()
+    for (const [id, li] of Object.entries(lineage || {})) {
+      if (!li || li.origin !== 'subagent' || !li.parentSession) continue
+      const p = String(li.parentSession)
+      if (!childMap.has(p)) childMap.set(p, [])
+      childMap.get(p).push(String(id))
+    }
+    const seen = new Set([String(delTarget.sessionId)])
+    const queue = [String(delTarget.sessionId)]
+    let n = 0
+    while (queue.length) {
+      const cur = queue.shift()
+      for (const kid of childMap.get(cur) || []) {
+        if (seen.has(kid)) continue
+        seen.add(kid); n++; queue.push(kid)
+      }
+    }
+    return n
+  }, [delTarget, lineage])
   const branchBadge = (sessionId) => {
     const li = lineage[String(sessionId)]
     if (!li || li.origin === 'subagent' || !li.parentSession) return null
@@ -1319,9 +1381,13 @@ function SessionPanel({ workspacesSvc }) {
 
   const toggle = (id) => setSelected((s) => ({ ...s, [id]: !s[id] }))
   const clearSel = () => setSelected({})
+  // issue #18 第 3 条：全选只选「当前列表里真正占据一行、且能单独勾选」的会话。
+  // 旧实现遍历的是过滤后的原始 list（含被折叠的子代理、被聚拢的分支成员、
+  // 合成头），于是全选会在界面上看不出任何变化的情况下选中一批不可见会话——
+  // 用户只能靠「取消全选」撤销，批量归档/删除会打到自己没看见的东西。
   const selectAll = () => {
     const o = {}
-    list.forEach((x) => { o[x.sessionId] = true })
+    topList.forEach((x) => { if (x && x.sessionId != null && !x.syntheticRoot) o[x.sessionId] = true })
     setSelected(o)
   }
 
@@ -1343,15 +1409,17 @@ function SessionPanel({ workspacesSvc }) {
   const doDeleteConfirmed = () => {
     if (!delTarget || busy) return
     setBusy(delTarget.sessionId)
-    postJSON('/archived-sessions/delete', { sessionId: delTarget.sessionId })
-      .then(() => {
+    postJSON('/archived-sessions/delete', { sessionId: delTarget.sessionId, cascadeSubagents: cascadeSub })
+      .then((r) => {
         setBusy(null)
         const n = delTarget.title || delTarget.sessionId
-        showToast(`已删除 ${n}（已移入回收站）`)
-        const sid = String(delTarget.sessionId)
+        const cascaded = Number((r && r.cascaded) || 0)
+        showToast(`已删除 ${n}${cascaded ? `（连同 ${cascaded} 个子代理会话）` : ''}（已移入回收站）`)
+        const gone = new Set([String(delTarget.sessionId), ...((r && r.cascadedIds) || []).map(String)])
         setDelTarget(null)
-        // 删除进入回收站：本地移除该行 + 单刷回收站，不整表 refresh。
-        setSessions((s) => s && s.filter((x) => String(x.sessionId) !== sid))
+        // 删除进入回收站：本地移除这些行（含被连带回收的子代理）+ 单刷回收站，
+        // 不整表 refresh——refresh 会清空多选状态。
+        setSessions((s) => s && s.filter((x) => !gone.has(String(x.sessionId))))
         loadTrash()
         dsmLoadTrashIds()
       })
@@ -1430,7 +1498,10 @@ function SessionPanel({ workspacesSvc }) {
     postJSON('/archived-sessions/trash/restore', { sessionId: sid })
       .then((r) => {
         setTrashBusy(null)
-        showToast(r && r.workspaceGone ? '已恢复会话（原工作区已删除，会话暂归「未分组」）' : '已恢复会话')
+        // 子代理随父会话一起回来时如实说明，避免用户以为只恢复了一条。
+        const cascaded = Number((r && r.cascaded) || 0)
+        const base = r && r.workspaceGone ? '已恢复会话（原工作区已删除，会话暂归「未分组」）' : '已恢复会话'
+        showToast(base + (cascaded ? `，连同 ${cascaded} 个子代理会话` : ''))
         loadTrash()
         refresh()
       })
@@ -1513,7 +1584,9 @@ function SessionPanel({ workspacesSvc }) {
       .then((r) => {
         setBusy(null)
         const n = (r && (r.archived || r.restored || r.deleted)) || selIds.length
-        showToast(`已处理 ${n} 个会话`)
+        // 批量删默认也级联子代理：如实说明连带回收了多少，避免「数量对不上」。
+        const cascaded = Number((r && r.cascaded) || 0)
+        showToast(`已处理 ${n} 个会话${cascaded ? `（连同 ${cascaded} 个子代理会话）` : ''}`)
         refresh()
       })
       .catch((e) => { setBusy(null); setConfirmBatch(false); setError(String((e && e.message) || e)) })
@@ -1699,7 +1772,7 @@ function SessionPanel({ workspacesSvc }) {
               onClick={copyBuildStamp}
             >v{String(capabilities.buildStamp).split('+')[0]}</span>
           : null}
-        {sessions !== null && <span className="archv-count" aria-label={`${sessions.length} 个会话`}>{sessions.length}</span>}
+        {sessions !== null && <span className="archv-count" title={groupByLineage ? '子代理会话折叠在父会话下，不计入此数' : undefined} aria-label={`${totalTopCount} 个会话`}>{totalTopCount}</span>}
       </div>
       <p className="archv-sub">
         统一管理全部会话：归档 / 恢复 / 移动到其他工作区 / 会话详情 / 批量操作，删除会先进入回收站，可在回收站内恢复或彻底清理。
@@ -1727,7 +1800,7 @@ function SessionPanel({ workspacesSvc }) {
         <>
           <div className={'sess-fwrap' + (moreOpen ? ' sess-fmore-open' : '') + (filter === 'starred' || filter === 'empty' || filter === 'trash' ? ' sess-fsec-on' : '')}>
             <div className="sess-filter" role="tablist" aria-label="会话筛选">
-              <button type="button" role="tab" aria-selected={filter === 'all'} className={'sess-fbtn' + (filter === 'all' ? ' sess-fbtn-on' : '')} onClick={() => { setFilter('all'); clearSel(); setConfirmBatch(false) }}>全部 ({sessions.length})</button>
+              <button type="button" role="tab" aria-selected={filter === 'all'} className={'sess-fbtn' + (filter === 'all' ? ' sess-fbtn-on' : '')} onClick={() => { setFilter('all'); clearSel(); setConfirmBatch(false) }}>全部 ({totalTopCount})</button>
               <button type="button" role="tab" aria-selected={filter === 'active'} className={'sess-fbtn' + (filter === 'active' ? ' sess-fbtn-on' : '')} onClick={() => { setFilter('active'); clearSel(); setConfirmBatch(false) }}>活动 ({activeList.length})</button>
               <button type="button" role="tab" aria-selected={filter === 'archived'} className={'sess-fbtn' + (filter === 'archived' ? ' sess-fbtn-on' : '')} onClick={() => { setFilter('archived'); clearSel(); setConfirmBatch(false) }}>已归档 ({archivedList.length})</button>
               <span className="sess-fmore" role="tablist" aria-label="更多会话筛选">
@@ -1998,7 +2071,7 @@ function SessionPanel({ workspacesSvc }) {
                   {foldedCount || branchFolded
                     ? `，另有 ${[foldedCount ? `${foldedCount} 个子代理折叠在父会话下` : '', branchFolded ? `${branchFolded} 个分支聚成 ${branchGroupCount} 组` : ''].filter(Boolean).join('、')}`
                     : query || workspaceFilter !== 'all' || tagFilter
-                      ? `，共 ${filter === 'archived' ? archivedList.length : filter === 'active' ? activeList.length : filter === 'starred' ? starredList.length : filter === 'empty' ? emptyList.length : sessions.length} 个`
+                      ? `，共 ${filter === 'archived' ? archivedList.length : filter === 'active' ? activeList.length : filter === 'starred' ? starredList.length : filter === 'empty' ? emptyList.length : totalTopCount} 个`
                       : (topList.length !== list.length ? `，共 ${list.length} 个` : '')}
                 </span>
                 {/* T4：计数行右侧的保存筛选控件组。保存 = 抓 {view,workspace,
@@ -2054,10 +2127,12 @@ function SessionPanel({ workspacesSvc }) {
             </>
           )}
 
-          {showSessionList && list.length > 0 && (
+          {showSessionList && (topList.length > 0 || orphanSubagents.length > 0) && (
             <div className={'sess-batch' + (selIds.length > 0 ? ' sess-batch-pin' : '')}>
-              <span className="sess-btntext">{selIds.length ? `已选 ${selIds.length} 项` : (filter === 'archived' ? `共 ${archivedList.length} 个归档会话` : filter === 'starred' ? `共 ${starredList.length} 个收藏会话` : `共 ${sessions.length} 个会话（活动 ${activeList.length} / 已归档 ${archivedList.length}）`)}</span>
-              <button type="button" className="archv-btn" disabled={list.length === 0} onClick={selectAll}>全选</button>
+              <span className="sess-btntext">{selIds.length ? `已选 ${selIds.length} 项` : (filter === 'archived' ? `共 ${archivedList.length} 个归档会话` : filter === 'starred' ? `共 ${starredList.length} 个收藏会话` : `共 ${totalTopCount} 个会话（活动 ${activeList.length} / 已归档 ${archivedList.length}）`)}</span>
+              {/* issue #18 第 3 条：全选只覆盖当前列表里能单独勾选的行；折叠中的
+                  子代理 / 分支成员与合成头不参与，避免「选中了看不见的东西」。 */}
+              <button type="button" className="archv-btn" disabled={topList.length === 0} title={groupByLineage ? '选中当前列表的会话行（折叠中的子代理与分支成员不会被选中）' : undefined} onClick={selectAll}>全选</button>
               {selIds.length > 0 && (
                 <>
                   {filter === 'archived' && (
@@ -2137,7 +2212,7 @@ function SessionPanel({ workspacesSvc }) {
             </div>
           )}
 
-          {showSessionList && list.length === 0 ? (
+          {showSessionList && topList.length === 0 && orphanSubagents.length === 0 ? (
             <div className="archv-empty">{query || workspaceFilter !== 'all' || tagFilter ? '没有匹配的会话。请调整搜索词、标签或工作区筛选。' : filter === 'archived' ? '目前没有归档会话。在“全部”里选中会话点“归档”即可收纳进来。' : filter === 'active' ? '目前没有活动会话。' : filter === 'starred' ? '还没有收藏的会话。点击会话左侧的星标即可收藏。' : filter === 'empty' ? '没有空白会话。新开会话还没产生内容时会归到这里，侧栏会自动隐藏它们。' : '暂无可管理的会话。'}</div>
           ) : showSessionList ? (
             <div className="archv-list" role="list">
@@ -2150,18 +2225,25 @@ function SessionPanel({ workspacesSvc }) {
                   const open = !!openBranches[root] || branchHit(root)
                   const srcTitle = dsmAuthoritativeTitles.get(root)
                   return (
-                    <div key={it.sessionId} className="dsm-src-head" role="listitem">
-                      <button
-                        type="button"
-                        className="dsm-kids-toggle"
-                        aria-expanded={open}
-                        title={(open ? '收起 ' : '展开 ') + members.length + ' 个分支会话（来源会话不在当前列表）'}
-                        onClick={() => toggleBranch(root)}
-                      >
-                        {open ? '▾' : '▸'} {members.length} 分支
-                      </button>
-                      <span className="dsm-src-name" title={root}>{'来源：' + (srcTitle || shortId(root))}</span>
-                    </div>
+                    // issue #18 第 2 条：合成头先前在这里提前 return，只渲染按钮与
+                    // 「来源：」，展开时什么都不会出现（成员列表只挂在普通卡片的
+                    // renderBranchGroup 上）。这里补上同一个成员渲染器——按钮、
+                    // 展开状态、搜索命中展开都复用分支组的既有语义。
+                    <React.Fragment key={it.sessionId}>
+                      <div className="dsm-src-head" role="listitem">
+                        <button
+                          type="button"
+                          className="dsm-kids-toggle"
+                          aria-expanded={open}
+                          title={(open ? '收起 ' : '展开 ') + members.length + ' 个分支会话（来源会话不在当前列表）'}
+                          onClick={() => toggleBranch(root)}
+                        >
+                          {open ? '▾' : '▸'} {members.length} 分支
+                        </button>
+                        <span className="dsm-src-name" title={root}>{'来源：' + (srcTitle || shortId(root))}</span>
+                      </div>
+                      {renderBranchGroup(root)}
+                    </React.Fragment>
                   )
                 }
                 const date = fmtDate(it.createdAt)
@@ -2375,6 +2457,63 @@ function SessionPanel({ workspacesSvc }) {
                   </div>
                 )
               })}
+              {/* issue #18 第 1 条：父会话不在当前列表（已删除 / 已归档 / 被筛选）
+                  的子代理不再平铺成上百个「(无标题)」行，统一收进这一张卡片：
+                  默认收起不占版面，展开后逐条可打开 / 归档 / 删除，一条都不丢。 */}
+              {groupByLineage && orphanSubagents.length > 0 && (
+                <div className="archv-card dsm-orphan-card" role="listitem">
+                  <div className="archv-row">
+                    <div className="archv-body">
+                      <div className="archv-main">
+                        <div className="archv-titlerow">
+                          <button
+                            type="button"
+                            className="dsm-kids-toggle"
+                            aria-expanded={orphanOpen}
+                            title={(orphanOpen ? '收起 ' : '展开 ') + orphanSubagents.length + ' 个未归属的子代理会话'}
+                            onClick={() => setOpenOrphans(!openOrphans)}
+                          >
+                            {orphanOpen ? '▾' : '▸'} {orphanSubagents.length} 子代理
+                          </button>
+                          <span className="archv-name">未归属的子代理会话</span>
+                        </div>
+                        <div className="archv-meta">
+                          <span className="archv-wtag archv-wgone">父会话不在当前列表</span>
+                          <span className="archv-dot">·</span>
+                          <span className="archv-date">不再混进上面的会话列表；展开后可打开 / 归档 / 删除</span>
+                        </div>
+                      </div>
+                    </div>
+                  </div>
+                  {orphanOpen && (
+                    <div className="dsm-kids" aria-label="未归属子代理会话">
+                      {orphanSubagents.map((k) => {
+                        const li = lineage[String(k.sessionId)]
+                        return (
+                          <div className="dsm-kid" key={k.sessionId}>
+                            <div className="dsm-kid-row">
+                              <span className="dsm-kid-name" title={k.title || k.sessionId}>{k.title || '(无标题)'}</span>
+                              {emptyBadge(k.sessionId)}
+                              {tagChips(k.sessionId)}
+                              <span className="dsm-kid-meta">{k.archived ? '已归档' : '活动'}{fmtDate(k.createdAt) ? ` · ${fmtDate(k.createdAt)}` : ''}</span>
+                              <span className="dsm-kid-acts">
+                                <button type="button" className="archv-btn" disabled={busy !== null} title="切换到这个子代理会话（设置面板挡着会话区，关掉即可看到）" onClick={async () => {
+                                  const name = k.title || (String(k.sessionId).slice(0, 8) + '…')
+                                  const res = await dsmOpenSessionById(k.sessionId, (li && li.parentSession) || null)
+                                  const msg = openSubagentToast(res, name, 'panel')
+                                  showToast(msg.text, msg.kind)
+                                }}>打开</button>
+                                <button type="button" className="archv-btn" disabled={busy !== null} onClick={() => act(k.archived ? 'restore' : 'archive', k)}>{k.archived ? '恢复' : '归档'}</button>
+                                <button type="button" className="archv-btn archv-del" disabled={busy !== null} title="移入回收站，可在回收站恢复" onClick={() => setDelTarget(k)}>删除</button>
+                              </span>
+                            </div>
+                          </div>
+                        )
+                      })}
+                    </div>
+                  )}
+                </div>
+              )}
             </div>
           ) : null}
         </>
@@ -2385,6 +2524,12 @@ function SessionPanel({ workspacesSvc }) {
           <div ref={dialogRef} className="dlg" role="alertdialog" aria-modal="true" aria-label="删除会话" onClick={(e) => e.stopPropagation()}>
             <h3 className="dlg-title">删除会话</h3>
             <p className="dlg-text">确认删除「{delTarget.title || delTarget.sessionId}」？将移入回收站，可在本页底部「回收站」中恢复或彻底删除。</p>
+            {delCascadeCount > 0 && (
+              <label className="dlg-check">
+                <input type="checkbox" checked={cascadeSub} disabled={busy !== null} onChange={(e) => setCascadeSub(e.target.checked)} />
+                <span>同时删除它的 {delCascadeCount} 个子代理会话（子代理生命周期跟随父会话）。取消勾选则保留，它们会收进「未归属的子代理会话」卡片，仍可单独处理。</span>
+              </label>
+            )}
             <div className="dlg-actions">
               <button type="button" className="archv-btn" disabled={busy !== null} onClick={() => setDelTarget(null)}>取消</button>
               <button type="button" className="archv-btn archv-del" disabled={busy !== null} onClick={doDeleteConfirmed}>移入回收站</button>
@@ -2588,6 +2733,9 @@ function dsmToggleManual(id) {
 // up under DSH's "未分组" group. Loaded from the backend on a throttle and
 // updated optimistically when our own ⋯-menu deletes a session.
 let dsmTrashIds = null
+// issue #16：回收站按 cwd 的条数（host 随 sidebar-state 下发）。折叠分组下
+// 上游把 group.sessions 收回成空数组，展开计数只能靠它来扣掉插件会隐藏的行。
+let dsmTrashCountByCwd = null
 let dsmServerPurgedIds = new Set()
 let dsmAuthoritativeTitles = new Map()
 let dsmTrashTick = 0
@@ -2648,6 +2796,11 @@ async function dsmLoadTrashIds() {
   try {
     const r = await postJSON('/archived-sessions/sidebar-state', {})
     dsmTrashIds = new Set(((r && r.trashedSessionIds) || []).map(String))
+    // issue #16：折叠分组的展开计数要用「组内总数 − 本组回收站条数」，
+    // 这份按 cwd 的统计由 host 计算后随同一响应下发（老 host 没有该字段 → null）。
+    dsmTrashCountByCwd = r && r.trashedCountByCwd && typeof r.trashedCountByCwd === 'object'
+      ? new Map(Object.entries(r.trashedCountByCwd).map(([k, v]) => [String(k), Number(v) || 0]))
+      : null
     dsmServerPurgedIds = new Set(((r && r.purgedSessionIds) || []).map(String))
     // 服务器已确认的乐观标记随即清除；未被确认的标记最多存活到下次刷新，
     // 绝不永久压住后来同 id 的新会话。
@@ -2726,6 +2879,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 +2941,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 +3246,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 +3298,347 @@ 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
+  }
+  // issue #16 补丁：本组「会话行」的收集器。
+  //
+  // 原先各处一律按 `scope.children` 找会话行，隐含假设「上游把 `[role=treeitem]`
+  // 直接放在分组容器下」。在 0.2.1-rc.2 的侧栏里这个假设不成立：上游把每个会话行
+  // 包进一层 `<span class="_root_*">` 再放进 `groupSection`，于是 `children` 拿到
+  // 的全是 SPAN（没有 role、没有 data-row-key）。
+  //
+  // 后果不是「少算几个数」，而是整段校准被短路：`rendered` 恒为空 → 命中
+  // 「DOM 里没有会话行」的保护分支直接 return → 按钮上的 data-dsm-* 一个都不写、
+  // 计数永远不校准。用户看到的就是「点了展开没反应」或数字与实际不符。
+  //
+  // 因此改为：先按直接子节点找；一个都没找到时，再向下找（wrapper），
+  // 仍要求命中 `[role=treeitem][data-row-key^="session:"]`，且不跨越嵌套子分组。
+  const groupSessionRows = (scope, btn) => {
+    const out = []
+    if (!scope || !scope.children) return out
+    for (const el of scope.children) {
+      if (el === btn || !el.getAttribute) continue
+      const k = el.getAttribute('data-row-key') || ''
+      if (el.getAttribute('role') === 'treeitem' && k.startsWith('session:')) out.push(el)
+    }
+    if (out.length) return out
+    // wrapper 结构兜底：只在「直接子节点没有会话行」时启用，避免与上一种形态重复计数。
+    let rows = null
+    try {
+      rows = scope.querySelectorAll('[role="treeitem"][data-row-key^="session:"]')
+    } catch (e) { return out }
+    for (const el of rows) {
+      // 跳过属于嵌套子分组的行：它最近的分组容器不是本 scope。
+      let owner = el.parentElement
+      let ok = true
+      while (owner && owner !== scope) {
+        if (owner.getAttribute && owner.getAttribute('role') === 'group') { ok = false; break }
+        owner = owner.parentElement
       }
+      if (ok) out.push(el)
+    }
+    return out
+  }
+  // 分组容器定位：从工作区标题行向上找「无 role 的普通容器」（顶层分组的
+  // groupSection）。上游可能把标题行包在 wrapper span 里，因此不能只取
+  // parentElement —— 那会拿到 SPAN，使空分组判定整段失效。
+  const groupContainerOf = (row) => {
+    let el = row ? row.parentElement : null
+    for (let depth = 0; el && depth < 4; depth++) {
+      if (typeof el.getAttribute !== 'function') return null
+      // role="group" 是子分组容器，role="tree" 是列表根，都不能当顶层组容器。
+      if (!el.getAttribute('role')) return el
+      el = el.parentElement
+    }
+    return null
+  }
+  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 {
+        // 容器必须是无 role 的普通元素（顶层分组）。子分组容器 role="group"
+        // 里装的是整段子分组，不能当组容器用——拿它当容器会把整段子分组藏掉。
+        // 上游把标题行包在 wrapper span 里时 parentElement 不是组容器，
+        // 因此向上找到真正的 groupSection（见 groupContainerOf）。
+        const scope = groupContainerOf(row)
+        if (!scope || scope === document.body) return
+        // 组内还有没被我们藏起来的会话行 → 绝不藏（也顺手还原）。
+        // 行可能被上游包在 wrapper span 里（见 groupSessionRows 的说明），
+        // 因此用收集器而不是直接遍历 scope.children。
+        let rendered = 0
+        for (const el of groupSessionRows(scope, row)) {
+          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 groupSessionRows(scope, btn)) {
+      if (el.hasAttribute(DSM_HIDDEN_ATTR)) continue
+      n++
+      const k = el.getAttribute('data-row-key') || ''
+      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)
+        // 工作区标题行：先按直接子节点找；上游 0.2.1-rc.2 把它也包进 wrapper 时
+        // 再向下找一层（与 groupSessionRows 同一套兜底思路）。
+        const wsKey = 'workspace:' + key
+        let wsRow = null
+        for (const el of scope.children) {
+          if (el.getAttribute && el.getAttribute('data-row-key') === wsKey) { wsRow = el; break }
+        }
+        if (!wsRow) {
+          try {
+            wsRow = scope.querySelector('[data-row-key="' + wsKey.replace(/"/g, '\\"') + '"]')
+          } catch (e) { wsRow = null }
+        }
+        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
+        }
+        // 分组折叠时上游把 `sessions` 收回成空数组（`expanded ? [...].map(...) : []`），
+        // 所以「空数组」不等于「这组没有会话」。若照旧走下面的空集保护，折叠态的
+        // 分组永远不会被校准 —— 而展开按钮本身就只在折叠态出现，等于整段逻辑永久失效。
+        //
+        // 上游同时给了 `sessionCount`（= 组内会话总数，与展开状态无关），用它来判定：
+        // 到底是真的没会话，还是只是还没展开。注意 `sessionCount` 已过上游的
+        // `sessionVisible` 过滤（排除 archived 与空白会话），但仍可能包含本插件
+        // 软删到回收站、尚未从会话列表摘掉的条目 —— 所以算可见数时要再扣一次。
+        const groupCount = group && typeof group.sessionCount === 'number' ? group.sessionCount : null
+        const collapsed = !nodes.length && groupCount != null && groupCount > 0
+        // 本组「上游会列出、且不会被插件藏起来」的会话集合。
+        const ids = new Set()
+        for (const node of (nodes && nodes.length ? 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 groupSessionRows(scope, btn)) {
+          const k = el.getAttribute('data-row-key') || ''
+          rendered.push({ id: k.slice('session:'.length), pluginHidden: el.hasAttribute(DSM_HIDDEN_ATTR) })
+        }
+        // 空集/口径不匹配的保护：数据层说「一条都没有」但 DOM 里明明有会话行，
+        // 说明 group.sessions 的语义变了（懒加载、上游又换了过滤条件）。此时按
+        // 未知处理，绝不能算出 0 把按钮藏掉 —— 那是把可见会话变成不可达。
+        // 折叠态（collapsed）不算「空集」：那是上游把 sessions 收回的正常表现，
+        // 继续走下面的计数分支，否则展开按钮永远得不到校准。
+        if (!nodes.length && !collapsed) {
+          restoreOverflowButton(btn)
+          OVERFLOW_SIGS.set(btn, overflowSignature(scope, btn, purgedNow))
+          return
+        }
+        if (!ids.size && rendered.length) {
+          restoreOverflowButton(btn)
+          OVERFLOW_SIGS.set(btn, overflowSignature(scope, btn, purgedNow))
+          return
+        }
+        // 折叠态：上游把 `group.sessions` 收回成空数组，而展开按钮正是这时候
+        // 出现的 —— 也就是说「数据层拿不到成员」和「按钮需要校准」同时发生，
+        // 旧实现于是在这里直接 return，展开计数永远得不到校准（issue #16 的
+        // 「点开没反应 / 数字不动」就是这么来的）。
+        //
+        // 折叠时不再依赖成员 id，改用两条与展开状态无关的信息：
+        //   1) `group.sessionCount` —— 组内会话总数（上游按工作区统计）；
+        //   2) `dsmTrashCountByCwd` —— host 下发的「本工作区回收站条数」。
+        // 两者相减即为展开后实际会出现的行数；折叠时 DOM 里没有会话行，
+        // 已渲染可见数按 0 计。
+        if (collapsed) {
+          const wsCwd = group && typeof group.cwd === 'string' ? group.cwd : null
+          const trashInGroup = wsCwd != null && dsmTrashCountByCwd ? (dsmTrashCountByCwd.get(wsCwd) || 0) : null
+          const visibleTotal = collapsedVisibleTotal(groupCount, trashInGroup)
+          if (visibleTotal == null) {
+            // 老 host / 拿不到 cwd：不猜数字，保持上游原文案。
+            restoreOverflowButton(btn)
+            OVERFLOW_SIGS.set(btn, overflowSignature(scope, btn, purgedNow))
+            return
+          }
+          const more = remainingRows(visibleTotal, 0)
+          applyOverflowPlan(btn, more, '折叠 总数 ' + groupCount + ' / 回收站 ' + trashInGroup)
+          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 +3684,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 +3720,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 +3864,9 @@ function installSidebarStatusDots() {
       }
       dot.style.background = color
     })
-    dsmSyncEmptyGroups()
+    dsmSyncEmptyGroups(purgedNow)
+    // issue #16：等隐藏标记落定后再校准展开计数（数据层优先，DOM 标记兜底）。
+    dsmSyncOverflowLabels(purgedNow)
   }
   dsmRepaintDots = paint
   const paintToast = (msg, kind) => {