diff --git a/DIVERGENCES.md b/DIVERGENCES.md
index ff4382af0a..623dba1a2b 100644
--- a/DIVERGENCES.md
+++ b/DIVERGENCES.md
@@ -117,7 +117,8 @@ from the squash message first, or use a plain merge.
 | `packages/ui/src/theme/themes/oc-2.json` | One character: the light variant's `"icon-weak-base": "C7C7C7"` → `"#C7C7C7"`. Not a brand change — an upstream typo, reported as [anomalyco/opencode#41503](https://github.com/anomalyco/opencode/issues/41503). Without the `#` it is still a valid *custom-property* declaration, so it parses cleanly and wins the cascade over the static `--icon-weak-base` in `packages/ui/src/styles/theme.css` (resolved tokens are injected into a `<style>` element by `theme/context.tsx`). It only fails at `var()` substitution, where an invalid computed value falls back to the inherited value for inherited properties and the initial value otherwise — so the failure looks different at every call site. Measured on the default light theme: `color:` consumers paint their parent's color instead of the weak grey, and `background:` / `fill:` consumers paint nothing. That blanks the `dialog-release-notes` carousel indicators and the neutral `diff-changes` blocks outright, and renders the `file-tree`, `settings-keybinds` and `settings-models` icons at full strength. `oc-2` is the only one of the 37 themes that declares this token literally and the only malformed one — the rest take the derived `neutral[6]` — and it is the default, so this is the default light-mode experience. Dark (`#343434`) was always correct. | Five consumers are visibly wrong on the default light theme and the fix is one character, so there is no reason to wait for upstream. | Drop this row and take upstream's line once the issue is fixed there. Until then keep ours, and take any upstream change to this value as long as it starts with `#`. |
 | `packages/app/src/components/session/session-new-design-view.tsx`, `packages/app/src/pages/new-session.tsx` | Drops the `WordmarkV2` watermark from the v2 new-session screen and centres the composer. Upstream absolutely positions the content block at `top-[25.375%]` to leave room for the wordmark above it; with the mark gone that offset just parks the composer high in an empty pane, so the outer element becomes `flex items-center justify-center` over `size-full` (carrying the `px-6` inset across) and the `mt-8` spacer under the wordmark goes away. The pane also takes the same raised card every session sits on: `bg-v2-background-bg-deep` → `bg-v2-background-bg-base` in the view, and `new-session.tsx`'s `rounded-[10px]` wrapper gains `bg-v2-background-bg-base shadow-[var(--v2-elevation-raised)]` — the exact pair `SessionPanelFrame` (`pages/session.tsx`) applies with `newLayout raised`. Verified equal at runtime: same background, same eight-layer shadow, same 10px radius. | The wordmark reads as clutter on the desktop new-session screen; without it the pane should be balanced, not top-weighted. And with the sidebar always on screen, upstream's `bg-deep` made the draft screen read as an extension of the window chrome while every session floated on a card — the two screens have to match. | Keep our centred layout and the card. If upstream restyles this view, re-apply the drop + centring rather than restoring `top-[25.375%]`, and re-check the background against whatever `SessionPanelFrame` then uses rather than hardcoding `bg-base`. Reinstating the watermark means restoring the offset too, or it will sit centred with the composer. |
 | `packages/app/src/pages/home.tsx`, `packages/app/src/pages/error.tsx`, `packages/enterprise/src/routes/share/[shareID].tsx` | `Logo` width utilities retuned for the codev wordmark's 4:1 box (upstream's is 5.57:1): home `md:w-xl` → `md:w-104`, error `w-58.5` → `w-42`, share (both call sites) `w-58.5` → `w-42` | Each value is the width at which the new wordmark renders at exactly the height the upstream one did, so no surrounding layout shifts. | Keep our widths; take upstream's surrounding changes. Recompute rather than restore if upstream changes the size. |
