dsh-delete-session 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DDDMUC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,64 @@
+# dsh-delete-session
+
+English | [中文](README.zh.md)
+
+Delete sessions right from the DSH Web sidebar. The session row's `...` menu
+(rename / fork / archive) gets one more action: **Delete session**. A
+risk-consent dialog shows the session name and id, and confirming removes the
+session log, its workspace accounting and its live session state.
+
+Built for DeepSeek Harness (DSH) Web, tested on `0.1.5-rc.1`.
+
+## Features
+
+- **Delete session** in the sidebar session `...` menu, without switching to
+  the conversation (the session id is read from the menu's React fiber, so the
+  action always targets the row you clicked).
+- **Risk-consent dialog**: shows the session title and id; the confirm button
+  stays disabled until the acknowledgement checkbox is ticked.
+- **Real deletion**: stops a running agent (cancel + quiescence), flushes and
+  detaches the live session, removes every on-disk session directory (both the
+  raw and `session-` prefixed id), verifies through the persistence service,
+  then detaches the session from workspace accounting so the sidebar drops the
+  row instead of showing an orphan under "Ungrouped".
+- **Safe by default**: the host route is loopback-only (loopback socket,
+  loopback Host header, same-origin check); a session still held open by DSH
+  is refused with a clear message instead of racing the active writer.
+- **Bilingual**: the menu item and dialog follow the DSH interface language
+  (zh / en) when the locale service is present, with a browser-language
+  fallback.
+
+## Install
+
+```sh
+dsh plugin --profile web add github:DDDMUC/dsh-delete-session
+```
+
+Then restart `dsh web`. The item appears in the sidebar session `...` menu.
+
+## How it works
+
+- `src/index.js` (host) registers one loopback-only route:
+  `POST /dsh-delete-session/delete` `{ sessionId }`.
+- `src/client.js` (browser) is a classic client bundle: it watches for the
+  portalled session menu (`body > [role="menu"]`), walks the React fiber chain
+  to the session node (`props.node.id`), clones a native menu row for styling,
+  and opens the confirmation dialog.
+- No DSH SDK imports: every service (`sessions`, `sessionPersistence`,
+  `agents`, `workspaceRegistry`, `webServer`) is resolved through the cordis
+  context at call time, and the plugin degrades to filesystem cleanup when a
+  service is absent.
+
+## Known limitations
+
+- A session that DSH currently holds open cannot be deleted: the runtime
+  exposes no public way to release the write ownership, so the request is
+  refused with a message asking to restart DSH and retry.
+- The sidebar menu injection is a DOM shim. Core UI changes to the menu markup
+  or the row fiber shape may require a plugin update; the menu item is simply
+  not injected when the contract changes, and nothing else breaks.
+- Deletion is permanent. There is no trash bin and no undo.
+
+## License
+
+MIT

package/README.zh.md

