diff --git a/packages/app/e2e/regression/session-actions-menu.spec.ts b/packages/app/e2e/regression/session-actions-menu.spec.ts
new file mode 100644
index 0000000000..5154d04782
--- /dev/null
+++ b/packages/app/e2e/regression/session-actions-menu.spec.ts
@@ -0,0 +1,203 @@
+import { expect, test, type Locator, type Page, type Request } from "@playwright/test"
+import { fixture, pageMessages } from "../smoke/session-timeline.fixture"
+import { mockOpenCodeServer } from "../utils/mock-server"
+import { expectAppVisible } from "../utils/waits"
+
+// Rename, Share, Archive and Delete used to be reachable only from the menu
+// beside a session title, i.e. only after opening the session. The same menu now
+// hangs off every row in the sidebar's Recents and on the "View all" list, and
+// the four items are one component behind all three call sites — so what is
+// worth testing is that a row can actually drive each action, on both lists.
+
+const sidebar = (page: Page) => page.locator('[data-component="app-sidebar"]')
+const sidebarRows = (page: Page) => sidebar(page).locator('[data-component="sidebar-session-row"]')
+const homeRows = (page: Page) => page.locator('[data-component="home-session-row"]')
+// The menu is a sibling of the row button, not a child of it — both sit in the
+// wrapper that owns the hover state.
+const rowMenu = (row: Locator) => row.locator("xpath=..").locator('[data-action="session-menu"]')
+
+const item = (page: Page, name: string | RegExp) => page.getByRole("menuitem", { name })
+const dialog = (page: Page) => page.locator('[data-slot="dialog-content"]')
+
+// Hover to reveal the trigger, then click it once. The hover is not optional:
+// the trigger is pointer-events-none until its row is hovered, and Playwright
+// hit-tests before it moves the mouse, so a bare click never becomes actionable.
+async function openRowMenu(row: Locator) {
+  await row.hover()
+  await rowMenu(row).click()
+  await expect(rowMenu(row)).toHaveAttribute("aria-expanded", "true")
+}
+
+type Sent = { method: string; url: string }
+
+async function boot(page: Page, options?: { share?: string }) {
+  const sent: Sent[] = []
+  await mockOpenCodeServer(page, {
+    sessions: fixture.sessions,
+    provider: fixture.provider,
+    directory: fixture.directory,
+    project: fixture.project,
+    pageMessages,
+  })
+  if (options?.share !== undefined) {
+    // Registered after the mock so it wins the route: sharing is read off the
+    // directory-scoped config, which the mock otherwise answers with {}.
+    await page.route("**/config**", (route) =>
+      route.fulfill({
+        status: 200,
+        contentType: "application/json",
+        headers: { "access-control-allow-origin": "*" },
+        body: JSON.stringify({ share: options.share }),
+      }),
+    )
+  }
+  await page.addInitScript((directory) => {
+    localStorage.setItem(
+      "opencode.global.dat:server",
+      JSON.stringify({
+        projects: { local: [{ worktree: directory, expanded: true }] },
+        lastProject: { local: directory },
+      }),
+    )
+  }, fixture.directory)
+  page.on("request", (request: Request) => {
+    if (request.method() === "GET" || request.method() === "OPTIONS") return
+    sent.push({ method: request.method(), url: request.url() })
+  })
+  await page.goto("/")
+  await expectAppVisible(sidebar(page))
+  await expectAppVisible(sidebarRows(page).first())
+  return { sent }
+}
+
+const wroteTo = (sent: Sent[], sessionID: string, method?: string) =>
+  sent.filter((request) => request.url.includes(`/session/${sessionID}`) && (!method || request.method === method))
+
+test("reveals the trigger on hover, and keeps it out of the way otherwise", async ({ page }) => {
+  await boot(page)
+  const row = sidebarRows(page).first()
+
+  // Hidden but present: a row at rest is just its title, and the dots fade in
+  // under the pointer. Faded rather than unmounted, so the row does not reflow
+  // as the pointer crosses the list — hence opacity rather than visibility, an
+  // opacity-0 button being both "visible" and "in viewport" as far as Playwright
+  // is concerned. The fade lives on the wrapper, not on the button.
+  const reveal = rowMenu(row).locator("xpath=..")
+  await expect(rowMenu(row)).toHaveCount(1)
+  await expect(reveal).toHaveCSS("opacity", "0")
+
+  await row.hover()
+  await expect(reveal).toHaveCSS("opacity", "1")
+})
+
+test("a sidebar row offers the same four actions as the session header", async ({ page }) => {
+  await boot(page)
+
+  await openRowMenu(sidebarRows(page).first())
+
+  await expect(item(page, "Rename")).toBeVisible()
+  await expect(item(page, /^Share/)).toBeVisible()
+  await expect(item(page, "Archive")).toBeVisible()
+  await expect(item(page, /^Delete/)).toBeVisible()
+})
+
+test("hides Share when the server has sharing disabled", async ({ page }) => {
+  await boot(page, { share: "disabled" })
+
+  await openRowMenu(sidebarRows(page).first())
+
+  // Offering it here would open the session and then leave the share popover
+  // refusing to appear, which is worse than not offering it at all.
+  await expect(item(page, "Rename")).toBeVisible()
+  await expect(item(page, "Archive")).toBeVisible()
+  await expect(item(page, /^Share/)).toHaveCount(0)
+})
+
+test("renames a session from its row, without opening it", async ({ page }) => {
+  const { sent } = await boot(page)
+
+  await openRowMenu(sidebarRows(page).first())
+  await item(page, "Rename").click()
+
+  // Renaming used to mean opening the session first; the row edits in place and
+  // the route does not move.
+  const input = sidebar(page).locator('[data-component="inline-input"]')
+  await expectAppVisible(input)
+  await expect(input).toBeFocused()
+  expect(new URL(page.url()).pathname).toBe("/")
+
+  await input.fill("Renamed from the sidebar")
+  await input.press("Enter")
+
+  await expect(input).toHaveCount(0)
+  await expect.poll(() => wroteTo(sent, fixture.targetID).length).toBeGreaterThan(0)
+})
+
+test("sends nothing when a rename is cancelled", async ({ page }) => {
+  const { sent } = await boot(page)
+
+  await openRowMenu(sidebarRows(page).first())
+  await item(page, "Rename").click()
+
+  const input = sidebar(page).locator('[data-component="inline-input"]')
+  await expectAppVisible(input)
+  await input.fill("Discarded")
+  await input.press("Escape")
+
+  await expect(input).toHaveCount(0)
+  await expect(sidebarRows(page).first()).toHaveAttribute("title", fixture.expected.targetTitle)
+  expect(wroteTo(sent, fixture.targetID)).toEqual([])
+})
+
+test("asks before deleting, and does nothing when the ask is declined", async ({ page }) => {
+  const { sent } = await boot(page)
+
+  await openRowMenu(sidebarRows(page).first())
+  await item(page, /^Delete/).click()
+
+  await expectAppVisible(dialog(page))
+  // The confirmation names the session, because the row it was opened from is
+  // no longer the thing you are looking at, and a delete takes the session's
+  // children with it.
+  await expect(dialog(page)).toContainText(fixture.expected.targetTitle)
+
+  await dialog(page).getByRole("button", { name: "Cancel" }).click()
+  await expect(dialog(page)).toHaveCount(0)
+  expect(wroteTo(sent, fixture.targetID, "DELETE")).toEqual([])
+  await expect(sidebarRows(page)).toHaveCount(2)
+})
+
+test("deletes the session once the ask is confirmed", async ({ page }) => {
+  const { sent } = await boot(page)
+
+  await openRowMenu(sidebarRows(page).first())
+  await item(page, /^Delete/).click()
+
+  await expectAppVisible(dialog(page))
+  await dialog(page).getByRole("button", { name: "Delete session" }).click()
+
+  await expect(dialog(page)).toHaveCount(0)
+  await expect.poll(() => wroteTo(sent, fixture.targetID, "DELETE").length).toBeGreaterThan(0)
+})
+
+test("archives a session from its row", async ({ page }) => {
+  const { sent } = await boot(page)
+
+  await openRowMenu(sidebarRows(page).first())
+  await item(page, "Archive").click()
+
+  // Archive is the one action with no confirmation step, so the request is the
+  // whole of it.
+  await expect.poll(() => wroteTo(sent, fixture.targetID).length).toBeGreaterThan(0)
+})
+
+test("the View all list carries the same menu", async ({ page }) => {
+  await boot(page)
+  await expectAppVisible(homeRows(page).first())
+
+  await openRowMenu(homeRows(page).first())
+
+  await expect(item(page, "Rename")).toBeVisible()
+  await expect(item(page, "Archive")).toBeVisible()
+  await expect(item(page, /^Delete/)).toBeVisible()
+})
diff --git a/packages/app/e2e/regression/sidebar-persistence.spec.ts b/packages/app/e2e/regression/sidebar-persistence.spec.ts
new file mode 100644
index 0000000000..853ddda6a6
--- /dev/null
+++ b/packages/app/e2e/regression/sidebar-persistence.spec.ts
@@ -0,0 +1,113 @@
+import { expect, test, type Page } from "@playwright/test"
+import { fixture, pageMessages } from "../smoke/session-timeline.fixture"
+import { mockOpenCodeServer } from "../utils/mock-server"
+import { expectAppVisible, expectSessionTitle } from "../utils/waits"
+
+// The sidebar used to be an <aside> owned by the home screen, so opening a
+// session left the window with no navigation but the tab strip. It is app chrome
+// now, and it carries the recent sessions — which is only true if it survives
+// the route change and if its rows actually open what they name.
+
+const sidebar = (page: Page) => page.locator('[data-component="app-sidebar"]')
+const recents = (page: Page) => sidebar(page).locator('[data-section="recents"]')
+const rows = (page: Page) => recents(page).locator('[data-component="sidebar-session-row"]')
+const newSession = (page: Page) => recents(page).locator('[data-action="sidebar-new-session"]')
+const viewAll = (page: Page) => recents(page).locator('[data-action="sidebar-view-all"]')
+const settings = (page: Page) => sidebar(page).getByRole("button", { name: "Settings" })
+
+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(sidebar(page))
+  await expectAppVisible(viewAll(page))
+}
+
+test("stays on screen once a session is open", async ({ page }) => {
+  await boot(page)
+
+  await rows(page).first().click()
+  await expectSessionTitle(page, fixture.expected.targetTitle)
+
+  // The whole point of the move out of home.tsx: still mounted, still listing,
+  // still offering the bottom nav, on a route that is not "/".
+  await expect(sidebar(page)).toBeVisible()
+  await expect(recents(page)).toBeVisible()
+  await expect(settings(page)).toBeVisible()
+  expect(new URL(page.url()).pathname).not.toBe("/")
+})
+
+test("lists recent sessions newest first", async ({ page }) => {
+  await boot(page)
+
+  // The fixture's target session was updated a second after the source one, so
+  // ordering by last update — not by the order the server listed them — puts it
+  // on top.
+  await expect(rows(page)).toHaveCount(2)
+  await expect(rows(page).first()).toHaveAttribute("title", fixture.expected.targetTitle)
+  await expect(rows(page).nth(1)).toHaveAttribute("title", fixture.expected.sourceTitle)
+})
+
+test("opens the session a row names, in a tab of its own", async ({ page }) => {
+  await boot(page)
+
+  // The second row, so a passing test cannot be one that opens whatever the
+  // list happened to put first.
+  await rows(page).nth(1).click()
+  await expectSessionTitle(page, fixture.expected.sourceTitle)
+
+  const tabs = page.locator('[data-slot="titlebar-tabs"] a')
+  await expect(tabs).toHaveCount(1)
+  await expect(tabs.first()).toHaveAttribute("href", new RegExp(`/session/${fixture.sourceID}$`))
+})
+
+test("marks the row whose session is already open", async ({ page }) => {
+  await boot(page)
+
+  await rows(page).nth(1).click()
+  await expectSessionTitle(page, fixture.expected.sourceTitle)
+
+  // data-selected is how a row says it already holds a tab; without it every row
+  // looks the same once you are inside one of them. On the click that opened the
+  // session, with no reload: the rows update in place rather than being rebuilt,
+  // so the marker lands on the row you clicked and on no other.
+  await expect(recents(page).locator('[data-component="sidebar-session-row"][data-selected]')).toHaveCount(1)
+  await expect(rows(page).nth(1)).toHaveAttribute("data-selected", "")
+})
+
+test("View all leads back to the recents screen from inside a session", async ({ page }) => {
+  await boot(page)
+
+  await rows(page).first().click()
+  await expectSessionTitle(page, fixture.expected.targetTitle)
+
+  await viewAll(page).click()
+  await expect.poll(() => new URL(page.url()).pathname).toBe("/")
+  // The placeholder picks up the project name when one is selected, so match
+  // the stem rather than the whole string.
+  await expect(page.getByRole("textbox", { name: /Search sessions/ })).toBeVisible()
+})
+
+test("New session opens a draft without leaving the sidebar behind", async ({ page }) => {
+  await boot(page)
+  await expectAppVisible(newSession(page))
+
+  await newSession(page).click()
+
+  await expectAppVisible(page.getByRole("textbox", { name: "Prompt" }))
+  await expect(sidebar(page)).toBeVisible()
+})
diff --git a/packages/app/e2e/regression/sidebar-toggle-search.spec.ts b/packages/app/e2e/regression/sidebar-toggle-search.spec.ts
new file mode 100644
index 0000000000..3baa38a2e5
--- /dev/null
+++ b/packages/app/e2e/regression/sidebar-toggle-search.spec.ts
@@ -0,0 +1,113 @@
+import { expect, test, type Page } from "@playwright/test"
+import { fixture, pageMessages } from "../smoke/session-timeline.fixture"
+import { mockOpenCodeServer } from "../utils/mock-server"
+import { expectAppVisible, expectSessionTitle } from "../utils/waits"
+
+// The titlebar's two buttons: the sidebar toggle that leads the row, and the
+// Search button beside Home. The toggle hides the column outright rather than
+// narrowing it to a rail, and it is the only way back, so its persistence
+// matters as much as the toggling itself.
+
+const sidebar = (page: Page) => page.locator('[data-component="app-sidebar"]')
+const toggle = (page: Page) => page.locator('[data-action="titlebar-sidebar-toggle"]')
+const search = (page: Page) => page.locator('[data-action="titlebar-search"]')
+const searchInput = (page: Page) => page.getByRole("textbox", { name: /Search sessions/ })
+const rows = (page: Page) => sidebar(page).locator('[data-component="sidebar-session-row"]')
+
+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(sidebar(page))
+  await expectAppVisible(toggle(page))
+}
+
+test("hides and restores the sidebar, tracking the pressed state", async ({ page }) => {
+  await boot(page)
+  await expect(toggle(page)).toHaveAttribute("aria-pressed", "true")
+
+  await toggle(page).click()
+  await expect(sidebar(page)).toHaveCount(0)
+  await expect(toggle(page)).toHaveAttribute("aria-pressed", "false")
+
+  // The toggle has to survive its own click: it is the only affordance that
+  // brings the column back, and it lives in the titlebar precisely so that
+  // collapsing cannot take it away.
+  await toggle(page).click()
+  await expectAppVisible(sidebar(page))
+  await expect(toggle(page)).toHaveAttribute("aria-pressed", "true")
+})
+
+test("comes up collapsed after a reload", async ({ page }) => {
+  await boot(page)
+
+  await toggle(page).click()
+  await expect(sidebar(page)).toHaveCount(0)
+
+  await page.reload()
+  await expectAppVisible(toggle(page))
+  // Persisted globally rather than per window, so this is the state a relaunch
+  // would land in too.
+  await expect(sidebar(page)).toHaveCount(0)
+  await expect(toggle(page)).toHaveAttribute("aria-pressed", "false")
+})
+
+test("stays collapsed across a route change", async ({ page }) => {
+  await boot(page)
+  await expectAppVisible(rows(page).first())
+
+  await rows(page).first().click()
+  await expectSessionTitle(page, fixture.expected.targetTitle)
+  await toggle(page).click()
+  await expect(sidebar(page)).toHaveCount(0)
+
+  // Navigating used to be what re-mounted the sidebar; collapsing has to
+  // outlive that or the column reappears the moment you open a session.
+  await search(page).click()
+  await expect.poll(() => new URL(page.url()).pathname).toBe("/")
+  await expect(sidebar(page)).toHaveCount(0)
+})
+
+test("Search opens the recents list and focuses its field", async ({ page }) => {
+  await boot(page)
+  await expectAppVisible(rows(page).first())
+
+  await rows(page).first().click()
+  await expectSessionTitle(page, fixture.expected.targetTitle)
+
+  await search(page).click()
+
+  await expect.poll(() => new URL(page.url()).pathname).toBe("/")
+  await expect(searchInput(page)).toBeFocused()
+  // The param is a one-shot handoff, not a mode: leaving it in the URL would
+  // re-focus the field on every later visit to "/", including the sidebar's
+  // "View all".
+  await expect.poll(() => new URL(page.url()).search).toBe("")
+})
+
+test("Search focuses the field when the recents list is already open", async ({ page }) => {
+  await boot(page)
+  await expectAppVisible(searchInput(page))
+  await expect(searchInput(page)).not.toBeFocused()
+
+  // Same route, so the effect has to fire on the param alone rather than on a
+  // navigation.
+  await search(page).click()
+
+  await expect(searchInput(page)).toBeFocused()
+  await expect.poll(() => new URL(page.url()).search).toBe("")
+})
diff --git a/packages/app/src/pages/home-model.tsx b/packages/app/src/pages/home-model.tsx
index faf33c6bfb..45906b4ea1 100644
--- a/packages/app/src/pages/home-model.tsx
+++ b/packages/app/src/pages/home-model.tsx
@@ -424,7 +424,9 @@ export function createHomeModel() {
   }
 }
 