-| `packages/app/src/components/titlebar.tsx` | Two changes, both to the **v2 titlebar branch only** (`useV2Titlebar()`); the legacy branch below it is untouched. (1) The Home button (and its `home.toggle` command, `mod+b`) opens a new session instead of toggling between `/` and the last active tab: `tabs.toggleHome(...)` becomes a `goHome` that selects an already-open draft if there is one and otherwise falls through to the existing `openNewTab()` project-resolution chain. Its pressed / `aria-pressed` state keys on `layout.route().type === "draft"` rather than `"home"`. The icon, label (`home.title`) and keybind are unchanged, as is `tabs.toggleHome` itself, which is simply no longer called. (2) `<ChannelIndicator>` is dropped from that row and the component gains an `export`, so the sidebar can render the DEV/BETA badge at its bottom instead; `Titlebar` keeps its `debugTools` prop because the legacy branch still renders the badge inline. (3) Two buttons added to the row: a sidebar collapse toggle (`sidebar-right` icon, `data-action="titlebar-sidebar-toggle"`, `pressed` while open) as its **first** child, ahead of the `windows() || linux()` `WindowsAppMenu`; and a Search button (`magnifying-glass`, `data-action="titlebar-search"`) immediately after Home, navigating to `/?focus=search`. The toggle reads the fork-only `useAppSidebar()` and is wrapped in `<Show when={appSidebar}>`, which is what keeps it out of the legacy shell. Labels reuse the existing `command.sidebar.toggle` and `home.sessions.search.placeholder` keys — no new i18n. | The home screen is a new session in this fork, so Home has to go there; toggling into the recent-sessions list contradicted that. Reuse-before-create keeps repeated presses from stacking up draft tabs — unlike the New session button, which is expected to always make a new one. Moving the badge lets Home lead the titlebar (measured: x 137 → 92 on macOS, the traffic-light inset). | Keep our `goHome` and the removed indicator. If upstream reworks the titlebar, re-apply both rather than restoring `toggleHome` or the inline badge. If upstream deletes `tabs.toggleHome`, nothing here breaks. Do not remove `Titlebar`'s `debugTools` prop — the legacy titlebar still needs it. Keep `useAppSidebar()` optional-by-design: `useV2Titlebar()` is just `newLayoutDesigns()`, so this titlebar also renders inside the legacy shell, which has no provider — swapping it for `createSimpleContext` would throw there (verified: with the new layout off, the legacy shell renders its own rail, no toggle, and no exception). |
+| `packages/app/src/components/titlebar.tsx` | Four changes, all to the **v2 titlebar branch only** (`useV2Titlebar()`); the legacy branch below it is untouched. (1) The Home button (and its `home.toggle` command, `mod+b`) opens a new session instead of toggling between `/` and the last active tab: `tabs.toggleHome(...)` becomes a `goHome` that selects an already-open draft if there is one and otherwise falls through to the existing `openNewTab()` project-resolution chain. Its pressed / `aria-pressed` state keys on `layout.route().type === "draft"` rather than `"home"`. The icon, label (`home.title`) and keybind are unchanged, as is `tabs.toggleHome` itself, which is simply no longer called. (2) `<ChannelIndicator>` is dropped from that row and the component gains an `export`, so the sidebar can render the DEV/BETA badge at its bottom instead; `Titlebar` keeps its `debugTools` prop because the legacy branch still renders the badge inline. (3) Two buttons added to the row: a sidebar collapse toggle (`sidebar-right` icon, `data-action="titlebar-sidebar-toggle"`, `pressed` while open) as its **first** child, ahead of the `windows() || linux()` `WindowsAppMenu`; and a Search button (`magnifying-glass`, `data-action="titlebar-search"`) immediately after Home, navigating to `/?focus=search`. The toggle reads the fork-only `useAppSidebar()` and is wrapped in `<Show when={appSidebar}>`, which is what keeps it out of the legacy shell. Labels reuse the existing `command.sidebar.toggle` and `home.sessions.search.placeholder` keys — no new i18n. (4) `openNewTab` routes all five of its project-resolution branches through a local `openDraftFor(...)`, which selects the draft already open for that server + directory — via the fork-only `findOpenDraft` in `pages/home-draft-reuse.ts` — and only calls `tabs.newDraft` when there is none. The `+` button gains `data-action="titlebar-new-tab"` so e2e can address it without colliding with the sidebar row, which carries the same accessible name. The model read off the active tab still seeds a *new* draft only; a reused one keeps its own, as selecting its tab by hand would. | The home screen is a new session in this fork, so Home has to go there; toggling into the recent-sessions list contradicted that. Reuse-before-create keeps repeated presses from stacking up draft tabs, which is now the rule for every new-session affordance rather than a Home-only quirk (see the `openNewTab` change and `pages/home-draft-reuse.ts`). Moving the badge lets Home lead the titlebar (measured: x 137 → 92 on macOS, the traffic-light inset). | Keep our `goHome` and the removed indicator. If upstream reworks the titlebar, re-apply both rather than restoring `toggleHome` or the inline badge. If upstream deletes `tabs.toggleHome`, nothing here breaks. Do not remove `Titlebar`'s `debugTools` prop — the legacy titlebar still needs it. Keep `useAppSidebar()` optional-by-design: `useV2Titlebar()` is just `newLayoutDesigns()`, so this titlebar also renders inside the legacy shell, which has no provider — swapping it for `createSimpleContext` would throw there (verified: with the new layout off, the legacy shell renders its own rail, no toggle, and no exception). |
+| `packages/app/src/context/tabs.tsx` | `newDraft` inserts with `tabs.unshift(tab)` instead of `tabs.push(tab)`, so a draft opens at the head of the tab strip. Session tabs (`addSessionTab`) still append, and nothing else about draft handling changes. | A draft is where you start a session, so it belongs at the front of the strip rather than behind every session already open — with several tabs open the New session tab was scrolling off the right-hand end. | Keep the `unshift`. On conflict take upstream's `newDraft` and swap the insert back. Note the knock-on: `promoteDraft` replaces the draft **at its own index**, so a promoted session keeps the head position and sessions accumulate newest-first. That is intended — the tab you are working in should not jump across the strip the moment you send the first message — but if it is ever unwanted, move the tab in `promoteDraft` rather than reverting this, or the New session tab goes back to the end. |
 | `packages/app/src/pages/layout-new.tsx` (again) | Mounts the fork-only `<LaunchNewSession />`, which on desktop redirects one time per boot to a new-session draft (reusing an existing empty draft rather than stacking one up per launch). It pins its decision to the pathname the window came up on and disarms as soon as anything navigates, so it can never hijack a later visit to `/` — the sidebar's "View all" links there. Desktop-only: in the browser there is no "launch" distinct from "navigate to /", so redirecting would make the recents screen unreachable by URL and would break two `packages/app/e2e` specs that `goto("/")`. | Launching should put you in front of a prompt, the way Claude Desktop does, rather than on a list. This supersedes the desktop's restore-last-screen behaviour (`getLastActiveUrl`, `packages/desktop/src/renderer/index.tsx`); the previous session stays one click away in Recents and its tab is still restored. | Keep the mount. If upstream restructures this layout, re-add it. Do not "simplify" the boot-window guard into a plain `location.pathname === "/"` check — that is the bug it exists to prevent. |
 | `packages/app/src/pages/layout-new.tsx`, `packages/app/src/pages/home.tsx`, `packages/app/src/i18n/{en,es}.ts` | **Persistent app sidebar.** Upstream's project column is an `<aside>` owned by `NewHome`, so it exists only on `/`. It becomes app chrome: `layout-new.tsx` wraps its `<main>` in a row flex and renders the fork-only `<AppSidebar class="hidden lg:flex">` beside it, so the sidebar survives every navigation. **The row components stay in `home.tsx`** — `HomeUtilityNav`, `HomeServerRow`, `HomeProjectList`, `HomeProjectEmpty`, `HomeRecentlyClosedRow` and the classes `HOME_PROJECT_NAV_ROW` / `HOME_PROJECT_NAV_LABEL` / `HOME_SECTION_LABEL` gain an `export` and nothing else, so upstream edits to them still apply cleanly; the fork-only `src/components/app-sidebar.tsx` imports and composes them, adding only the column shell and the Recents section (`HOME_SECTION_LABEL` is consumed one level down, by the fork-only `src/components/sidebar-section.tsx`). `home.tsx` otherwise loses just `HomeProjectColumn` (dead once the sidebar owns that composition) and the `NewHome` selection/action block, and its grid collapses from `lg:grid-cols-[280px_minmax(0,720px)]` to one `max-w-[760px]` column. The sub-`lg` `HomeUtilityNav` mount is untouched, so the stacked mobile layout is upstream's. The state both screens need (`focusedServer`, `projects`, `selectedProject`, `newSessionProject`, `projectDirectories`, the session-index query, `openNewSession`, `openProjectNewSession`, `openSession`, `selectProject`, `addProjects`, `editProject`, `closeProject`, `unseenCount`, `clearNotifications`, `chooseProject`, `isBackgroundOpen`, `buildHomeSessionRecords`, `HomeSessionRecord`) moves to fork-only `src/pages/home-model.tsx`, which both callers instantiate — safe because the selection lives in `useLayout().home`, the index is one TanStack query deduped by key, and the server-normalizing effect is idempotent. New i18n keys `sidebar.recents`, `sidebar.recents.new`, `sidebar.recents.viewAll` in `en` + `es`. `layout-new.tsx` additionally wraps its shell in the fork-only `<AppSidebarProvider>` (so the titlebar toggle and the sidebar share one collapse state), `AppSidebar` renders nothing while collapsed, and `NewHome` consumes a `?focus=search` param — clearing it after use, the way `pages/new-session.tsx` handles `?prompt` — to focus the search field for the titlebar's Search button. That focus ref changed from a `let` to a signal because `HomeSessionSearch` binds it from `onMount`, which runs after `NewHome`'s effects, so a plain ref is still undefined when the param arrives. `AppSidebarProvider` also registers the `sidebar.toggle` command (no keybind — `mod+b` is Home's here, unlike in the legacy layout), which is what the app menu's View → Toggle Sidebar dispatches; only `LegacyLayout` registered it before, so that item did nothing on this layout. It lives on the provider, not on `AppSidebar`, so collapsing does not unregister the command that undoes it. Both shells can be mounted at once on `/:dir` routes, so the id may be registered twice there; the command registry keeps the first entry, which is the outer (new-layout) one. Every `data-component`/`data-action` hook is untouched (`home-project-row`, `home-add-project`, `home-session-row`, `home-session-search`, …) because `packages/app/e2e` selects on them. | The desktop app should navigate like Claude Desktop — one always-visible sidebar with Projects, Recents and pinned Settings/Help — instead of losing all navigation the moment a session opens. Exporting the row components in place rather than relocating them keeps `home.tsx` down to ~36 added lines: upstream changes to those components merge without a conflict, which relocating them would have forfeited. | Keep our structure. On conflict take upstream's `home.tsx` wholesale and re-apply the four edits: the `export` keywords, the `HomeProjectColumn` deletion, the `createHomeModel()` swap in `NewHome`, and the single-column grid. If upstream edits an exported row component, just take it. Never let a `data-component`/`data-action` hook drift — the e2e suite has no other handle on these rows. |
 | `packages/app/src/context/settings.tsx`, `packages/app/src/components/settings-general.tsx`, `packages/app/src/components/settings-v2/general.tsx`, `packages/app/src/context/settings.test.ts`, `packages/app/src/pages/session/composer/session-revert-dock.stories.tsx`, deleted `packages/app/src/components/settings-v2/interface-transition.tsx` + `interface-transition.stories.tsx`, deleted `packages/app/e2e/regression/legacy-new-session.spec.ts`, `packages/app/e2e/regression/session-timeline-projection.spec.ts`, `packages/app/e2e/performance/timeline-stability/fixture.ts` | **The legacy layout is retired: the fork ships one layout and no way back.** Upstream runs a timed migration — `oldInterfaceSunset` (a hardcoded date), a per-profile `layoutTransitionEligible` flag, a `newLayoutDesigns` preference and a Settings → General **New layout** switch — so existing users can flip between layouts until the sunset passes. All of it goes. `newLayoutDesigns` becomes `createMemo(() => true)`: reading a constant rather than the persisted value is what makes a profile carrying `newLayoutDesigns: false` (older build, another device via sync, hand-edited store) still come up on the new layout, which suppressing the toggle alone would not. `setNewLayoutDesigns`, `layoutTransitionAvailable`, `newInterfaceNoticeVisible` and `dismissNewInterfaceNotice` are **removed from the context rather than stubbed** — a no-op setter would let a caller look like it was switching layouts, so re-introducing the toggle has to be a compile error. Both Settings screens (v1 `settings-general.tsx` and v2 `settings-v2/general.tsx`) lose their `InterfaceSection` + `InterfaceNoticeSection` and the `<Show>` blocks that mounted them; `interface-transition.tsx` and its story are deleted with their last caller. The sunset machinery in `settings.tsx` goes with it — `oldInterfaceSunset`, `legacyNewLayoutDesignsDefault`, `newLayoutDesignsDefault`, `newLayoutDesignsUpgradeCutoff`, `shouldEnableNewLayout`, `layoutTransitionState`, `maximumSunsetTimeout`, `nextSunsetCheckDelay`, `resolveNewLayoutDesigns`, the retirement `setTimeout` and the two `createEffect`s that wrote `newLayoutDesigns` back to the store — along with their tests; `settings.test.ts` keeps only the `isAppUpgrade` / `shouldDisplayTabsToast` block. **Deliberately kept**: `layoutTransitionEligible`, `layoutTransitionClassified` and `setOldLayoutEligible` (with the desktop `isOldLayoutEligible` IPC that feeds them), because the tabs toast still uses eligibility to tell a fresh profile from an existing install — they no longer gate any layout. Also kept: every `newLayoutDesigns()` **read** in `app.tsx` and the `LegacyServerLayout` / `LegacyHome` code behind them. That shell is still mounted on `/:dir` routes, and leaving the branches in place keeps upstream's edits to them applying cleanly; deleting the legacy layout outright is a far larger diff for no user-visible gain. On the test side `legacy-new-session.spec.ts` is deleted (it asserted a redirect to a route that no longer resolves), `session-timeline-projection.spec.ts` drops its one `settings: { newLayoutDesigns: false }` pin, and the timeline-stability fixture drops the `newLayoutDesigns === false` branch that back-dated `app-version.v1`. The many specs that set `newLayoutDesigns: true` are untouched — the value is simply ignored now. The fork-only `packages/app/e2e/regression/layout-theme-lock.spec.ts` covers both locks from a seeded profile; each of its four cases was checked to fail when the matching source file is reverted to upstream's. | The fork ships one layout. Leaving a switch that drops users into a layout the fork does not design for, style-test or screenshot means two UIs to maintain and support, and the upstream sunset date would have retired it anyway. | Keep ours. On conflict take upstream's file and re-apply: the constant `newLayoutDesigns`, the four removed context members, the two deleted Settings sections. If upstream adds a new layout-preference surface, remove it too rather than wiring it up. Do **not** "restore" `setNewLayoutDesigns` to make a new upstream caller compile — delete the caller. Do not delete the `LegacyServerLayout` branches in `app.tsx`; they are load-bearing on `/:dir` and deliberately left as upstream's. |
diff --git a/packages/app/e2e/regression/new-session-reuses-draft.spec.ts b/packages/app/e2e/regression/new-session-reuses-draft.spec.ts
new file mode 100644
index 0000000000..69e6f3aefe
--- /dev/null
+++ b/packages/app/e2e/regression/new-session-reuses-draft.spec.ts
@@ -0,0 +1,145 @@
+import { expect, test, type Page } from "@playwright/test"
+import { fixture, pageMessages } from "../smoke/session-timeline.fixture"
+import { mockOpenCodeServer } from "../utils/mock-server"
+
+const sidebar = (page: Page) => page.locator('[data-component="app-sidebar"]')
+const newSession = (page: Page) => sidebar(page).locator('[data-action="sidebar-new-session"]')
+const tabs = (page: Page) => page.locator("[data-titlebar-tab-slot]")
+const draftTabs = (page: Page) => tabs(page).filter({ has: page.locator('a[href^="/new-session"]') })
+
+async function boot(page: Page) {
+  await mockOpenCodeServer(page, {
+    sessions: fixture.sessions,
+    provider: fixture.provider,
+    directory: fixture.directory,
+    project: fixture.project,
+    pageMessages,
+  })
+  await page.addInitScript((directory) => {
+    localStorage.setItem(
+      "opencode.global.dat:server",
+      JSON.stringify({
+        projects: { local: [{ worktree: directory, expanded: true }] },
+        lastProject: { local: directory },
+      }),
+    )
+  }, fixture.directory)
+  await page.goto("/")
+  await expect(newSession(page)).toBeVisible({ timeout: 30_000 })
+}
+
+test("New session focuses the draft already open instead of stacking another", async ({ page }) => {
+  await boot(page)
+  expect(await draftTabs(page).count()).toBe(0)
+
+  await newSession(page).click()
+  await expect(page).toHaveURL(/\/new-session/)
+  await expect(draftTabs(page)).toHaveCount(1)
+  const href = await draftTabs(page).locator("a").first().getAttribute("href")
+  expect(href).toBeTruthy()
+
+  // Navigate away so the second click is a real navigation rather than a no-op
+  // on the page we are already sitting on.
+  await sidebar(page).locator('[data-action="sidebar-view-all"]').click()
+  await expect(page).not.toHaveURL(/\/new-session/)
+
+  // The draft persists until it is promoted or closed, so a second New session
+  // used to push an identical empty draft beside the first.
+  await newSession(page).click()
+  await expect(page).toHaveURL(/\/new-session/)
+  await expect(draftTabs(page)).toHaveCount(1)
+  // And it is the same draft, not a replacement carrying a fresh id.
+  expect(await draftTabs(page).locator("a").first().getAttribute("href")).toBe(href)
+})
+
+test("a third click still lands on the one draft", async ({ page }) => {
+  await boot(page)
+  for (let click = 0; click < 3; click++) {
+    await newSession(page).click()
+    await expect(page).toHaveURL(/\/new-session/)
+    await sidebar(page).locator('[data-action="sidebar-view-all"]').click()
+    await expect(page).not.toHaveURL(/\/new-session/)
+  }
+  await expect(draftTabs(page)).toHaveCount(1)
+})
+
+// The tab bar's + and mod+t share `openNewTab`, which resolves the project from
+// whatever is on screen and then opened an unconditional draft. Both are
+// labelled "New session", so they follow the same rule.
+// By hook, not by accessible name: the sidebar row is also a button named
+// "New session", so a role query would have matched it and quietly re-tested
+// the path the tests above already cover.
+const plusButton = (page: Page) => page.locator('[data-action="titlebar-new-tab"]')
+
+test("the tab bar + goes to the draft already open", async ({ page }) => {
+  await boot(page)
+  await newSession(page).click()
+  await expect(draftTabs(page)).toHaveCount(1)
+  const href = await draftTabs(page).locator("a").first().getAttribute("href")
+
+  await sidebar(page).locator('[data-action="sidebar-view-all"]').click()
+  await expect(page).not.toHaveURL(/\/new-session/)
+
+  await plusButton(page).click()
+  await expect(page).toHaveURL(/\/new-session/)
+  await expect(draftTabs(page)).toHaveCount(1)
+  expect(await draftTabs(page).locator("a").first().getAttribute("href")).toBe(href)
+})
+
+test("mod+t goes to the draft already open", async ({ page }) => {
+  await boot(page)
+  await newSession(page).click()
+  await expect(draftTabs(page)).toHaveCount(1)
+  const href = await draftTabs(page).locator("a").first().getAttribute("href")
+
+  await sidebar(page).locator('[data-action="sidebar-view-all"]').click()
+  await expect(page).not.toHaveURL(/\/new-session/)
+
+  // Modifier read from the page, not the host: the Desktop Chrome profile
+  // always reports Win32, so `mod` resolves to Control here (see #190).
+  const mac = await page.evaluate(() => /(Mac|iPod|iPhone|iPad)/.test(navigator.platform))
+  await page.keyboard.press(mac ? "Meta+t" : "Control+t")
+  await expect(page).toHaveURL(/\/new-session/)
+  await expect(draftTabs(page)).toHaveCount(1)
+  expect(await draftTabs(page).locator("a").first().getAttribute("href")).toBe(href)
+})
+
+test("a new draft opens at the head of the tab strip, not after the sessions", async ({ page }) => {
+  await mockOpenCodeServer(page, {
+    sessions: fixture.sessions,
+    provider: fixture.provider,
+    directory: fixture.directory,
+    project: fixture.project,
+    pageMessages,
+  })
+  await page.addInitScript(
+    ({ directory, seeded }) => {
+      localStorage.setItem(
+        "opencode.global.dat:server",
+        JSON.stringify({
+          projects: { local: [{ worktree: directory, expanded: true }] },
+          lastProject: { local: directory },
+        }),
+      )
+      localStorage.setItem("opencode.window.browser.dat:tabs", JSON.stringify(seeded))
+    },
+    {
+      directory: fixture.directory,
+      seeded: [
+        { type: "session", server: "http://127.0.0.1:4096", sessionId: fixture.sourceID },
+        { type: "session", server: "http://127.0.0.1:4096", sessionId: fixture.targetID },
+      ],
+    },
+  )
+  await page.goto("/")
+  await expect(tabs(page)).toHaveCount(2)
+
+  await newSession(page).click()
+  await expect(page).toHaveURL(/\/new-session/)
+  await expect(tabs(page)).toHaveCount(3)
+
+  // A draft is where you start, so it leads the strip rather than trailing
+  // every session already open. Session tabs still append.
+  await expect(tabs(page).first()).toContainText("New session")
+  await expect(tabs(page).nth(1)).toContainText("Uncommitted changes inquiry")
+})
diff --git a/packages/app/src/components/titlebar.tsx b/packages/app/src/components/titlebar.tsx
index 5f7bfce177..cff5ddc823 100644
--- a/packages/app/src/components/titlebar.tsx
+++ b/packages/app/src/components/titlebar.tsx
@@ -24,9 +24,11 @@ import { makeEventListener } from "@solid-primitives/event-listener"
 import { createMediaQuery } from "@solid-primitives/media"
 import { readSessionTabsRemovedDetail, SESSION_TABS_REMOVED_EVENT } from "@/components/titlebar-session-events"
 import { useGlobal } from "@/context/global"
+import { findOpenDraft } from "@/pages/home-draft-reuse"
 import { ServerConnection, useServer } from "@/context/server"
 import { tabKey, useTabs } from "@/context/tabs"
 import type { PromptSession } from "@/context/prompt"
+import type { PromptModel } from "@/context/prompt-state"
 import "./titlebar.css"
 import { newTabTooltipKeybind } from "./command-tooltip-keybind"
 
@@ -325,6 +327,21 @@ export function Titlebar(props: { update?: TitlebarUpdate; debugTools?: { visibl
               tabsStoreActions.removeSessions(detail)
             })
 
+            // Same rule the sidebar's New session follows: land on the draft
+            // this project already has open rather than stacking an identical
+            // empty one beside it. Scoped to server + directory, so a draft for
+            // another project is never reused. The model carried over from the
+            // active tab only seeds a new draft — an existing one keeps the
+            // model it already has, exactly as selecting its tab by hand would.
+            const openDraftFor = (draft: { server: ServerConnection.Key; directory: string }, model?: PromptModel) => {
+              const existing = findOpenDraft(tabsStore, draft)
+              if (existing) {
+                tabs.select(existing)
+                return
+              }
+              tabs.newDraft(draft, "", model)
+            }
+
             const openNewTab = () => {
               const route = layout.route()
               const activeSession = session()
@@ -335,14 +352,14 @@ export function Titlebar(props: { update?: TitlebarUpdate; debugTools?: { visibl
                   sessionId: activeSession.id,
                 }
                 const model = tabs.stateValue<PromptSession>(sessionTab, "prompt")?.model.current()
-                tabs.newDraft({ server: sessionTab.server, directory: activeSession.directory }, "", model)
+                openDraftFor({ server: sessionTab.server, directory: activeSession.directory }, model)
                 return
               }
 
               const activeTab = currentTab()
               if (activeTab?.type === "draft") {
                 const model = tabs.stateValue<PromptSession>(activeTab, "prompt")?.model.current()
-                tabs.newDraft({ server: activeTab.server, directory: activeTab.directory }, "", model)
+                openDraftFor({ server: activeTab.server, directory: activeTab.directory }, model)
                 return
               }
 
@@ -356,14 +373,14 @@ export function Titlebar(props: { update?: TitlebarUpdate; debugTools?: { visibl
                       .find((item) => item.worktree === selection.directory)
                   : undefined
                 if (conn && project) {
-                  tabs.newDraft({ server: ServerConnection.key(conn), directory: project.worktree }, "")
+                  openDraftFor({ server: ServerConnection.key(conn), directory: project.worktree })
                   return
                 }
               }
 
               const current = layout.projects.list()[0]
               if (current) {
-                tabs.newDraft({ server: server.key, directory: current.worktree }, "")
+                openDraftFor({ server: server.key, directory: current.worktree })
                 return
               }
 
@@ -373,7 +390,7 @@ export function Titlebar(props: { update?: TitlebarUpdate; debugTools?: { visibl
               })[0]
               if (!fallback) return
 
-              tabs.newDraft({ server: fallback.server, directory: fallback.project.worktree }, "")
+              openDraftFor({ server: fallback.server, directory: fallback.project.worktree })
             }
             // The home screen is a new session, not the recent-sessions list, so
             // this goes there rather than toggling between "/" and the last tab.
@@ -573,6 +590,7 @@ export function Titlebar(props: { update?: TitlebarUpdate; debugTools?: { visibl
                       class="shrink-0"
                       icon={<IconV2 name="plus" />}
                       onClick={openNewTab}
+                      data-action="titlebar-new-tab"
                       aria-label={language.t("command.session.new")}
                     />
                   </TooltipV2>
diff --git a/packages/app/src/context/tabs.tsx b/packages/app/src/context/tabs.tsx
index 75191d54cf..302ecf285f 100644
--- a/packages/app/src/context/tabs.tsx
+++ b/packages/app/src/context/tabs.tsx
@@ -215,7 +215,10 @@ export const { use: useTabs, provider: TabsProvider } = createSimpleContext({
         await startTransition(() => {
           setStore(
             produce((tabs) => {
-              tabs.push(tab)
+              // Front, not back: a draft is where you start, so it belongs at
+              // the head of the strip rather than after every session you have
+              // open. Session tabs still append.
+              tabs.unshift(tab)
             }),
           )
           navigate(draftHref(draftID))
diff --git a/packages/app/src/pages/home-draft-reuse.test.ts b/packages/app/src/pages/home-draft-reuse.test.ts
new file mode 100644
index 0000000000..f25362e435
--- /dev/null
+++ b/packages/app/src/pages/home-draft-reuse.test.ts
@@ -0,0 +1,48 @@
+import { describe, expect, test } from "bun:test"
+import { findOpenDraft } from "./home-draft-reuse"
+
+const server = "http://127.0.0.1:4096"
+const other = "http://127.0.0.1:4097"
+const directory = "C:/project"
+
+const draft = (overrides: { draftID?: string; server?: string; directory?: string } = {}) => ({
+  type: "draft",
+  draftID: "draft-1",
+  server,
+  directory,
+  ...overrides,
+})
+// Session tabs carry no directory at all, which is why the helper treats it as
+// optional rather than requiring it of every tab.
+const session = (sessionId = "ses_1") => ({ type: "session", server, sessionId })
+
+describe("findOpenDraft", () => {
+  test("finds the draft already open for this project", () => {
+    const open = draft()
+    expect(findOpenDraft([session(), open], { server, directory })).toBe(open)
+  })
+
+  test("ignores session tabs", () => {
+    expect(findOpenDraft([session("a"), session("b")], { server, directory })).toBeUndefined()
+  })
+
+  test("will not reuse a draft pointing at another project", () => {
+    // Jumping to a draft for the wrong directory is worse than opening a new
+    // one, so this has to miss.
+    expect(findOpenDraft([draft({ directory: "C:/elsewhere" })], { server, directory })).toBeUndefined()
+  })
+
+  test("will not reuse a draft belonging to another server", () => {
+    expect(findOpenDraft([draft({ server: other })], { server, directory })).toBeUndefined()
+  })
+
+  test("takes the first match when several drafts exist for one project", () => {
+    const first = draft({ draftID: "draft-1" })
+    const second = draft({ draftID: "draft-2" })
+    expect(findOpenDraft([first, second], { server, directory })).toBe(first)
+  })
+
+  test("is undefined with no tabs at all", () => {
+    expect(findOpenDraft([], { server, directory })).toBeUndefined()
+  })
+})
diff --git a/packages/app/src/pages/home-draft-reuse.ts b/packages/app/src/pages/home-draft-reuse.ts
new file mode 100644
index 0000000000..f1d8544a9c
--- /dev/null
+++ b/packages/app/src/pages/home-draft-reuse.ts
@@ -0,0 +1,15 @@
+// Draft tabs persist until they are promoted into a session or closed, so
+// "New session" used to stack an identical empty draft beside the one already
+// open. Find that one instead of making another.
+//
+// Matched on server *and* directory: a draft belongs to a project, and jumping
+// to one pointing somewhere else would be a worse answer than opening a new
+// draft. Typed structurally — `directory` is optional because session tabs
+// carry none — so this needs nothing from the tabs context, at build time or
+// run time.
+export function findOpenDraft<T extends { type: string; server: string; directory?: string }>(
+  tabs: readonly T[],
+  target: { server: string; directory: string },
+) {
+  return tabs.find((tab) => tab.type === "draft" && tab.server === target.server && tab.directory === target.directory)
+}
diff --git a/packages/app/src/pages/home-model.tsx b/packages/app/src/pages/home-model.tsx
index aead0695ac..6a47a3d310 100644
--- a/packages/app/src/pages/home-model.tsx
+++ b/packages/app/src/pages/home-model.tsx
@@ -31,6 +31,7 @@ import { notifySessionTabsRemoved } from "@/components/titlebar-session-events"
 import { pathKey } from "@/utils/path-key"
 import { showToast } from "@/utils/toast"
 import { archiveHomeSession } from "./home-session-archive"
+import { findOpenDraft } from "./home-draft-reuse"
 import { shouldOpenSessionInBackground } from "./home-session-open"
 
 export const HOME_SESSION_LIMIT = 64
@@ -257,7 +258,16 @@ export function createHomeModel() {
     const ctx = global.ensureServerCtx(conn)
     ctx.projects.open(directory)
     ctx.projects.touch(directory)
-    tabs.newDraft({ server: ServerConnection.key(conn), directory })
+    const server = ServerConnection.key(conn)
+    // Focus the draft this project already has open rather than stacking a
+    // second empty one beside it. LaunchNewSession does the same at boot; this
+    // extends it to every deliberate "New session".
+    const existing = findOpenDraft(tabs.store, { server, directory })
+    if (existing) {
+      tabs.select(existing)
+      return
+    }
+    tabs.newDraft({ server, directory })
   }
 
   function editProject(conn: ServerConnection.Any, project: LocalProject) {