@@ -0,0 +1,52 @@
+# dsh-delete-session
+
+[English](README.md) | 中文
+
+在 DSH Web 侧边栏直接删除会话：会话行的 `...` 菜单（重命名 / 分叉 / 归档）里会多出一项
+**删除会话**。点击后弹出风险确认对话框（显示会话名称与 ID），确认后删除会话日志、
+工作区记账与宿主内存中的会话状态。
+
+为 DeepSeek Harness（DSH）Web 构建，已在 `0.1.5-rc.1` 上实测。
+
+## 功能
+
+- **侧边栏会话菜单里的「删除会话」**：无需切换会话（会话 ID 从菜单的 React fiber 读取，
+  永远作用于你点击的那一行）。
+- **风险确认对话框**：显示会话标题与 ID；勾选「我已了解，永久删除」前确认按钮不可用。
+- **真正的删除**：停止运行中的 agent（cancel + 等待空闲）、flush 并 detach 活跃会话、
+  删除磁盘上的全部会话目录（原始 ID 与 `session-` 前缀两种写法）、经持久化服务复核，
+  最后从工作区记账中移除，避免侧栏残留「未分组」孤儿。
+- **默认安全**：宿主路由仅限本机回环（回环 socket + 回环 Host 头 + 同源校验）；
+  被 DSH 打开占用中的会话会被明确拒绝，而不是与活跃写者竞争。
+- **中英双语**：菜单项与对话框跟随 DSH 界面语言（存在 locale 服务时），否则按浏览器语言回退。
+
+## 安装
+
+```sh
+dsh plugin --profile web add github:DDDMUC/dsh-delete-session
+```
+
+重启 `dsh web` 后，在侧边栏会话 `...` 菜单中即可看到「删除会话」。
+
+## 工作原理
+
+- `src/index.js`（宿主）：注册一条仅限回环的路由
+  `POST /dsh-delete-session/delete` `{ sessionId }`。
+- `src/client.js`（浏览器）：经典客户端 bundle——监听 portal 到 body 的会话菜单
+  （`body > [role="menu"]`），沿 React fiber 链读取会话节点（`props.node.id`），
+  克隆原生菜单行保持样式一致，然后打开确认对话框。
+- 不引入任何 DSH SDK：所有服务（`sessions`、`sessionPersistence`、`agents`、
+  `workspaceRegistry`、`webServer`）都在调用时通过 cordis 上下文获取；
+  服务缺失时退化为纯文件系统清理。
+
+## 已知限制
+
+- 被 DSH 当前打开占用的会话无法删除：运行时没有公开的写所有权释放入口，
+  因此会明确拒绝并提示「重启 DSH 后再试」。
+- 侧边栏菜单注入是 DOM shim。核心 UI 若调整菜单结构或行 fiber 形状，可能需要插件跟进更新；
+  契约变化时插件只是不再注入菜单项，不会影响其他功能。
+- 删除不可恢复：没有回收站，也没有撤销。
+
+## License
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,7 @@
+# dsh-delete-session bundle patch: inserts the plugin row into the profile
+# roster. The node half serves the /dsh-delete-session/* JSON routes; the
+# browser half (exports "./client") injects the sidebar session-row menu item
+# and the confirmation dialog.
+- insert:
+    - id: dsh-delete-session
+      name: 'dsh-delete-session'

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "dsh-delete-session",
+  "version": "0.1.1",
+  "description": "Delete sessions from the DSH Web sidebar: adds a Delete action to the session row menu with a risk-consent dialog, then removes the session log, workspace accounting and live session state.",
+  "type": "module",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./client": "./src/client.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "cordis.patch.yml",
+    "README.md",
+    "README.zh.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "session",
+    "delete"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DDDMUC/dsh-delete-session.git"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime"
+      ],
+      "platform": "web"
+    }
+  }
+}

package/src/client.js

