@ybbmm/dsh-session-delete 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 deepseek-harness-session-delete contributors
+
+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

@@ -1,3 +1,118 @@
-# Temporary Holding Version
+# @ybbmm/dsh-session-delete
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**Permanently delete a conversation from the DeepSeek Harness sidebar.**
+**在 DeepSeek Harness 侧边栏永久删除对话。**
+
+DeepSeek Harness can archive a conversation but never delete one — the session
+log accumulates on disk forever. This plugin adds the missing action.
+
+> [中文说明](#中文说明) 在下方。
+
+---
+
+## What it adds
+
+| Where | What |
+|---|---|
+| Session **"…" menu** | A red **Delete conversation** row, separated from the shipped pin / rename / fork / archive rows |
+| Session **row hover** | A trash button beside the shipped archive and pin buttons |
+| **Confirmation dialog** | Shows the conversation title and states that deletion is permanent |
+
+Deleting the conversation that is currently open moves the main view to a new
+session.
+
+## What exactly is removed
+
+| Artifact | Effect |
+|---|---|
+| Session log directory (`~/.dsh/sessions/<project-key>/<session-id>/`) | removed |
+| Projection cache record (`~/.dsh/storages/session_projcache/sessions/<id>.json`) | removed |
+| Workspace accounting — membership, saved order, pin, archive mark | released |
+| Live session and agent store entries | detached *first*, so no writer re-creates the log |
+| Attachments (`~/.dsh/attachments`) | **kept** — content-addressed and shared between sessions |
+| Temp spill files | not touched (the host sweeps them by age) |
+
+## Safety
+
+- **Permanent.** There is no undo and no trash. Archiving is still the
+  reversible option and is untouched by this plugin.
+- **Refuses while the conversation is busy.** If a turn, subagent, background
+  job or scheduled reminder still belongs to it, the Host rejects the request
+  and the dialog shows why.
+- The session is detached from the live stores *before* its files are removed,
+  so a closing writer cannot resurrect a half-deleted log.
+
+## Install
+
+From the plugin market: search for **Session Delete**.
+
+Manually:
+
+```bash
+dsh plugin add @ybbmm/dsh-session-delete
+```
+
+From a local tarball:
+
+```bash
+npm pack
+dsh plugin add ./ybbmm-dsh-session-delete-0.1.0.tgz
+```
+
+Restart the Harness if your profile does not hot-reload plugin bundles.
+
+## Compatibility
+
+- Built and verified against DeepSeek Harness **0.2.1-rc.2** (Desktop/Web GUI,
+  Windows, Chinese and English UI).
+- **No runtime dependencies.** The bundle imports only `node:fs/promises` and
+  `node:path`, and loads nothing from `@deepseek-ai/*` at runtime.
+- It deliberately builds on a few host internals: the session store and
+  persistence services, and the API Gateway's runtime *SRC* dispatch for
+  services that carry a `typertRemote` binding plus Remote method markers.
+  A host release that reshapes those may need a plugin update — pin your host
+  version if you depend on this.
+
+## How it works
+
+- **Host half** (`index.js`) registers a `sessionDelete` service with a
+  `typertRemote` binding and a hand-written Remote method marker, which makes
+  `sessionDelete/delete` reachable through the Gateway without generated
+  Typert artifacts. The method resolves the target (live or stored), runs the
+  activity gate, stops remaining work, detaches the live session, releases the
+  workspace accounting, removes the log directory via the store's own
+  `locate()` path, drops the projection-cache row, and announces
+  `api-session/removed` so the sidebar drops the row.
+- **Browser half** (`client.js`) registers into
+  `sidebar.workspaces.session.menu.item`,
+  `sidebar.workspaces.session.row.action` and `shell.overlay`, and calls the
+  endpoint over the shared connection RPC.
+- Styles copy the host's own geometry, renamed under a plugin prefix, and use
+  only `--dsw-alias-*` theme tokens, so light/dark and theme switching follow
+  the app.
+
+## Known limitations
+
+- **No success toast.** The workspace toast slot's key domain is closed to
+  third-party plugins, so the row disappearing is the only confirmation.
+- **UI copy is English and Chinese only.**
+- Deleting a conversation does not delete files the conversation *produced* in
+  your workspace — only the conversation itself.
+
+## 中文说明
+
+DeepSeek Harness 只能归档会话、无法真正删除，日志会一直堆积在磁盘上。这个插件补上了缺失的删除能力。
+
+**新增内容**：会话「…」菜单里的**红色「删除对话」**、会话行悬停时的垃圾桶按钮，以及一个显示对话标题、写明"永久删除"的确认框。删除当前正在看的对话后，主视图会切换到一个新会话。
+
+**会被删掉的**：会话日志目录、投影缓存记录、工作区记账（成员关系/排序/置顶/归档标记）；活跃会话会先被摘除再删文件，避免写入器把日志复活。
+
+**不会删的**：附件目录（按内容寻址、被多个会话共享）、临时 spill 文件。
+
+**安全性**：永久删除，无回收站、不可撤销——归档依然是可逆选项。当对话还有运行中的回合、子代理、后台任务或定时提醒时，宿主会拒绝删除并说明原因。
+
+**兼容性**：在 DeepSeek Harness `0.2.1-rc.2`（Desktop/Web，Windows，中英文界面）上验证；零运行时依赖。实现依赖少量宿主内部机制（会话存储/持久化服务、以及 API Gateway 对带 `typertRemote` 绑定的服务的运行时派发），宿主大版本变更时可能需要跟进更新。
+
+## License
+
+[MIT](LICENSE)

package/client.js

@@ -0,0 +1,279 @@
+/**
+ * Browser half of the @ybbmm/dsh-session-delete bundle.
+ *
+ * Adds a "Delete conversation" entry to the sidebar session list: one row in
+ * the Session "..." menu, one hover button, and one confirmation dialog. The
+ * deletion itself runs on the Host through the `sessionDelete/delete` Remote
+ * endpoint; this half only collects the request and shows the outcome.
+ */
+window.__ModuleLoader__.load({
+  id: '@ybbmm/dsh-session-delete',
+  factory(require) {
+    const React = require('react')
+    const h = React.createElement
+    const { Button, IconTrashOutlineRegular, MenuItemButton, Modal, Tooltip } =
+      require('@deepseek-ai/dsh-client-ui-primitives')
+
+    const NS = 'ybbmm.dsh-session-delete'
+    const PLUGIN = '@ybbmm/dsh-session-delete'
+
+    const en = {
+      'menu.delete': 'Delete conversation',
+      'actions.delete': 'Delete conversation',
+      'dialog.title': 'Delete conversation?',
+      'dialog.description':
+        '“{title}” will be permanently deleted. Its messages cannot be recovered.',
+      'dialog.confirm': 'Delete',
+      'dialog.cancel': 'Cancel',
+      'dialog.close': 'Close',
+      'dialog.pending': 'Deleting…',
+    }
+    const zh = {
+      'menu.delete': '删除对话',
+      'actions.delete': '删除对话',
+      'dialog.title': '删除对话？',
+      'dialog.description': '“{title}” 将被永久删除，其中的消息无法恢复。',
+      'dialog.confirm': '删除',
+      'dialog.cancel': '取消',
+      'dialog.close': '关闭',
+      'dialog.pending': '正在删除…',
+    }
+
+    // The hover button and the dialog copy the host's own geometry, renamed
+    // under this plugin's prefix and keeping only theme-token references.
+    const css = '.dshSessionDelete_iconButton{border-radius:var(--dsw-radius-xs);cursor:pointer;width:16px;height:16px;color:var(--dsw-alias-label-tertiary);background:0 0;border:none;flex:none;justify-content:center;align-items:center;padding:0;display:inline-flex}.dshSessionDelete_iconButton:hover{color:var(--dsw-alias-label-primary)}.dshSessionDelete_deleteAction:not(:disabled){color:var(--dsw-alias-state-error-primary)}.dshSessionDelete_status{color:var(--dsw-alias-label-secondary);font-size:12px;line-height:18px}.dshSessionDelete_error{color:var(--dsw-alias-state-error-primary);margin-top:8px;font-size:12px;line-height:18px}'
+    const cssTagId = `${PLUGIN}/session-delete.css`
+    if (typeof document !== 'undefined' && document.querySelector(`style[data-plugin-css=${JSON.stringify(cssTagId)}]`) === null) {
+      const tag = document.createElement('style')
+      tag.dataset.plugin = PLUGIN
+      tag.dataset.pluginCss = cssTagId
+      tag.textContent = css
+      document.head.appendChild(tag)
+    }
+
+    /** One minimal observable the slot renderer turns into a selector hook. */
+    function createObservable(initial) {
+      let value = initial
+      const listeners = new Set()
+      return {
+        getSnapshot: () => value,
+        subscribe(listener) {
+          listeners.add(listener)
+          return () => {
+            listeners.delete(listener)
+          }
+        },
+        set(next) {
+          if (Object.is(next, value)) return
+          value = next
+          for (const listener of [...listeners]) listener()
+        },
+      }
+    }
+
+    /** Read an optional client service without failing when it is absent. */
+    function optionalService(ctx, name) {
+      try {
+        return ctx.get(name)
+      } catch {
+        return undefined
+      }
+    }
+
+    /** The Session the main view currently shows, when there is one. */
+    function currentSessionId(ctx) {
+      const uiSession = optionalService(ctx, 'uiSession')
+      const key = uiSession?.current?.value?.key
+      return typeof key === 'string' && key.length > 0 ? key : undefined
+    }
+
+    /** Ask the Host to delete one conversation. */
+    async function requestDeletion(ctx, sessionId) {
+      const connection = optionalService(ctx, 'connection')
+      if (!connection) throw new Error('The Harness is not connected to its Host.')
+      const result = await connection.rpc.call(
+        '/api',
+        'sessionDelete/delete',
+        { args: { sessionId } },
+      )
+      if (!result?.ok) {
+        const failure = result?.error
+        throw new Error(failure?.message ?? 'The conversation could not be deleted.')
+      }
+      return result.value
+    }
+
+    /** The "..." menu row: ask for the confirmation. */
+    function DeleteSessionMenuItem({ sessionId, displayTitle, useMenuOpenState, requestDelete, t }) {
+      const [, setMenuOpen] = useMenuOpenState()
+      return h(
+        MenuItemButton,
+        {
+          danger: true,
+          separatorBefore: true,
+          icon: h(IconTrashOutlineRegular, { size: 14 }),
+          onSelect: () => {
+            setMenuOpen(false)
+            requestDelete(sessionId, displayTitle)
+          },
+        },
+        t('menu.delete'),
+      )
+    }
+
+    /** The hover button: ask for the confirmation. */
+    function DeleteSessionRowButton({ sessionId, displayTitle, requestDelete, t }) {
+      return h(
+        Tooltip,
+        { label: t('actions.delete'), side: 'bottom', align: 'end', delayMs: 500, portal: true },
+        h(
+          'button',
+          {
+            type: 'button',
+            className: 'dshSessionDelete_iconButton',
+            'aria-label': t('menu.delete'),
+            onClick: () => {
+              requestDelete(sessionId, displayTitle)
+            },
+          },
+          h(IconTrashOutlineRegular, { size: 14 }),
+        ),
+      )
+    }
+
+    /** The confirmation dialog. */
+    function DeleteSessionDialog({ useDeleteRequest, settleDelete, confirmDelete, t }) {
+      const request = useDeleteRequest((pending) => pending)
+      if (!request) return null
+      return h(
+        Modal,
+        {
+          open: true,
+          onClose: settleDelete,
+          closeLabel: t('dialog.close'),
+          title: t('dialog.title'),
+          description: t('dialog.description', { title: request.displayTitle }),
+          footer: h(
+            React.Fragment,
+            null,
+            h(
+              Button,
+              { variant: 'outline', disabled: request.pending, onClick: settleDelete },
+              t('dialog.cancel'),
+            ),
+            h(
+              Button,
+              {
+                variant: 'outline',
+                className: 'dshSessionDelete_deleteAction',
+                disabled: request.pending,
+                onClick: confirmDelete,
+              },
+              t('dialog.confirm'),
+            ),
+          ),
+          children: h(
+            React.Fragment,
+            null,
+            request.pending
+              ? h(
+                  'div',
+                  { role: 'status', className: 'dshSessionDelete_status', key: 'pending' },
+                  t('dialog.pending'),
+                )
+              : null,
+            request.error
+              ? h(
+                  'div',
+                  { role: 'alert', className: 'dshSessionDelete_error', key: 'error' },
+                  request.error,
+                )
+              : null,
+          ),
+        },
+      )
+    }
+
+    return {
+      inject: ['slots', 'locale'],
+      apply(ctx) {
+        ctx.effect(
+          () => ctx.locale.register(NS, { zh, en }),
+          'ybbmm.dsh-session-delete: dictionaries',
+        )
+
+        const pending = createObservable(null)
+
+        const requestDelete = (sessionId, displayTitle) => {
+          pending.set({ sessionId, displayTitle, pending: false, error: undefined })
+        }
+        const settleDelete = () => {
+          pending.set(null)
+        }
+        const confirmDelete = async () => {
+          const request = pending.getSnapshot()
+          if (!request || request.pending) return
+          pending.set({ ...request, pending: true, error: undefined })
+          try {
+            await requestDeletion(ctx, request.sessionId)
+            pending.set(null)
+            if (currentSessionId(ctx) === request.sessionId) {
+              const uiWorkspace = optionalService(ctx, 'uiWorkspace')
+              try {
+                uiWorkspace?.startSession()
+              } catch (error) {
+                console.warn('ybbmm.dsh-session-delete: could not open a new session:', error)
+              }
+            }
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error)
+            pending.set({ ...request, pending: false, error: message })
+          }
+        }
+
+        const actionInjected = () => ({ requestDelete })
+        const dialogInjected = () => ({
+          hooks: { deleteRequest: pending },
+          settleDelete,
+          confirmDelete,
+        })
+
+        ctx.slots.inject('sidebar.workspaces.session.menu.item', function* () {
+          yield ctx.slots.register(
+            {
+              name: 'sidebar.workspaces.session.menu.item',
+              id: 'ybbmm.dsh-session-delete',
+              order: 500,
+              locale: NS,
+              inject: actionInjected,
+            },
+            DeleteSessionMenuItem,
+          )
+        })
+        ctx.slots.inject('sidebar.workspaces.session.row.action', function* () {
+          yield ctx.slots.register(
+            {
+              name: 'sidebar.workspaces.session.row.action',
+              id: 'ybbmm.dsh-session-delete',
+              order: 300,
+              locale: NS,
+              inject: actionInjected,
+            },
+            DeleteSessionRowButton,
+          )
+        })
+        ctx.slots.inject('shell.overlay', function* () {
+          yield ctx.slots.register(
+            {
+              name: 'shell.overlay',
+              id: 'ybbmm.dsh-session-delete',
+              locale: NS,
+              inject: dialogInjected,
+            },
+            DeleteSessionDialog,
+          )
+        })
+      },
+    }
+  },
+})

