0.2.1: unsent draft of a new session is gone after switching chats (regression from 0.2.0 blank-session reuse)

[ancientrs]

Summary

In 0.2.1-rc.2, anything typed into a brand-new session — before the first message is sent — disappears as soon as you open another chat and come back to "+". It worked on 0.2.0-rc.2.

Steps to reproduce

1. In a workspace, click + (new session).
2. Type text into the composer; do not send.
3. Click an existing session in the sidebar.
4. Click + again. The composer is empty, and the abandoned session is no longer listed anywhere, so the text is unreachable.

Re-entering a saved session that has unsent text still restores that draft, so the loss only affects the unsent new session.

What looks wrong

• @deepseek-ai/dsh-client-ui-workspace/lib/client.js → startSession() without options now runs
  openWorkspaceSession(target, void 0, void 0) → connectBlank(workspaceId, undefined) → sessions.create({ workspaceId }),
  i.e. a fresh blank session on every "+".
• In 0.2.0-rc.2 and 0.1.7-rc.2 the same path went openWorkspace() → connectWorkspace() → reuseOrCreateBlank(), which re-created the existing blank by sessionId, so the id — and the draft persisted under it — survived.
• Blank sessions are only visible while current: sessionVisible() has if (session.blank && session.id !== current) return false, so the abandoned blank drops out of the sidebar and cannot be reopened.
• The text is not actually lost: it is persisted per session in localStorage under dsh.conversation.<sessionId> (readConversationDraft()), but with a new blank id nothing ever reads the old key again.

The reuse machinery still exists on both sides — client connectBlank() → createInWorkspace() (finds an existing blank in the same cwd and passes its sessionId), host createSession() reusing a named blank — so the no-options path looks like it lost its reuse argument.

Side effect: every "+" creates a real (empty) session directory. Abandoned blanks pile up on disk as ~350-byte session.v4.jsonl.zstd files under ~/.dsh/sessions/<cwd>/.

Suggested fix

Pass the reuse preset instead of undefined on the no-options branch, or restore the 0.2.0 reuseOrCreateBlank() behaviour there:

