@@ -17,7 +17,9 @@ file is the human-readable summary of what changed and why.
   returns you to the session you were last in on that side rather than opening
   a blank new session; with no history it falls back to a new session, and to
   the home screen when that side has nothing to open yet. Switching to Work
-  with no sandbox yet offers to create one — cancelling leaves you on Code.
+  with no sandbox yet offers to create one — cancelling leaves you on Code —
+  and deleting your last sandbox returns you to Code rather than leaving you
+  on an empty Work side.
   The **Home** button has been removed from the titlebar: it opened a new
   session rather than a home screen, which is what the tabs now decide. The
   recent-sessions screen is still one click away behind the search button and
 
@@ -194,7 +194,7 @@ from the squash message first, or use a plain merge.
 
 | Desktop identity: `packages/desktop/src/main/{index,store}.ts`, `packages/desktop/electron-builder.config{,.test}.ts`, `packages/desktop/scripts/copy-metainfo.ts`, `packages/desktop/resources/linux/opencode-desktop.desktop` (deleted), `packages/app/src/pages/layout/{deep-links.ts,helpers.test.ts}`, `packages/codev-brand/test/brand.test.ts` | appId `ai.opencode.desktop{,.beta,.dev}` → `ai.codev.desktop{,.beta,.dev}` (both copies: `APP_IDS` in main and in the builder config, plus the unpackaged fallback); deep-link scheme `opencode://` → `codev://` in all three places that must agree — `protocols.schemes`, `app.setAsDefaultProtocolClient`, and the renderer's `parseUrl` — plus the `argv.startsWith` filter the second-instance handler uses; `rpm.packageName` `opencode`/`opencode-beta`/`opencode-dev` → `codev`/`codev-beta`/`codev-dev`; the hidden `opencode-desktop.desktop` legacy launcher and its `deb`/`rpm` fpm wiring deleted. `src/main/migrate.ts` keeps the old ids — they name the *Tauri* app's directories, not ours. | The appId is the whole desktop identity: `app.setPath("userData", join(appData, appId))`, so it also names the data directory, and it drives the macOS bundle id, the Windows AppUserModelId and NSIS keys, the Linux `.desktop` filename, `executableName` and `StartupWMClass`, and the AppStream metainfo id. Leaving it as opencode meant the fork's app identified itself as upstream to the OS. Renamed as a clean cut with no data migration and no back-compat shim, on the explicit basis that there is no installed base: existing profiles under `appData/ai.opencode.desktop*` are simply orphaned (settings, session history, sandboxes and the downloaded guest image), and a packaged update across the rename would install beside the old app rather than replace it. The legacy launcher went with it — it existed to rescue GNOME/KDE pins from a superseded packaging id, and its `Exec=/opt/OpenCode/...` no longer matched any install layout. | Keep our ids and scheme; take upstream's other config. Never rename the `TAURI_APP_IDS` in `migrate.ts` to match — a blind find-and-replace there points the Tauri migration at a directory that never existed. All three deep-link sites have to move together or links open nothing; `electron-builder.config.test.ts` covers the ids, the package names and the scheme per channel. |
 