@@ -0,0 +1,347 @@
+// dsh-delete-session - client half.
+//
+// DSH's sidebar session-row "..." menu (rename / fork / archive) is rendered
+// by the core UI and offers no plugin slot for extra rows, so the delete item
+// is injected at the DOM level:
+//
+//   * watch for the portalled session menu (body > [role="menu"]);
+//   * walk the React fiber chain from that menu to the session node and read
+//     its real id (props.node.id) - no title matching, no conversation jump;
+//   * clone a native menu row so the new item keeps the core styling;
+//   * open a risk-consent dialog and POST /dsh-delete-session/delete.
+//
+// The module is a classic client bundle (client-modules protocol): it
+// registers a factory with window.__ModuleLoader__ and returns apply().
+// No React, no SDK imports - theme tokens and DOM only, so it survives core
+// UI revisions that keep the menu contract.
+window.__ModuleLoader__.load({
+  id: 'dsh-delete-session',
+  factory: () => {
+    const NS = 'dsh-delete-session'
+
+    const zh = {
+      menu: '删除会话',
+      title: '删除会话',
+      desc: '将永久删除该会话及其全部对话记录（会话日志、工作区记账与统计），此操作不可恢复。',
+      cancel: '取消',
+      confirm: '删除',
+      deleting: '删除中…',
+      ack: '我已了解，永久删除',
+      done: '已删除会话',
+      failed: '删除失败：',
+      busy: '该会话正被 DSH 打开，暂时无法删除；请重启 DSH 后再试。',
+      notFound: '未找到该会话（可能已被删除）。',
+      untitled: '未命名会话',
+    }
+
+    const en = {
+      menu: 'Delete session',
+      title: 'Delete session',
+      desc: 'This permanently deletes the session and all of its conversation records (log, workspace accounting and statistics). This action cannot be undone.',
+      cancel: 'Cancel',
+      confirm: 'Delete',
+      deleting: 'Deleting...',
+      ack: 'I understand - delete permanently',
+      done: 'Session deleted',
+      failed: 'Delete failed: ',
+      busy: 'This session is currently open in DSH and cannot be deleted yet. Restart DSH and try again.',
+      notFound: 'Session not found (it may already be deleted).',
+      untitled: 'Untitled session',
+    }
+
+    let localeSvc = null
+    let sessionsSvc = null
+
+    function browserLang() {
+      if (typeof navigator === 'undefined') return 'zh'
+      for (const tag of (navigator.languages || []).concat([navigator.language])) {
+        const primary = String(tag || '').toLowerCase().split('-')[0]
+        if (primary === 'zh' || primary === 'en') return primary
+      }
+      return 'zh'
+    }
+
+    function t(key) {
+      if (localeSvc && typeof localeSvc.translate === 'function') {
+        try {
+          const text = localeSvc.translate(NS, key)
+          if (typeof text === 'string' && text !== key) return text
+        } catch {
+          // fall back to the built-in dictionaries
+        }
+      }
+      return (browserLang() === 'en' ? en : zh)[key] || key
+    }
+
+    // --- fiber access ----------------------------------------------------------
+
+    function findFiber(el) {
+      const key = Object.keys(el).find((k) => k.startsWith('__reactFiber') || k.startsWith('__reactInternalInstance'))
+      return key ? el[key] : null
+    }
+
+    // Walk up from the portalled menu element to the session row component
+    // that carries `node.id`. A menu without such a node is not a session
+    // menu (settings, header dropdowns) and is left alone.
+    function sessionInfoFromMenu(menuEl) {
+      let fiber = findFiber(menuEl)
+      let guard = 0
+      while (fiber && guard++ < 300) {
+        const props = fiber.memoizedProps
+        if (props && props.node && typeof props.node.id === 'string' && props.node.id) {
+          const title = props.node.title || props.node.name || null
+          return { id: props.node.id, title: typeof title === 'string' ? title : null }
+        }
+        fiber = fiber.return
+      }
+      return null
+    }
+
+    // --- styles ----------------------------------------------------------------
+
+    const CSS = [
+      '.dsdel-backdrop{position:fixed;inset:0;z-index:2147483600;background:rgba(0,0,0,.58);display:flex;align-items:center;justify-content:center;padding:16px}',
+      '.dsdel-dialog{width:min(420px,92vw);border:1px solid var(--dsw-alias-border-l3,rgba(128,128,128,.3));border-radius:14px;padding:18px;box-shadow:0 16px 48px rgba(0,0,0,.32);display:flex;flex-direction:column;gap:12px;color:var(--dsw-alias-label-primary,inherit);background:linear-gradient(var(--dsw-alias-bg-layer-2,#fff),var(--dsw-alias-bg-layer-2,#fff)),linear-gradient(var(--dsw-alias-bg-layer-2,#fff),var(--dsw-alias-bg-layer-2,#fff)),linear-gradient(var(--dsw-alias-bg-layer-2,#fff),var(--dsw-alias-bg-layer-2,#fff)),var(--dsw-alias-bg-base,#fff);-webkit-backdrop-filter:blur(18px) saturate(140%);backdrop-filter:blur(18px) saturate(140%)}',
+      '.dsdel-title{font-size:15px;font-weight:650;color:var(--dsw-alias-label-primary,inherit);margin:0}',
+      '.dsdel-text{font-size:13px;line-height:1.6;color:var(--dsw-alias-label-secondary,#666);margin:0;word-break:break-all}',
+      '.dsdel-meta{font-size:12px;line-height:1.6;color:var(--dsw-alias-label-tertiary,#888);margin:0;word-break:break-all}',
+      '.dsdel-ack{display:flex;align-items:center;gap:8px;font-size:13px;line-height:20px;color:var(--dsw-alias-label-primary,inherit);cursor:pointer}',
+      '.dsdel-ack input{width:15px;height:15px;accent-color:var(--dsw-alias-state-error-primary,#e5484d);cursor:pointer;flex:none}',
+      '.dsdel-error{font-size:12px;line-height:16px;color:var(--dsw-alias-state-error-primary,#e5484d);margin:0}',
+      '.dsdel-actions{display:flex;justify-content:flex-end;gap:8px;margin-top:2px}',
+      '.dsdel-btn{appearance:none;min-height:32px;padding:0 14px;border:1px solid var(--dsw-alias-border-l2,rgba(128,128,128,.4));background:var(--dsw-alias-fill-elevated,rgba(128,128,128,.08));color:var(--dsw-alias-label-primary,inherit);border-radius:8px;font-size:13px;cursor:pointer}',
+      '.dsdel-btn:disabled{opacity:.5;cursor:default}',
+      '.dsdel-danger{border-color:var(--dsw-alias-state-error-primary,#e5484d);background:var(--dsw-alias-state-error-primary,#e5484d);color:#fff}',
+      '.dsdel-toast{position:fixed;bottom:20px;left:50%;transform:translateX(-50%);z-index:2147483601;background:Canvas;color:CanvasText;border:1px solid color-mix(in srgb,CanvasText 25%,transparent);padding:9px 16px;border-radius:999px;font-size:12px;box-shadow:0 8px 24px rgba(0,0,0,.25);max-width:min(92vw,460px);cursor:pointer}',
+    ].join('')
+
+    function ensureStyle() {
+      if (document.querySelector('style[data-dsh-delete-session]')) return
+      const style = document.createElement('style')
+      style.dataset.dshSessionDelete = '1'
+      style.textContent = CSS
+      document.head.appendChild(style)
+    }
+
+    // --- feedback --------------------------------------------------------------
+
+    function closeMenu() {
+      try { document.dispatchEvent(new MouseEvent('mousedown', { bubbles: true })) } catch { /* ignore */ }
+      try { document.dispatchEvent(new PointerEvent('pointerdown', { bubbles: true })) } catch { /* ignore */ }
+    }
+
+    function toast(text, isError) {
+      const el = document.createElement('div')
+      el.className = 'dsdel-toast'
+      el.setAttribute('role', 'status')
+      el.textContent = text
+      if (isError) {
+        el.style.background = '#4A1D1D'
+        el.style.color = '#FFD9D9'
+      }
+      document.body.appendChild(el)
+      const kill = () => el.remove()
+      el.addEventListener('click', kill)
+      setTimeout(kill, 3200)
+    }
+
+    function refreshList() {
+      const svc = sessionsSvc
+      if (svc) {
+        try {
+          if (typeof svc.refresh === 'function') { svc.refresh(); return }
+          if (typeof svc.refreshList === 'function') { svc.refreshList(); return }
+        } catch {
+          // fall through to reload
+        }
+      }
+      try { window.location.reload() } catch { /* ignore */ }
+    }
+
+    // --- dialog ----------------------------------------------------------------
+
+    function openDialog(info) {
+      ensureStyle()
+      const backdrop = document.createElement('div')
+      backdrop.className = 'dsdel-backdrop'
+      const dialog = document.createElement('div')
+      dialog.className = 'dsdel-dialog'
+
+      const title = document.createElement('h3')
+      title.className = 'dsdel-title'
+      title.textContent = t('title')
+
+      const meta = document.createElement('p')
+      meta.className = 'dsdel-meta'
+      meta.textContent = `${info.title || t('untitled')} · ${info.id}`
+
+      const text = document.createElement('p')
+      text.className = 'dsdel-text'
+      text.textContent = t('desc')
+
+      const ack = document.createElement('label')
+      ack.className = 'dsdel-ack'
+      const checkbox = document.createElement('input')
+      checkbox.type = 'checkbox'
+      const ackText = document.createElement('span')
+      ackText.textContent = t('ack')
+      ack.appendChild(checkbox)
+      ack.appendChild(ackText)
+
+      const error = document.createElement('p')
+      error.className = 'dsdel-error'
+      error.style.display = 'none'
+
+      const actions = document.createElement('div')
+      actions.className = 'dsdel-actions'
+      const cancel = document.createElement('button')
+      cancel.type = 'button'
+      cancel.className = 'dsdel-btn'
+      cancel.textContent = t('cancel')
+      const confirm = document.createElement('button')
+      confirm.type = 'button'
+      confirm.className = 'dsdel-btn dsdel-danger'
+      confirm.textContent = t('confirm')
+      confirm.disabled = true
+      actions.appendChild(cancel)
+      actions.appendChild(confirm)
+
+      dialog.appendChild(title)
+      dialog.appendChild(meta)
+      dialog.appendChild(text)
+      dialog.appendChild(ack)
+      dialog.appendChild(error)
+      dialog.appendChild(actions)
+      backdrop.appendChild(dialog)
+      document.body.appendChild(backdrop)
+
+      let busy = false
+      const close = () => {
+        if (busy) return
+        backdrop.remove()
+      }
+      checkbox.addEventListener('change', () => { confirm.disabled = !checkbox.checked })
+      cancel.addEventListener('click', close)
+      backdrop.addEventListener('click', (e) => { if (e.target === backdrop) close() })
+      backdrop.addEventListener('keydown', (e) => { if (e.key === 'Escape') close() })
+
+      confirm.addEventListener('click', () => {
+        if (busy || !checkbox.checked) return
+        busy = true
+        confirm.disabled = true
+        cancel.disabled = true
+        confirm.textContent = t('deleting')
+        error.style.display = 'none'
+        fetch('/dsh-delete-session/delete', {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ sessionId: info.id }),
+        })
+          .then(async (res) => {
+            let data = {}
+            try { data = await res.json() } catch { /* keep {} */ }
+            if (!res.ok || !data.ok) {
+              const code = data && data.code
+              const message = code === 'busy'
+                ? t('busy')
+                : code === 'not-found'
+                  ? t('notFound')
+                  : (data && data.error) || `HTTP ${res.status}`
+              throw new Error(message)
+            }
+            backdrop.remove()
+            toast(t('done'))
+            refreshList()
+          })
+          .catch((reason) => {
+            busy = false
+            confirm.disabled = !checkbox.checked
+            cancel.disabled = false
+            confirm.textContent = t('confirm')
+            error.textContent = t('failed') + String((reason && reason.message) || reason)
+            error.style.display = 'block'
+          })
+      })
+    }
+
+    // --- sidebar menu injection ------------------------------------------------
+
+    const TRASH_ICON = '<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M4 7h16"/><path d="M10 11v6"/><path d="M14 11v6"/><path d="M6 7l1 13a1 1 0 0 0 1 1h8a1 1 0 0 0 1-1l1-13"/><path d="M9 7V4h6v3"/></svg>'
+
+    function augmentMenu(menuEl, info) {
+      if (menuEl.querySelector('[data-dsh-delete-session]')) return
+      const viewport = menuEl.querySelector('[role="presentation"]') || menuEl.firstElementChild
+      if (!viewport) return
+      const proto = menuEl.querySelector('[role="menuitem"]')
+      if (!proto) return
+      const protoWrap = proto.parentElement
+      const wrap = protoWrap ? protoWrap.cloneNode(false) : document.createElement('div')
+      if (protoWrap && protoWrap.className) wrap.className = protoWrap.className
+
+      const button = document.createElement('button')
+      button.type = 'button'
+      button.setAttribute('role', 'menuitem')
+      button.setAttribute('data-dsh-delete-session', '1')
+      if (proto.className) button.className = proto.className
+      button.style.color = 'var(--dsw-alias-state-error-primary,#e5484d)'
+
+      const icon = document.createElement('span')
+      icon.style.cssText = 'display:inline-flex;flex:none;width:16px;height:16px;align-items:center;justify-content:center'
+      icon.innerHTML = TRASH_ICON
+      const label = document.createElement('span')
+      label.style.cssText = 'flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap'
+      label.textContent = t('menu')
+
+      button.appendChild(icon)
+      button.appendChild(label)
+      button.addEventListener('click', (e) => {
+        e.stopPropagation()
+        e.preventDefault()
+        closeMenu()
+        openDialog(info)
+      })
+      wrap.appendChild(button)
+      viewport.appendChild(wrap)
+
+      // The portalled menu measured its height before this row existed; nudge
+      // the core placement so the grown card is re-clamped on screen.
+      window.dispatchEvent(new Event('resize'))
+    }
+
+    function install() {
+      if (typeof document === 'undefined' || !document.body) return null
+      ensureStyle()
+      const seen = new WeakSet()
+      const scan = () => {
+        const menus = document.querySelectorAll('body > [role="menu"]')
+        menus.forEach((menuEl) => {
+          if (seen.has(menuEl)) return
+          let info = null
+          try { info = sessionInfoFromMenu(menuEl) } catch { /* ignore */ }
+          if (!info) return
+          seen.add(menuEl)
+          try { augmentMenu(menuEl, info) } catch { /* best-effort DOM shim */ }
+        })
+      }
+      scan()
+      const observer = new MutationObserver(scan)
+      observer.observe(document.body, { childList: true, subtree: false })
+      return () => observer.disconnect()
+    }
+
+    function apply(ctx) {
+      sessionsSvc = ctx.get('sessions') || null
+      if (!sessionsSvc) {
+        try { ctx.inject(['sessions'], (sub) => { sessionsSvc = sub.sessions }) } catch { /* optional */ }
+      }
+      localeSvc = ctx.get('locale') || null
+      if (!localeSvc) {
+        try { ctx.inject(['locale'], (sub) => { localeSvc = sub.locale }) } catch { /* optional */ }
+      }
+      const dispose = install()
+      if (dispose) ctx.effect(() => dispose)
+    }
+
+    return { apply }
+  },
+})

