diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8ba6e74541..f68d1e769f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,20 @@ file is the human-readable summary of what changed and why.
 
 ### Desktop / Web UI
 
+- **The ⋮ menu on a session row opens on the first click** — it used to ignore
+  one click and open on the next, both in the sidebar's Recents and on the
+  **View all** list. The rows were being rebuilt from scratch whenever anything
+  the session list depends on changed, which could happen mid-click and threw
+  the click away; they are now updated in place. The same rebuild could also
+  close the menu under you while it was open, or drop a rename you were
+  part-way through typing. The ⋯ menu beside a session title was never
+  affected.
+
+- **Recents no longer draws a half-cut View all** — in a window short enough
+  that the list has no room for a whole row (roughly under 380px tall), **View
+  all** was still drawn and clipped by the edge of the list. It is now left out
+  at those sizes instead.
+
 - **Delete reads as destructive** — the **Delete** item in a session's ⋮ / ⋯
   menu is now red, in both the sidebar rows and the menu beside a session
   title, and it has lost its trailing ellipsis. It still asks for confirmation
diff --git a/DIVERGENCES.md b/DIVERGENCES.md
index 4019e0c3bd..7208d8ceb2 100644
--- a/DIVERGENCES.md
+++ b/DIVERGENCES.md
@@ -124,6 +124,7 @@ from the squash message first, or use a plain merge.
 | `packages/ui/src/theme/context.tsx`, `packages/app/public/oc-theme-preload.js`, `packages/app/src/theme-preload.test.ts`, `packages/app/src/pages/layout.tsx`, `packages/app/src/components/settings-general.tsx`, `packages/app/src/components/settings-v2/general.tsx` | **One theme in the web/desktop UI; light and dark are the only axis.** Upstream ships 36 selectable palettes with a Settings → Appearance **Theme** picker and command-palette entries. The fork exposes none of them: OC-2 is the theme, `colorScheme` (system/light/dark) is the only appearance choice. The lock lives at `normalize()` in `theme/context.tsx`, renamed to the exported `normalizeThemeID()` and returning the exported `SHIPPED_THEME_ID` unconditionally — that one function is already on every path (provider init, the `onMount` migration, `load`, the cross-tab `storage` listener, `setTheme`, `previewTheme`), so a stored id from before the picker was removed, or one written by another tab, resolves to OC-2 without a second guard. It is exported (and the six call sites renamed) so `theme/context.test.ts` can cover the invariant directly instead of only through its call sites — the module imports cleanly under `bun test` because `import.meta.glob` is called lazily inside `getFiles()`. It also gives the migration for free: `onMount` already rewrites `opencode-theme-id` and calls `clear()` when the raw value differs from the normalized one, which now drops the stale `opencode-theme-css-{light,dark}` cache. `ids()` returns `["oc-2"]` and `loadThemes()` loads only OC-2 instead of all 36 (it was `Promise.all(themeIDs().map(load))`). The bundled theme JSON, the `names` map and `registerTheme` are **left alone** — unreferenced data costs nothing and keeps upstream's theme edits applying cleanly. `oc-theme-preload.js` does the same rewrite *before* mount, so the first launch after upgrading does not paint the user's old palette for a frame; with no other theme reachable its cached-CSS `<style>` injection is gone and it only sets the mode attributes. Removed surfaces: the **Theme** `SettingsRow`/`SettingsRowV2` in both Settings screens (with the `…/themes` docs "Learn more" link, `themeOptions`, the `ThemeOption` type and the `onMount(loadThemes)` that fed them), and in `pages/layout.tsx` the `theme.cycle` command with its `mod+shift+t` keybind, the `cycleTheme` helper and the `theme.set.<id>` command loop (with `availableThemeEntries`). The **colour-scheme** commands stay: `theme.scheme.cycle` (`mod+shift+s`), the three `theme.scheme.<scheme>` entries and their preview/commit wiring. i18n keys (`settings.general.row.theme.*`, `command.theme.cycle`, `command.theme.set`, `toast.theme.title`) are left in the dicts — unused keys are harmless and removing them only creates conflicts. | Every fork surface — the brand, the icons, the screenshots, the docs — is drawn against OC-2. A palette picker means 36 combinations nobody verifies, and a user on Synthwave '84 files bug reports about a UI the fork never shipped. Light/dark still covers the real need. | Keep ours. Take upstream's surrounding changes; re-apply the `normalize()` constant, the `ids()`/`loadThemes()` narrowing, the preload rewrite, and the removed rows/commands. If upstream adds a new theme-selection surface, remove it rather than wiring it up. Do not "fix" `normalize()` back to the `oc-1 → oc-2` mapping — that mapping is a subset of what it does now. Leave the bundled theme files and `names` map in place; deleting them is a much bigger conflict surface for no gain. |
 | `packages/app/src/pages/session/timeline/message-timeline.tsx` | **Session actions menu extracted.** The ⋯ menu beside the session title — both renderings, the legacy `DropdownMenu` and the v2 `MenuV2`, ~145 lines — and the `DialogDeleteSession` closure move to the fork-only `packages/app/src/components/session-actions-menu.tsx` (verbatim at extraction; the v2 Delete item has since dropped its ellipsis and taken the danger colour, so do not diff the two expecting a match), and this file renders `<SessionActionsMenu>` instead, passing its existing `openTitleEditor` / share / `archiveSession` / `deleteSession` as callbacks and its trigger element out through `triggerRef` (the share popover still anchors to it). The extracted dialog takes a resolved `title` and an `onConfirm` rather than a `sessionID`, so the caller supplies `sessionTitle(sync().session.get(id)?.title)`. The `title` store loses `pendingRename`/`pendingShare`: deferring Rename and Share until the menu's `onCloseAutoFocus` is now the component's job, since every caller needs it (a list row's inline editor is blurred by the returning focus exactly as the header's was). Also gains one fork-only `createEffect` that consumes `consumeSessionShareRequest(sessionID())` and opens the share popover — the session rows' Share routes through it. | The sidebar's Recents rows and the home session list open the same menu; three copies of four items would drift. Only this file rendered the menu, so extraction is the smallest way to share it. | Keep the extraction. On conflict, take upstream's `message-timeline.tsx` wholesale and re-apply: delete both inline menu blocks and the local `DialogDeleteSession`, mount `<SessionActionsMenu>` with the same callbacks, drop the two `pending*` store fields, and re-add the share-request effect. If upstream adds a menu item, add it to `session-actions-menu.tsx` (both variants) rather than back here. Do not "simplify" the component's deferred rename/share into a plain `onSelect` — focus return is what it exists to survive. |
 | `packages/app/src/pages/home.tsx` | `HomeSessionRow` gains the same `<SessionActionsMenu>` (hover/focus/menu-open revealed, vertical dots) and inline rename: while renaming, the row renders a `div` with `InlineEditor` instead of the `button`, because an input inside a button is invalid markup and swallows keystrokes into the open-session handler. `NewHome` holds one `createInlineEditorController()` for the list and passes it plus the model down. Its local `archiveSession` is deleted — `createHomeModel()` owns `archiveSession`/`renameSession`/`deleteSession` now, so the sidebar and this screen run one implementation (extends the "state both screens need moves to home-model.tsx" split in the persistent-sidebar row above); the call site becomes `model.archiveSession`. Upstream's `SHOW_HOME_SESSION_ARCHIVE` block is left exactly as-is — the flag is `false`, so it renders nothing, and touching it would widen the diff for no gain. `data-component="home-session-row"` and every other selector are untouched (`packages/app/e2e` binds to them); the menu adds `data-action="session-menu"`. | The Recents rows and "View all" are the same list at two sizes; a menu on one and not the other makes "View all" a dead end. | Keep our row structure. On conflict take upstream's row and re-apply the menu, the editing branch, and the `model.*` action wiring. Never let a `data-component`/`data-action` hook drift. If upstream re-enables `SHOW_HOME_SESSION_ARCHIVE`, drop that block instead — its absolutely-positioned archive button would sit on top of the menu. |