-| Code/Work workspace split: `packages/app/src/context/layout.tsx`, `packages/app/src/components/{app-sidebar,titlebar}.tsx`, `packages/app/src/i18n/{en,es}.ts` | The sidebar gains two tabs above Projects — **Code** (every non-sandbox server: the local sidecar, WSL, remote, SSH) and **Work** (the sandboxes) — backed by the fork-only `packages/app/src/workspace/{side.ts,tabs.tsx}`. `layout.tsx` stores `home.workspace` and `home.lastSession` (per side) and records the latter from an effect on `route()`; `app-sidebar.tsx` renders `<WorkspaceTabs/>`, swaps `global.servers.list()` for a side-filtered memo in all six places it indexed it, and adds an empty-state branch because a side can now have no servers at all; `titlebar.tsx` loses the Home button and its `home.toggle` command (`mod+b`) and filters the tab strip, its reorder and `tab.prev`/`tab.next` to the visible side; `effectiveSide` falls back to Code only where the platform has no sandbox support — deliberately not on an empty sandbox list, which is indistinguishable from one that has not loaded; `layout.tsx` also holds an effect keeping `home.selection.server` on the showing side, because a sandbox joins the server list only once it has finished starting, so the one-shot correction inside a switch cannot cover a sandbox created moments earlier; the fork-only `DialogAddSandbox` gains an `onCreated` callback so the Work gate switches on the create's own result rather than on the asynchronous sandbox list; i18n gains `workspace.{code,work,empty.none,empty.starting}`. | Sandboxes were just another row in a list of servers, so the isolated environment and the local machine were one undifferentiated pile. Splitting them makes "am I running on my machine or in a sandbox?" a property of where you are rather than something to infer from a server name. The Home button went because it opened a draft rather than a home screen, which is the behaviour the tabs replace: a tab returns you to that side's last session, falling back to a draft and then to the home screen. All the logic lives in the fork-only module; the upstream files hold wiring only, and every section below the tabs is the same component reading a filtered list. | Keep the wiring and take upstream's surrounding changes. The six `sideServers()` call sites in `app-sidebar.tsx` were `global.servers.list()` — if upstream adds a seventh, filter it too or that branch will show sandboxes under Code. Read `useWorkspaceSide()` rather than `layout.home.workspace()`: it collapses to Code where the platform has no sandbox support, which is what keeps the web build coherent. The tab strip filter and `reorderWithinSide` go together — `tabs.reorder()` rejects a partial key list, so a filtered strip without the merge silently ignores drags. |
+| Code/Work workspace split: `packages/app/src/context/layout.tsx`, `packages/app/src/components/{app-sidebar,titlebar}.tsx`, `packages/app/src/i18n/{en,es}.ts` | The sidebar gains two tabs above Projects — **Code** (every non-sandbox server: the local sidecar, WSL, remote, SSH) and **Work** (the sandboxes) — backed by the fork-only `packages/app/src/workspace/{side.ts,tabs.tsx}`. `layout.tsx` stores `home.workspace` and `home.lastSession` (per side) and records the latter from an effect on `route()`; `app-sidebar.tsx` renders `<WorkspaceTabs/>`, swaps `global.servers.list()` for a side-filtered memo in all six places it indexed it, and adds an empty-state branch because a side can now have no servers at all; `titlebar.tsx` loses the Home button and its `home.toggle` command (`mod+b`) and filters the tab strip, its reorder and `tab.prev`/`tab.next` to the visible side; `effectiveSide` falls back to Code only where the platform has no sandbox support — deliberately not on an empty sandbox list, which is indistinguishable from one that has not loaded; `layout.tsx` also holds an effect keeping `home.selection.server` on the showing side, because a sandbox joins the server list only once it has finished starting, so the one-shot correction inside a switch cannot cover a sandbox created moments earlier; the fork-only `DialogAddSandbox` gains an `onCreated` callback so the Work gate switches on the create's own result rather than on the asynchronous sandbox list; `dialog-select-server.tsx` `handleRemove` calls `workspace.removedServer(key)` beside the tab cleanup, which steps back to Code when the sandbox being deleted is the last one; i18n gains `workspace.{code,work,empty.none,empty.starting}`. | Sandboxes were just another row in a list of servers, so the isolated environment and the local machine were one undifferentiated pile. Splitting them makes "am I running on my machine or in a sandbox?" a property of where you are rather than something to infer from a server name. The Home button went because it opened a draft rather than a home screen, which is the behaviour the tabs replace: a tab returns you to that side's last session, falling back to a draft and then to the home screen. All the logic lives in the fork-only module; the upstream files hold wiring only, and every section below the tabs is the same component reading a filtered list. | Keep the wiring and take upstream's surrounding changes. The six `sideServers()` call sites in `app-sidebar.tsx` were `global.servers.list()` — if upstream adds a seventh, filter it too or that branch will show sandboxes under Code. Read `useWorkspaceSide()` rather than `layout.home.workspace()`: it collapses to Code where the platform has no sandbox support, which is what keeps the web build coherent. The tab strip filter and `reorderWithinSide` go together — `tabs.reorder()` rejects a partial key list, so a filtered strip without the merge silently ignores drags. |
 
 | `packages/app/src/context/global.tsx` | Two lines: imports `seedSandboxProjects` from the fork-only `packages/app/src/sandbox/projects.ts` and calls it with `server.list` + `ensureServerCtx`, beside the memo that already creates a ctx per connection. All the logic lives in the fork-only module. | A sandbox exposes exactly one directory (`/workspace` on vz/bwrap, the wslpath translation on WSL) and the guest registers it as its own project, but the app's per-server project list starts empty and nothing ever fills it. With no project, every "New session" entry point — `home-model.openNewSession`, the titlebar's `openNewTab` fallback chain — finds nothing for that server and falls back to another one, so the sandbox looks selected while the session runs on the local server. The seed reads `sync.data.path.directory`, which every server ctx already fetches, so it stays backend-agnostic. The same module also names that project after the sandbox's host folder (via `client.project.update`, the call behind rename-project), because the guest sees only its mount point and every sandbox would otherwise read "workspace" in the sidebar, tabs and palette. | Keep both lines; take upstream's other changes to the file. The call must stay inside the Global context init (it needs `ensureServerCtx`) — `SandboxesProvider` is mounted above `GlobalProvider` in `app.tsx`, so it cannot live there. |
 
 
