dsh-forget-session-en

English fork of dsh-forget-session by 2026heshao. This fork translates the UI text, code comments, documentation, and error messages to English, and uses its own package, plugin-row, service, and slot IDs so it can be installed alongside the original instead of colliding with it. The behavior is otherwise identical to upstream v2.2.1.

See docs/verification-checklist.md for the verification and troubleshooting checklist.

A DeepSeek Harness (DSH) plugin that adds a "Forget session" item to the session row's "…" menu and removes that session completely from the sidebar and from disk. Data accumulated by the Lingxu memory plugin is not affected. It works on both the desktop and web builds (the plugin UI runs in the same browser rendering layer in both, so behavior is identical).

Compatibility: fully tested on DeepSeek Harness 44.7.0 (host bundles @deepseek-ai/dsh-typert-protocol@0.2.1-rc.2 / cordis 4.0.5); the declared peer range >=0.1.5-rc.1 still covers it, and this version needs no code changes.

Features

Adds exactly one item, in the session row "…" menu:

• "Forget session" (order 500, placed after the official "Pin / Rename / Branch / Archive" items)
• Two-step confirmation after clicking: the row becomes "Click again to confirm", and only the next click executes (everything happens inside the menu, with no dialog; failures are shown directly on this row, never silently)
• On success the row disappears and a top Toast reports the deletion summary (how many artifacts were deleted, how many warnings)

Deleted object	Method
Running work	Official workspace/session-stop waterfall (stopActivity archive path)
Live session (inside the Session store)	Official entry.detach() internal channel: store.delete + attachments.delete + emitDisposed (new in v2.2; see root cause 3 below)
Workspace accounting (sessionIds in workspace.json)	Official detachSession channel (domain write chain)
Archive set / pinned set	Official unarchiveSession / unpinSession
Session log directory ~/.dsh/sessions/<project key>/<id>	Whole-directory delete (including _no-cwd, legacy unprefixed layouts, and in-use retries)
Projection cache shard ~/.dsh/storages/session_projcache/sessions/<id>.json	Delete
Table entry in the projection cache ~/.dsh/storages/session_projcache.json	Read-modify-write; everything else is preserved as-is
Resurrected files (leftover handles / recreated by late writes)	The Host "resurrection guard" deletes them again automatically within a ~2-minute window
Sidebar session row (client session list)	Official sessions.handleSessionRemoved(id) + sessions.refresh()

Data left untouched: Lingxu memory (~/.dsh/.dsh-memory), attachments, and any other session.

What was fixed (why deleted sessions returned to "Ungrouped")

"Ungrouped" = ids in the client session list − the union of all workspace.sessionIds. After gathering evidence package by package from the official source, three resurrection paths were confirmed:

Root cause	Mechanism	Countermeasure
Windows live-deletion race	Once a session has been opened there is a write handle / cross-process lease: rm on the directory reports EBUSY/EPERM, v1 failed silently → files remained → the registry re-adopted them after a restart; and a late append from the live teardown after deletion could recreate the deleted directory	Verification re-check after deletion, with backoff retries for in-use errors; set up a resurrection guard: exponential backoff starting at 2s (capped at 32s) and periodic re-checks for a total window of ~130s, immediately deleting any recreated directory
Client list resurrection	The Host's session.list still lists live sessions; any client refreshList (triggered on reconnect) merges the deleted rows back	After deletion, call the official sessions.refresh() to reload the baseline, so the resurrected row is removed again before it becomes visible
Live entry never detached (root-fixed in v2.2)	SessionStore has no public remove API: once a session enters the store, session.list (which merges live + persisted sessions) always lists it — after deletion it immediately returns to "Ungrouped"; and the persistence writer holds a write handle that keeps the disk busy, so rm gets EBUSY and even the resurrection guard deleting for ~130s is wasted	Use the official entry.detach() carried by every store entry (= store.delete + attachments.delete + emitDisposed): this both removes the row from session.list (official api-session/removed frame) and releases the persistence write handle — only then does the disk deletion actually work

v2 once also added extra remote endpoints such as "session health check / empty-shell sweep / audit inventory", but they were never mounted with the client contract; clicking them only produced a typert gateway error, making them a useless surface — they have all been removed, and the contract surface keeps only the single delete method.

Remote contract

The forgetSessionEn service exposes only one method:

Method	Parameters	Behavior
delete	{ sessionId }	Full waterfall deletion (authoritative state + disk artifacts + resurrection guard)

Installation

Install from npm with the official DSH command (whichever profile you install into is where it takes effect):

dsh plugin --profile web add dsh-forget-session-en

Or install directly from the repository:

dsh plugin --profile web add github:esketids/dsh-forget-session-en

Restart DSH after installation for it to take effect (replace the value after --profile with the profile name you actually use).

Uninstall

dsh plugin --profile web remove dsh-forget-session-en

remove also removes the dependency and the patch layer; after restarting DSH the menu returns to its original state.

How it works (for maintainers)

• Host half (lib/index.js): a TypertRemoteService named forgetSessionEn with inject: ["workspaceRegistry"]. delete() goes through the official state channels (stop / unarchive / unpin / live detach / detach), then deletes disk artifacts using the same path algorithm as session-persistence-jsonl (projectKey + encodeSegment) (retrying in-use errors with backoff + verification re-check), cleans the projection cache, and finally sets up the resurrection guard. It never edits workspace.json by hand — accounting is done through the registry's official mutate write chain. Live removal obtains the entry via ctx.get("sessions").store (a public class field Map) and calls entry.detach(), which is equivalent to the official SessionStore.detachEntered.
• Browser half (lib/client.js): a window.__ModuleLoader__ bundle; ctx.remote.$mount mounts a contract with only the single delete method (strict codec writes both keys); ctx.slots.inject("sidebar.workspaces.session.menu.item", ...) registers the menu row. Toasts use primitives.Toast, rendered through a module-level toast bus + a resident shell.overlay component (React hooks must never be called inside apply() — there is no dispatcher outside a render context, which makes the whole fiber FAILED).
• Resurrection guard: started after a successful delete() (whether or not this pass removed everything); each step re-checks the log directory (located by project key when cwd is known, otherwise a full scan) and the shard cache, and a successful deletion also clears the shard. An explicit delete of the same session resets the guard.

Tests

cd <this repository directory>
node test/verify.mjs

With an isolated HOME (DSH_FORGET_SESSION_HOME points at a temporary directory), 15 assertions cover: the contract surface contains only delete, the full delete waterfall (live flush/detach, directory/shard/table entry/workspace detach), zero collateral damage to normal sessions, idempotency, missing-argument errors, and the resurrection guard deleting a recreated directory.

The test needs @deepseek-ai/cordis and @deepseek-ai/dsh-typert-protocol (peer dependencies, supplied by DSH) and can be run directly inside a profile where this plugin is installed.

Known limitations

• The official DSH design is "archive sessions, never delete them" (see the dsh-client-ui-workspace README); this plugin is a user-level addition beyond the official channels.
• If the deleted session is live in this process: buffered events are first flushed to disk, then the session is detached from the store via entry.detach() (the official dispose channel closes the persistence write handle). Late writes from the teardown within the guard window (~130s) are deleted afterwards. Deleting idle sessions is recommended.
• For the session search index (session-query-sqlite), when openAt is not never, deleted session rows converge automatically on the next _reconcile (any search) — the persisted list no longer contains the id, and the index clears it through persistentDeletes; openAt: never (the default) is in-memory and self-heals.

License

MIT