-function descendantIDs(sessions: Session[], rootID: string) {
+// Exported for the same reason buildHomeSessionRecords is: it is the rule that
+// decides how much a delete takes with it, and it is worth testing on its own.
+export function descendantIDs(sessions: Session[], rootID: string) {
   const byParent = new Map<string, string[]>()
   for (const item of sessions) {
     if (!item.parentID) continue
diff --git a/packages/app/src/utils/session-share-request.test.ts b/packages/app/src/utils/session-share-request.test.ts
new file mode 100644
index 0000000000..9b2c357b60
--- /dev/null
+++ b/packages/app/src/utils/session-share-request.test.ts
@@ -0,0 +1,37 @@
+import { expect, test } from "bun:test"
+import { consumeSessionShareRequest, requestSessionShare } from "./session-share-request"
+
+// A session row cannot host the share popover itself, so "Share" on a row opens
+// the session and parks the intent here for the timeline to pick up on mount.
+// The handoff is one shared slot, so the rules that matter are: exactly one
+// consumer wins, and a request meant for another session is never swallowed.
+
+test("consumes nothing when no share was requested", () => {
+  expect(consumeSessionShareRequest("ses_idle")).toBe(false)
+})
+
+test("hands the request to the session it names, once", () => {
+  requestSessionShare("ses_one")
+
+  expect(consumeSessionShareRequest("ses_one")).toBe(true)
+  // The second consumer is the same timeline remounting — it must not reopen
+  // the popover the first one already handled.
+  expect(consumeSessionShareRequest("ses_one")).toBe(false)
+})
+
+test("leaves a pending request alone when another session asks", () => {
+  requestSessionShare("ses_target")
+
+  // Background tabs mount their own timelines; the wrong one asking first must
+  // not consume the request the right one is still waiting to see.
+  expect(consumeSessionShareRequest("ses_other")).toBe(false)
+  expect(consumeSessionShareRequest("ses_target")).toBe(true)
+})
+
+test("keeps only the newest request when two are made back to back", () => {
+  requestSessionShare("ses_first")
+  requestSessionShare("ses_second")
+
+  expect(consumeSessionShareRequest("ses_first")).toBe(false)
+  expect(consumeSessionShareRequest("ses_second")).toBe(true)
+})
diff --git a/packages/app/test-browser/home-session-records.test.ts b/packages/app/test-browser/home-session-records.test.ts
new file mode 100644
index 0000000000..86d55d5621
--- /dev/null
+++ b/packages/app/test-browser/home-session-records.test.ts
@@ -0,0 +1,199 @@
+import { describe, expect, test } from "bun:test"
+import type { Session } from "@opencode-ai/sdk/v2/client"
+import type { LocalProject } from "@/context/layout"
+import { buildHomeSessionRecords, descendantIDs } from "@/pages/home-model"
+
+// The recents list the persistent sidebar and the home screen both render comes
+// out of buildHomeSessionRecords, and the subtree a delete evicts comes out of
+// descendantIDs. Neither is reachable from a rendered component without a live
+// server context, so both are covered here.
+
+const project = (worktree: string, extra?: Partial<LocalProject>): LocalProject => ({
+  worktree,
+  expanded: true,
+  name: undefined,
+  sandboxes: [],
+  ...extra,
+})
+
+const session = (id: string, directory: string, time: { created: number; updated?: number }, extra?: Partial<Session>) =>
+  ({
+    id,
+    projectID: "proj",
+    directory,
+    title: id,
+    time,
+    ...extra,
+  }) as unknown as Session
+
+function build(input: {
+  sessions: Session[]
+  projectDirectories: string[]
+  projects: LocalProject[]
+  byID?: Map<string, LocalProject>
+}) {
+  return buildHomeSessionRecords({
+    sessions: () => input.sessions,
+    projectDirectories: () => input.projectDirectories,
+    projects: () => input.projects,
+    projectByID: () =>
+      input.byID ?? new Map(input.projects.flatMap((item) => (item.id ? [[item.id, item] as const] : []))),
+  })
+}
+
+describe("buildHomeSessionRecords", () => {
+  test("keeps only sessions inside the listed directories", () => {
+    const inside = session("ses_inside", "/work/app", { created: 1 })
+    const outside = session("ses_outside", "/work/other", { created: 2 })
+
+    const records = build({
+      sessions: [inside, outside],
+      projectDirectories: ["/work/app"],
+      projects: [project("/work/app"), project("/work/other")],
+    })
+
+    expect(records.map((record) => record.session.id)).toEqual(["ses_inside"])
+  })
+
+  test("matches directories through pathKey rather than by string equality", () => {
+    // A trailing slash and Windows separators are the same directory. The list
+    // is filtered against a Set of keys, so a raw compare would silently drop
+    // every session on Windows.
+    const records = build({
+      sessions: [session("ses_win", "C:\\Work\\App", { created: 1 })],
+      projectDirectories: ["C:/Work/App/"],
+      projects: [project("C:/Work/App")],
+    })
+
+    expect(records.map((record) => record.session.id)).toEqual(["ses_win"])
+  })
+
+  test("sorts by last update, falling back to creation time", () => {
+    const records = build({
+      sessions: [
+        session("ses_old", "/work/app", { created: 10, updated: 10 }),
+        session("ses_new", "/work/app", { created: 1, updated: 300 }),
+        // No `updated` at all: its creation time has to stand in, or it sorts
+        // as if it were the oldest session on the list.
+        session("ses_created_only", "/work/app", { created: 200 }),
+      ],
+      projectDirectories: ["/work/app"],
+      projects: [project("/work/app")],
+    })
+
+    expect(records.map((record) => record.session.id)).toEqual(["ses_new", "ses_created_only", "ses_old"])
+  })
+
+  test("collapses duplicate ids, keeping the last copy seen", () => {
+    // The index merges a cached page with live events, so the same session can
+    // arrive twice — the fresher copy is the one appended later.
+    const records = build({
+      sessions: [
+        session("ses_dupe", "/work/app", { created: 1, updated: 1 }, { title: "stale" }),
+        session("ses_dupe", "/work/app", { created: 1, updated: 5 }, { title: "fresh" }),
+      ],
+      projectDirectories: ["/work/app"],
+      projects: [project("/work/app")],
+    })
+
+    expect(records).toHaveLength(1)
+    expect(records[0]!.session.title).toBe("fresh")
+  })
+
+  test("resolves a session living in a project sandbox", () => {
+    const withSandbox = project("/work/app", { sandboxes: ["/work/app-sandbox"] })
+
+    const records = build({
+      sessions: [session("ses_sandbox", "/work/app-sandbox", { created: 1 })],
+      projectDirectories: ["/work/app", "/work/app-sandbox"],
+      projects: [withSandbox],
+    })
+
+    expect(records).toHaveLength(1)
+    expect(records[0]!.project.worktree).toBe("/work/app")
+  })
+
+  test("falls back to the project id when no directory matches", () => {
+    // The directory filter passes on the sandbox path, but no project claims
+    // that path by worktree — projectForSession has to recover it by projectID.
+    const owner = project("/work/app", { id: "proj_owner" })
+
+    const records = build({
+      sessions: [session("ses_by_id", "/work/detached", { created: 1 }, { projectID: "proj_owner" } as Partial<Session>)],
+      projectDirectories: ["/work/detached"],
+      projects: [owner],
+    })
+
+    expect(records).toHaveLength(1)
+    expect(records[0]!.project.worktree).toBe("/work/app")
+  })
+
+  test("drops a session whose project cannot be resolved at all", () => {
+    // Rendering it would mean a row with no project avatar and nowhere to open.
+    const records = build({
+      sessions: [session("ses_orphan", "/work/gone", { created: 1 }, { projectID: "proj_missing" } as Partial<Session>)],
+      projectDirectories: ["/work/gone"],
+      projects: [],
+    })
+
+    expect(records).toEqual([])
+  })
+
+  test("names each record by the project display name", () => {
+    const records = build({
+      sessions: [
+        session("ses_named", "/work/app", { created: 2 }),
+        session("ses_unnamed", "/work/lib", { created: 1 }),
+      ],
+      projectDirectories: ["/work/app", "/work/lib"],
+      // A project without a name falls back to the last path segment.
+      projects: [project("/work/app", { name: "Application" }), project("/work/lib")],
+    })
+
+    expect(records.map((record) => record.projectName)).toEqual(["Application", "lib"])
+  })
+})
+
+describe("descendantIDs", () => {
+  const tree = [
+    { id: "root" },
+    { id: "child_a", parentID: "root" },
+    { id: "child_b", parentID: "root" },
+    { id: "grandchild", parentID: "child_a" },
+    { id: "unrelated" },
+    { id: "unrelated_child", parentID: "unrelated" },
+  ] as unknown as Session[]
+
+  test("collects the whole subtree, including the root", () => {
+    expect([...descendantIDs(tree, "root")].sort()).toEqual(["child_a", "child_b", "grandchild", "root"])
+  })
+
+  test("collects only the branch below a child", () => {
+    expect([...descendantIDs(tree, "child_a")].sort()).toEqual(["child_a", "grandchild"])
+  })
+
+  test("leaves unrelated trees alone", () => {
+    const removed = descendantIDs(tree, "root")
+    expect(removed.has("unrelated")).toBe(false)
+    expect(removed.has("unrelated_child")).toBe(false)
+  })
+
+  test("returns just the id for a session with no children", () => {
+    expect([...descendantIDs(tree, "grandchild")]).toEqual(["grandchild"])
+  })
+
+  test("returns just the id for a session the list does not contain", () => {
+    expect([...descendantIDs(tree, "ses_unknown")]).toEqual(["ses_unknown"])
+  })
+
+  test("terminates on a parent cycle", () => {
+    // Nothing should produce one, but the walk is over server data and an
+    // unguarded revisit would hang the delete instead of failing it.
+    const cyclic = [
+      { id: "a", parentID: "b" },
+      { id: "b", parentID: "a" },
+    ] as unknown as Session[]
+
+    expect([...descendantIDs(cyclic, "a")].sort()).toEqual(["a", "b"])
+  })
+})