dsh-delete-session 0.2.0 → 0.2.1

package/README.md

@@ -23,6 +23,7 @@ DSH 侧边栏的会话菜单只有**重命名 / 分叉 / 归档**——归档只
 - **删除至系统回收站（默认开）** —— 会话日志、工作区记账与投影缓存一并进**系统回收站**：Windows 回收站、macOS 废纸篓、Linux 的 `gio trash`。删错了从回收站还原即可。设置页可以关掉它，关掉后就是**直接从硬盘移除，不可恢复**
 - **对话框文案跟随开关** —— 勾选时写「并放进系统回收站」，取消勾选时写「永久删除…不可恢复」。你看到的永远是你实际会得到的
 - **风险确认** —— 每次删除弹出确认对话框，显示会话标题与 ID。要不要弹这个框**只在设置页改**，弹窗里没有快捷勾选；**按住 Shift 点击**可以临时强制弹窗
+- **子会话一起删** —— 子代理是**独立会话**（独立目录、独立日志），父会话删掉后它们会变成孤儿留在磁盘上。现在删除对话时会处理它派生的子会话：设置里勾选「同时删除子会话」就一起删；不勾选则弹窗列出子会话，由你勾选要删哪些（默认全选）
 - **多选批量删除** —— 会话菜单「多选」进入选择模式：勾选多行后底部操作条显示「已选 N 个 / 取消 / 删除」；点删除立即批量执行，被选中的行乐观隐藏、操作条实时显示进度，客户端 6 路并发、工作区记账串行；失败的行恢复显示并保持选中，方便重试；Esc 退出
 - **产出文件隔离（可选，默认关闭）** —— 打开后，删除会话时还能把这个对话在工作目录里产出的文件**移进隔离夹**，而不是直接删掉；范围可选「仅新建」或「新建的和改过的」，模式可选「全部直接隔离」或「先列清单由你勾选」
 - **跳过 git 仓库内的文件（默认开）** —— 在项目里干过活的对话，产出文件里往往就是项目源码。开启后仓库内的文件一律不碰，避免删一个对话把项目搬空
@@ -67,6 +68,7 @@ dsh plugin --profile web add github:DDDMUC/dsh-delete-session
 | 产出文件默认全部进隔离夹 | 关 | 关：先列清单由你勾选；开：整批自动移走，不列清单也不扫描 |
 | 范围：仅新建 / 新建的和改过的 | 仅新建 | 只动对话自己创建的文件，还是连它改写过的既有文件一起 |
 | **跳过 git 仓库内的文件** | **开** | 仓库内的文件一律不碰 |
+| **同时删除子会话** | **关** | 开：删对话时把它派生的子代理会话一起删掉。关：弹窗列出子会话，由你勾选 |
 | 隔离夹保存位置 | 空（= `$DSH_HOME`） | 可手输、可点「选择文件夹…」调系统对话框、可点「打开」在资源管理器里定位 |
 
 ### 删除之后文件在哪
@@ -131,14 +133,12 @@ node test/checkbox.dom.test.js     # 67 项，客户端半
 
 ### 已知限制
 
-- **取消勾选「删除至回收站」后不可恢复**，没有撤销
-- **系统回收站有每盘容量上限**：超出时 Windows 会永久删除而不是报错。会话只有 KB～MB，实际碰不到
 - **macOS 首次使用会请求 Finder 自动化权限**，拒绝后文件留在暂存目录，不会假装删掉
 - 被 DSH 打开占用的会话：删除会自动等待写所有权释放（通常几秒）后完成；极少数仍被占用时提示稍后重试或重启 DSH
 - 多选勾选框仍是对会话行的 DOM 装饰，依赖宿主 `data-row-key="session:<id>"`；核心 UI 若改名，多选会静默失效（**菜单与对话框不受影响**，它们走官方槽位）
 - 产出文件清理默认关闭，打开后仍有几条边界：`bash` / `pwsh` 里创建的文件（`npm run build`、`git clone`、`> file`）**永远检测不到**；**目录永不移走**；清单上限 500 条；**没有还原界面**，隔离夹靠手工搬回
 - 「新建 vs 改过」的判定依赖 `fs-observation-policy` 保持启用
-- 批量删除（多选）**不**处理产出文件
+- 批量删除（多选）**不**处理产出文件，也**不**处理子会话
 - 暂存目录与隔离夹**没有自动清理**，会一直堆在 `$DSH_HOME` 下
 
 ### 兼容性
@@ -275,14 +275,12 @@ Both suites are **mutation-checked**: reverting an implementation or breaking it
 
 ### Known limitations
 
-- **Unchecking "Delete to the system trash" is not recoverable** — there is no undo
-- **The system trash has a per-volume size cap**: over it Windows deletes permanently instead of complaining. Sessions are KB–MB, so this does not come up in practice
 - **macOS asks for Finder automation permission the first time**; denied, the files stay in the staging folder rather than pretending the delete happened
 - A session the host holds open is waited for (usually seconds); in rare cases it asks you to retry or restart DSH
 - The multi-select tick is still a DOM decoration on session rows and depends on `data-row-key="session:<id>"`. If core UI renames it, multi-select goes quiet (the menu and dialog are unaffected — they use official slots)
 - Produced-file handling is off by default and still has edges: files created inside `bash` / `pwsh` (`npm run build`, `git clone`, `> file`) are **never detected**; **directories are never moved**; the list caps at 500; there is **no restore UI** — move files back from the quarantine by hand
 - Created-vs-changed depends on `fs-observation-policy` staying enabled
-- Batch delete does **not** handle produced files
+- Batch delete does **not** handle produced files, and does **not** touch child sessions
 - Staging and quarantine folders **are never cleaned up automatically**
 
 ### Compatibility

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-delete-session",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Delete sessions from the DSH Web sidebar: adds a Delete action to the session row menu with a risk-consent dialog, sends the session log, workspace accounting and live session state to the system trash (or removes them outright), and, when opted in, quarantines the files the conversation produced.",
   "type": "module",
   "main": "src/index.js",