@@ -19,6 +19,7 @@ import { normalizeServerUrl, ServerConnection, useServer } from "@/context/serve
 import { type ServerHealth, useCheckServerHealth } from "@/utils/server-health"
 import { useSettings } from "@/context/settings"
 import { useTabs } from "@/context/tabs"
+import { useWorkspaceSwitch } from "@/workspace/tabs"
 
 const DEFAULT_USERNAME = "opencode"
 
@@ -193,6 +194,7 @@ export function useServerManagementController(options: { onSelect?: () => void;
   const navigate = useNavigate()
   const server = useServer()
   const tabs = useTabs()
+  const workspace = useWorkspaceSwitch()
   const global = useGlobal()
   const platform = usePlatform()
   const language = useLanguage()
@@ -517,6 +519,9 @@ export function useServerManagementController(options: { onSelect?: () => void;
       // server that is already gone, and the tab-pruning effect that catches
       // them does not discard their draft state the way removeServer does.
       tabs.removeServer(key)
+      // Fork: before the awaits, so the switch lands with the tab cleanup
+      // rather than after a delete that takes as long as erasing a disk.
+      workspace.removedServer(key)
       server.remove(key)
       if (key.startsWith("wsl:")) await platform.wslServers?.removeServer(key)
       if (key.startsWith("sandbox:")) await platform.sandboxes?.remove(key)
 
@@ -54,6 +54,13 @@ export function selectionForSide(
   return kept ?? available[0]
 }
 
+// Whether removing this server empties the Work side. Answered from the list
+// as it stands *before* the removal lands — the sandbox list updates over IPC a
+// beat later, so reading it afterwards is a race.
+export function leavesWorkEmpty(sandboxes: { config: { id: string } }[], removed: string) {
+  return sideForServerKey(removed) === "work" && !sandboxes.some((item) => item.config.id !== removed)
+}
+
 // The tab strip only renders one side, so it can only ever reorder that side's
 // keys. Splice the new order back into the slots those tabs already occupy and
 // leave the other side untouched — tabs.reorder() rejects a list that is not
 
@@ -10,7 +10,7 @@ import { findOpenDraft } from "@/pages/home-draft-reuse"
 import { sessionHref } from "@/utils/session-route"
 import { useSandboxes } from "@/sandbox/context"
 import { usePlatform } from "@/context/platform"
-import { effectiveSide, selectionForSide, WORKSPACE_SIDES, type WorkspaceSide } from "./side"
+import { effectiveSide, leavesWorkEmpty, selectionForSide, WORKSPACE_SIDES, type WorkspaceSide } from "./side"
 
 // The side everything should actually render, as opposed to the side that
 // happens to be persisted. Read this rather than layout.home.workspace().
@@ -88,6 +88,14 @@ export function useWorkspaceSwitch() {
       }
       enter(next)
     },
+    // Deleting the last sandbox leaves Work with nothing to show, and the
+    // session on screen belonged to the server that just went away. Step back
+    // to Code and navigate there, the same way selecting the tab would.
+    removedServer(key: string) {
+      if (side() !== "work") return
+      if (!leavesWorkEmpty(sandboxes.state.data?.sandboxes ?? [], key)) return
+      enter("code")
+    },
   }
 }
 
 
@@ -3,6 +3,7 @@ import { ServerConnection } from "@/context/server"
 import { tabKey, type Tab } from "@/context/tabs"
 import {
   effectiveSide,
+  leavesWorkEmpty,
   reorderWithinSide,
   selectionForSide,
   serversForSide,
@@ -112,3 +113,16 @@ test("collapses to Code where sandboxes are unsupported", () => {
 test("keeps Work selected even with no sandboxes", () => {
   expect(effectiveSide("work", true)).toBe("work")
 })
+
+// Answered from the list as it stands before the removal: the sandbox list
+// updates over IPC a beat later, so reading it afterwards is a race.
+test("knows when removing a server empties the Work side", () => {
+  const configured = [{ config: { id: "sandbox:a" } }, { config: { id: "sandbox:b" } }]
+  expect(leavesWorkEmpty(configured, "sandbox:a")).toBe(false)
+  expect(leavesWorkEmpty([{ config: { id: "sandbox:a" } }], "sandbox:a")).toBe(true)
+})
+
+test("removing a non-sandbox server never empties Work", () => {
+  expect(leavesWorkEmpty([], "wsl:Ubuntu-24.04")).toBe(false)
+  expect(leavesWorkEmpty([], "sidecar")).toBe(false)
+})