package/cordis.patch.yml

@@ -0,0 +1,7 @@
+- insert:
+    - id: ybbmm-dsh-session-delete
+      name: '@ybbmm/dsh-session-delete'
+      inject:
+        - sessions
+        - sessionPersistence
+        - workspaceRegistry

package/icon.svg

@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" role="img" aria-label="Delete conversation">
+  <path d="M4 7h16" />
+  <path d="M10 11v6" />
+  <path d="M14 11v6" />
+  <path d="M6 7l1 12a2 2 0 0 0 2 2h6a2 2 0 0 0 2-2l1-12" />
+  <path d="M9 7V5a1 1 0 0 1 1-1h4a1 1 0 0 1 1 1v2" />
+</svg>

package/index.js

@@ -0,0 +1,223 @@
+/**
+ * Host half of the session-delete bundle.
+ *
+ * Owns one operation: permanently delete a stored conversation. The session's
+ * durable log directory goes away, its workspace accounting (membership, pin,
+ * archive) is released, its projection-cache record is dropped, and the
+ * browser is told the row is gone.
+ *
+ * The browser half calls `sessionDelete/delete` over the shared Remote
+ * carrier. The endpoint is reachable through the API Gateway's runtime "SRC"
+ * dispatch: the Gateway looks for a live Service that carries a
+ * `typertRemote` binding plus Remote method markers, so this bundle needs no
+ * generated Typert artifact.
+ *
+ * The bundle deliberately has no package dependencies: a bundle installed from
+ * a local directory resolves its imports from that directory, so every import
+ * would have to be a Node built-in.
+ */
+import { rm } from 'node:fs/promises'
+import { dirname } from 'node:path'
+
+/** Cordis service key of this plugin's service. */
+const SERVICE_KEY = 'sessionDelete'
+/** Wire namespace the API Gateway exposes for this service. */
+const NAMESPACE = 'sessionDelete'
+/** Property the Typert protocol stores Remote method markers under. */
+const REMOTE_METHODS = '@deepseek-ai/dsh-typert-protocol/remote-methods'
+/** Shared symbol Cordis uses to bind a service value to its owning context. */
+const TRACKER = Symbol.for('cordis.tracker')
+/** Milliseconds between removal attempts while a writer settles. */
+const REMOVE_RETRY_MS = 60
+/** How many times the removal is repeated. */
+const REMOVE_ATTEMPTS = 4
+
+/** Read an optional service without failing when the composition lacks it. */
+function optionalService(ctx, name) {
+  try {
+    return ctx.get(name)
+  } catch {
+    return undefined
+  }
+}
+
+/** Pause for `ms` milliseconds. */
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+class SessionDeleteService {
+  /**
+   * @param ctx - the owning plugin context.
+   */
+  constructor(ctx) {
+    this.ctx = ctx
+    this.name = SERVICE_KEY
+    this.typertRemote = Object.freeze({
+      service: this,
+      serviceKey: SERVICE_KEY,
+      namespace: NAMESPACE,
+    })
+  }
+
+  /**
+   * Delete one conversation.
+   * @param sessionId - durable Session identity.
+   * @returns the deleted identity and whether a stored log was removed.
+   */
+  async delete(sessionId) {
+    const ctx = this.ctx
+    if (typeof sessionId !== 'string' || sessionId.length === 0) {
+      throw new Error('sessionDelete: a session id is required')
+    }
+
+    // 1. Resolve the target: a live session, otherwise a stored one.
+    const live = ctx.sessions.get(sessionId)
+    let header = live?.header
+    if (!header) {
+      const snapshot = await ctx.sessionPersistence.stat(sessionId)
+      if (!snapshot) throw new Error(`sessionDelete: session "${sessionId}" was not found`)
+      header = snapshot.header
+      if (!header) throw new Error(`sessionDelete: session "${sessionId}" carries no stored header`)
+    }
+
+    // 2. Refuse while the conversation still owns running work.
+    const activity = await ctx.waterfall(
+      'workspace/session-activity',
+      { sessionId },
+      () => Promise.resolve([]),
+    )
+    if (Array.isArray(activity) && activity.length > 0) {
+      throw new Error(
+        `sessionDelete: session "${sessionId}" is still running work; stop it before deleting`,
+      )
+    }
+
+    // 3. Stop what is left, then let a live session leave the stores so its
+    //    writer closes and the row leaves the list.
+    await ctx.parallel('workspace/session-stop', { sessionId }).catch(() => {})
+    if (live) {
+      await ctx.sessions.flush(live).catch(() => {})
+      this.detach(sessionId)
+    }
+
+    // 4. Release the durable workspace accounting.
+    const registry = optionalService(ctx, 'workspaceRegistry')
+    if (registry) {
+      await registry.unpinSession(sessionId).catch(() => {})
+      await registry.unarchiveSession(sessionId).catch(() => {})
+      for (const workspace of registry.list()) {
+        if (workspace.record?.sessionIds?.includes(sessionId)) {
+          await workspace.detachSession(sessionId).catch(() => {})
+        }
+      }
+    }
+
+    // 5. Remove the stored conversation.
+    const removed = await this.removeStoredLog(header)
+
+    // 6. Drop the projection-cache record so no stale hint survives.
+    await this.removeProjectionCache(sessionId)
+
+    // 7. A live session announced its own removal through `session/disposed`;
+    //    a stored one has no such event, so announce it here.
+    if (!live) ctx.emit('api-session/removed', sessionId)
+
+    return { sessionId, removed }
+  }
+
+  /**
+   * Remove one session from the live session and agent stores.
+   * @param sessionId - durable Session identity.
+   */
+  detach(sessionId) {
+    const ctx = this.ctx
+    const sessions = optionalService(ctx, 'sessions')
+    const entry = sessions?.store?.get(sessionId)
+    if (entry && typeof sessions.detachEntered === 'function') {
+      try {
+        sessions.detachEntered(entry)
+      } catch (error) {
+        ctx.logger?.warn(`sessionDelete: detaching session "${sessionId}" failed: ${String(error)}`)
+      }
+    }
+    const agents = optionalService(ctx, 'agents')
+    const agentEntry = agents?.store?.get(sessionId)
+    if (agentEntry && typeof agents.detachEntered === 'function') {
+      try {
+        agents.detachEntered(agentEntry)
+      } catch (error) {
+        ctx.logger?.warn(`sessionDelete: detaching agent "${sessionId}" failed: ${String(error)}`)
+      }
+    }
+  }
+
+  /**
+   * Remove the session's stored log directory.
+   *
+   * The store owns the on-disk layout, so its own locator names the artifact
+   * and the session directory is that artifact's parent. A writer that is
+   * still closing can append once more and recreate the file, so the removal
+   * is repeated briefly.
+   * @param header - the stored session header.
+   * @returns whether a stored log was removed.
+   */
+  async removeStoredLog(header) {
+    const persistence = this.ctx.sessionPersistence
+    const locate = persistence?.locate
+    if (typeof locate !== 'function') {
+      throw new Error('sessionDelete: this session store does not expose its on-disk layout')
+    }
+    const location = locate.call(persistence, header)
+    if (!location?.path) return false
+    const directory = dirname(location.path)
+    for (let attempt = 0; attempt < REMOVE_ATTEMPTS; attempt++) {
+      await rm(directory, { recursive: true, force: true })
+      if (attempt < REMOVE_ATTEMPTS - 1) await delay(REMOVE_RETRY_MS)
+    }
+    return true
+  }
+
+  /**
+   * Drop the stored projection-cache record of one session.
+   * @param sessionId - durable Session identity.
+   */
+  async removeProjectionCache(sessionId) {
+    const storageDomain = optionalService(this.ctx, 'storageDomain')
+    if (!storageDomain || typeof storageDomain.get !== 'function') return
+    const domain = storageDomain.get('session_projcache')
+    if (!domain || typeof domain.table !== 'function') return
+    await domain.table('sessions').delete(sessionId).catch(() => {})
+  }
+}
+
+// Declare the Remote method for the API Gateway's runtime dispatch. The
+// marker format is the Typert protocol's public, versioned descriptor: a
+// frozen record on the class prototype naming the exported methods.
+Object.defineProperty(SessionDeleteService.prototype, REMOTE_METHODS, {
+  configurable: true,
+  value: Object.freeze({
+    version: 1,
+    methods: Object.freeze([
+      Object.freeze({
+        method: 'delete',
+        invocation: Object.freeze({ kind: 'direct' }),
+        resources: Object.freeze({ session: (request) => request?.sessionId }),
+      }),
+    ]),
+  }),
+})
+
+/**
+ * Register the deletion service and let the browser reach it.
+ * @param ctx - the owning plugin context.
+ */
+export function apply(ctx) {
+  const service = new SessionDeleteService(ctx)
+  // Bind the service to the calling context the way a Cordis Service does, so
+  // the API Gateway reaches it through the same traced proxy.
+  Object.defineProperty(service, TRACKER, {
+    value: { associate: SERVICE_KEY, property: 'ctx' },
+  })
+  ctx.reflect.provide(SERVICE_KEY, service, undefined)
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Session Delete",
+    "description": "Adds a Delete conversation action to the sidebar session menu and permanently removes the conversation from disk."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "删除会话",
+    "description": "在侧边栏会话菜单中新增「删除对话」，永久清除该对话的本地记录。"
+  }
+}

package/package.json

@@ -1,6 +1,61 @@
 {
   "name": "@ybbmm/dsh-session-delete",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Permanently delete a DeepSeek Harness conversation from the sidebar session menu: removes the session log, its projection cache and its workspace accounting. | 在 DeepSeek Harness 侧边栏永久删除对话，清除会话日志、投影缓存与工作区记账。",
+  "license": "MIT",
+  "author": "jack-001-a",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jack-001-a/deepseek-harness-session-delete.git"
+  },
+  "homepage": "https://github.com/jack-001-a/deepseek-harness-session-delete#readme",
+  "bugs": {
+    "url": "https://github.com/jack-001-a/deepseek-harness-session-delete/issues"
+  },
+  "keywords": [
+    "dsh-plugin",
+    "deepseek-harness",
+    "dsh",
+    "session",
+    "conversation",
+    "delete",
+    "sidebar",
+    "plugin"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "cordis.patch.yml",
+    "locale/*.json",
+    "icon.svg",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-workspace",
+        "@deepseek-ai/dsh-client-ui-renderer",
+        "@deepseek-ai/dsh-client-locale"
+      ]
+    }
+  }
+}