reinocheong/dsh-session-move

dsh-session-move

Manage DeepSeek Harness sessions from the Web UI — move, delete, and AI-rename, with drag & drop.

A dual-face (host + browser) plugin for DeepSeek Harness (dsh). It fills the gaps the official UI leaves open:

Each feature also ships as an agent tool (workbench_session_move, workbench_session_delete, workbench_session_rename_ai), so your agents can organize sessions too.

---

Install

# from GitHub (recommended until published to npm)
dsh plugin --profile web add https://github.com/reinocheong/dsh-session-move/archive/refs/tags/v0.1.5.tar.gz

Restart the profile for the plugin to load:

# systemd-managed installs
sudo systemctl restart dsh

Note for manual installs (copying the package into ~/.dsh/profiles/node_modules/ yourself): you must also register it in the profile's cordis.patch.yml:

- insert:
    - id: session-move
      name: dsh-session-move

dsh plugin add does this automatically.

---

Usage

🗂 Move a session to another folder

Drag & drop — grab any session row in the sidebar and drop it onto the title of another folder. The target folder highlights while you hover; release to move.

Menu — open a session's ... menu → Move to folder… → pick the target folder → confirm.

Moving a session relocates its working directory: the session header's cwd is rewritten, the persisted log is moved to the target folder's storage slug, and the workspace accounting is updated — history travels with it, and the session keeps working in the new directory afterwards.

🗑 Delete a session

Open a session's ... menu → Delete session → tick "I understand the consequences" → confirm.

Deletion is complete and permanent: running agents are stopped first, then the log directory, projection-cache row, and workspace accounting are removed. Nothing lingers in "Ungrouped".

✨ AI rename

Open a session's ... menu → AI Rename — the LLM reads a representative sample across the whole conversation (evenly sampled to fit the token budget), fixes any typos, and writes a concise title in the conversation's language.

By default it uses the session's own model route. To pin a different provider/model, configure the plugin row:

- id: session-move
  name: dsh-session-move
  config:
    renameAi:
      provider: deepseek-official
      model: deepseek-v4-flash
      targetWords: 6
      targetCjkCharacters: 14
      maxInputBytes: 8192
      maxOutputTokens: 96
      timeoutMs: 60000

---

Agent tools

---

HTTP endpoints

These power the UI; they are also usable directly:

---

How it works (the short version)

dsh folders ("workspaces") are not free-form containers. A session belongs to the workspace whose path equals the session's working directory (cwd), which is frozen in the header line of the session's zstd-compressed log. Moving a session therefore means:

1. stop/flush any live agent,
2. rewrite the header line's cwd to the target folder's path (decompress the first zstd frame, patch the JSON, recompress, keep the trailing frames byte-for-byte),
3. physically move the log directory to the target folder's storage slug,
4. detach from the old workspace and attach to the new one through the workspace registry (which also refreshes the in-memory index, so the UI updates instantly — no restart needed).

All storage mutation goes through dsh's own storageDomain, keeping memory and disk consistent; nothing is left half-accounted.

Reliability (v0.1.5)

The session id localization layer now uses identical safety standards across all code paths:

• Title-based matching is unique-only across all four paths. Previously only the displayTitle fallback (the v0.1.4 path for title-less sessions) guarded against ambiguity; the two higher-priority title-based loops (exact s.title match and fork-stripped s.title match) still silently returned the first hit. Two ordinary sessions in this very profile share the durable title "开始 Gyden OS WebUI 设计治理" — so the missing guard was not theoretical. A single uniqueBy(pick, wantText) helper now enforces the same rule everywhere: operate only on an unambiguous match; otherwise report "not found". For the (infrequent) case where two sessions hold the same title the plugin can no longer act, the pop-up shows "not found" with a blank session id — a deliberate fail-safe rather than a silent deletion of the wrong session.
• Fiber degradation is now loud. The three failure branches of readSessionIdFromRow each emit a console.warn([dsh-session-move] …), making it visible when React's internal DOM key structure changes. The fallback to title matching is unchanged, but an operator can now tell from the DevTools console that the fallback was used — previously it was silent.

Reliability (v0.1.4)

Sessions without a durable title can now be operated on — previously they could not be deleted at all:

• The row's real session id is read from React's fiber tree. A sidebar row carries its id only as a React prop (node.id); the DOM exposes no attribute for it. The plugin used to scrape the row's displayed text and match it against SessionSummary.title, which is optional and stays undefined until the host projects a durable title. Every title-less session — empty ones included — therefore failed to resolve: the dialog reported "not found" and the confirm button stayed disabled no matter what the user did. The id is now read from row.__reactFiber$… (walking up to memoizedProps.node.id, validated against the session-id shape) — the same value the official row writes into dataTransfer on dragstart.
• Title matching survives as a guarded fallback. When the fiber read fails, the plugin falls back to the human-facing displayTitle (always present, unlike title) and accepts the match only when it is unique. Several title-less sessions in one folder all display the same cwd basename as their label, and guessing wrong would act on the wrong session — an irreversible outcome for deletion — so an ambiguous match is reported as "not found" rather than resolved.

