From ccd769c61fd81291b5443fd83520894be3398577 Mon Sep 17 00:00:00 2001
From: Luke Parker <10430890+Hona@users.noreply.github.com>
Date: Mon, 26 Oct 2026 14:32:09 +1000
Subject: [PATCH 01/10] fix(session-ui): hide a folded message's duplicate
 footer actions

Active message transitions forced visibility: visible, so Rewind, Fork, Move to queue and Delete stayed exposed (and focusable) in the hidden footer of a folded run message, beside the copy shown next to its bubble. Active transitions now inherit visibility. Unquarantines the session-queue tests that caught it.
---
 .../app/e2e/regression/session-queue.spec.ts    | 17 +++++++++++------
 .../session-ui/src/components/message-part.css  |  8 ++++----
 2 files changed, 15 insertions(+), 10 deletions(-)

diff --git a/packages/app/e2e/regression/session-queue.spec.ts b/packages/app/e2e/regression/session-queue.spec.ts
index bccaa288b5bb..2b5086d217e2 100644
--- a/packages/app/e2e/regression/session-queue.spec.ts
+++ b/packages/app/e2e/regression/session-queue.spec.ts
@@ -851,7 +851,7 @@ for (const delivery of ["queue", "steer"] as const) {
   })
 }
 
-test("reverting to another prompt replaces the file chips of an earlier restore @quarantine", async ({ page }) => {
+test("reverting to another prompt replaces the file chips of an earlier restore", async ({ page }) => {
   const mock = createQueueMock(
     [],
     [
@@ -1012,7 +1012,7 @@ for (const [action, status] of [
   })
 }
 
-test("waiting steers group under one Pending line, each keeping its own actions beside its bubble @quarantine", async ({
+test("waiting steers group under one Pending line, each keeping its own actions beside its bubble", async ({
   page,
 }) => {
   const mock = createQueueMock(
@@ -1028,7 +1028,7 @@ test("waiting steers group under one Pending line, each keeping its own actions
   await expect(first.locator('[data-component="user-message"]')).toHaveAttribute("data-pending", "true")
 
   // The run's last steer carries the one Pending line; the first folds its line away.
-  await expect(last.locator('[data-slot="user-message-meta"]')).toContainText("Pending")
+  await expect(last.locator('[data-slot="user-message-meta"]')).toContainText("Pending", { useInnerText: true })
   await expect(first.locator('[data-slot="user-message-meta"]')).toBeHidden()
 
   await first.locator('[data-slot="user-message-text"]').hover()
@@ -1084,7 +1084,7 @@ test("/undo returns a pending steer's review comment to the composer", async ({
 })
 
 for (const delivery of ["steer", "queue"] as const) {
-  test(`keeps finished tools above a pending ${delivery === "queue" ? "queue-to-steer" : "steer"} follow-up${delivery === "steer" ? " @quarantine" : ""}`, async ({
+  test(`keeps finished tools above a pending ${delivery === "queue" ? "queue-to-steer" : "steer"} follow-up`, async ({
     page,
   }, testInfo) => {
     const model = { id: "queue-model", providerID: "opencode" }
@@ -1171,7 +1171,10 @@ for (const delivery of ["steer", "queue"] as const) {
       await expect(bubble).toHaveCSS("color", colors.pending.text)
       await expect(bubble).toHaveCSS("transition-duration", "0s")
       await expect(pending.locator('[data-slot="user-message-copy-wrapper"]')).toHaveCSS("opacity", "1")
-      await expect(pending.locator('[data-slot="user-message-meta"]')).toHaveText(/^Pending\s*·\s*Queue Model$/)
+      // Pending stands in for the time of a steer that has not been sent.
+      await expect(pending.locator('[data-slot="user-message-meta"]')).toHaveText(/^Pending\s*·\s*Queue Model$/, {
+        useInnerText: true,
+      })
       await bubble.evaluate((element) => (element.dataset.deliveryMarker = "pending"))
     }
 
@@ -1253,7 +1256,9 @@ for (const delivery of ["steer", "queue"] as const) {
 
     if (colors) {
       await expect(bubble).toHaveAttribute("data-delivery-marker", "pending")
-      await expect(pending.locator('[data-slot="user-message-meta"]')).toHaveText("Queue Model")
+      await expect(pending.locator('[data-slot="user-message-meta"]')).toHaveText(/^Queue Model\s*·\s*Just now$/, {
+        useInnerText: true,
+      })
       await expect(bubble).toHaveCSS("background-color", colors.delivered.background)
       await expect(bubble).toHaveCSS("color", colors.delivered.text)
       // Only delivery animates the colour; reduced motion switches instantly.
diff --git a/packages/session-ui/src/components/message-part.css b/packages/session-ui/src/components/message-part.css
index 4c435321e657..41f2c6ccd223 100644
--- a/packages/session-ui/src/components/message-part.css
+++ b/packages/session-ui/src/components/message-part.css
@@ -339,12 +339,13 @@
     visibility: hidden;
     margin-inline-end: calc(-1 * var(--user-message-transition-gap));
 
-    /* Labels and actions slide in as they arrive and leave at once, like the Pending label on delivery. */
+    /* Labels and actions slide in as they arrive and leave at once, like the Pending label on delivery. Active ones
+       inherit visibility, so a folded message's hidden footer also hides them. */
     &[data-active="true"] {
       grid-template-columns: 1fr;
       margin-inline-end: 0;
       opacity: 1;
-      visibility: visible;
+      visibility: inherit;
       transition:
         grid-template-columns 200ms ease-out,
         margin-inline-end 200ms ease-out,
@@ -407,8 +408,7 @@
     }
   }
 
-  &[data-run-meta-hidden] [data-slot="user-message-copy-wrapper"],
-  &[data-run-meta-hidden] [data-slot="user-message-meta-tail"] {
+  &[data-run-meta-hidden] [data-slot="user-message-copy-wrapper"] {
     visibility: hidden;
   }
 

From 9bf385e4d769cf30d36dfb8f8e42a14106fb1e20 Mon Sep 17 00:00:00 2001
From: Luke Parker <10430890+Hona@users.noreply.github.com>
Date: Mon, 26 Oct 2026 14:32:10 +1000
Subject: [PATCH 02/10] test(app): assert the semantic user bubble and rendered
 message meta

#57463 replaced the blue user bubble with layer-02/text-base, and #58089 keeps the hidden Pending label and time in the meta DOM, so read rendered text.
---
 packages/app/e2e/regression/new-session.spec.ts             | 6 +++---
 .../e2e/regression/session-timeline-accessibility.spec.ts   | 5 +++--
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/packages/app/e2e/regression/new-session.spec.ts b/packages/app/e2e/regression/new-session.spec.ts
index 075f4135585f..96d3aab6df0a 100644
--- a/packages/app/e2e/regression/new-session.spec.ts
+++ b/packages/app/e2e/regression/new-session.spec.ts
@@ -704,7 +704,7 @@ for (const row of [
     accent: false,
   },
 ]) {
-  test(`keeps the user message blue for ${row.name} @quarantine`, async ({ page }) => {
+  test(`keeps the user message grey for ${row.name}`, async ({ page }) => {
     const inventory: WorktreeDirectory[] = [{ directory: accentRoot }, { directory: accentWorkspace, strategy: "git" }]
 
     const listed = page.waitForResponse(
@@ -750,8 +750,8 @@ for (const row of [
     await expectBackground(send, "icon-button-contrast")
     const message = page.locator('[data-slot="user-message-text"]')
     await expect(message).toHaveText("Check this fixture workspace.")
-    await expectToken(message, "background-color", "--v2-blue-100")
-    await expectToken(message, "color", "--v2-blue-700")
+    await expectToken(message, "background-color", "--v2-background-bg-layer-02")
+    await expectToken(message, "color", "--v2-text-text-base")
 
     if (!row.accent) return
 
diff --git a/packages/app/e2e/regression/session-timeline-accessibility.spec.ts b/packages/app/e2e/regression/session-timeline-accessibility.spec.ts
index 4078ce66774a..2375e103b53f 100644
--- a/packages/app/e2e/regression/session-timeline-accessibility.spec.ts
+++ b/packages/app/e2e/regression/session-timeline-accessibility.spec.ts
@@ -75,7 +75,7 @@ function lines(count: number) {
 }
 
 for (const visible of [false, true]) {
-  test(`${visible ? "shows" : "omits"} the agent name in message meta when agents are ${visible ? "on @quarantine" : "off"}`, async ({
+  test(`${visible ? "shows" : "omits"} the agent name in message meta when agents are ${visible ? "on" : "off"}`, async ({
     page,
   }, testInfo) => {
     await setupTimeline(page, {
@@ -93,7 +93,8 @@ for (const visible of [false, true]) {
     const meta = [user.locator('[data-slot="user-message-meta"]'), assistant.locator('[data-slot="text-part-meta"]')]
 
     for (const item of meta) {
-      if (visible) await expect(item).toContainText(/^Build\s·\s/)
+      // A delivered message keeps its hidden Pending label in the DOM, so read only the rendered text.
+      if (visible) await expect(item).toContainText(/^Build\s*·/, { useInnerText: true })
       else await expect(item).not.toContainText("Build")
     }
   })

From 6960a41789d52ca7ad8f5adc259a0994ce773575 Mon Sep 17 00:00:00 2001
From: Luke Parker <10430890+Hona@users.noreply.github.com>
Date: Mon, 26 Oct 2026 14:40:37 +1000
Subject: [PATCH 03/10] fix(app): repair app component tests broken by the beta
 merge

- Size composer suggestion menus for their 6px padding (#58418 changed it from 8px), so history shows no clipped row under Search.
- Isolate the session story's stacking like the app's chat panel, so the web search provider menu opens above the dock.
- Expect the virtualizer's 82px tail (#57273, #57883) in the offset-only reconnect case.
- Pause the clock and wait for fonts before measuring the activity panel, which a late Inter swap widened on Windows.
- Remove the @quarantine tags from the fixed tests.
---
 .../component-tests/activity-chips.spec.ts    |  4 +
 packages/app/component-tests/composer.spec.ts |  6 +-
 .../timeline-virtualizer.spec.ts              | 88 +++++++++----------
 .../app/component-tests/websearch.spec.ts     | 59 ++++++-------
 packages/app/src/composer/editor/editor.tsx   |  2 +-
 packages/app/src/session/story-model.tsx      |  3 +-
 6 files changed, 81 insertions(+), 81 deletions(-)

diff --git a/packages/app/component-tests/activity-chips.spec.ts b/packages/app/component-tests/activity-chips.spec.ts
index 3add92d44ed4..dcc7c882c8eb 100644
--- a/packages/app/component-tests/activity-chips.spec.ts
+++ b/packages/app/component-tests/activity-chips.spec.ts
@@ -1,7 +1,9 @@
 import { expect, story } from "../../stories/playwright/story"
 
 story("shows how long each background item has been running, ticking while open", async ({ mount, page }) => {
+  // Time moves only when the test advances it, so waiting for fonts cannot add a tick.
   await page.clock.install({ time: new Date("2026-10-19T12:00:00Z") })
+  await page.clock.pauseAt(new Date("2026-10-19T12:00:00Z"))
   await mount("session-activity-chips--subagents-and-shells")
 
   await page.locator('[data-slot="session-activity-chip"]').click()
@@ -9,6 +11,8 @@ story("shows how long each background item has been running, ticking while open"
 
   // The story starts its subagents 12 s and 65 s ago, and its shells 62 min and 341 s ago.
   await expect(elapsed).toHaveText(["12s", "1m 05s", "1h 02m", "5m 41s"])
+  // A late Inter swap widens the panel; measure after fonts settle.
+  await page.evaluate(() => document.fonts.ready.then(() => undefined))
   const width = await page.locator('[data-slot="session-activity-panel"]').evaluate((node) => node.clientWidth)
 
   await page.clock.runFor(1_000)
diff --git a/packages/app/component-tests/composer.spec.ts b/packages/app/component-tests/composer.spec.ts
index 5bd24552dd02..95dde796838d 100644
--- a/packages/app/component-tests/composer.spec.ts
+++ b/packages/app/component-tests/composer.spec.ts
@@ -472,7 +472,7 @@ story("grows suggestions while preserving visible timeline context", async ({ mo
   const boundary = component.locator('[data-slot="composer-suggestion-boundary-story"]')
   const suggestions = component.locator('[data-component="composer-suggestions"]')
 
-  await expect(suggestions).toHaveCSS("max-height", "166px")
+  await expect(suggestions).toHaveCSS("max-height", "164px")
   await expect(suggestions).toHaveCSS("scroll-padding-bottom", "18px")
   await expect.poll(() => suggestions.evaluate((element) => element.scrollHeight > element.clientHeight)).toBe(true)
   await expect
@@ -497,12 +497,12 @@ story("grows suggestions while preserving visible timeline context", async ({ mo
   await boundary.evaluate((element) => {
     element.style.height = "400px"
   })
-  await expect(suggestions).toHaveCSS("max-height", "306px")
+  await expect(suggestions).toHaveCSS("max-height", "304px")
 })
 
 story("ignores a detached suggestion boundary", async ({ mount }) => {
   const component = await mount("opencode-composer-flow--detached-command-suggestion-boundary")
-  await expect(component.locator('[data-component="composer-suggestions"]')).toHaveCSS("max-height", "306px")
+  await expect(component.locator('[data-component="composer-suggestions"]')).toHaveCSS("max-height", "304px")
 })
 
 // ThemeProvider writes resolved token values into a <style> block, so toggling data-color-scheme by hand
diff --git a/packages/app/component-tests/timeline-virtualizer.spec.ts b/packages/app/component-tests/timeline-virtualizer.spec.ts
index 9497a32a9d11..7a5ba2579c63 100644
--- a/packages/app/component-tests/timeline-virtualizer.spec.ts
+++ b/packages/app/component-tests/timeline-virtualizer.spec.ts
@@ -59,53 +59,51 @@ for (const input of [
   { name: "offset-only", count: 1, rowHeight: 600, reveal: { scrollTop: 0 } },
   { name: "zero-height", count: 4, rowHeight: 60, reveal: {} },
 ]) {
-  story(
-    `reveals ready measured rows after an ${input.name} reconnect${input.name === "offset-only" ? " @quarantine" : ""}`,
-    async ({ page }) => {
-      await page.evaluate(
-        async ({ fixture, input }) => {
-          const { mountTimelineVirtualizer } = await import(fixture)
-          mountTimelineVirtualizer(input)
-        },
-        { fixture, input },
-      )
-      const root = page.getByTestId("timeline-virtualizer-fixture")
-      const content = root.locator("[data-timeline-virtual-content]")
-      await expect(root).toHaveAttribute("data-observed-height", "180")
-      await expect(content).toHaveCSS("visibility", "hidden")
-      await expect(content.locator("[data-timeline-key]")).toHaveCount(1)
+  story(`reveals ready measured rows after an ${input.name} reconnect`, async ({ page }) => {
+    await page.evaluate(
+      async ({ fixture, input }) => {
+        const { mountTimelineVirtualizer } = await import(fixture)
+        mountTimelineVirtualizer(input)
+      },
+      { fixture, input },
+    )
+    const root = page.getByTestId("timeline-virtualizer-fixture")
+    const content = root.locator("[data-timeline-virtual-content]")
+    await expect(root).toHaveAttribute("data-observed-height", "180")
+    await expect(content).toHaveCSS("visibility", "hidden")
+    await expect(content.locator("[data-timeline-key]")).toHaveCount(1)
 
-      if (input.name === "offset-only") {
-        await expect(root).toHaveAttribute("data-last-scroll-top", "484")
-        await root.locator("[data-scrollable]").dispatchEvent("wheel", { deltaY: -1 })
-        await expect(root.getByTestId("timeline-controls")).toHaveAttribute("data-pinned", "false")
-      }
+    if (input.name === "offset-only") {
+      // Pinned to the end: the 600px row and the virtualizer's 82px tail, less the 180px viewport.
+      await expect(root).toHaveAttribute("data-last-scroll-top", "502")
+      await root.locator("[data-scrollable]").dispatchEvent("wheel", { deltaY: -1 })
+      await expect(root.getByTestId("timeline-controls")).toHaveAttribute("data-pinned", "false")
+    }
 
-      if (input.name === "zero-height") {
-        await root.getByRole("button", { name: "Hide viewport", exact: true }).click()
-        // Wait for ResizeObserver to clear the actual range, not just for display:none.
-        await expect(root).toHaveAttribute("data-observed-height", "0")
-        await expect(content.locator("[data-timeline-key]")).toHaveCount(0)
-      }
+    if (input.name === "zero-height") {
+      await root.getByRole("button", { name: "Hide viewport", exact: true }).click()
+      // Wait for ResizeObserver to clear the actual range, not just for display:none.
+      await expect(root).toHaveAttribute("data-observed-height", "0")
+      await expect(content.locator("[data-timeline-key]")).toHaveCount(0)
+    }
 
-      await expect(root).not.toHaveAttribute("data-first-reveal")
-      const resizes = await root.getAttribute("data-viewport-resizes")
-      await root.getByRole("button", { name: "Reconnect ready rows", exact: true }).click()
-      await expect(content).toHaveCSS("visibility", "visible")
-      await expect(root).toHaveAttribute("data-first-reveal", /.+/)
-      expect(await root.evaluate((element) => JSON.parse(element.dataset.firstReveal!))).toMatchObject({
-        rows: input.count === 1 ? [0] : [0, 1, 2, 3],
-        pendingMarkdown: 0,
-        clipped: [],
-        viewportHeight: 180,
-        ...input.reveal,
-      })
+    await expect(root).not.toHaveAttribute("data-first-reveal")
+    const resizes = await root.getAttribute("data-viewport-resizes")
+    await root.getByRole("button", { name: "Reconnect ready rows", exact: true }).click()
+    await expect(content).toHaveCSS("visibility", "visible")
+    await expect(root).toHaveAttribute("data-first-reveal", /.+/)
+    expect(await root.evaluate((element) => JSON.parse(element.dataset.firstReveal!))).toMatchObject({
+      rows: input.count === 1 ? [0] : [0, 1, 2, 3],
+      pendingMarkdown: 0,
+      clipped: [],
+      viewportHeight: 180,
+      ...input.reveal,
+    })
 
-      if (input.name === "offset-only") {
-        // This repair must not depend on another native scroll or resize delivery.
-        await expect(root).toHaveAttribute("data-scrolls", "0")
-        await expect(root).toHaveAttribute("data-viewport-resizes", resizes!)
-      }
-    },
-  )
+    if (input.name === "offset-only") {
+      // This repair must not depend on another native scroll or resize delivery.
+      await expect(root).toHaveAttribute("data-scrolls", "0")
+      await expect(root).toHaveAttribute("data-viewport-resizes", resizes!)
+    }
+  })
 }
diff --git a/packages/app/component-tests/websearch.spec.ts b/packages/app/component-tests/websearch.spec.ts
index 7db11efea9a5..6f6c0b93bff1 100644
--- a/packages/app/component-tests/websearch.spec.ts
+++ b/packages/app/component-tests/websearch.spec.ts
@@ -51,39 +51,36 @@ story("sizes provider options to their content", async ({ mount, page }) => {
 for (const width of [360, 1200]) {
   for (const direction of ["ltr", "rtl"]) {
     for (const theme of ["light", "dark"]) {
-      story(
-        `selects and confirms a provider at ${width}px in ${direction} ${theme}${width === 360 ? " @quarantine" : ""}`,
-        async ({ mount, page }) => {
-          await page.setViewportSize({ width, height: 900 })
+      story(`selects and confirms a provider at ${width}px in ${direction} ${theme}`, async ({ mount, page }) => {
+        await page.setViewportSize({ width, height: 900 })
 
-          const component = await mount("app-current-session-surface--web-search-request", {
-            globals: { theme, direction },
-          })
+        const component = await mount("app-current-session-surface--web-search-request", {
+          globals: { theme, direction },
+        })
 
-          const card = component.getByRole("region", { name: "Third-party web search" })
-          const select = card.getByRole("button", { name: /^Search provider/ })
-          await expect(select).toBeEnabled()
-          await expect(card).toHaveCSS("direction", direction)
-          expect(await card.evaluate((node) => node.scrollWidth <= node.clientWidth)).toBe(true)
-          await select.focus()
-          await select.press("Enter")
-          const list = page.getByRole("listbox", { name: "Search provider", exact: true })
-          await expect(list).toHaveCSS("direction", direction)
-          await list.getByRole("option", { name: "Parallel", exact: true }).click()
-          await expect(select).toHaveText("Parallel")
-          await expect(card).toBeVisible()
-          await expect(component.getByRole("status")).toHaveText("Ready")
-          await expect(select).toBeFocused()
-          await select.press("Tab")
-          await expect(card.getByRole("button", { name: "Don’t use search", exact: true })).toBeFocused()
-          await page.keyboard.press("Tab")
-          const enable = card.getByRole("button", { name: "Enable", exact: true })
-          await expect(enable).toBeFocused()
-          await enable.press("Enter")
-          await expect(component.getByRole("status")).toHaveText("Web search selection (local only): parallel")
-          await expect(card).toHaveCount(0)
-        },
-      )
+        const card = component.getByRole("region", { name: "Third-party web search" })
+        const select = card.getByRole("button", { name: /^Search provider/ })
+        await expect(select).toBeEnabled()
+        await expect(card).toHaveCSS("direction", direction)
+        expect(await card.evaluate((node) => node.scrollWidth <= node.clientWidth)).toBe(true)
+        await select.focus()
+        await select.press("Enter")
+        const list = page.getByRole("listbox", { name: "Search provider", exact: true })
+        await expect(list).toHaveCSS("direction", direction)
+        await list.getByRole("option", { name: "Parallel", exact: true }).click()
+        await expect(select).toHaveText("Parallel")
+        await expect(card).toBeVisible()
+        await expect(component.getByRole("status")).toHaveText("Ready")
+        await expect(select).toBeFocused()
+        await select.press("Tab")
+        await expect(card.getByRole("button", { name: "Don’t use search", exact: true })).toBeFocused()
+        await page.keyboard.press("Tab")
+        const enable = card.getByRole("button", { name: "Enable", exact: true })
+        await expect(enable).toBeFocused()
+        await enable.press("Enter")
+        await expect(component.getByRole("status")).toHaveText("Web search selection (local only): parallel")
+        await expect(card).toHaveCount(0)
+      })
     }
   }
 }
diff --git a/packages/app/src/composer/editor/editor.tsx b/packages/app/src/composer/editor/editor.tsx
index e36589d5ec5d..cfe3972fbe82 100644
--- a/packages/app/src/composer/editor/editor.tsx
+++ b/packages/app/src/composer/editor/editor.tsx
@@ -64,7 +64,7 @@ const COMPOSER_SUGGESTION_ROW_HEIGHT = 28
 
 const COMPOSER_SUGGESTION_ROW_PEEK = 18
 
-const COMPOSER_SUGGESTION_TOP_PADDING = 8
+const COMPOSER_SUGGESTION_TOP_PADDING = 6
 
 const COMPOSER_SUGGESTION_SEARCH_HEIGHT = 28
 
diff --git a/packages/app/src/session/story-model.tsx b/packages/app/src/session/story-model.tsx
index 0f4b382a97e5..3f2152a6e2e7 100644
--- a/packages/app/src/session/story-model.tsx
+++ b/packages/app/src/session/story-model.tsx
@@ -262,8 +262,9 @@ function SessionSurfaceState(props: SessionPreviewProps & { onReset: () => void
     showComposer: () => true,
   } satisfies SessionComposerRegionViewController
 
+  // Contain the composer region's z-index as the app's session chat panel does, so portaled menus open above it.
   return (
-    <div class="mx-auto h-screen min-h-[640px] w-full max-w-[1440px]">
+    <div class="mx-auto h-screen min-h-[640px] w-full max-w-[1440px] isolate">
       <SessionRouteFrame padded>
         <SessionPanelFrame raised>
           <main class="flex min-h-0 flex-1 flex-col">

From 09593e35e4e1b636e5f10b556e10f3d23674ee42 Mon Sep 17 00:00:00 2001
From: Luke Parker <10430890+Hona@users.noreply.github.com>
Date: Mon, 26 Oct 2026 14:45:15 +1000
Subject: [PATCH 04/10] test(app): unquarantine review open-file, artifact
 reread, and review-state cases

- Expect the session directory on file search requests; the mock forwards it since #57725.
- Scroll a windowed file view to its end before reading the draft; text files over 200 lines window since #57551.
- Wait for side-panel focus before Ctrl+W; Close Tab follows focus since #57935.
- Wait for the file tree's scroll suppression to clear before clicking a row, so Playwright's retry scroll does not move the position under test.
---
 packages/app/e2e/regression/review.spec.ts | 35 +++++++++++++++-------
 1 file changed, 24 insertions(+), 11 deletions(-)

diff --git a/packages/app/e2e/regression/review.spec.ts b/packages/app/e2e/regression/review.spec.ts
index 8adcb4121df9..729e5a51bbd4 100644
--- a/packages/app/e2e/regression/review.spec.ts
+++ b/packages/app/e2e/regression/review.spec.ts
@@ -123,8 +123,8 @@ test("a rejected Git init releases its session's button without showing an error
   await expect(init).toBeEnabled()
 })
 
-test("open file tab browses, searches, and tracks missing files @quarantine", async ({ page }) => {
-  const searches: { query: string; dirs?: string; limit?: number }[] = []
+test("open file tab browses, searches, and tracks missing files", async ({ page }) => {
+  const searches: { query: string; dirs?: string; limit?: number; directory: string }[] = []
   const directory = "C:/OpenCode/ReviewOpenFile"
   const files = Array.from({ length: 80 }, (_, index) => `file-${String(index).padStart(2, "0")}.ts`)
 
@@ -216,7 +216,7 @@ test("open file tab browses, searches, and tracks missing files @quarantine", as
   await expect(tab("nested.ts")).toHaveAttribute("aria-selected", "true")
   await expect(sidebarToggle).toBeEnabled()
   await expect(panel.getByText("contents:src/nested.ts", { exact: true })).toBeVisible()
-  expect(searches).toContainEqual({ query: "nested", dirs: "file", limit: 200 })
+  expect(searches).toContainEqual({ query: "nested", dirs: "file", limit: 200, directory })
 
   await browseFiles(page)
   await expect(tab("nested.ts")).toHaveCount(1)
@@ -252,6 +252,9 @@ test("open file tab browses, searches, and tracks missing files @quarantine", as
   await expect
     .poll(() => viewport.evaluate((element) => element.scrollHeight - element.clientHeight - element.scrollTop))
     .toBeLessThanOrEqual(1)
+  // The tree ignores the pointer until a scroll settles. A click before then hits the scroller, and Playwright's retry
+  // scrolls the row into view itself, which moves the position this case guards.
+  await expect(viewport.locator("[data-file-tree-virtualized-list]")).not.toHaveAttribute("data-is-scrolling")
   const scrolled = await viewport.evaluate((element) => element.scrollTop)
   expect(scrolled).toBeGreaterThan(0)
   await root.evaluate((element) => void (element.dataset.e2eProbe = "original"))
@@ -586,7 +589,7 @@ test("file tree expands Windows paths and scrolls long names in both directions"
   await expect(panel.getByText("contents:frontend/app.ts", { exact: true })).toBeVisible()
 })
 
-test("rereads a file each time an artifact link opens it @quarantine", async ({ page }) => {
+test("rereads a file each time an artifact link opens it", async ({ page }) => {
   // Enough lines to scroll the code view, ending in the draft's name.
   const draft = (name: string) => [...Array.from({ length: 200 }, (_, index) => `item ${index + 1}`), name].join("\n")
   const file = { content: draft("first draft") }
@@ -613,17 +616,24 @@ test("rereads a file each time an artifact link opens it @quarantine", async ({
   const link = page.getByRole("link", { name: "shopping.txt", exact: true })
   const panel = page.locator("#review-panel")
   const tab = panel.getByRole("tab", { name: "shopping.txt" })
+  const code = panel.locator("[data-scrollable]", { has: page.locator('[data-component="file"]') })
+
+  // A long file opens at its top and mounts only the rows near the viewport, so its last line needs a scroll.
+  const scrollToEnd = async () => {
+    await expect(panel.getByText("item 1", { exact: true })).toBeVisible()
+    await code.hover()
+    await page.mouse.wheel(0, 100_000)
+    await expect
+      .poll(() => code.evaluate((element) => element.scrollHeight - element.clientHeight - element.scrollTop))
+      .toBeLessThanOrEqual(1)
+  }
+
   await link.click()
   await expect(tab).toHaveAttribute("aria-selected", "true")
+  await scrollToEnd()
   await expect(panel.getByText("first draft", { exact: true })).toBeVisible()
 
   // Rereading the open file updates it in place: the code view keeps its node and never jumps back to the top.
-  const code = panel.locator("[data-scrollable]", { has: page.locator('[data-component="file"]') })
-  await code.hover()
-  await page.mouse.wheel(0, 100_000)
-  await expect
-    .poll(() => code.evaluate((element) => element.scrollHeight - element.clientHeight - element.scrollTop))
-    .toBeLessThanOrEqual(1)
   const scrolled = await code.evaluate((element) => element.scrollTop)
   expect(scrolled).toBeGreaterThan(0)
   await code.evaluate((element) => void (element.dataset.e2eProbe = "original"))
@@ -638,6 +648,7 @@ test("rereads a file each time an artifact link opens it @quarantine", async ({
   await expect(tab).toHaveCount(0)
   await link.click()
   await expect(tab).toHaveAttribute("aria-selected", "true")
+  await scrollToEnd()
   await expect(panel.getByText("third draft", { exact: true })).toBeVisible()
   await expect(panel.getByText("second draft", { exact: true })).toHaveCount(0)
 
@@ -985,7 +996,7 @@ test("video files stream into the viewer behind a loading state, open into the p
   expect(await page.evaluate(() => document.fullscreenElement)).toBeNull()
 })
 
-test("restores review state and the side-panel tab per session @quarantine", async ({ page }) => {
+test("restores review state and the side-panel tab per session", async ({ page }) => {
   const sessions = [
     { id: "ses_review_state_a", title: "Alpha review state" },
     { id: "ses_review_state_b", title: "Beta review state" },
@@ -1082,6 +1093,8 @@ test("restores review state and the side-panel tab per session @quarantine", asy
   await toggle.click()
   await selectedTab("README.md")
 
+  // Opening moves focus into the side panel once its motion lands; from there Close Tab closes the side tab.
+  await expect(panel).toBeFocused()
   await page.keyboard.press("Control+w")
   await expect(panel.getByRole("tab", { name: "README.md", exact: true })).toHaveCount(0)
   await expect(review).toHaveAttribute("aria-selected", "true")

From 20a22c3632907c3a58e271d99482ebe04a77f3bf Mon Sep 17 00:00:00 2001
From: Luke Parker <10430890+Hona@users.noreply.github.com>
Date: Mon, 26 Oct 2026 14:46:39 +1000
Subject: [PATCH 05/10] fix(app): unquarantine timeline-stream e2e tests

- Notices: assert the v2 faint text token from #58115.
- Revealed shell: re-target TanStack on every anchor pin so its exact landing cannot undo a 1px compensation.
- Activity menu: list blocking subagents before backgrounded ones again (lost in 3dca04a956).
- Markdown tables: keep header cells selectable so quotes and copies keep the header row (#58372).
- Live Thinking: wait for the busy status before jumping the fake clock, which fires in-flight request timeouts.
---
 .../app/e2e/regression/timeline-stream.spec.ts | 18 +++++++++++-------
 .../app/src/session/requests/background.ts     |  3 ++-
 .../app/src/session/timeline/virtualizer.tsx   |  4 +++-
 .../session-ui/src/components/markdown.css     |  1 -
 4 files changed, 16 insertions(+), 10 deletions(-)

diff --git a/packages/app/e2e/regression/timeline-stream.spec.ts b/packages/app/e2e/regression/timeline-stream.spec.ts
index 77fa7b1961a6..924b81dfb5c3 100644
--- a/packages/app/e2e/regression/timeline-stream.spec.ts
+++ b/packages/app/e2e/regression/timeline-stream.spec.ts
@@ -43,7 +43,7 @@ const completed = {
 } satisfies SessionMessageAssistant
 
 test.describe("static projection", () => {
-  test("renders current protocol notices in CLI order @quarantine", async ({ page }) => {
+  test("renders current protocol notices in CLI order", async ({ page }) => {
     const ownerWarnings: string[] = []
     page.on("console", (message) => {
       if (message.text().includes("computations created outside a `createRoot` or `render`"))
@@ -80,8 +80,13 @@ test.describe("static projection", () => {
     await expect(notices.nth(1)).toContainText("Explore finished · Search code")
     await expect(notices.nth(2)).toContainText("Continuing after restart")
     await expect(notices.nth(3)).toContainText("Skill · Review")
-    await expect(notices).toHaveClass([/text-text-weak/, /text-text-weak/, /text-text-weak/, /text-text-weak/])
-    await expect(notices.locator(".text-text-strong")).toHaveCount(0)
+    await expect(notices).toHaveClass([
+      /text-v2-text-text-faint/,
+      /text-v2-text-text-faint/,
+      /text-v2-text-text-faint/,
+      /text-v2-text-text-faint/,
+    ])
+    await expect(notices.locator(".text-v2-text-text-base")).toHaveCount(0)
     expect(ownerWarnings).toEqual([])
   })
 
@@ -797,14 +802,15 @@ test.describe("Working", () => {
     await page.clock.install({ time: 1700000001000 })
     await page.reload()
     await timeline.transport.waitForConnection()
-    await page.clock.pauseAt(1700000001000 + 492_000)
 
     const working = page.locator('[data-component="session-working"]')
     const group = page.locator('[data-component="collapsed-tool-group"]')
     const trigger = group.locator('[data-component="context-tool-group-trigger"]')
     const elapsed = trigger.locator('[data-slot="basic-tool-tool-subtitle"]')
     await expect(group).toHaveAttribute("data-timeline-part-ids", `${assistantID}:reasoning:0`)
+    // The jump below fires the 60 s timeout of any request still in flight, so the busy status must land first.
     await expect(trigger).toHaveAttribute("aria-label", "Thinking")
+    await page.clock.pauseAt(1700000001000 + 492_000)
     await expect(trigger.locator('[data-component="text-shimmer"]')).toHaveAttribute("data-active", "true")
     await expect(elapsed).toHaveText("8m 12s")
     await expect(working).toHaveCount(0)
@@ -1409,9 +1415,7 @@ test.describe("background shortcut", () => {
     // Reaching the shell lands on the end of the timeline, which would otherwise follow new content again.
     { name: "at the end of the timeline", before: 40, searches: 0, after: 0 },
   ]) {
-    test(`holds a revealed shell ${fixture.name} just under its stuck group header${fixture.name === "from far below" ? " @quarantine" : ""}`, async ({
-      page,
-    }) => {
+    test(`holds a revealed shell ${fixture.name} just under its stuck group header`, async ({ page }) => {
       const timeline = await setupTimeline(page, {
         settings: { timelineDetail: detailed },
         sessionStatus: { [sessionID]: { type: "busy" } },
diff --git a/packages/app/src/session/requests/background.ts b/packages/app/src/session/requests/background.ts
index cc45a4aa276a..b6afdd88cdb8 100644
--- a/packages/app/src/session/requests/background.ts
+++ b/packages/app/src/session/requests/background.ts
@@ -143,7 +143,8 @@ export function createSessionBackground(input: {
           ],
     )
 
-    return [...pending, ...running]
+    // Work that blocks the run comes before work already in the background.
+    return [...pending, ...running.filter((task) => task.partID), ...running.filter((task) => !task.partID)]
   })
 
   // Background work: running subagents whose call no longer blocks the run, and the session's live shells outside
diff --git a/packages/app/src/session/timeline/virtualizer.tsx b/packages/app/src/session/timeline/virtualizer.tsx
index 3eb0a56bc5c6..c1d9f408252b 100644
--- a/packages/app/src/session/timeline/virtualizer.tsx
+++ b/packages/app/src/session/timeline/virtualizer.tsx
@@ -501,7 +501,9 @@ export function createTimelineVirtualizer(input: Input) {
       ),
     )
 
-    if (Math.abs(offset - root.scrollTop) > 1) virtualizer.scrollToOffset(offset)
+    // Hand over every pin, even one the scroll already reaches: TanStack lands exactly on its last target once the
+    // scroll is within a pixel of it, which would undo a compensation for a row above that resized since.
+    virtualizer.scrollToOffset(offset)
   }
 
   function releaseAnchor() {
diff --git a/packages/session-ui/src/components/markdown.css b/packages/session-ui/src/components/markdown.css
index 2240aac50fd2..3a4a8700d234 100644
--- a/packages/session-ui/src/components/markdown.css
+++ b/packages/session-ui/src/components/markdown.css
@@ -448,7 +448,6 @@
     padding: 8px 12px;
     color: var(--v2-text-text-faint);
     font-weight: 500;
-    user-select: none;
   }
 
   td {

From d4b7c54973ddc82a0a8bb2cf694fdf0d115b4c7f Mon Sep 17 00:00:00 2001
From: Luke Parker <10430890+Hona@users.noreply.github.com>
Date: Mon, 26 Oct 2026 14:54:58 +1000
Subject: [PATCH 06/10] fix(app): render session header actions once

SessionHeaderLayout read its JSX actions prop in both the Show condition and its children, so it rendered the actions twice. The detached copy's Find input took the search controller's input ref, and Mod+F focused it instead of the visible field. Also update the workspace-switch test for the header's project label.
---
 packages/app/e2e/regression/timeline-cache.spec.ts   | 10 ++++------
 packages/app/src/session/session-identity-header.tsx |  5 ++---
 2 files changed, 6 insertions(+), 9 deletions(-)

diff --git a/packages/app/e2e/regression/timeline-cache.spec.ts b/packages/app/e2e/regression/timeline-cache.spec.ts
index 193be05135d1..54655b068028 100644
--- a/packages/app/e2e/regression/timeline-cache.spec.ts
+++ b/packages/app/e2e/regression/timeline-cache.spec.ts
@@ -334,7 +334,7 @@ test("recovers from a failed cold history load when another session is selected"
   await expect(page.getByRole("heading", { name: "Something went wrong", exact: true })).toHaveCount(0)
 })
 
-test("focuses Find in the selected cached timeline @quarantine", async ({ page }) => {
+test("focuses Find in the selected cached timeline", async ({ page }) => {
   await openTabs(page, { pageMessages: placeholderHistory })
   await page.goto(sessionHref(fixture.sourceID))
   await expect(page.getByText(`History for ${fixture.sourceID}`, { exact: true })).toBeVisible()
@@ -355,7 +355,7 @@ test("focuses Find in the selected cached timeline @quarantine", async ({ page }
   await expect(search).toHaveCount(0)
 })
 
-test("disposes the old workspace's shell while destination history is loading @quarantine", async ({ page }) => {
+test("disposes the old workspace's shell while destination history is loading", async ({ page }) => {
   const destination = "C:/OpenCode/OtherProject"
   const requested = Promise.withResolvers<void>()
   const release = Promise.withResolvers<void>()
@@ -426,7 +426,7 @@ test("disposes the old workspace's shell while destination history is loading @q
   try {
     await tab(page, fixture.targetID).click()
     await requested.promise
-    await expect(page.locator("[data-session-title]")).toHaveText(fixture.expected.targetTitle)
+    await expect(page.locator("[data-session-title] h1")).toHaveText(fixture.expected.targetTitle)
     output.text += "Output after returning\n"
     await tab(page, fixture.sourceID).click()
     await expect(shell.locator('[data-slot="bash-result"]')).toContainText("Output after returning")
@@ -759,9 +759,7 @@ async function sampleTabPaint(page: Page, sessionID: string) {
   return {
     async firstPaint() {
       await expect.poll(read).toBeDefined()
-      await expect
-        .poll(() => page.evaluate(() => window.__tabPaint!.settled))
-        .toBe(true)
+      await expect.poll(() => page.evaluate(() => window.__tabPaint!.settled)).toBe(true)
 
       return (await read())!
     },
diff --git a/packages/app/src/session/session-identity-header.tsx b/packages/app/src/session/session-identity-header.tsx
index 6d718ce2b333..be7ec456a052 100644
--- a/packages/app/src/session/session-identity-header.tsx
+++ b/packages/app/src/session/session-identity-header.tsx
@@ -81,9 +81,8 @@ export function SessionHeaderLayout(
           </span>
           {props.children}
         </div>
-        <Show when={props.actions}>
-          <div class="session-header-actions">{props.actions}</div>
-        </Show>
+        {/* Each read of a JSX prop renders it again, so the actions render once, from the condition's value. */}
+        <Show when={props.actions}>{(actions) => <div class="session-header-actions">{actions()}</div>}</Show>
       </div>
     </SessionHeaderCollapse.Provider>
   )

From 2cf4f51d5b047cdec70dd94f378a720e91cf88ee Mon Sep 17 00:00:00 2001
From: Luke Parker <10430890+Hona@users.noreply.github.com>
Date: Mon, 26 Oct 2026 14:54:58 +1000
Subject: [PATCH 07/10] test(app): fix quarantined capsule, touch-scroll and
 painted-motion e2e

Count only the activity capsule's own animation, not its spinner's loop. Move the touch-out-of-view drag to a row that leaves the virtual window now that the timeline scrolls under the composer, and anchor on a row that stays in view below the session location bar. Disable the bubble's colour transition while marking prompts for the frame reader.
---
 .../regression/mobile-timeline-scroll.spec.ts    | 16 +++++++++-------
 packages/app/e2e/regression/tabs.spec.ts         |  9 ++++-----
 packages/app/e2e/utils/prompt-motion.ts          |  5 ++++-
 3 files changed, 17 insertions(+), 13 deletions(-)

diff --git a/packages/app/e2e/regression/mobile-timeline-scroll.spec.ts b/packages/app/e2e/regression/mobile-timeline-scroll.spec.ts
index 1c1d29eceeb4..60edbef654ab 100644
--- a/packages/app/e2e/regression/mobile-timeline-scroll.spec.ts
+++ b/packages/app/e2e/regression/mobile-timeline-scroll.spec.ts
@@ -647,9 +647,7 @@ for (const device of ["Pixel 7", "iPhone 13"]) {
         const cause =
           detach === "scroll" ? "scrolling the touch target out of view" : "streaming replaces the touch target"
 
-        test(`returns Home after ${cause} (${release})${detach === "scroll" ? " @quarantine" : ""}`, async ({
-          page,
-        }, testInfo) => {
+        test(`returns Home after ${cause} (${release})`, async ({ page }, testInfo) => {
           const image = Promise.withResolvers<void>()
           const url = new URL(`/${detach}-target-image.svg`, testInfo.project.use.baseURL).href
           await page.route(url, async (route) => {
@@ -722,18 +720,22 @@ for (const device of ["Pixel 7", "iPhone 13"]) {
 
           if (detach === "scroll") {
             const bounds = (await scroller.boundingBox())!
-            const touched = page.getByText("Part 66.", { exact: true })
+            // The timeline scrolls on under the composer, and rows behind it stay mounted, so the drag must carry the
+            // touched row past the bottom of the screen before virtualization removes it.
+            const touched = page.getByText("Part 68.", { exact: true })
             await expect(touched).toBeInViewport()
+            const box = (await touched.boundingBox())!
+            const point = { x: bounds.x + 100, y: box.y + box.height / 2 }
             await devtools.send("Input.dispatchTouchEvent", {
               type: "touchStart",
-              touchPoints: [{ x: bounds.x + 100, y: bounds.y + 70 }],
+              touchPoints: [point],
               timestamp: restingTimestamp(),
             })
 
             for (let step = 1; step <= 23; step++)
               await devtools.send("Input.dispatchTouchEvent", {
                 type: "touchMove",
-                touchPoints: [{ x: bounds.x + 100, y: bounds.y + 70 + step * 30 }],
+                touchPoints: [{ x: point.x, y: point.y + step * 30 }],
                 timestamp: restingTimestamp(),
               })
             await expect(touched).not.toBeInViewport()
@@ -765,7 +767,7 @@ for (const device of ["Pixel 7", "iPhone 13"]) {
             await expect(hidden).toHaveCount(1)
           }
 
-          const anchor = page.getByText(detach === "scroll" ? "Part 47." : "Reading 20.", { exact: true })
+          const anchor = page.getByText(detach === "scroll" ? "Part 48." : "Reading 20.", { exact: true })
           await expect(anchor).toBeInViewport()
           const before = await anchor.evaluate((element) => element.getBoundingClientRect().top)
           image.resolve()
diff --git a/packages/app/e2e/regression/tabs.spec.ts b/packages/app/e2e/regression/tabs.spec.ts
index f98089b8b13d..7e4265f36b7f 100644
--- a/packages/app/e2e/regression/tabs.spec.ts
+++ b/packages/app/e2e/regression/tabs.spec.ts
@@ -858,9 +858,7 @@ test("inactive tabs stay busy while work waits in their inbox, and pulse on a ne
   await expect(tab(a.id).locator('[data-slot="tab-prompt-pulse"]')).toHaveCount(0)
 })
 
-test("switching between busy sessions keeps the busy indicators and the activity capsule at rest @quarantine", async ({
-  page,
-}) => {
+test("switching between busy sessions keeps the busy indicators and the activity capsule at rest", async ({ page }) => {
   const children = [
     { id: "ses_tab_a_child", title: "Map the orchard", parentID: a.id },
     { id: "ses_tab_b_child", title: "Chart the harbor", parentID: b.id },
@@ -882,11 +880,12 @@ test("switching between busy sessions keeps the busy indicators and the activity
   await expect(capsule).toHaveText("1 subagent")
   await expect(capsule).toHaveCSS("opacity", "1")
 
-  // Record any capsule animation or any moment without a capsule, and mark the indicators to compare them later.
+  // Record any capsule animation or any moment without a capsule, and mark the indicators to compare them later. The
+  // capsule's spinner always runs its own phase-synced loop, so only an animation of the capsule itself counts.
   await page.evaluate(() => {
     const record = document.documentElement
     document.addEventListener("animationstart", (event) => {
-      if (event.target instanceof Element && event.target.closest('[data-slot="session-activity-chip"]'))
+      if (event.target instanceof Element && event.target.matches('[data-slot="session-activity-chip"]'))
         record.setAttribute("data-test-capsule-animated", "")
     })
     new MutationObserver(() => {
diff --git a/packages/app/e2e/utils/prompt-motion.ts b/packages/app/e2e/utils/prompt-motion.ts
index f48c75f5e76c..c8fc8e5dee9e 100644
--- a/packages/app/e2e/utils/prompt-motion.ts
+++ b/packages/app/e2e/utils/prompt-motion.ts
@@ -3,8 +3,11 @@ import type { Page } from "@playwright/test"
 export type PromptPosition = { frame: number; top: number | null }
 
 // Paint user bubbles a test-only blue that the frame reader can tell from everything else, whatever the theme colour.
+// The bubble's colour transition would otherwise paint the next frames in a blend of grey and blue.
 export async function markPrompt(page: Page) {
-  await page.addStyleTag({ content: '[data-slot="user-message-text"] { background: rgb(0 0 255) !important; }' })
+  await page.addStyleTag({
+    content: '[data-slot="user-message-text"] { background: rgb(0 0 255) !important; transition: none !important; }',
+  })
 }
 
 // Records painted compositor frames; the returned stop function reads the prompt position in each frame.

From 73412683b0dada41cb70d6d51aa1f20f6c73f785 Mon Sep 17 00:00:00 2001
From: Luke Parker <10430890+Hona@users.noreply.github.com>
Date: Mon, 26 Oct 2026 14:57:06 +1000
Subject: [PATCH 08/10] test(app): clear the e2e quarantine list

---
 packages/app/e2e/QUARANTINE.md | 40 +++++-----------------------------
 1 file changed, 5 insertions(+), 35 deletions(-)

diff --git a/packages/app/e2e/QUARANTINE.md b/packages/app/e2e/QUARANTINE.md
index 373f4643cc33..04d4494bd6c9 100644
--- a/packages/app/e2e/QUARANTINE.md
+++ b/packages/app/e2e/QUARANTINE.md
@@ -1,42 +1,12 @@
 # Quarantined browser tests
 
-Beta pull request and push runs skip the 23 tests tagged `@quarantine` (`--grep-invert @quarantine`). Most failed in every beta run, so they gave no signal and slowed every leg with retries. `dev` runs are unchanged.
+Beta pull request and push runs skip tests tagged `@quarantine` (`--grep-invert @quarantine`), so a test that fails in every run stops slowing every leg with retries. `dev` runs are unchanged.
 
-To run only the quarantined tests, use `gh workflow run check-test.yml --ref beta -f quarantine=true`. Their legs report without failing the e2e checks. `nightly-beta.yml` dispatches that run, plus a full beta run, every night. GitHub fires schedules only from the default branch (`dev`), so the nightly run starts once that workflow is on `dev`; until then, dispatch by hand.
+To run only the quarantined tests, use `gh workflow run check-test.yml --ref beta -f quarantine=true`. Their legs report without failing the e2e checks. `nightly-beta.yml` dispatches that run, plus a full beta run, every night.
 
 **Rule:** fix a quarantined test or delete it within 14 days of quarantine. When a fix lands, remove the tag and its row in the same pull request. Never quarantine a test that fails because of your own change; fix the test or the change.
 
-Quarantined 2026-10-21, so the deadline is **2026-11-04**; the rows first seen red on 2026-10-22 were added that day and are due **2026-11-05**. "First red" is the earliest beta run seen failing; runs before 2026-10-20 05:32 UTC were not collected. "Unowned" means `git blame` points at the history import (#53822).
+No tests are quarantined. When you quarantine one, list it below with its failure signature, the date it was first seen red, and its owner.
 
-## App e2e (`packages/app/e2e`)
-
-| Test                                                                                                                                 | Failure signature                                                             | First red          | Owner       |
-| ------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------- | ------------------ | ----------- |
-| `regression/timeline-cache.spec.ts` › focuses Find in the selected cached timeline                                                   | `timeline-search-bar input` `toBeFocused()`: inactive                         | ≤ 2026-10-20 05:32 | unowned     |
-| `regression/timeline-cache.spec.ts` › disposes the old workspace's shell while destination history is loading                        | `[data-session-title]` text has a `smoke-project/` prefix                     | ≤ 2026-10-20 05:32 | unowned     |
-| `regression/mobile-timeline-scroll.spec.ts` › Pixel 7 › returns Home after scrolling the touch target out of view (touchEnd)         | `Part 66.` `not.toBeInViewport()`: still in viewport                          | ≤ 2026-10-20 05:32 | unowned     |
-| `regression/mobile-timeline-scroll.spec.ts` › Pixel 7 › returns Home after scrolling the touch target out of view (touchCancel)      | same                                                                          | ≤ 2026-10-20 05:32 | unowned     |
-| `regression/mobile-timeline-scroll.spec.ts` › iPhone 13 › returns Home after scrolling the touch target out of view (touchEnd)       | same                                                                          | ≤ 2026-10-20 05:32 | unowned     |
-| `regression/mobile-timeline-scroll.spec.ts` › iPhone 13 › returns Home after scrolling the touch target out of view (touchCancel)    | same                                                                          | ≤ 2026-10-20 05:32 | unowned     |
-| `regression/new-session.spec.ts` › keeps the user message blue for a managed worktree                                                | `user-message-text` color `rgb(245, 248, 255)`, received `rgb(242, 242, 242)` | ≤ 2026-10-20 11:29 | Luke Parker |
-| `regression/new-session.spec.ts` › keeps the user message blue for the main root written with Windows case and separators            | same                                                                          | ≤ 2026-10-20 11:29 | Luke Parker |
-| `regression/review.spec.ts` › open file tab browses, searches, and tracks missing files                                              | file search request has an unexpected `directory` field                       | ≤ 2026-10-20 11:29 | unowned     |
-| `regression/review.spec.ts` › rereads a file each time an artifact link opens it                                                     | `first draft` never visible in `#review-panel`                                | ≤ 2026-10-20 11:29 | unowned     |
-| `regression/session-queue.spec.ts` › keeps finished tools above a pending steer follow-up                                            | pending steer color `rgb(242, 242, 242)`, received `rgb(250, 250, 250)`       | ≤ 2026-10-20 11:29 | unowned     |
-| `regression/tabs.spec.ts` › switching between busy sessions keeps the busy indicators and the activity capsule at rest               | `html` keeps `data-test-capsule-missing`                                      | ≤ 2026-10-20 05:32 | Kit Langton |
-| `regression/review.spec.ts` › restores review state and the side-panel tab per session                                               | heading `Alpha review state` not found                                        | ≤ 2026-10-22 16:26 | unowned     |
-| `regression/session-queue.spec.ts` › reverting to another prompt replaces the file chips of an earlier restore                       | `Rewind to here` resolves to 2 buttons (strict mode)                          | ≤ 2026-10-22 16:26 | unowned     |
-| `regression/session-queue.spec.ts` › waiting steers group under one Pending line, each keeping its own actions beside its bubble     | `Move to queue` resolves to 2 buttons (strict mode)                           | ≤ 2026-10-22 16:26 | Kit Langton |
-| `regression/session-timeline-accessibility.spec.ts` › shows the agent name in message meta when agents are on                        | meta `Pending·Build·…`, expected `/^Build\s·\s/`                              | ≤ 2026-10-22 16:26 | Kit Langton |
-| `regression/timeline-stream.spec.ts` › static projection › renders current protocol notices in CLI order                             | `session-timeline-notice` classes differ                                      | ≤ 2026-10-22 16:26 | unowned     |
-| `regression/timeline-stream.spec.ts` › background shortcut › holds a revealed shell from far below just under its stuck group header | predicate expected `0`, received `1` (10 s)                                   | ≤ 2026-10-22 16:26 | unowned     |
-
-## App component tests (`packages/app/component-tests`)
-
-| Test                                                                                        | Failure signature                                                  | First red          | Owner   |
-| ------------------------------------------------------------------------------------------- | ------------------------------------------------------------------ | ------------------ | ------- |
-| `websearch.spec.ts` › selects and confirms a provider at 360px in ltr light                 | 60 s timeout clicking the `Parallel` option: element is not stable | ≤ 2026-10-20 06:39 | unowned |
-| `websearch.spec.ts` › selects and confirms a provider at 360px in ltr dark                  | same                                                               | ≤ 2026-10-20 06:39 | unowned |
-| `websearch.spec.ts` › selects and confirms a provider at 360px in rtl light                 | same                                                               | ≤ 2026-10-20 06:39 | unowned |
-| `websearch.spec.ts` › selects and confirms a provider at 360px in rtl dark                  | same                                                               | ≤ 2026-10-20 06:39 | unowned |
-| `timeline-virtualizer.spec.ts` › reveals ready measured rows after an offset-only reconnect | `data-last-scroll-top` `484`, received `502`                       | ≤ 2026-10-20 06:39 | unowned |
+| Test | Failure signature | First red | Owner |
+| ---- | ----------------- | --------- | ----- |

From 7bc5499ddf4775602d473e410c4171ca272b7f42 Mon Sep 17 00:00:00 2001
From: Luke Parker <10430890+Hona@users.noreply.github.com>
Date: Mon, 26 Oct 2026 14:59:01 +1000
Subject: [PATCH 09/10] test(app): keep the touched e2e files lint-clean

---
 packages/app/e2e/regression/new-session.spec.ts |  1 +
 packages/app/e2e/regression/tabs.spec.ts        |  2 ++
 .../app/e2e/regression/timeline-stream.spec.ts  | 17 ++++++++++++-----
 packages/app/src/session/requests/background.ts |  2 ++
 4 files changed, 17 insertions(+), 5 deletions(-)

diff --git a/packages/app/e2e/regression/new-session.spec.ts b/packages/app/e2e/regression/new-session.spec.ts
index 96d3aab6df0a..24a93a7d7760 100644
--- a/packages/app/e2e/regression/new-session.spec.ts
+++ b/packages/app/e2e/regression/new-session.spec.ts
@@ -154,6 +154,7 @@ test("branch search keeps results on screen while a query is pending", async ({
     const observer = new MutationObserver(() => {
       if (!list.querySelector('[role="option"]')) list.setAttribute("data-emptied", "")
     })
+
     observer.observe(list, { childList: true, subtree: true })
   })
 
diff --git a/packages/app/e2e/regression/tabs.spec.ts b/packages/app/e2e/regression/tabs.spec.ts
index 7e4265f36b7f..af20b8227af8 100644
--- a/packages/app/e2e/regression/tabs.spec.ts
+++ b/packages/app/e2e/regression/tabs.spec.ts
@@ -32,6 +32,7 @@ test("recently closed shows ten sessions and searches older closures in close or
     id: `ses_closed_${index}`,
     title: `Closed session ${index}`,
   }))
+
   await mockWorkspace(page, {
     name: "ClosedTabs",
     sessions,
@@ -86,6 +87,7 @@ test("recently closed fills remaining slots in Home order without open or duplic
     title: `Other session ${index}`,
     time: { created: 1700000000000, updated: 1700000000000 + (12 - index) * 1000 },
   }))
+
   await mockWorkspace(page, {
     name: "OtherTabs",
     sessions: [
diff --git a/packages/app/e2e/regression/timeline-stream.spec.ts b/packages/app/e2e/regression/timeline-stream.spec.ts
index 924b81dfb5c3..8ddefd4a8012 100644
--- a/packages/app/e2e/regression/timeline-stream.spec.ts
+++ b/packages/app/e2e/regression/timeline-stream.spec.ts
@@ -617,7 +617,10 @@ test("shows a background subagent's outcome as its own row where it finished", a
     }),
     inboxDelivered({ sessionID, inboxID: "msg_outcome" }),
     stepStarted(after),
-    ...partUpdated({ ...toolPart("call_read_after", "read", "completed", { filePath: "AGENTS.md" }), messageID: after.id }),
+    ...partUpdated({
+      ...toolPart("call_read_after", "read", "completed", { filePath: "AGENTS.md" }),
+      messageID: after.id,
+    }),
     messageUpdated(completedAssistantInfo(after)),
   ])
 
@@ -666,6 +669,7 @@ test("holds undelivered input still while live status above it comes and goes",
   const working = page.locator('[data-component="session-working"]')
   const activity = page.locator('[data-timeline-key="activity"]')
   const lane = async () => (await activity.boundingBox())?.height
+
   const outcome = (id: string, description: string) =>
     inboxEnqueued({
       sessionID,
@@ -682,6 +686,7 @@ test("holds undelivered input still while live status above it comes and goes",
     })
 
   const first = page.locator('[data-slot="session-timeline-notice"]').filter({ hasText: "Audit constraints" })
+
   const gap = async () => {
     const [above, below] = await Promise.all([answer.boundingBox(), first.boundingBox()])
 
@@ -908,7 +913,9 @@ test.describe("Working", () => {
     await expect(working).toBeVisible()
 
     await timeline.send(partUpdated(toolPart("prt_read_four", "read", "running", { path: "src/four.ts" })))
-    await expect(group.locator('[data-slot="basic-tool-tool-subtitle"]')).toHaveText("one.ts, two.ts, three.ts, four.ts")
+    await expect(group.locator('[data-slot="basic-tool-tool-subtitle"]')).toHaveText(
+      "one.ts, two.ts, three.ts, four.ts",
+    )
     await expect(working).toBeVisible()
 
     await timeline.send(partUpdated(toolPart("prt_read_four", "read", "completed", { path: "src/four.ts" })))
@@ -1143,6 +1150,7 @@ test.describe("background shortcut", () => {
         .poll(async () => {
           const panel = (await list.boundingBox())!
           const anchor = (await capsule.boundingBox())!
+
           const end = await list
             .getByRole("menuitem")
             .locator('[data-slot="session-activity-elapsed"]')
@@ -1194,6 +1202,7 @@ test.describe("background shortcut", () => {
       ],
       sessions: [session(), session({ id: childID, parentID: sessionID, title: "Stale task", agent: "explore" })],
     })
+
     const capsule = page.locator('[data-slot="session-activity-chip"]')
 
     await expect(page.locator('[data-timeline-part-id="call_stale"]')).toContainText("Stale task (background)")
@@ -1638,9 +1647,7 @@ test.describe("compaction", () => {
     await expect(compaction).not.toContainText("Partial automatic summary.")
     await expect(compaction).not.toContainText("Session compaction started")
 
-    await timeline.send(
-      compactionEnded({ sessionID, reason: "auto", text: "## Checkpoint\n\nAutomatic details." }),
-    )
+    await timeline.send(compactionEnded({ sessionID, reason: "auto", text: "## Checkpoint\n\nAutomatic details." }))
     await expect(divider).toHaveAttribute("data-state", "done")
     await expect(divider).toHaveAccessibleName("Compacted")
     await expect(compaction).not.toContainText("Automatic details.")
diff --git a/packages/app/src/session/requests/background.ts b/packages/app/src/session/requests/background.ts
index b6afdd88cdb8..1f3057814503 100644
--- a/packages/app/src/session/requests/background.ts
+++ b/packages/app/src/session/requests/background.ts
@@ -96,6 +96,7 @@ export function createSessionBackground(input: {
     const descends = (sessionID: string) => {
       const seen = new Set<string>()
       let parentID = parents.get(sessionID)
+
       while (parentID && !seen.has(parentID)) {
         if (parentID === id) return true
         seen.add(parentID)
@@ -107,6 +108,7 @@ export function createSessionBackground(input: {
 
     // A call names its child once the child exists; until the call reports it, the child's title is its description.
     const calls = current.blocking.flatMap((item) => (item.type === "subagent" ? [item] : []))
+
     const child = (item: (typeof calls)[number], info: SessionInfo) =>
       item.id ? info.id === item.id : !!item.label && info.parentID === id && info.title === item.label
 

From 746f364ac82269513018e1114c6fad775c82a6cc Mon Sep 17 00:00:00 2001
From: Luke Parker <10430890+Hona@users.noreply.github.com>
Date: Mon, 26 Oct 2026 15:15:50 +1000
Subject: [PATCH 10/10] test(app): let a reopened file tab restore its scroll
 in the reread test

---
 packages/app/e2e/regression/review.spec.ts | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/packages/app/e2e/regression/review.spec.ts b/packages/app/e2e/regression/review.spec.ts
index 729e5a51bbd4..21c442fe5f42 100644
--- a/packages/app/e2e/regression/review.spec.ts
+++ b/packages/app/e2e/regression/review.spec.ts
@@ -618,9 +618,10 @@ test("rereads a file each time an artifact link opens it", async ({ page }) => {
   const tab = panel.getByRole("tab", { name: "shopping.txt" })
   const code = panel.locator("[data-scrollable]", { has: page.locator('[data-component="file"]') })
 
-  // A long file opens at its top and mounts only the rows near the viewport, so its last line needs a scroll.
+  // A long file mounts only the rows near the viewport, so its last line needs a scroll. A reopened tab may restore its
+  // earlier scroll position, so this starts from wherever the view is once its rows overflow.
   const scrollToEnd = async () => {
-    await expect(panel.getByText("item 1", { exact: true })).toBeVisible()
+    await expect.poll(() => code.evaluate((element) => element.scrollHeight - element.clientHeight)).toBeGreaterThan(0)
     await code.hover()
     await page.mouse.wheel(0, 100_000)
     await expect
@@ -630,6 +631,8 @@ test("rereads a file each time an artifact link opens it", async ({ page }) => {
 
   await link.click()
   await expect(tab).toHaveAttribute("aria-selected", "true")
+  // The first open starts at the top.
+  await expect(panel.getByText("item 1", { exact: true })).toBeVisible()
   await scrollToEnd()
   await expect(panel.getByText("first draft", { exact: true })).toBeVisible()