package/src/client.js

@@ -60,6 +60,12 @@ window.__ModuleLoader__.load({
       batchFailed: '批量删除失败：',
       pageAsk: '删除时询问',
       pageRecycle: '删除至回收站',
+      pageSyncChildren: '同时删除子会话',
+      starAsk: '⭐ 顺手留颗 Star，作者能高兴一整天',
+      starCta: '行，给你一颗 Star',
+      pageSyncChildrenOn: '删除对话时，把它派生的子代理会话一起删掉。',
+      pageSyncChildrenOff: '不勾选时，删除前会列出子会话，由你勾选要删哪些。',
+      childrenHint: '这个对话有 {n} 个子会话（子代理），勾选的会一起删除。',
       pageRecycleOn: '删除后放进系统回收站，可以还原。',
       pageRecycleOff: '删除后直接从硬盘移除，不可恢复。',
       pageHintAsk: '每次删除会话前都会弹出确认框。',
@@ -148,6 +154,12 @@ window.__ModuleLoader__.load({
       batchFailed: 'Batch delete failed: ',
       pageAsk: 'Ask before deleting',
       pageRecycle: 'Delete to the Recycle Bin',
+      pageSyncChildren: 'Delete child sessions too',
+      starAsk: '⭐ A star would make the author\'s day',
+      starCta: 'Fine — have one',
+      pageSyncChildrenOn: 'A delete also removes the subagent sessions it spawned.',
+      pageSyncChildrenOff: 'When off, the dialog lists the child sessions and you tick the ones to delete.',
+      childrenHint: 'This conversation has {n} child sessions (subagents). Ticked ones are deleted too.',
       pageRecycleOn: 'The session goes to the system trash and can be restored.',
       pageRecycleOff: 'The session is removed from the disk right away and cannot be restored.',
       pageHintAsk: 'Show a confirmation dialog before every session delete.',
@@ -366,6 +378,8 @@ window.__ModuleLoader__.load({
     const SKIP_GIT_KEY = 'dsh-delete-session:skip-git'
     /** Whether a delete goes to the system trash instead of vanishing. */
     const RECYCLE_KEY = 'dsh-delete-session:recycle'
+    /** Whether a delete takes the subagent sessions with it, without asking. */
+    const SYNC_CHILDREN_KEY = 'dsh-delete-session:sync-children'
     /** How many artifact rows the dialog lists before collapsing the rest. */
     const ARTIFACT_ROWS_SHOWN = 40
     const prefListeners = new Set()
@@ -449,6 +463,18 @@ window.__ModuleLoader__.load({
       writePref(RECYCLE_KEY, on ? null : '0')
     }
 
+    /**
+     * Take the child sessions along without asking. Off by default: a subagent is
+     * a conversation of its own, so it is offered rather than swept up.
+     */
+    function syncChildren() {
+      return readPref(SYNC_CHILDREN_KEY, '0') === '1'
+    }
+
+    function setSyncChildren(on) {
+      writePref(SYNC_CHILDREN_KEY, on ? '1' : null)
+    }
+
     /** The chosen quarantine root, or '' for "use the host default". */
     function quarantineRoot() {
       return readPref(ROOT_KEY, '')
@@ -535,10 +561,15 @@ window.__ModuleLoader__.load({
         .catch((reason) => toast(t('rootOpenFailed') + String((reason && reason.message) || reason), true))
     }
 
-    function postDelete(sessionId, quarantine) {
+    function postDelete(sessionId, quarantine, childSessionIds) {
       const root = quarantineRoot()
       const payload = quarantine === undefined ? { sessionId } : { sessionId, quarantine }
       if (root !== '') payload.root = root
+      // Subagent sessions are sessions of their own, so they travel as a list the
+      // host can verify rather than something it has to discover.
+      if (Array.isArray(childSessionIds) && childSessionIds.length > 0) {
+        payload.childSessionIds = childSessionIds
+      }
       // Whether the files go to the system trash is a per-delete choice, so it
       // travels with the request rather than being read from the host config.
       payload.recycle = recycleSession()
@@ -628,6 +659,8 @@ window.__ModuleLoader__.load({
       '.dsdel-bar-danger{border-color:var(--dsw-alias-state-error-primary,#e5484d);background:var(--dsw-alias-state-error-primary,#e5484d);color:#fff}',
       '.dsdel-page{display:flex;flex-direction:column;gap:8px}',
       '.dsdel-page-hint{margin:0;color:var(--dsw-alias-label-tertiary,#888);font-size:13px;line-height:20px}',
+      '.dsdel-star{display:flex;align-items:center;justify-content:flex-end;gap:8px;flex-wrap:wrap;font-size:12px;color:var(--dsw-alias-label-tertiary,#8b93a1);padding:2px 2px 0;}',
+      '.dsdel-star-link{color:var(--dsw-alias-brand-primary,#4d76e6);text-decoration:underline;}',
       '.dsdel-root-input{flex:1 1 220px;min-width:160px;min-height:30px;padding:0 10px;border:1px solid var(--dsw-alias-border-secondary,#d0d0d0);border-radius:6px;background:transparent;color:inherit;font:inherit;font-size:13px}',
       '.dsdel-picker-path{margin:0 0 8px;font-size:12px;line-height:1.6;color:var(--dsw-alias-label-secondary,#666);word-break:break-all}',
       // A wider confirmation dialog: the class reaches it when `Modal` forwards
@@ -1063,9 +1096,63 @@ window.__ModuleLoader__.load({
         : artifactsAuto()
           ? { auto: true, loading: false, plan: null, error: null, selected: new Set() }
           : { auto: false, loading: true, plan: null, error: null, selected: new Set() }
-      state.dialog = { sessionId, title: title || null, busy: false, error: null, skip: false, artifacts }
+      state.dialog = {
+        sessionId,
+        title: title || null,
+        busy: false,
+        error: null,
+        artifacts,
+        // The subagent sessions this conversation spawned. Filled in after the
+        // dialog opens: the list costs one host call, and on most conversations
+        // there is nothing to list.
+        children: { loading: true, list: [], selected: new Set() },
+      }
       publish()
       if (artifacts !== null && artifacts.auto !== true) loadArtifacts(sessionId)
+      loadChildren(sessionId)
+    }
+
+    /**
+     * List the subagent sessions behind this conversation. With the switch on they
+     * are all taken with the parent; with it off every one starts ticked and the
+     * dialog lets the user narrow the set.
+     */
+    function loadChildren(sessionId) {
+      fetch(`/dsh-delete-session/children`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ sessionId }),
+      })
+        .then(async (res) => {
+          let data = {}
+          try { data = await res.json() } catch { /* keep {} */ }
+          const list = res.ok && Array.isArray(data.children) ? data.children : []
+          const dialog = state.dialog
+          if (dialog === null || dialog.sessionId !== sessionId) return
+          dialog.children = {
+            loading: false,
+            list,
+            selected: new Set(list.map((child) => child.id)),
+          }
+          publish()
+        })
+        .catch(() => {
+          const dialog = state.dialog
+          if (dialog === null || dialog.sessionId !== sessionId) return
+          // A host that cannot list children still deletes the parent; reporting
+          // an error here would block a delete that is otherwise fine.
+          dialog.children = { loading: false, list: [], selected: new Set() }
+          publish()
+        })
+    }
+
+    /** The children this delete should take along. */
+    function childSessionIdsFor(dialog) {
+      if (dialog.children === undefined || dialog.children === null) return []
+      if (syncChildren()) return dialog.children.list.map((child) => child.id)
+      return dialog.children.list
+        .filter((child) => dialog.children.selected.has(child.id))
+        .map((child) => child.id)
     }
 
     /** Fetch the read-only scan and preselect the current scope's candidates. */
@@ -1221,11 +1308,12 @@ window.__ModuleLoader__.load({
       const dialog = state.dialog
       if (dialog === null || dialog.busy) return
       const quarantine = quarantineRequest(dialog)
+      const childSessionIds = childSessionIdsFor(dialog)
       dialog.busy = true
       dialog.error = null
       state.pending.add(dialog.sessionId)
       publish()
-      postDelete(dialog.sessionId, quarantine)
+      postDelete(dialog.sessionId, quarantine, childSessionIds)
         .then((result) => {
           state.dialog = null
           const outcome = result && result.quarantine ? result.quarantine : null
@@ -1320,6 +1408,32 @@ window.__ModuleLoader__.load({
      * (ask mode) or a single line stating how many files will move (auto mode).
      * A null `artifacts` means the feature is off and the dialog says nothing.
      */
+    /**
+     * The subagent sessions behind this conversation. Hidden while the switch
+     * already answers the question, and while the list is still loading.
+     */
+    function renderChildren(dialog, translate) {
+      const children = dialog.children
+      if (children === undefined || children === null) return null
+      if (children.loading) return null
+      if (children.list.length === 0) return null
+      if (syncChildren()) return null
+      return h('div', { key: 'children', className: 'dsdel-modal-children' },
+        h('p', { key: 'hint', className: 'dsdel-modal-text' },
+          translate('childrenHint', children.list.length)),
+        ...children.list.map((child) => h(primitives.Checkbox, {
+          key: `child:${child.id}`,
+          checked: children.selected.has(child.id),
+          label: child.cwd ? `${child.id} · ${child.cwd}` : child.id,
+          onChange: (checked) => {
+            if (checked === true) children.selected.add(child.id)
+            else children.selected.delete(child.id)
+            publish()
+          },
+        })),
+      )
+    }
+
     function renderArtifacts(artifacts, translate) {
       if (artifacts === null) return null
       // Auto mode never scanned, so there is no plan to describe: name the
@@ -1512,6 +1626,7 @@ window.__ModuleLoader__.load({
           h('p', { key: 'desc', className: 'dsdel-modal-text' },
             translate(recycleSession() ? 'descRecycle' : 'descPermanent')),
           renderArtifacts(dialog.artifacts, translate),
+          renderChildren(dialog, translate),
           // Whether a delete asks first is a setting, not a dialog affordance:
           // it lives on the plugin page only, so this dialog never changes it.
           dialog.error !== null
@@ -1540,6 +1655,7 @@ window.__ModuleLoader__.load({
       const defaultRootValue = () => (pageSnapshot && pageSnapshot.defaultRoot) || ''
       const [ask, setAsk] = react.useState(!skipConfirm())
       const [recycle, setRecycle] = react.useState(recycleSession())
+      const [syncChildrenState, setSyncChildrenState] = react.useState(syncChildren())
       const [off, setOff] = react.useState(artifactsOff())
       const [auto, setAuto] = react.useState(artifactsAuto())
       const [scope, setScope] = react.useState(artifactScope())
@@ -1586,6 +1702,18 @@ window.__ModuleLoader__.load({
         h('p', { key: 'recycleHint', className: 'dsdel-page-hint' },
           translate(recycle ? 'pageRecycleOn' : 'pageRecycleOff')),
 
+        h(primitives.Checkbox, {
+          key: 'syncChildren',
+          checked: syncChildrenState,
+          label: translate('pageSyncChildren'),
+          onChange: (checked) => {
+            setSyncChildrenState(checked === true)
+            setSyncChildren(checked === true)
+          },
+        }),
+        h('p', { key: 'syncChildrenHint', className: 'dsdel-page-hint' },
+          translate(syncChildrenState ? 'pageSyncChildrenOn' : 'pageSyncChildrenOff')),
+
         h(primitives.Checkbox, {
           key: 'off',
           checked: off,
@@ -1713,6 +1841,19 @@ window.__ModuleLoader__.load({
         )
       }
 
+      // A quiet link to the repository, last in the card. It is a nudge, not a
+      // setting, so it never competes with the controls above it — and it is a
+      // plain anchor, so clicking it opens the page instead of switching tabs here.
+      children.push(h('div', { key: 'star', className: 'dsdel-star' },
+        h('span', { key: 'ask' }, translate('starAsk')),
+        h('a', {
+          key: 'cta',
+          className: 'dsdel-star-link',
+          href: 'https://github.com/DDDMUC/dsh-delete-session',
+          target: '_blank',
+          rel: 'noreferrer',
+        }, translate('starCta'))))
+
       return h('div', { className: 'dsdel-page' }, children)
     }
 

package/src/index.js

@@ -66,6 +66,132 @@ function idVariants(sessionId) {
   else out.add(`session-${sessionId}`)
   return [...out]
 }
+/** The bare uuid, for comparing ids that may or may not carry the prefix. */
+function bareSessionId(sessionId) {
+  return sessionId.startsWith('session-') ? sessionId.slice('session-'.length) : sessionId
+}
+
+/**
+ * Every session header the host knows about, or `[]` when no service can list
+ * them. `sessionQuery` merges live and persisted sessions and carries
+ * `parentSession`, so the parent/child map never has to be decoded out of the
+ * zstd logs.
+ */
+async function listSessionHeaders(ctx) {
+  try {
+    const query = ctx.get('sessionQuery')
+    if (query && typeof query.listSessions === 'function') {
+      const records = await query.listSessions()
+      const headers = records
+        .map((record) => record && record.header)
+        .filter((header) => header && typeof header.id === 'string')
+      if (headers.length > 0) return headers
+    }
+  } catch {
+    // fall through to the persistence service
+  }
+  try {
+    const persistence = ctx.get('sessionPersistence')
+    if (persistence && typeof persistence.list === 'function') {
+      const snapshots = await persistence.list({})
+      return snapshots
+        .map((snapshot) => snapshot && snapshot.header)
+        .filter((header) => header && typeof header.id === 'string')
+    }
+  } catch {
+    // no service can list sessions on this host
+  }
+  return []
+}
+
+/**
+ * Every descendant of one session, breadth first. A subagent is a session of
+ * its own — its own directory and its own log — linked only by `parentSession`,
+ * so a delete that ignores the link leaves orphans behind.
+ *
+ * @param headers - the host session headers.
+ * @param sessionId - the session being deleted.
+ * @returns descendant headers, parents before their own children.
+ */
+function collectDescendants(headers, sessionId) {
+  const byParent = new Map()
+  for (const header of headers) {
+    if (typeof header.parentSession !== 'string') continue
+    const key = bareSessionId(header.parentSession)
+    const list = byParent.get(key)
+    if (list === undefined) byParent.set(key, [header])
+    else list.push(header)
+  }
+  const found = []
+  const seen = new Set([bareSessionId(sessionId)])
+  const queue = [bareSessionId(sessionId)]
+  while (queue.length > 0) {
+    const current = queue.shift()
+    for (const child of byParent.get(current) ?? []) {
+      const key = bareSessionId(child.id)
+      if (seen.has(key)) continue
+      seen.add(key)
+      found.push(child)
+      queue.push(key)
+    }
+  }
+  return found
+}
+
+/**
+ * Sessions whose parent no longer exists. Deleting a parent used to leave these
+ * on disk, and the sidebar cannot show the ones that never joined a workspace.
+ */
+function collectOrphans(headers) {
+  const present = new Set(headers.map((entry) => bareSessionId(entry.id)))
+  return headers.filter((entry) => typeof entry.parentSession === 'string'
+    && !present.has(bareSessionId(entry.parentSession)))
+}
+
+/**
+ * The child list the dialog shows: identity, nesting depth and the project the
+ * subagent ran in, so the names are recognisable before anything is ticked.
+ */
+function describeChildren(headers, sessionId) {
+  const byBare = new Map(headers.map((entry) => [bareSessionId(entry.id), entry]))
+  return collectDescendants(headers, sessionId).map((entry) => {
+    let depth = 1
+    let cursor = entry
+    while (typeof cursor.parentSession === 'string') {
+      const parent = byBare.get(bareSessionId(cursor.parentSession))
+      if (parent === undefined || bareSessionId(parent.id) === bareSessionId(sessionId)) break
+      depth += 1
+      cursor = parent
+    }
+    return {
+      id: entry.id,
+      depth,
+      cwd: typeof entry.cwd === 'string' ? entry.cwd : undefined,
+    }
+  })
+}
+
+/**
+ * The children the caller asked to delete, narrowed to real descendants. A
+ * stale or unrelated id is dropped instead of failing the delete: the parent is
+ * the session the user clicked, and that click must still land.
+ *
+ * @returns the descendants' own ids, in the order they were asked for.
+ */
+function selectChildDeletes(headers, sessionId, requested) {
+  if (!Array.isArray(requested) || requested.length === 0) return []
+  const descendants = new Map()
+  for (const entry of collectDescendants(headers, sessionId)) {
+    descendants.set(bareSessionId(entry.id), entry.id)
+  }
+  const picked = []
+  for (const id of requested) {
+    if (typeof id !== 'string' || id === '') continue
+    const hit = descendants.get(bareSessionId(id))
+    if (hit !== undefined && !picked.includes(hit)) picked.push(hit)
+  }
+  return picked
+}
 
 // Scan every workspace directory under $DSH_HOME/sessions for the session's
 // directories, so the workspace-path encoding never has to be re-derived here.
@@ -604,6 +730,14 @@ async function deleteSession(ctx, sessionId, options) {
   // Undoable by default: only an explicit `recycle: false` sends the files to a
   // plain removal instead of the system trash.
   const recycle = options === undefined || options === null || options.recycle !== false
+  // Subagent sessions are sessions of their own; the ones the caller ticked are
+  // taken with their parent. Anything that is not a well-formed id is dropped
+  // here, before it reaches the filesystem.
+  const childSessionIds = options !== undefined && options !== null && Array.isArray(options.childSessionIds)
+    ? options.childSessionIds
+      .filter((id) => typeof id === 'string' && SESSION_ID_RE.test(id))
+      .filter((id) => bareSessionId(id) !== bareSessionId(sessionId))
+    : []
   const stopped = await quiesceAgent(ctx, sessionId)
   const { flushed, detached } = await flushAndDetach(ctx, sessionId)
   await assertNoActiveWriter(ctx, sessionId)
@@ -612,14 +746,7 @@ async function deleteSession(ctx, sessionId, options) {
   // Bin switch on (the default) they are staged and the shell moves them to the
   // bin in the background; switched off, they are removed outright — that is what
   // the dialog promises in that state.
-  //
-  // The second directory pass costs nothing when the drain recreated nothing,
-  // which is the normal case.
-  const cacheFiles = findSessionCaches(sessionId)
-  const targets = [...findSessionDirs(sessionId), ...cacheFiles]
-  let removed = await retireTargets(targets, recycle)
-  await new Promise((resolve) => setImmediate(resolve))
-  removed = removed.concat(await retireTargets(findSessionDirs(sessionId), recycle))
+  const { removed, caches } = await retireSessionFiles(sessionId, recycle)
 
   const sp = ctx.get('sessionPersistence')
   if (sp && typeof sp.stat === 'function') {
@@ -633,18 +760,49 @@ async function deleteSession(ctx, sessionId, options) {
     throw new HttpError(500, 'verify-failed', 'session directories could not be fully removed')
   }
 
-  // Cache rows are projection state, not the source of truth: retire them even
-  // when the directories were already gone, so a deleted session cannot leave
-  // a ghost behind.
-  // Anything of the cache set that survived the shared call is reported, so a
-  // locked row is still visible in the result.
-  const cachesRemoved = cacheFiles.filter((file) => !fs.existsSync(file))
-
   const workspaceDetached = await withWorkspaceLock(() => detachFromWorkspace(ctx, sessionId))
-  if (removed.length === 0 && !workspaceDetached && !flushed && !detached && cachesRemoved.length === 0) {
+  if (removed === 0 && !workspaceDetached && !flushed && !detached && caches === 0) {
     throw new HttpError(404, 'not-found', 'session not found')
   }
-  return { removed: removed.length, caches: cachesRemoved.length, stopped, flushed, detached, workspaceDetached }
+
+  // Children last, and one failure never takes the parent result down with it:
+  // the parent is what the user clicked, so that click has to land.
+  const children = []
+  for (const childId of childSessionIds) {
+    try {
+      const childFiles = await retireSessionFiles(childId, recycle)
+      await withWorkspaceLock(() => detachFromWorkspace(ctx, childId))
+      children.push({ id: childId, removed: childFiles.removed, caches: childFiles.caches })
+    } catch (error) {
+      children.push({ id: childId, removed: 0, caches: 0, error: String((error && error.message) || error) })
+    }
+  }
+
+  return {
+    removed,
+    caches,
+    stopped,
+    flushed,
+    detached,
+    workspaceDetached,
+    children,
+  }
+}
+
+/**
+ * Take one session off the disk: its directories and its cache rows, then any
+ * directory the drain recreated. Shared by the parent and every child, so a
+ * subagent is retired exactly like the conversation the user clicked.
+ *
+ * @returns how many paths went away, and how many cache rows are now gone.
+ */
+async function retireSessionFiles(sessionId, recycle) {
+  const cacheFiles = findSessionCaches(sessionId)
+  const targets = [...findSessionDirs(sessionId), ...cacheFiles]
+  let gone = await retireTargets(targets, recycle)
+  await new Promise((resolve) => setImmediate(resolve))
+  gone = gone.concat(await retireTargets(findSessionDirs(sessionId), recycle))
+  return { removed: gone.length, caches: cacheFiles.filter((file) => !fs.existsSync(file)).length }
 }
 
 // --- artifacts: what a session touched, and quarantining it -----------------
@@ -1871,6 +2029,41 @@ export function apply(ctx) {
       },
     }))
 
+    // The subagent sessions behind one conversation. A subagent is a session of
+    // its own, linked only by `parentSession`, so the dialog needs this list
+    // before it can offer anything to tick.
+    fiber.effect(() => webServer.register({
+      kind: 'exact',
+      path: `${ROUTE_PREFIX}/children`,
+      handler: async (req, res) => {
+        if (!guard(req, res)) return
+        if (req.method !== 'POST') {
+          sendJson(res, 405, { ok: false, code: 'method', error: 'POST only' })
+          return
+        }
+        let body = {}
+        try {
+          const raw = await readBody(req)
+          if (raw) body = JSON.parse(raw)
+        } catch {
+          sendJson(res, 400, { ok: false, code: 'invalid', error: 'malformed JSON body' })
+          return
+        }
+        const sessionId = typeof body.sessionId === 'string' ? body.sessionId.trim() : ''
+        if (!SESSION_ID_RE.test(sessionId)) {
+          sendJson(res, 400, { ok: false, code: 'invalid', error: 'invalid session id' })
+          return
+        }
+        try {
+          const headers = await listSessionHeaders(ctx)
+          sendJson(res, 200, { ok: true, children: describeChildren(headers, sessionId) })
+        } catch (error) {
+          const status = error instanceof HttpError ? error.status : 500
+          const code = error instanceof HttpError ? error.code : 'internal'
+          sendJson(res, status, { ok: false, code, error: String((error && error.message) || error) })
+        }
+      },
+    }))
     fiber.effect(() => webServer.register({
       kind: 'exact',
       path: `${ROUTE_PREFIX}/delete`,
@@ -1907,7 +2100,10 @@ export function apply(ctx) {
             ? await planArtifacts(ctx, sessionId, undefined, { skipGit: body.quarantine.skipGit === true })
             : null
           const quarantine = await runQuarantine(ctx, sessionId, body.quarantine, plan)
-          const result = await deleteSession(ctx, sessionId, { recycle: body.recycle !== false })
+          const result = await deleteSession(ctx, sessionId, {
+            recycle: body.recycle !== false,
+            childSessionIds: Array.isArray(body.childSessionIds) ? body.childSessionIds : [],
+          })
           sendJson(res, 200, quarantine === null ? { ok: true, ...result } : { ok: true, ...result, quarantine })
         } catch (error) {
           const status = error instanceof HttpError ? error.status : 500
@@ -1952,7 +2148,10 @@ export function apply(ctx) {
         // deletions of the same storage.
         const results = await runWithConcurrency(sessionIds, BATCH_CONCURRENCY, async (sessionId) => {
           try {
-            const result = await deleteSession(ctx, sessionId, { recycle: body.recycle !== false })
+            const result = await deleteSession(ctx, sessionId, {
+              recycle: body.recycle !== false,
+              childSessionIds: Array.isArray(body.childSessionIds) ? body.childSessionIds : [],
+            })
             return { sessionId, ok: true, removed: result.removed }
           } catch (error) {
             return {
@@ -1997,8 +2196,15 @@ export const internals = {
   quarantineFiles,
   resolveQuarantineRoot,
   removeForever,
+  deleteSession,
   retirePaths,
   retireTargets,
+  listSessionHeaders,
+  collectOrphans,
+  collectDescendants,
+  bareSessionId,
+  describeChildren,
+  selectChildDeletes,
   runQuarantine,
   sendToRecycleBin,
   toolTarget,

package/test/artifacts.host.test.js

@@ -951,3 +951,191 @@ test('the switch decides between staging for the bin and removing outright', asy
   const stagedAfterPermanent = fs.readdirSync(HOME_ROOT).filter((n) => n.startsWith('session-trash-')).length
   assert.equal(stagedAfterPermanent, stagedBeforePermanent, 'a permanent delete stages nothing')
 })
+
+// --- subagent sessions are separate sessions, linked by parentSession ------
+
+const header = (id, parentSession) => (parentSession === undefined ? { id } : { id, parentSession })
+
+function fakeContext(services) {
+  return { get: (name) => services[name] }
+}
+
+test('a delete finds the grandchildren behind a child, not just the children', () => {
+  const headers = [
+    header('session-parent'),
+    header('session-child', 'session-parent'),
+    header('session-grandchild', 'session-child'),
+  ]
+
+  const found = internals.collectDescendants(headers, 'session-parent')
+
+  assert.deepEqual(found.map((h) => h.id), ['session-child', 'session-grandchild'],
+    'parents come before their own children')
+})
+
+test('a parent link matches whether or not either id carries the prefix', () => {
+  const headers = [
+    header('session-parent'),
+    header('child-uuid', 'parent-uuid'),
+  ]
+
+  const found = internals.collectDescendants(headers, 'parent-uuid')
+
+  assert.deepEqual(found.map((h) => h.id), ['child-uuid'])
+})
+
+test('a session that names itself as its parent does not loop forever', () => {
+  const headers = [
+    header('session-parent'),
+    header('session-child', 'session-child'),
+  ]
+
+  const found = internals.collectDescendants(headers, 'session-parent')
+
+  assert.deepEqual(found, [], 'a self-parented session is not its own descendant')
+})
+
+test('an orphan is a session whose parent is gone', () => {
+  const headers = [
+    header('session-parent'),
+    header('session-kept', 'session-parent'),
+    header('session-orphan', 'session-deleted-long-ago'),
+  ]
+
+  const orphans = internals.collectOrphans(headers)
+
+  assert.deepEqual(orphans.map((h) => h.id), ['session-orphan'])
+})
+
+test('session headers come from the query service when the host has one', async () => {
+  const headers = [header('session-a'), header('session-b', 'session-a')]
+  const ctx = fakeContext({
+    sessionQuery: { listSessions: async () => headers.map((h) => ({ header: h })) },
+    sessionPersistence: { list: async () => { throw new Error('should not be reached') } },
+  })
+
+  const listed = await internals.listSessionHeaders(ctx)
+
+  assert.deepEqual(listed.map((h) => h.id), ['session-a', 'session-b'])
+})
+
+test('session headers fall back to persistence when there is no query service', async () => {
+  const headers = [header('session-a')]
+  const ctx = fakeContext({ sessionPersistence: { list: async () => headers.map((h) => ({ header: h })) } })
+
+  const listed = await internals.listSessionHeaders(ctx)
+
+  assert.deepEqual(listed.map((h) => h.id), ['session-a'])
+})
+
+test('a host that can list nothing yields no headers rather than throwing', async () => {
+  const listed = await internals.listSessionHeaders(fakeContext({}))
+  assert.deepEqual(listed, [])
+})
+
+test('the child list carries a depth so nesting is visible in the dialog', () => {
+  const headers = [
+    header('session-parent'),
+    { id: 'session-child', parentSession: 'session-parent', cwd: 'E:\\work' },
+    { id: 'session-grandchild', parentSession: 'session-child', cwd: 'E:\\work' },
+  ]
+
+  const children = internals.describeChildren(headers, 'session-parent')
+
+  assert.deepEqual(children, [
+    { id: 'session-child', depth: 1, cwd: 'E:\\work' },
+    { id: 'session-grandchild', depth: 2, cwd: 'E:\\work' },
+  ])
+})
+
+test('only the ids the user picked, and only real descendants, are deleted', () => {
+  const headers = [
+    header('session-parent'),
+    header('session-child', 'session-parent'),
+    header('session-grandchild', 'session-child'),
+    header('session-unrelated'),
+  ]
+
+  const picked = internals.selectChildDeletes(headers, 'session-parent', [
+    'session-child',
+    'session-unrelated',
+    'session-does-not-exist',
+  ])
+
+  assert.deepEqual(picked, ['session-child'], 'an unrelated id can never ride along on a delete')
+})
+
+test('a picked child is matched by its bare uuid but deleted under its own id', () => {
+  const headers = [
+    header('session-parent'),
+    header('session-grandchild', 'session-child'),
+    header('session-child', 'session-parent'),
+  ]
+
+  // The dialog may hold either spelling; the delete always uses the header's own.
+  const picked = internals.selectChildDeletes(headers, 'session-parent', ['child'])
+
+  assert.deepEqual(picked, ['session-child'], 'the bare uuid matches the prefixed id')
+  const byPrefixed = internals.selectChildDeletes(headers, 'session-parent', ['session-child'])
+  assert.deepEqual(byPrefixed, ['session-child'], 'and the prefixed one matches too')
+  const unrelated = internals.selectChildDeletes(headers, 'session-parent', ['session-grandchild-ish'])
+  assert.deepEqual(unrelated, [], 'a near miss is not a descendant')
+})
+
+test('no picked children means the parent goes alone', () => {
+  const headers = [header('session-parent'), header('session-child', 'session-parent')]
+
+  assert.deepEqual(internals.selectChildDeletes(headers, 'session-parent', undefined), [])
+  assert.deepEqual(internals.selectChildDeletes(headers, 'session-parent', []), [])
+})
+
+const PARENT_ID = 'session-22222222-2222-4222-8222-222222222222'
+const CHILD_ID = 'session-11111111-1111-4111-8111-111111111111'
+const OTHER_ID = 'session-33333333-3333-4333-8333-333333333333'
+
+/** Plant a session the way the JSONL backend lays one out, plus its cache row. */
+function plantSession(id) {
+  const dir = path.join(HOME_ROOT, 'sessions', '--tmp-work--', id)
+  fs.mkdirSync(dir, { recursive: true })
+  fs.writeFileSync(path.join(dir, 'session.v4.jsonl.zstd'), 'x')
+  const cache = path.join(HOME_ROOT, 'storages', 'session_projcache', 'sessions', `${id}.json`)
+  fs.mkdirSync(path.dirname(cache), { recursive: true })
+  fs.writeFileSync(cache, '{}')
+  return { dir, cache }
+}
+
+const serviceFree = { get: () => undefined }
+
+test('a delete takes the child sessions it was handed with it', async () => {
+  const parent = plantSession(PARENT_ID)
+  const child = plantSession(CHILD_ID)
+  const bystander = plantSession(OTHER_ID)
+
+  await internals.deleteSession(serviceFree, PARENT_ID, { recycle: false, childSessionIds: [CHILD_ID] })
+
+  assert.equal(fs.existsSync(parent.dir), false, 'the parent is gone')
+  assert.equal(fs.existsSync(child.dir), false, 'the ticked child went with it')
+  assert.equal(fs.existsSync(child.cache), false, 'and so did the child cache row')
+  assert.equal(fs.existsSync(bystander.dir), true, 'a session nobody ticked stays')
+})
+
+test('without a child list the parent goes alone', async () => {
+  const parent = plantSession(PARENT_ID)
+  const child = plantSession(CHILD_ID)
+
+  await internals.deleteSession(serviceFree, PARENT_ID, { recycle: false })
+
+  assert.equal(fs.existsSync(parent.dir), false)
+  assert.equal(fs.existsSync(child.dir), true, 'unticked children are left standing')
+})
+
+test('the delete reports which children failed', async () => {
+  const parent = plantSession(PARENT_ID)
+
+  const result = await internals.deleteSession(serviceFree, PARENT_ID, {
+    recycle: false,
+    childSessionIds: ['not-a-session-id'],
+  })
+
+  assert.equal(result.children.length, 0, 'an invalid id never becomes a child delete')
+})

package/test/checkbox.dom.test.js

@@ -307,6 +307,11 @@ async function loadPlugin(options = {}) {
       const plan = options.plan ?? { created: [], modified: [], refused: [], truncated: false, warnings: [] }
       return { ok: true, status: 200, json: async () => ({ ok: true, ...plan }) }
     }
+    // The subagent sessions behind one conversation.
+    if (href.endsWith('/dsh-delete-session/children')) {
+      const children = options.children ?? []
+      return { ok: true, status: 200, json: async () => ({ ok: true, children }) }
+    }
     // The folder picker asks for one directory listing per navigation.
     if (href.endsWith('/dsh-delete-session/browse')) {
       const asked = JSON.parse((init && init.body) || '{}')
@@ -632,7 +637,7 @@ test('the delete row reads its session id from the host props, not from a fiber'
   element.props.onSelect({ shiftKey: false })
   const parts = dialogParts(harness)
   assert.ok(parts, 'the dialog opened for the id the host injected')
-  assert.equal(harness.requests.length, 0, 'opening the dialog sends nothing yet')
+  assert.equal(deleteCalls(harness), 0, 'opening the dialog deletes nothing yet')
 })
 
 test('shift-click forces the dialog even after asking was turned off', async () => {
@@ -651,7 +656,7 @@ test('shift-click forces the dialog even after asking was turned off', async ()
   const forced = deleteRow(harness)
   forced.element.props.onSelect({ shiftKey: true })
   assert.ok(dialogParts(harness), 'shift-click brings the dialog back')
-  assert.equal(harness.requests.length, 1, 'and still sends nothing until confirmed')
+  assert.equal(deleteCalls(harness), 1, 'and still deletes nothing until confirmed')
 })
 
 // --- the regression ---------------------------------------------------------
@@ -896,6 +901,9 @@ const rowConfig = (harness) =>
 const pageCard = (harness, view = 'page') => rowConfig(harness).Component({ view })
 // The settings belonging to the master switch live in a nested container, so the
 // walk descends into any element that carries a children list.
+/** Only the delete request itself: opening the dialog now reads one thing. */
+const deleteCalls = (harness) =>
+  harness.requests.filter((call) => call.url === '/dsh-delete-session/delete').length
 const collectChecks = (nodes, harness, out = []) => {
   for (const node of nodes || []) {
     if (node === null || node === undefined) continue
@@ -1047,7 +1055,7 @@ test('the produced-files feature ships off: no scan, no section, no quarantine f
 
 test('the page hides the artifact sub-controls while the master switch is on', async () => {
   const harness = await loadPlugin()
-  assert.equal(pageChecks(harness).length, 3, 'ask, recycle and the master switch render')
+  assert.equal(pageChecks(harness).length, 4, 'ask, recycle, subagents and the master switch render')
   assert.equal(offCheckbox(harness).props.checked, true, 'the master switch starts ticked')
 })
 
@@ -1056,7 +1064,7 @@ test('clearing the master switch reveals the auto and scope controls', async ()
   offCheckbox(harness).props.onChange(false)
 
   assert.equal(localStorage.getItem(OFF_KEY), '0', 'the opt-in was stored')
-  assert.equal(pageChecks(harness).length, 7, 'the sub-controls render once enabled')
+  assert.equal(pageChecks(harness).length, 8, 'the sub-controls render once enabled')
   assert.equal(autoCheckbox(harness).props.checked, false, 'asking is the default once enabled')
   assert.equal(scopeCreatedCheckbox(harness).props.checked, true, 'created-only is the default scope')
   assert.equal(scopeAllCheckbox(harness).props.checked, false)
@@ -1842,3 +1850,98 @@ test('unchecking it switches both the sentence and the request to a hard delete'
   await flush()
   assert.equal(deleteBody(harness).recycle, false, 'the host is told to remove it outright')
 })
+
+// --- subagent sessions: ticked in the dialog, or taken with the parent ------
+
+const SYNC_CHILDREN_KEY = 'dsh-delete-session:sync-children'
+const CHILDREN = [
+  { id: 'session-child-one', depth: 1, cwd: 'E:\\work' },
+  { id: 'session-child-two', depth: 2, cwd: 'E:\\work' },
+]
+
+const childChecks = (harness) => {
+  const modal = dialogElement(harness)
+  if (modal === null) return []
+  const section = (modal.props.children ?? []).filter(Boolean).find((node) => node.props.key === 'children')
+  return section === undefined ? [] : collectChecks([section], harness)
+}
+
+test('the page offers to take child sessions with their parent, off by default', async () => {
+  const harness = await loadPlugin()
+  const box = pageCheck(harness, 'syncChildren')
+
+  assert.ok(box, 'the switch renders with the other delete controls')
+  assert.equal(box.props.checked, false, 'asking is the default')
+  assert.equal(box.props.label, '同时删除子会话')
+
+  box.props.onChange(true)
+  assert.equal(localStorage.getItem(SYNC_CHILDREN_KEY), '1', 'the choice is remembered')
+})
+
+test('with the switch off the dialog lists the children, ticked, for you to narrow', async () => {
+  const harness = await loadPlugin({ children: CHILDREN })
+  mountRow(harness, SESSION_A)
+
+  const { element } = deleteRow(harness, SESSION_A)
+  element.props.onSelect({ shiftKey: false })
+  await flush()
+
+  const checks = childChecks(harness)
+  assert.equal(checks.length, 2, 'every child is offered')
+  assert.deepEqual(checks.map((c) => c.props.checked), [true, true], 'they start ticked')
+})
+
+test('unticking a child keeps it out of the delete', async () => {
+  const harness = await loadPlugin({ children: CHILDREN })
+  mountRow(harness, SESSION_A)
+
+  const { element } = deleteRow(harness, SESSION_A)
+  element.props.onSelect({ shiftKey: false })
+  await flush()
+
+  childChecks(harness)[0].props.onChange(false)
+  dialogParts(harness).confirm.props.onClick()
+  await flush()
+
+  assert.deepEqual(deleteBody(harness).childSessionIds, ['session-child-two'], 'only the remaining tick is deleted')
+})
+
+test('with the switch on the children ride along without asking', async () => {
+  const harness = await loadPlugin({ children: CHILDREN })
+  localStorage.setItem(SYNC_CHILDREN_KEY, '1')
+  mountRow(harness, SESSION_A)
+
+  const { element } = deleteRow(harness, SESSION_A)
+  element.props.onSelect({ shiftKey: false })
+  await flush()
+
+  assert.equal(childChecks(harness).length, 0, 'no list when the switch already answered')
+
+  dialogParts(harness).confirm.props.onClick()
+  await flush()
+
+  assert.deepEqual(
+    deleteBody(harness).childSessionIds,
+    ['session-child-one', 'session-child-two'],
+    'every child goes with the parent',
+  )
+})
+
+// --- the quiet repository link at the bottom of the page --------------------
+
+test('the page ends with a quiet link to the repository', async () => {
+  const harness = await loadPlugin()
+  const card = pageCard(harness)
+  const star = findByKey(card.props.children, 'star')[0]
+
+  assert.ok(star, 'the star line renders with the card')
+  assert.match(star.props.className, /dsdel-star\b/)
+
+  const [ask, cta] = star.props.children
+  assert.equal(ask.props.children, '⭐ 顺手留颗 Star，作者能高兴一整天')
+  assert.equal(cta.type, 'a', 'the call to action is a real link')
+  assert.equal(cta.props.href, 'https://github.com/DDDMUC/dsh-delete-session')
+  assert.equal(cta.props.target, '_blank')
+  assert.equal(cta.props.rel, 'noreferrer')
+  assert.equal(cta.props.children, '行，给你一颗 Star')
+})