- (draftOptions === void 0 ? this.openWorkspaceSession(target, void 0, void 0) : …
+ (draftOptions === void 0 ? this.openWorkspaceSession(target, void 0, {})  : …

Verified locally on 0.2.1-rc.2 by patching the built bundle: after this one-token change and a page reload, "+" reopens the same blank session and the draft comes back. (startSession() calls that pass prompt/clearPreviousDraft are unaffected — they already take the reuse path.)

An alternative would be to keep abandoned blank sessions reachable in the sidebar, but that changes the list semantics, so the reuse route seems closer to intent.

Environment

• dsh 0.2.1-rc.2, npm global install, macOS (darwin/arm64), Web UI at 127.0.0.1:3080, Chrome
• Worked on 0.2.0-rc.2; broken on 0.2.1-rc.1 and later

[argszero]

Verdict

Your mechanism is exactly right, and the boundary you measured is right at the release-line level. But the option-less New Session path is not an accident that lost an argument: it is a deliberate, documented change shipped with an upgrade guide in the same commit. So the one-token patch in your report is correct about where the reuse went, and wrong as the fix — it restores the behaviour the guide exists to retire. The real defect is narrower and survives that: the change removed the only path to a per-Session draft key without migrating or surfacing what was already stored under it.

1. Your trace matches the source

dsh-v0.2.1-rc.2 is the current tip of master (both are 687f282e86), so these line numbers are your build's. In packages/client/ui-workspace/src/client/navigation.ts:

• :343-344 — draftOptions === undefined ? this.openWorkspaceSession(target, undefined, undefined) : …
• :288-296 — openWorkspaceSession → connectBlank(workspaceId, reuse)
• :209 — if (reuse === undefined) return this.sessions.create({ workspaceId })
• :220-234 — the reusing branch, createInWorkspace, names an existing blank by cwd: summary.blank && summary.cwd === workspace.path && workspace.sessionIds.includes(id) && !archived.includes(id), then passes its sessionId to the Host.

And the consequences you describe are likewise as written: the draft is per Session id (ui-conversation/src/client/stores.ts:8, :47; restored at input/hub.ts:170 with shell.setDraft(readConversationDraft(binding.sessionId))), while a non-current blank leaves the tree at tree.ts:245 (if (session.blank && session.id !== current) return false). A new id on every press therefore makes an existing storage key unreachable — your "the text is not actually lost" observation is right, and so is the empty session.v4.jsonl.zstd side effect, which follows directly from sessions.create on every press.

2. It is a documented change, not a regression

The same commit that introduced it shipped an upgrade guide, still present in master:

docs/upgrade-guide/v0.2.1-alpha.1/new-session-generations/guide.md

In Web and Desktop, New Session creates a fresh Session and Agent using the current preset definition. It previously reused an existing empty Session in the workspace, which could retain an earlier preset definition.
Client calls to uiWorkspace.startSession(workspaceId) follow the same behavior. Workspace reconnection through openWorkspace or connectWorkspace still reuses an eligible blank.

The commit is 55dfd3bab1d (2026-10-06, "fix(plugins): narrow optional bundles and create fresh session agents"), whose rewording of startSession is exactly the branch you quoted: ? this.openWorkspaceSession(target, undefined, false) — a boolean reuse: false at the time. 3c1e3571329 (2026-10-09) then turned that boolean into the preset object and kept the meaning, which is where today's reuse === undefined early return comes from.

One refinement to your version table, by tag containment:

Tag	Contains 55dfd3bab1d	Plain New Session
dsh-v0.2.0-rc.2	no	reuses the blank
dsh-v0.2.1-alpha.1	no	reuses the blank
dsh-v0.2.1-alpha.2	yes	creates a fresh Session
dsh-v0.2.1-alpha.3 … -rc.2	yes	creates a fresh Session

So 0.2.1-rc.1 is where you met it; the first release carrying the change is 0.2.1-alpha.2.

3. Why {} is not the fix

Passing {} sends a preset-less create, and on the Host that means "run the configured default, do not resolve the recorded preset" (packages/api/session-controller/src/agent.ts:262-266). For a blank that is already live under that same preset id — the ordinary case for a "+"-and-type flow — reuseLive returns it untouched (agent.ts:520: if (presets === undefined || target === undefined || target === current) return live). The Agent you get back is the one built when that blank was created, so a preset definition edited since then is not re-applied: precisely the retention the guide retires. Your patch buys the draft back by re-opening the path the change was made to close.

4. What is actually defective

The change is about which Agent you get. It silently changed which storage key your unsent text lives under, and nothing carried that over:

• no migration of dsh.conversation.<abandoned id> to the new id;
• no signal at the moment a blank becomes non-current (the tree simply stops listing it, tree.ts:245);
• the guide's own Change/Migration sections list preset consequences and say nothing about drafts, so a user reading it has no way to know a typed draft is about to be orphaned.

That is consistent with your report and with the same defect reported a day earlier in #9902 — two independent users hitting it within 24 hours is the measure of how surprising it is.

5. Fixes that keep the documented behaviour

1. Hand the draft over (smallest, keeps "fresh Agent with the current preset"). In the option-less branch, run the same blank predicate createInWorkspace already uses (navigation.ts:223-227) before creating, and pass a beforeOpen to openWorkspaceSession — it already accepts one (navigation.ts:288-296), exactly as the draft branch passes one into openWorkspace at :345-349 — to re-apply that stored draft to the new Session through the existing public seam (IConversation.input, requestDraftInitialization / setDraft), then drop the old key. New Agent, fresh Session, and the text follows the user; the drained blank is also the natural place to archive it and stop the files piling up.
2. Key an unsent draft by Workspace instead of by Session id until the first message. Before a Session exists, the draft is not really that Session's property, and the per-id key is what makes this class of loss possible at all. Larger, but it removes the failure mode rather than this instance of it.
3. Your alternative — keep an abandoned blank listed while its stored draft is non-empty — also works and needs no new plumbing; it changes list semantics, which you already noticed.

6. Getting your text back today

In the app's DevTools:

Object.keys(localStorage).filter(k => k.startsWith('dsh.conversation.'))
  .map(k => [k, localStorage.getItem(k)])

Each value is { draft, view, viewRequest }; draft.text is what you typed. Inline reference chips come back too (they ride in references), attached files and images do not — attachments are runtime-only and never entered the stored draft. #9902 has the fuller walk-through of the same recovery.

Note on #9902

I answered that thread before finding the upgrade guide, and called the behaviour a regression. The mechanism and the recovery steps there stand; the framing does not — this thread is the accurate account, and fix 1 above supersedes the "reuse the blank when a draft is pending" suggestion I made there, which would have traded the draft back for the retained composition the guide set out to remove.

[akol1]

Update: an applyable fix for the draft regression

The mechanism traced earlier in this thread is the one that reproduces here, and a patch that fixes it without restoring blank reuse is ready to apply to master (687f282e86, v0.2.1-rc.2).

What the patch does. An option-less New Session still creates a fresh Session with its own id. Immediately after the navigation retains that Session and before selection publishes, ui-workspace offers the Workspace's abandoned blanks to the conversation input, newest first. conversation.input.handOffDraft then:

• reads the candidate's live composer snapshot when it is still mounted, otherwise its last saved draft;
• skips candidates without text, inline references, or a command token;
• imports the first draft that holds content through the existing structured-draft editor path;
• writes the adopted draft under the target's dsh.conversation.<sessionId> record beside its stored View, then removes the source record;
• leaves both drafts untouched when the target already holds text or attachments, when its input is blocked by a pending submission, or when the navigation does not retain the target.

The public surface added is one client service method, SessionInputResolver.handOffDraft(sources, target); no command, configuration, wire, or persistence-format change. dsh.conversation.<sessionId> keeps its { draft, view, viewRequest } record, legacy string readers keep working, and there is no new storage key or migration.

Why not reuse the blank. The fresh-Session behavior for the option-less path is the documented change from 0.2.1-alpha.2 (55dfd3bab1d) with an upgrade guide retiring reuseOrCreateBlank. Reusing the abandoned blank would reopen the path that change closes, and the preset-less Host create keeps the live Agent, so the one-token openWorkspaceSession(target, void 0, {}) change from the first report is not the fix. Explicit-preset New Session and Workspace-row opens still reuse an eligible blank exactly as before; the hand-off only runs where a new id actually replaced the mounted blank.

Two limitations, both intentional:

• Attachments stay with the Session that owns their browser objects; only text, reference chips, and a command chip move.
• A candidate that is no longer mounted contributes its last saved draft, and the drained blank's saved View preference is removed with its record; the target keeps its own View.

Evidence. The patch is at https://raw.githubusercontent.com/akol1/deepseek-harness/draft-carry-assets/0001-fix-ui-workspace-keep-unstarted-draft.patch. It touches packages/client/ui-conversation, packages/client/ui-workspace, the matching bilingual READMEs and Agent Note, the generated client API catalog, one browser e2e scenario, and focused unit specs.

• pnpm exec vitest run packages/client/ui-conversation/tests/conversation-store.client.spec.ts packages/client/ui-conversation/tests/draft-hub.client.spec.ts packages/client/ui-workspace/tests/workspaces-service.client.spec.ts — 146 passed.
• DSH_SNAPSHOT=replay pnpm exec vitest run --config vitest.web.config.ts apps/web/tests/draft-initialization.e2e.ts — 10 passed, including the new scenario that types draft 未开始 🧭 é 雪 into the mounted blank, starts a New Session, asserts the new composer and stored record hold the draft, asserts the source key is gone, then reloads and asserts restoration. With the client changes reverted the same scenario fails with expected { text: '', references: [] } to deeply equal { text: 'draft 未开始 🧭 é 雪', …(1) }.
• pnpm run typecheck, pnpm run build, pnpm run lint, pnpm run duplication, pnpm run verify-client-ui-i18n pass; pnpm run doc-sync has the same single pre-existing verify-repository-references failure at python/sdk/uv.lock:113 that reproduces on the base commit.

The recording below shows the reported flow end to end on the patched tree: type a draft, press New session, see the text land in the new composer, open Plugins, return to the Session, and reload the page. It was recorded from a clean worktree with the real server and a fresh scratch profile; no message is sent and no model round runs. The GIF replays 2.0–11.0 s of the 14.0 s real-time capture at 1.25× speed with a 1.2 s final hold, so its playback time is not a measurement of application latency.

If the team would rather take a different shape — for example surfacing the abandoned blank in the Session tree instead of moving its draft — the storage helpers and the handOffDraft call site are separable and can be dropped without touching the persistence format.

Related: #9902.

[Alaric-L]

One addition the comments above don't cover: you can reopen the abandoned session itself, not just read the text out of localStorage.

1. Open DevTools — in the packaged desktop app, F12 (Ctrl+Shift+I on Windows, ⌘⌥I on macOS) works; these shortcuts ride hidden toggleDevTools application-menu items (apps/desktop/README.md, "including in packaged builds").

2. Find the abandoned session id: the dsh.conversation.<id> key whose draft.text holds your text.

3. Point the saved selection at it and reload:

   localStorage.setItem('dsh.sessions.current', JSON.stringify({ sessionId: '<id>' }))
   location.reload()

   On startup, restoreSelection treats a saved blank as a restore candidate and restoreBlank names that exact session id (packages/client/ui-workspace/src/client/navigation.ts:457-459), so the Host reuses the same blank and InputHub.shellFor re-seeds the composer from dsh.conversation.<id> (packages/client/ui-conversation/src/client/input/hub.ts:170). Text and inline reference chips come back; attachments/images do not — they are runtime-only and never entered the stored draft (same as the attachment threads).

4. Set the key and reload immediately — any in-app navigation before the reload rewrites dsh.sessions.current.

Independently reproduced on 687f282e86 (0.2.1-rc.2, desktop). Same report: deepseek-ai/deepseek-harness#9902, deepseek-ai/deepseek-harness#10223.