Reliability (v0.1.3)

This release fixes two AI-rename defects that could leave the dialog spinning forever:

• Endless abort/restart loop (client) — the rename effect called setBusy(true) while busy was still in its dependency array. React therefore ran the previous effect's cleanup on every state change, which aborted the fetch that had just been issued; the aborted request then set busy back to false, restarting the cycle. The symptom was a spinner that never stopped, never succeeded, and never reported an error. The effect now carries a startedRef guard keyed on the session id and depends on target only, so each rename issues exactly one request.
• timeoutMs was configured but never applied (host) — AI_RENAME_DEFAULTS declared timeoutMs: 60000, yet the stream was handed a bare new AbortController().signal that could never fire, so a stalled provider hung the HTTP request indefinitely. The LLM stream is now wrapped in deadline(request.signal, config.timeoutMs, ...) from @deepseek-ai/dsh-timeout — the same pattern the official dsh-session-title-llm provider uses — making the documented timeout real.
• The result survives long enough to be seen (client) — the session list refresh moved out of the request handler into the dialog's close path. Refreshing mid-request re-mounted the dialog and wiped its state, so a rename that had already succeeded showed no confirmation.

Reliability (v0.1.2)

The move keeps every place a session's location is recorded in sync — not just the header and the log directory:

• Projection cache — the session's identity.cwd in the projection cache (session_projcache) follows the move, so the web session list resolves the correct storage slug immediately (no ENOENT on cold sessions and no "Ungrouped" residue after a move).
• Boot reconciliation — on startup the plugin audits every stored projection-cache record against its on-disk header and repairs stale identity.cwd entries left behind by earlier half-applied moves or manual reorgs, so the list shows real session titles from the first render instead of the folder placeholder.
• Live sessions — a session that is loaded in memory when moved has a frozen header snapshot; the plugin detaches it from the live agents store before re-attaching it to the target workspace, so the attach validation never sees a stale cwd (this was the cause of moves silently landing in "Ungrouped" while the physical move succeeded).
• Running sessions (fixed in v0.1.2) — when the moved session is actively executing a task, the plugin now also releases the agent from the agents registry (emits agent/disposed), not just cancels its current turn. This is the load-bearing part: dsh's agent factory waits for BOTH the session and the agent to leave their registries (waitForDrainingConfiguredIdentity listens for session/disposed and agent/disposed) before rebuilding a live session; cancelling the turn alone leaves the agent registered, so the wait never resolves and the moved session can never be re-opened or resumed (symptom: you can type and hear the notification sound, but the agent never replies). The client also seamlessly reloads the moved session's view after a successful move — the host flags the resident conversation instance as removed ("session unavailable" input) and that flag cannot be reset in place, so the plugin switches to another listed session first (while the moved session is still unlisted, sweepDeferred genuinely drops its stale scope), refreshes the list, then switches back — the session re-opens cold from its new location with history intact in a few hundred milliseconds and no page reload. Any step that fails falls back to an automatic full page reload, so the view can never stay stuck on "session unavailable".

Each fix is fail-soft: if a repair can't run, the plugin logs a warning and leaves the state untouched rather than corrupting it.

---

Performance & footprint

The plugin is designed to be lightweight:

• Zero runtime dependencies — it only uses Node built-ins plus packages dsh already ships (dsh-tools, dsh-llm, dsh-session-title, dsh-session-title-llm, dsh-timeout). Nothing new is installed.
• No background work — no timers, polling, or resident connections. Move/delete/rename are purely request-driven: work happens while the request runs, then the plugin goes idle.
• Tiny footprint — the whole plugin is ~100 KB of source; its resident memory is negligible against a running dsh process.
• Fast operations — the stateless endpoints answer in ~1 ms (e.g. /__sessionmove/info); the only potentially slow step is AI rename, which calls the LLM once on demand (a few seconds, timeout-configurable) and never runs otherwise.
• Cheap client side — one DOM observer plus three dialogs that render only when opened; nothing runs in the browser while idle.

---

Requirements

• Node.js >=22.19.0 (same as dsh)
• dsh 0.1.0-rc.6 or newer
• AI rename additionally needs the official @deepseek-ai/dsh-session-title / @deepseek-ai/dsh-session-title-llm packages (bundled with dsh)

License

MIT