+| `packages/app/src/pages/home.tsx` (again) | **Session lists keyed by id.** The "View all" list iterates `groups().map((group) => group.id)` and, within each group, `group.sessions.map((record) => record.session.id)`, resolving each back through a `createMemo` + `<Show>` rather than handing the objects to `<For>`. `groupSessions` mints new group objects on every call and `createHomeModel`'s records memo mints a new `{session, project, projectName}` wrapper per session on every recompute — the `projects` memo alone returns a fresh array on a pointerdown — and `<For>` keys on reference, so the rows were torn down and rebuilt on recomputes that changed nothing visible. When that landed between a pointerdown and its mouseup the browser had no surviving common ancestor to fire `click` on, so a row's ⋮ menu ignored its first click; the same rebuild could close an open menu or drop an in-progress rename. `data-component="home-session-row"`, `data-action="session-menu"` and the group header refs / opacity keys are unchanged. The fork-only `packages/app/src/components/app-sidebar.tsx` carries the same shape for the Recents list. | A menu that swallows the first click reads as broken, and the cause is structural rather than incidental: any refresh of the session index rebuilt every row. | Keep the id keying. On conflict take upstream's list body and re-apply both `<For>` wrappers. Do not "simplify" back to `<For each={groups()}>` / `<For each={group.sessions}>` — that is the bug. If upstream ever makes groups or records referentially stable this can go, but prove it with `packages/app/e2e/regression/home-session-menu-first-click.spec.ts` before removing it. |
 | `packages/desktop/icons/{dev,beta,prod}/` (all PNGs, `icon.icns`, `icon.ico`, `dock.png`), `packages/desktop/icons/README.md` | Regenerated from the fork-only `packages/desktop/icons/icon.svg` by the fork-only `packages/desktop/scripts/generate-icons.ts`: the brand-red `#ee0033` CoDev "C" — the `--mini` splash badge glyph, at the VS Code extension icon's proportions (unit = 120/1024, mark 480x600 centered) — on a white tile, replacing upstream's black/blueprint "o" mark. All three channels are byte-identical for now (chosen deliberately over upstream's per-channel treatments); the generator still writes them separately so a channel can diverge later. `icon.icns` members and `dock.png` use the macOS Big Sur grid (824/1024 inset + drop shadow); Windows, Linux and Store assets stay full-bleed. README rewritten from the Tauri-CLI + Image2Icon recipe to the generator. The stale Tauri-era `android/` and `ios/` subfolders are left untouched — nothing in the Electron build reads them. | Closes the "desktop app icons need design assets" rebrand gap: the Dock/taskbar icon was still upstream's mark. | Keep our assets and README (binary: take ours wholesale). Regenerate via the script rather than hand-editing; if upstream adds an icon size, add it to `FLAT_PNGS`/`ICONSET` and rerun. |
 | `packages/tui/src/theme/assets/codev.json` (new file), `packages/tui/src/theme/index.ts`, `packages/tui/src/context/theme.tsx` | Added the `codev` theme — upstream's `opencode.json` palette with `darkSecondary` → `#0891b2` (brand teal) — registered it in the theme index, and made it the default/fallback theme (`"opencode"` → `"codev"` in the store default, kv fallback, and load-failure fallbacks). `theme/assets/opencode.json` itself matches upstream again. | Brand accent lives in a fork-owned theme instead of edits to upstream's palette; the default theme carries the brand. | Keep our theme file, its index registration, and the fallback strings; when upstream changes the opencode palette, mirror it into `codev.json` (keeping our `darkSecondary`). |
 | `packages/opencode/src/cli/ui.ts` | `wordmark`/`logo()` render the lowercase codev wordmark via `ansiWordmark` (bold, no shadow, "dev" in brand red on TTY) | Help banner matches the TUI home banner. | Keep our wordmark + logo(); take upstream's surrounding changes. |
diff --git a/packages/app/e2e/regression/home-session-menu-first-click.spec.ts b/packages/app/e2e/regression/home-session-menu-first-click.spec.ts
new file mode 100644
index 0000000000..cc03afa187
--- /dev/null
+++ b/packages/app/e2e/regression/home-session-menu-first-click.spec.ts
@@ -0,0 +1,69 @@
+import { expect, test, type Page } from "@playwright/test"
+import { fixture, pageMessages } from "../smoke/session-timeline.fixture"
+import { mockOpenCodeServer } from "../utils/mock-server"
+import { expectAppVisible } from "../utils/waits"
+
+// The "View all" screen — the same session rows as the sidebar, grouped by day,
+// rendered by home.tsx rather than app-sidebar.tsx. It carried the same
+// first-click defect for the same reason: reference-keyed lists over objects
+// that get rebuilt on unrelated recomputes.
+const main = (page: Page) => page.locator("main")
+const rows = (page: Page) => main(page).locator('[data-component="home-session-row"]')
+const content = (page: Page) => page.locator('[data-component="menu-v2-content"]')
+
+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 expectAppVisible(rows(page).first())
+  await expect(rows(page)).toHaveCount(fixture.sessions.length)
+}
+
+async function revealActions(page: Page) {
+  await rows(page).first().hover()
+  await expect(main(page).locator('[data-action="session-menu"]').first()).toBeVisible()
+}
+
+test("the View all row menu opens on the first click", async ({ page }) => {
+  await boot(page)
+  await revealActions(page)
+
+  await main(page).locator('[data-action="session-menu"]').first().click()
+  await expect(content(page)).toHaveCount(1)
+})
+
+test("a record rebuild leaves the View all rows and their groups alone", async ({ page }) => {
+  await boot(page)
+  await revealActions(page)
+  await main(page).locator('[data-action="session-menu"]').first().click()
+  await expectAppVisible(content(page))
+
+  const row = await rows(page).first().elementHandle()
+
+  // Re-runs the records memo, which hands both the group list and the row list
+  // a fresh set of objects. Keyed by id, neither level may rebuild.
+  await page.evaluate(() => window.dispatchEvent(new Event("focus")))
+  await page.evaluate(() => window.dispatchEvent(new Event("online")))
+  await page.waitForTimeout(600)
+
+  await expect(content(page)).toHaveCount(1)
+  expect(
+    await rows(page)
+      .first()
+      .evaluate((el, previous) => el === previous, row),
+  ).toBe(true)
+})
diff --git a/packages/app/e2e/regression/sidebar-section-collapse.spec.ts b/packages/app/e2e/regression/sidebar-section-collapse.spec.ts
index aaaf01600b..6055985c42 100644
--- a/packages/app/e2e/regression/sidebar-section-collapse.spec.ts
+++ b/packages/app/e2e/regression/sidebar-section-collapse.spec.ts
@@ -100,13 +100,11 @@ test("View all is never pushed out of the list as the window shortens", async ({
   // silently cuts View all off. Compare against the list box rather than the
   // viewport, and sweep heights so the assertion does not depend on landing in
   // a lucky band.
-  // Stops at 400. Below that the flexible area itself drops under one row
-  // (12px at a 380px window, 0 at 360) and View all is drawn anyway, so it is
-  // clipped — capacity clamps the session rows to zero but nothing withholds
-  // View all when there is no room for it either. That is pre-existing, not
-  // something the collapse work introduced, and it wants its own fix; this
-  // sweep guards the range where the reservation is supposed to hold.
-  for (const height of [900, 700, 560, 480, 420, 400]) {
+  // Swept down past 400, where the flexible area drops under one row (12px at
+  // a 380px window, none at 360). View all is withheld entirely at those sizes
+  // rather than drawn into space that clips it, so the invariant holds all the
+  // way down: it is either whole or absent, never cut in half.
+  for (const height of [900, 700, 560, 480, 420, 400, 380, 360, 320]) {
     await page.setViewportSize({ width: 1280, height })
     // The row count is driven by a ResizeObserver, so the list is briefly still
     // filled for the old box after a resize. Poll rather than measure the frame
@@ -114,8 +112,13 @@ test("View all is never pushed out of the list as the window shortens", async ({
     // reflow without waiting away the failure.
     await expect(async () => {
       const list = await recents(page).locator('[data-slot="sidebar-recents-list"]').boundingBox()
-      const all = await viewAll(page).boundingBox()
-      if (!all) return // too short to draw the section at all
+      // Withheld outright once the list cannot hold a whole row — absent is a
+      // pass, clipped is not.
+      if ((await viewAll(page).count()) === 0) {
+        expect({ height, listFits: (list?.height ?? 0) >= 28 }).toEqual({ height, listFits: false })
+        return
+      }
+      const all = (await viewAll(page).boundingBox())!
       expect(list).not.toBeNull()
       expect(
         { height, bottomOverflow: Math.max(0, Math.round(all.y + all.height - (list!.y + list!.height))) },
diff --git a/packages/app/e2e/regression/sidebar-session-menu-first-click.spec.ts b/packages/app/e2e/regression/sidebar-session-menu-first-click.spec.ts
new file mode 100644
index 0000000000..a4c6f3b078
--- /dev/null
+++ b/packages/app/e2e/regression/sidebar-session-menu-first-click.spec.ts
@@ -0,0 +1,75 @@
+import { expect, test, type Page } from "@playwright/test"
+import { fixture, pageMessages } from "../smoke/session-timeline.fixture"
+import { mockOpenCodeServer } from "../utils/mock-server"
+import { expectAppVisible } from "../utils/waits"
+
+const sidebar = (page: Page) => page.locator('[data-component="app-sidebar"]')
+const rows = (page: Page) => sidebar(page).locator('[data-component="sidebar-session-row"]')
+const content = (page: Page) => page.locator('[data-component="menu-v2-content"]')
+
+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 expectAppVisible(rows(page).first())
+  // Let the initial burst of record rebuilds finish, so this measures the
+  // steady state rather than boot churn.
+  await expect(rows(page)).toHaveCount(fixture.sessions.length)
+}
+
+async function revealActions(page: Page) {
+  await rows(page).first().hover()
+  // The wrapper fades out of pointer-events:none; the button is "visible" to
+  // Playwright at opacity 0, so the fade is the only honest signal.
+  await expect(sidebar(page).locator('[data-slot="session-row-actions"]').first()).toHaveCSS("opacity", "1")
+}
+
+test("the row menu opens on the first click", async ({ page }) => {
+  await boot(page)
+  await revealActions(page)
+
+  // Exactly one click. The records memo rebuilds its `{session, project}`
+  // wrappers on unrelated recomputes, and while the list was keyed on those
+  // references the row was torn down between pointerdown and mouseup — no
+  // common ancestor survived for the browser to fire `click` on, so the first
+  // click did nothing and only the second opened the menu.
+  await sidebar(page).locator('[data-action="session-menu"]').first().click()
+  await expect(content(page)).toHaveCount(1)
+})
+
+test("a record rebuild leaves the open menu and the row DOM alone", async ({ page }) => {
+  await boot(page)
+  await revealActions(page)
+  await sidebar(page).locator('[data-action="session-menu"]').first().click()
+  await expectAppVisible(content(page))
+
+  const row = await rows(page).first().elementHandle()
+
+  // Force the rebuild the sidebar used to be destroyed by. Refetching the
+  // session index re-runs the records memo and hands `<For>` a fresh set of
+  // record objects; keyed by id, the rows have to survive it.
+  await page.evaluate(() => window.dispatchEvent(new Event("focus")))
+  await page.evaluate(() => window.dispatchEvent(new Event("online")))
+  await page.waitForTimeout(600)
+
+  await expect(content(page)).toHaveCount(1)
+  expect(
+    await rows(page)
+      .first()
+      .evaluate((el, previous) => el === previous, row),
+  ).toBe(true)
+})
diff --git a/packages/app/src/components/app-sidebar-rows.test.ts b/packages/app/src/components/app-sidebar-rows.test.ts
index 04c07da1ae..15c5b11802 100644
--- a/packages/app/src/components/app-sidebar-rows.test.ts
+++ b/packages/app/src/components/app-sidebar-rows.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import { HOME_NAV_ROW_GAP, HOME_NAV_ROW_PITCH, recentsRowCapacity } from "./app-sidebar-rows"
+import { fitsRecentsRow, HOME_NAV_ROW_GAP, HOME_NAV_ROW_PITCH, recentsRowCapacity } from "./app-sidebar-rows"
 
 // n rows laid out at this pitch occupy 32n - 4: the last row carries no
 // trailing gap. Deriving the fixtures rather than hardcoding pixel counts keeps
@@ -33,3 +33,26 @@ describe("recentsRowCapacity", () => {
     expect(heights.map(recentsRowCapacity)).toEqual([0, 1, 2, 3, 4, 5, 6, 7])
   })
 })
+
+describe("fitsRecentsRow", () => {
+  test("takes one whole row of space", () => {
+    expect(fitsRecentsRow(exactly(1))).toBe(true)
+    expect(fitsRecentsRow(exactly(1) - 1)).toBe(false)
+  })
+
+  test("refuses the heights where View all used to be clipped", () => {
+    // Measured from the real column: a 380px window leaves 12px of flexible
+    // area and a 360px window leaves none, and the list clips rather than
+    // scrolls, so View all was drawn cut in half or not at all.
+    expect(fitsRecentsRow(12)).toBe(false)
+    expect(fitsRecentsRow(0)).toBe(false)
+  })
+
+  test("agrees with the capacity budget once a session fits", () => {
+    // Anywhere capacity allows a session row, there is by construction room for
+    // View all too — the budget reserves it. The two must not disagree.
+    for (let height = 0; height <= 400; height += 1) {
+      if (recentsRowCapacity(height) > 0) expect(fitsRecentsRow(height)).toBe(true)
+    }
+  })
+})
diff --git a/packages/app/src/components/app-sidebar-rows.ts b/packages/app/src/components/app-sidebar-rows.ts
index 4a83f0513b..135744919c 100644
--- a/packages/app/src/components/app-sidebar-rows.ts
+++ b/packages/app/src/components/app-sidebar-rows.ts
@@ -11,3 +11,12 @@ export const HOME_NAV_ROW_GAP = 4
 export function recentsRowCapacity(height: number) {
   return Math.max(0, Math.floor((height + HOME_NAV_ROW_GAP) / HOME_NAV_ROW_PITCH) - 1)
 }
+
+// Whether the list can draw "View all" at all. The capacity above clamps the
+// session rows to zero once the flexible area falls under two rows, but the
+// area keeps shrinking past that — under one row at a ~380px window, to nothing
+// at ~360 — and the list clips with overflow-hidden, so drawing the row anyway
+// just cut it in half. One row is the floor for showing it.
+export function fitsRecentsRow(height: number) {
+  return height >= HOME_NAV_ROW_PITCH - HOME_NAV_ROW_GAP
+}
diff --git a/packages/app/src/components/app-sidebar.tsx b/packages/app/src/components/app-sidebar.tsx
index 7f054ffba3..4357d85836 100644
--- a/packages/app/src/components/app-sidebar.tsx
+++ b/packages/app/src/components/app-sidebar.tsx
@@ -9,7 +9,7 @@ import { Icon as IconV2 } from "@opencode-ai/ui/v2/icon"
 import { IconButtonV2 } from "@opencode-ai/ui/v2/icon-button-v2"
 import { TooltipV2 } from "@opencode-ai/ui/v2/tooltip-v2"
 import { useDialog } from "@opencode-ai/ui/context/dialog"
-import { recentsRowCapacity } from "@/components/app-sidebar-rows"
+import { fitsRecentsRow, recentsRowCapacity } from "@/components/app-sidebar-rows"
 import { useServerManagementController } from "@/components/dialog-select-server"
 import { DialogDeleteSession, SessionActionsMenu } from "@/components/session-actions-menu"
 import { DialogServerV2 } from "@/components/settings-v2/dialog-server-v2"
@@ -271,18 +271,32 @@ function SidebarRecents(props: {
         data-slot="sidebar-recents-list"
         class="flex min-h-0 min-w-0 flex-1 flex-col gap-1 overflow-hidden"
       >
-        <For each={visible()}>
-          {(record) => (
-            <SidebarSessionRow
-              record={record}
-              server={props.server}
-              openSession={props.openSession}
-              model={props.model}
-              editor={editor}
-            />
-          )}
+        {/* Iterated by session id, not by record. `createHomeModel`'s records
+            memo rebuilds every `{session, project}` wrapper whenever anything
+            it reads changes — the projects memo alone hands back a fresh array
+            on a pointerdown — and `<For>` keys on reference, so passing records
+            straight in tore down and rebuilt every row on those recomputes.
+            That destroyed the ⋮ trigger between pointerdown and mouseup, so the
+            browser had no common ancestor to fire `click` on and the menu
+            silently ate the gesture. Ids compare by value, so the rows now
+            survive a rebuild and take the new record reactively. */}
+        <For each={visible().map((record) => record.session.id)}>
+          {(id) => {
+            const record = createMemo(() => props.records.find((item) => item.session.id === id))
+            return (
+              <Show when={record()}>
+                <SidebarSessionRow
+                  record={record()!}
+                  server={props.server}
+                  openSession={props.openSession}
+                  model={props.model}
+                  editor={editor}
+                />
+              </Show>
+            )
+          }}
         </For>
-        <Show when={!props.loading && props.records.length > 0}>
+        <Show when={!props.loading && props.records.length > 0 && fitsRecentsRow(listHeight())}>
           <A
             href="/"
             data-action="sidebar-view-all"
diff --git a/packages/app/src/pages/home.tsx b/packages/app/src/pages/home.tsx
index 0e4b3be9ca..f658e9604c 100644
--- a/packages/app/src/pages/home.tsx
+++ b/packages/app/src/pages/home.tsx
@@ -473,34 +473,55 @@ export function NewHome() {
                   fallback={<HomeSessionsEmpty onNewSession={newSessionProject() ? model.openNewSession : undefined} />}
                 >
                   <div ref={sessionHeaderOpacity.setContentRef} class="flex flex-col pt-3 pr-3 pb-16">
-                    <For each={groups()}>
-                      {(group, index) => (
-                        <>
-                          <HomeSessionGroupHeader
-                            title={group.title}
-                            titleOpacity={sessionHeaderOpacity.titleOpacity(group.id)}
-                            ref={(el) => sessionHeaderOpacity.setHeaderRef(group.id, el)}
-                            elevated={index() === 0}
-                          />
-                          <div
-                            class={`flex min-w-0 flex-col gap-px pt-4 ${index() === groups().length - 1 ? "" : "mb-6"}`}
-                          >
-                            <For each={group.sessions}>
-                              {(record) => (
-                                <HomeSessionRow
-                                  record={record}
-                                  showProjectName={!selectedProject()}
-                                  server={selection().server}
-                                  openSession={model.openSession}
-                                  archiveSession={model.archiveSession}
-                                  model={model}
-                                  editor={sessionEditor}
-                                />
-                              )}
-                            </For>
-                          </div>
-                        </>
-                      )}
+                    {/* Both levels iterate ids, not the objects themselves.
+                        `groupSessions` rebuilds its groups and `createHomeModel`
+                        rebuilds every `{session, project}` record on any
+                        recompute of what they read, and `<For>` keys on
+                        reference — so passing the objects straight in tore down
+                        and rebuilt these rows whenever that happened, including
+                        between a pointerdown and its mouseup. That left the
+                        browser no common ancestor to fire `click` on, which is
+                        why a row's ⋮ menu ignored its first click. Ids compare
+                        by value, so the rows now survive a rebuild and take the
+                        new record reactively. */}
+                    <For each={groups().map((group) => group.id)}>
+                      {(id, index) => {
+                        const group = createMemo(() => groups().find((item) => item.id === id))
+                        return (
+                          <Show when={group()}>
+                            <HomeSessionGroupHeader
+                              title={group()!.title}
+                              titleOpacity={sessionHeaderOpacity.titleOpacity(id)}
+                              ref={(el) => sessionHeaderOpacity.setHeaderRef(id, el)}
+                              elevated={index() === 0}
+                            />
+                            <div
+                              class={`flex min-w-0 flex-col gap-px pt-4 ${index() === groups().length - 1 ? "" : "mb-6"}`}
+                            >
+                              <For each={group()!.sessions.map((record) => record.session.id)}>
+                                {(sessionID) => {
+                                  const record = createMemo(() =>
+                                    group()?.sessions.find((item) => item.session.id === sessionID),
+                                  )
+                                  return (
+                                    <Show when={record()}>
+                                      <HomeSessionRow
+                                        record={record()!}
+                                        showProjectName={!selectedProject()}
+                                        server={selection().server}
+                                        openSession={model.openSession}
+                                        archiveSession={model.archiveSession}
+                                        model={model}
+                                        editor={sessionEditor}
+                                      />
+                                    </Show>
+                                  )
+                                }}
+                              </For>
+                            </div>
+                          </Show>
+                        )
+                      }}
                     </For>
                   </div>
                 </Show>