package/src/index.js

@@ -0,0 +1,369 @@
+// dsh-delete-session - host half.
+//
+// One loopback-only HTTP route serves the client menu item:
+//
+//   POST /dsh-delete-session/delete   { sessionId }
+//
+// Deletion pipeline, kept consistent with the live DSH services so in-memory
+// state and on-disk units cannot disagree after the request returns:
+//
+//   1. stop a running agent (cancel + time-boxed quiescence) when one exists;
+//   2. flush and detach the live session so its async dispose cannot rewrite
+//      the log directory after we remove it, and wait for the persistence
+//      retirement that session/disposed starts;
+//   3. take the persistence write lease briefly: a busy lease means the
+//      session is still open in DSH, so the request is refused with 409
+//      instead of racing the active writer;
+//   4. remove every on-disk session directory (raw id and session- prefix);
+//   5. verify through the persistence service and a directory re-scan;
+//   6. detach the session from workspace accounting so the sidebar drops the
+//      row instead of re-grouping an orphan under "Ungrouped".
+//
+// The plugin imports nothing from the DSH SDK: every service is resolved
+// through the cordis context at call time, so the module loads on any profile
+// and degrades to the filesystem path when a service is absent.
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+export const name = 'dsh-delete-session'
+
+const ROUTE_PREFIX = '/dsh-delete-session'
+const SESSION_ID_RE = /^(session-)?[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+class HttpError extends Error {
+  constructor(status, code, message) {
+    super(message)
+    this.status = status
+    this.code = code
+  }
+}
+
+// --- paths -------------------------------------------------------------------
+
+function dshHome() {
+  return process.env.DSH_HOME || path.join(os.homedir(), '.dsh')
+}
+
+function sessionsRoot() {
+  return path.join(dshHome(), 'sessions')
+}
+
+// A session id travels in two spellings: the raw uuid and `session-<uuid>`.
+// The on-disk JSONL backend uses the prefixed form for the directory name,
+// while workspace and projection rows may carry either. Clean both.
+function idVariants(sessionId) {
+  const out = new Set([sessionId])
+  if (sessionId.startsWith('session-')) out.add(sessionId.slice('session-'.length))
+  else out.add(`session-${sessionId}`)
+  return [...out]
+}
+
+// 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.
+function findSessionDirs(sessionId) {
+  const root = sessionsRoot()
+  let entries
+  try {
+    entries = fs.readdirSync(root, { withFileTypes: true })
+  } catch {
+    return []
+  }
+  const variants = idVariants(sessionId)
+  const found = []
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue
+    for (const variant of variants) {
+      const candidate = path.join(root, entry.name, variant)
+      try {
+        if (fs.statSync(candidate).isDirectory() && !found.includes(candidate)) found.push(candidate)
+      } catch {
+        // keep scanning
+      }
+    }
+  }
+  return found
+}
+
+function removeSessionDirs(sessionId) {
+  const dirs = findSessionDirs(sessionId)
+  for (const dir of dirs) fs.rmSync(dir, { recursive: true, force: true })
+  return dirs
+}
+
+// --- live state --------------------------------------------------------------
+
+// Stop a running agent before its session disappears: cancel the active turn
+// and wait, time-boxed, so a stuck driver never blocks the deletion.
+async function quiesceAgent(ctx, sessionId) {
+  const agents = ctx.get('agents')
+  if (!agents || typeof agents.get !== 'function') return false
+  const agent = agents.get(sessionId)
+  if (!agent) return false
+  try {
+    if (typeof agent.cancel === 'function') agent.cancel({ kind: 'user' })
+  } catch {
+    // agent may already be settling
+  }
+  if (typeof agent.whenIdle === 'function') {
+    try {
+      await Promise.race([agent.whenIdle(), new Promise((resolve) => setTimeout(resolve, 10000))])
+    } catch {
+      // proceed with deletion anyway
+    }
+  }
+  return true
+}
+
+// Flush a live session, then detach its entered record so DSH emits
+// host/session-removed and the client list drops the row. The persistence
+// retirement started by session/disposed is awaited before the caller unlinks
+// anything, because its final drain could otherwise recreate the directory.
+async function flushAndDetach(ctx, sessionId) {
+  const sessions = ctx.get('sessions')
+  let flushed = false
+  let detached = false
+  if (sessions) {
+    for (const variant of idVariants(sessionId)) {
+      const live = typeof sessions.get === 'function' ? sessions.get(variant) : undefined
+      if (!live) continue
+      if (typeof sessions.flush === 'function') {
+        try {
+          await sessions.flush(live)
+          flushed = true
+        } catch {
+          // the log is removed anyway
+        }
+      }
+      try {
+        const entered = sessions.store && typeof sessions.store.get === 'function' ? sessions.store.get(variant) : undefined
+        if (entered && typeof entered.detach === 'function') {
+          entered.detach()
+          detached = true
+        }
+      } catch {
+        // best effort: the directory removal below is the authority
+      }
+    }
+  }
+  const sp = ctx.get('sessionPersistence')
+  try {
+    const retirement = sp && sp.retirements && typeof sp.retirements.get === 'function' ? sp.retirements.get(sessionId) : undefined
+    if (retirement && typeof retirement.then === 'function') await retirement
+  } catch {
+    // no retirement registry: nothing to wait for
+  }
+  return { flushed, detached }
+}
+
+// Probe the persistence write lease. Holding it proves no active writer is
+// around; it is released immediately. A busy lease means DSH still has the
+// session open (the runtime offers no public way to release it), so the
+// request is refused and the caller can retry after restarting DSH.
+async function assertNoActiveWriter(ctx, sessionId) {
+  const sp = ctx.get('sessionPersistence')
+  if (!sp || typeof sp.open !== 'function') return false
+  let handle = null
+  try {
+    handle = await sp.open(sessionId, 'write')
+  } catch (error) {
+    const message = String((error && error.message) || error)
+    if (/own|busy|lock|hold|writer/i.test(message)) {
+      throw new HttpError(409, 'busy', 'session is currently open in DSH')
+    }
+    return false
+  } finally {
+    try {
+      if (handle && typeof handle.close === 'function') await handle.close()
+    } catch {
+      // lease release failure is harmless: the directory is removed next
+    }
+  }
+  return true
+}
+
+async function detachFromWorkspace(ctx, sessionId) {
+  const workspace = ctx.get('workspaceRegistry')
+  if (!workspace) return false
+  const variants = idVariants(sessionId)
+  let touched = false
+  try {
+    if (typeof workspace.list === 'function') {
+      for (const entry of workspace.list()) {
+        if (!entry || !Array.isArray(entry.sessionIds)) continue
+        if (!variants.some((variant) => entry.sessionIds.includes(variant))) continue
+        try {
+          await entry.detachSession(sessionId)
+          touched = true
+        } catch {
+          // keep going: the header index cleanup below still applies
+        }
+      }
+    }
+  } catch {
+    // registry unavailable
+  }
+  try {
+    if (workspace.sessionPaths && typeof workspace.sessionPaths.delete === 'function') {
+      for (const variant of variants) workspace.sessionPaths.delete(variant)
+    }
+  } catch {
+    // private map absent on this version
+  }
+  try {
+    if (workspace.headers && typeof workspace.headers.delete === 'function') {
+      for (const variant of variants) workspace.headers.delete(variant)
+    }
+  } catch {
+    // private map absent on this version
+  }
+  return touched
+}
+
+// --- core delete -------------------------------------------------------------
+
+async function deleteSession(ctx, sessionId) {
+  if (!SESSION_ID_RE.test(sessionId)) {
+    throw new HttpError(400, 'invalid', 'invalid session id')
+  }
+  const stopped = await quiesceAgent(ctx, sessionId)
+  const { flushed, detached } = await flushAndDetach(ctx, sessionId)
+  await assertNoActiveWriter(ctx, sessionId)
+
+  // Remove the on-disk directories first. If the filesystem refuses, fail
+  // before touching workspace accounting so a half-deleted session cannot
+  // fall out of its group into "Ungrouped".
+  let removed = removeSessionDirs(sessionId)
+  await new Promise((resolve) => setImmediate(resolve))
+  removed = removed.concat(removeSessionDirs(sessionId))
+
+  const sp = ctx.get('sessionPersistence')
+  if (sp && typeof sp.stat === 'function') {
+    const after = await sp.stat(sessionId).catch(() => undefined)
+    if (after) {
+      throw new HttpError(500, 'verify-failed', 'session is still visible to the persistence service after deletion')
+    }
+  }
+  const leftover = findSessionDirs(sessionId)
+  if (leftover.length > 0) {
+    throw new HttpError(500, 'verify-failed', 'session directories could not be fully removed')
+  }
+
+  const workspaceDetached = await detachFromWorkspace(ctx, sessionId)
+  if (removed.length === 0 && !workspaceDetached && !flushed && !detached) {
+    throw new HttpError(404, 'not-found', 'session not found')
+  }
+  return { removed: removed.length, stopped, flushed, detached, workspaceDetached }
+}
+
+// --- http --------------------------------------------------------------------
+
+function isLoopbackAddress(address) {
+  if (typeof address !== 'string' || address.length === 0) return false
+  return address === '127.0.0.1' || address === '::1' || address === '::ffff:127.0.0.1' || address.startsWith('127.')
+}
+
+function isLocalHostHeader(host) {
+  if (typeof host !== 'string' || host.length === 0) return false
+  const name = host.split(':')[0].replace(/^\[|\]$/g, '').toLowerCase()
+  return name === 'localhost' || name === '127.0.0.1' || name === '::1'
+}
+
+function sendJson(res, status, body) {
+  const payload = JSON.stringify(body)
+  res.writeHead(status, {
+    'content-type': 'application/json; charset=utf-8',
+    'content-length': Buffer.byteLength(payload),
+  })
+  res.end(payload)
+}
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let data = ''
+    req.on('data', (chunk) => {
+      data += chunk
+      if (data.length > 1e6) req.destroy()
+    })
+    req.on('end', () => resolve(data))
+    req.on('error', reject)
+    req.on('aborted', () => reject(new Error('aborted')))
+  })
+}
+
+// Destructive local endpoint: loopback socket, loopback Host header, and a
+// same-origin check when the browser sends Origin. Tunneled or LAN clients
+// get 403 before any session data is touched.
+function guard(req, res) {
+  if (!isLoopbackAddress(req.socket && req.socket.remoteAddress)) {
+    sendJson(res, 403, { ok: false, code: 'forbidden', error: 'loopback only' })
+    return false
+  }
+  const host = req.headers.host
+  if (!isLocalHostHeader(host)) {
+    sendJson(res, 403, { ok: false, code: 'forbidden', error: 'unexpected host' })
+    return false
+  }
+  const origin = req.headers.origin
+  if (typeof origin === 'string' && origin.length > 0) {
+    let originHost = null
+    try {
+      originHost = new URL(origin).host
+    } catch {
+      originHost = null
+    }
+    if (originHost !== host) {
+      sendJson(res, 403, { ok: false, code: 'forbidden', error: 'cross-origin request' })
+      return false
+    }
+  }
+  return true
+}
+
+// --- plugin ------------------------------------------------------------------
+
+export function apply(ctx) {
+  const registerRoutes = (webServer, fiber) => {
+    fiber.effect(() => webServer.register({
+      kind: 'exact',
+      path: `${ROUTE_PREFIX}/delete`,
+      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 (!sessionId) {
+          sendJson(res, 400, { ok: false, code: 'invalid', error: 'sessionId required' })
+          return
+        }
+        try {
+          const result = await deleteSession(ctx, sessionId)
+          sendJson(res, 200, { ok: true, ...result })
+        } 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) })
+        }
+      },
+    }))
+  }
+
+  const webServer = ctx.get('webServer')
+  if (webServer) {
+    registerRoutes(webServer, ctx)
+  } else {
+    // A terminal-only profile never provides a web surface; register once one
+    // appears instead of waiting on a service that will never arrive.
+    ctx.inject(['webServer'], (sub) => registerRoutes(sub.webServer, sub))
+  }
+}