diff --git a/.storybook/test-runner.ts b/.storybook/test-runner.ts
index a9aab189e5f..77a28909c49 100644
--- a/.storybook/test-runner.ts
+++ b/.storybook/test-runner.ts
@@ -2,14 +2,14 @@ import type { TestRunnerConfig } from "@storybook/test-runner";
 // This hook is reloaded between Jest suites in the same worker. Importing @playwright/test
 // initializes a second test runner and fails on reload; use browser waits and Node assertions.
 import assert from "node:assert/strict";
-import { MOBILE_TOUCH_TARGET_PX } from "../src/constants/layout";
+import { MOBILE_TOUCH_TARGET_PX, TABLET_TOUCH_TARGET_PX } from "../src/constants/layout";
 
 // Real :hover for the primary-button contrast stories (#6022). A play runs inside the page and
 // cannot set :hover, so only stories under this id prefix get two page-level helpers backed by
 // Playwright. All other stories run exactly as before.
 const HOVER_STORY_PREFIX = "app-primarybuttoncontrast--";
 const hoverReady = new WeakSet<object>();
-// The Narrow story's strip scrolls up to 621 px, and the shortest swipe seen moved it 56 px:
+// The Narrow story's strip scrolls up to 669 px, and the shortest swipe seen moved it 56 px:
 // 16 swipes cover it with room to spare.
 const MAX_TOUCH_SWIPES = 16;
 
@@ -71,6 +71,62 @@ async function assertPhoneFooterTouchTargets(page: StoryPage) {
   }
 }
 
+const TOUCH_RESIZE_STORY = "app-seededworkspacea11y--narrow-sidebar-dark";
+
+/**
+ * A finger must drag the right sidebar's resize handle: a touch drag fires no mouse events, and
+ * iPads report a coarse pointer even with a trackpad. Plays dispatch synthetic events, so only
+ * browser input proves the handle takes a touch drag (and that the page does not pan instead).
+ */
+async function assertTouchResizesRightSidebar(page: StoryPage) {
+  const client = await page.context().newCDPSession(page);
+  const viewport = page.viewportSize();
+  // The drag persists the new width; restore storage for the stories that run after this one.
+  const storage = await page.evaluate(() => Object.entries(localStorage));
+  const sidebar = page.getByRole("complementary", { name: "Workspace insights" });
+  try {
+    await client.send("Emulation.setTouchEmulationEnabled", { enabled: true });
+    await page.setViewportSize({ width: 1200, height: 900 });
+    await page.waitForFunction(() => matchMedia("(pointer: coarse)").matches, undefined, {
+      timeout: 5000,
+    });
+    const before = await sidebar.boundingBox();
+    const handle = await page.locator("[data-sidebar-resize-handle]").boundingBox();
+    if (!before || !handle) throw new Error("Right sidebar or its resize handle is missing");
+    const x = handle.x + handle.width / 2;
+    const y = handle.y + handle.height / 2;
+    await client.send("Input.dispatchTouchEvent", { type: "touchStart", touchPoints: [{ x, y }] });
+    for (let step = 1; step <= 4; step++) {
+      // A frame per move: the drag listeners attach in an effect after the touch starts.
+      await page.evaluate(
+        () => new Promise<void>((resolve) => requestAnimationFrame(() => resolve()))
+      );
+      await client.send("Input.dispatchTouchEvent", {
+        type: "touchMove",
+        touchPoints: [{ x: x - 20 * step, y }],
+      });
+    }
+    await client.send("Input.dispatchTouchEvent", { type: "touchEnd", touchPoints: [] });
+    // Dragging the left-edge handle 80 px left widens the sidebar by as much.
+    await page.waitForFunction(
+      (start) => {
+        const element = document.querySelector('[aria-label="Workspace insights"]');
+        return element != null && element.getBoundingClientRect().width >= start + 60;
+      },
+      before.width,
+      { timeout: 5000 }
+    );
+  } finally {
+    await client.send("Emulation.setTouchEmulationEnabled", { enabled: false });
+    await client.detach();
+    if (viewport) await page.setViewportSize(viewport);
+    await page.evaluate((entries) => {
+      localStorage.clear();
+      for (const [key, value] of entries) localStorage.setItem(key, value);
+    }, storage);
+  }
+}
+
 const config: TestRunnerConfig = {
   async preVisit(page, context) {
     // exposeFunction throws on a second registration, so register once per Playwright page.
@@ -86,24 +142,43 @@ const config: TestRunnerConfig = {
       }
       return;
     }
+    if (context.id === TOUCH_RESIZE_STORY) {
+      if (page.context().browser()?.browserType().name() === "chromium") {
+        await assertTouchResizesRightSidebar(page);
+      }
+      return;
+    }
     if (context.id === "app-rightsidebar-stable-tab-controls--wide") {
       if (page.context().browser()?.browserType().name() !== "chromium") return;
-      // A tablet (coarse pointer above the phone breakpoint) gets no global 44px button floor,
-      // so the collapse button must size itself for touch. Plays cannot emulate the pointer.
+      // A tablet (coarse pointer above the phone breakpoint) gets no global 44px button floor.
+      // Its strip keeps the desktop height (44px rows made it far taller than the header), so
+      // the controls must size themselves to the 24px minimum. Plays cannot emulate the pointer.
       const client = await page.context().newCDPSession(page);
       const viewport = page.viewportSize();
+      const strip = page.getByRole("tablist").locator("..");
       try {
-        await client.send("Emulation.setTouchEmulationEnabled", { enabled: true });
         await page.setViewportSize({ width: 1200, height: 900 });
+        const desktop = await strip.boundingBox();
+        await client.send("Emulation.setTouchEmulationEnabled", { enabled: true });
         await page.waitForFunction(() => matchMedia("(pointer: coarse)").matches, undefined, {
           timeout: 5000,
         });
-        const box = await page.getByRole("button", { name: "Collapse sidebar" }).boundingBox();
-        if (!box) throw new Error("Collapse sidebar button is missing");
-        assert(
-          box.width >= 44 && box.height >= 44,
-          `Collapse target is ${box.width}x${box.height}`
-        );
+        const tablet = await strip.boundingBox();
+        if (!desktop || !tablet) throw new Error("Tab strip is missing");
+        assert.equal(tablet.height, desktop.height, "Touch must not grow the tablet tab strip");
+        for (const name of [
+          "Close New tab",
+          "Close Instructions",
+          "All tabs",
+          "Collapse sidebar",
+        ]) {
+          const box = await page.getByRole("button", { name, exact: true }).boundingBox();
+          if (!box) throw new Error(`${name} button is missing`);
+          assert(
+            box.width >= TABLET_TOUCH_TARGET_PX && box.height >= TABLET_TOUCH_TARGET_PX,
+            `${name} target is ${box.width}x${box.height}`
+          );
+        }
       } finally {
         await client.send("Emulation.setTouchEmulationEnabled", { enabled: false });
         await client.detach();
@@ -173,12 +248,13 @@ const config: TestRunnerConfig = {
           }
           await client.send("Input.dispatchTouchEvent", { type: "touchEnd", touchPoints: [] });
           await row.and(page.locator("[data-scroll-settled]")).waitFor({ timeout: 5000 });
+          // The tap below lands 20 px into the last tab's visible part: on a phone, a long title
+          // can be wider than the row, so the tab's own left edge never scrolls into view.
           const reachedLastTab = await row.evaluate((el) => {
             const last = Array.from(el.querySelectorAll('[role="tab"]')).at(-1);
             if (!last) return false;
             const bounds = el.getBoundingClientRect();
-            const tapX = last.getBoundingClientRect().left + 20;
-            return tapX >= bounds.left && tapX < bounds.right;
+            return Math.max(last.getBoundingClientRect().left, bounds.left) + 20 < bounds.right;
           });
           if (reachedLastTab) break;
         }
@@ -196,11 +272,11 @@ const config: TestRunnerConfig = {
         const last = await tabs.last().boundingBox();
         const bounds = await row.boundingBox();
         if (!last || !bounds) throw new Error("Scrolled tab is missing");
-        assert(last.x + 20 >= bounds.x, "Last tab must be inside the left edge");
-        assert(last.x + 20 < bounds.x + bounds.width, "Last tab must be inside the right edge");
+        const tapX = Math.max(last.x, bounds.x) + 20;
+        assert(tapX < bounds.x + bounds.width, "Last tab must be inside the right edge");
         await client.send("Input.dispatchTouchEvent", {
           type: "touchStart",
-          touchPoints: [{ x: last.x + 20, y: last.y + last.height / 2 }],
+          touchPoints: [{ x: tapX, y: last.y + last.height / 2 }],
         });
         await client.send("Input.dispatchTouchEvent", { type: "touchEnd", touchPoints: [] });
         await tabs.last().and(page.locator('[aria-selected="true"]')).waitFor({ timeout: 5000 });
diff --git a/docs/config/keybinds.mdx b/docs/config/keybinds.mdx
index d3e5358b949..a5c5b5bd03b 100644
--- a/docs/config/keybinds.mdx
+++ b/docs/config/keybinds.mdx
@@ -72,7 +72,7 @@ While a workspace's actions menu (`⋮` in the sidebar row, `…` in the header)
 | New right sidebar tab (lists the tools) | `Ctrl+Alt+N`   |
 | Close the right sidebar's active tab    | `Ctrl+W`       |
 
-The right sidebar shows only the tabs you open. A new tab lists the tools it can show (Stats, Review, Instructions, Goal, Terminal, and more); pick one to open it in that tab's place.
+The right sidebar shows only the tabs you open. A new tab lists the tools it can show (Stats, Review, Instructions, Goal, Terminal, and more); pick one to open it in that tab's place. The chevron at the right end of the tab strip lists your open tabs, with **New tab** at the bottom.
 
 ### Command Palette
 
diff --git a/src/browser/components/LeftSidebar/LeftSidebar.stories.tsx b/src/browser/components/LeftSidebar/LeftSidebar.stories.tsx
index 2ed80b3905b..e637086733a 100644
--- a/src/browser/components/LeftSidebar/LeftSidebar.stories.tsx
+++ b/src/browser/components/LeftSidebar/LeftSidebar.stories.tsx
@@ -65,7 +65,7 @@ interface LeftSidebarStoryOverrides {
   collapsed?: boolean;
   widthPx?: number;
   isResizing?: boolean;
-  onStartResize?: (e: React.MouseEvent) => void;
+  onStartResize?: (e: React.PointerEvent) => void;
   onToggleCollapsed?: () => void;
 }
 
diff --git a/src/browser/components/LeftSidebar/LeftSidebar.tsx b/src/browser/components/LeftSidebar/LeftSidebar.tsx
index d25de30e6c8..43886ccc393 100644
--- a/src/browser/components/LeftSidebar/LeftSidebar.tsx
+++ b/src/browser/components/LeftSidebar/LeftSidebar.tsx
@@ -11,7 +11,7 @@ interface LeftSidebarProps {
   onToggleCollapsed: () => void;
   widthPx?: number;
   isResizing?: boolean;
-  onStartResize?: (e: React.MouseEvent) => void;
+  onStartResize?: (e: React.PointerEvent) => void;
   sortedWorkspacesByProject: Map<string, FrontendWorkspaceMetadata[]>;
   workspaceRecency: Record<string, number>;
 }
@@ -100,10 +100,10 @@ export function LeftSidebar(props: LeftSidebarProps) {
           <div
             data-testid="left-sidebar-resize-handle"
             className={cn(
-              "absolute right-0 top-0 bottom-0 w-0.5 z-10 cursor-col-resize transition-[background] duration-150",
+              "absolute right-0 top-0 bottom-0 w-0.5 z-10 cursor-col-resize touch-none transition-[background] duration-150",
               isResizing ? "bg-accent" : "bg-border-light hover:bg-accent"
             )}
-            onMouseDown={(e) => onStartResize(e)}
+            onPointerDown={(e) => onStartResize(e)}
           />
         )}
       </div>
diff --git a/src/browser/features/RightSidebar/NewTabLauncher.tsx b/src/browser/features/RightSidebar/NewTabLauncher.tsx
index 7127df4138e..a972815ae08 100644
--- a/src/browser/features/RightSidebar/NewTabLauncher.tsx
+++ b/src/browser/features/RightSidebar/NewTabLauncher.tsx
@@ -26,9 +26,9 @@ interface NewTabLauncherProps {
   onOpenSideChat?: () => void;
   creatingSideChat: boolean;
   /**
-   * Focus the first row once shown. Set only when the user asked for a New tab ("+" or the
-   * shortcut), never for the New tab a fresh workspace starts with, so the launcher does not
-   * steal focus from the chat input.
+   * Focus the first row once shown. Set only when the user asked for a New tab (its row in the
+   * All tabs menu or the shortcut), never for the New tab a fresh workspace starts with, so the
+   * launcher does not steal focus from the chat input.
    */
   autoFocus: boolean;
   onAutoFocusConsumed: () => void;
diff --git a/src/browser/features/RightSidebar/RightSidebar.stories.tsx b/src/browser/features/RightSidebar/RightSidebar.stories.tsx
index 9fca404356e..23754eed881 100644
--- a/src/browser/features/RightSidebar/RightSidebar.stories.tsx
+++ b/src/browser/features/RightSidebar/RightSidebar.stories.tsx
@@ -32,7 +32,7 @@ import { createAssistantMessage, createUserMessage } from "@/browser/stories/moc
 import type { MockSessionUsage } from "@/browser/stories/mocks/orpc";
 import { AppWithMocks, PIXEL_DISABLED } from "@/browser/stories/meta.js";
 import { createWorkspace } from "@/browser/stories/mocks/workspaces";
-import { blurActiveElement } from "@/browser/stories/storyPlayHelpers";
+import { blurActiveElement, openSidebarNewTab } from "@/browser/stories/storyPlayHelpers";
 import { setupSimpleChatStory, setupStreamingChatStory } from "@/browser/stories/helpers/chatSetup";
 import { textsBelowAaInThemes } from "@/browser/stories/helpers/contrast";
 import { setHunkFirstSeen } from "@/browser/stories/helpers/reviews";
@@ -206,7 +206,7 @@ function seedSidebarLayout(workspaceId: string, tabs: TabType[], activeTab: TabT
 
 /**
  * The selected tab lies fully inside its strip's scroll viewport (not cut off at an edge or
- * hidden behind "+"). Retries because labels grow after mount (cost badge, counts) and the
+ * hidden behind All tabs). Retries because labels grow after mount (cost badge, counts) and the
  * strip re-scrolls when they do. Stories using it fix the sidebar width themselves, so this
  * holds at any test-runner viewport size.
  */
@@ -1585,15 +1585,27 @@ export const NewTabLauncher: Story = {
           document.activeElement === tab || panel?.contains(document.activeElement)
         ).toBe(true);
       });
-      await userEvent.click(canvas.getByRole("button", { name: "New tab" }));
+      await openSidebarNewTab(canvasElement);
     }
+    // The New tab row hands focus to the launcher, which keeps it after the menu unmounts: Radix
+    // refocuses the menu button on a timer then if focus is still inside the menu.
+    const launcherHasFocus = () =>
+      canvasElement
+        .querySelector('[role="tabpanel"][id$="-panel-new"]')
+        ?.contains(document.activeElement) === true;
+    await waitFor(() => expect(launcherHasFocus()).toBe(true));
+    await waitFor(() =>
+      expect(within(document.body).queryByRole("dialog", { name: "All tabs" })).toBeNull()
+    );
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    await expect(launcherHasFocus()).toBe(true);
   },
 };
 
 /**
  * The New tab launcher at the sidebar's minimum width (300px), next to more open tabs than fit:
  * launcher rows wrap their descriptions instead of overflowing, and the strip stays one row
- * that scrolls sideways (hidden scrollbar, faded edges) with "+" pinned at the end.
+ * that scrolls sideways (hidden scrollbar, faded edges) with All tabs pinned at the end.
  */
 export const NewTabLauncherNarrow: Story = {
   // Match Pixel's named desktop exactly; the global Storybook "desktop" is smaller.
@@ -1721,7 +1733,7 @@ export const ManyTabsSingleRow: Story = {
   play: async ({ canvasElement }) => {
     const canvas = within(canvasElement);
     await canvas.findByRole("tab", { name: /^timeline/i, selected: true });
-    await canvas.findByRole("button", { name: "New tab" });
+    await canvas.findByRole("button", { name: "All tabs" });
     // Wait for the cost badge: it widens Stats after mount, pushing the selected tab right.
     await canvas.findByRole("tab", { name: /stats.*\$0\.34/i });
     await expectSelectedTabVisible(canvasElement);
@@ -1770,8 +1782,12 @@ export const TabsReachableUnderWideTitlebarInset: Story = {
     const stats = await canvas.findByRole("tab", { name: /^stats/i, selected: true });
     const review = await canvas.findByRole("tab", { name: /^review/i });
     await expectSelectedTabVisible(canvasElement);
+    // All tabs must stay clickable too: it reaches every tab and the New tab.
     await waitFor(() => {
       if (!isHitTarget(stats)) throw new Error("selected tab is not under the pointer");
+      if (!isHitTarget(canvas.getByRole("button", { name: "All tabs" }))) {
+        throw new Error("All tabs is not under the pointer");
+      }
     });
     // Like Playwright: bring the other tab into view, then it must take the click.
     review.scrollIntoView({ block: "nearest", inline: "nearest" });
diff --git a/src/browser/features/RightSidebar/RightSidebar.tsx b/src/browser/features/RightSidebar/RightSidebar.tsx
index dd18c543fa5..61d7912310f 100644
--- a/src/browser/features/RightSidebar/RightSidebar.tsx
+++ b/src/browser/features/RightSidebar/RightSidebar.tsx
@@ -261,9 +261,14 @@ const SidebarContainer: React.FC<SidebarContainerProps> = ({
               // (0.75rem), so it sits evenly in the corner.
               isDesktop ? "top-12" : "top-11",
             ]
-          : // No width transition: expanding swaps the floating card for the docked panel, and
-            // animating the width between those two layouts reads as the card stretching.
-            "bg-surface-primary flex-shrink-0 overflow-hidden border-l"
+          : [
+              // No width transition: expanding swaps the floating card for the docked panel, and
+              // animating the width between those two layouts reads as the card stretching.
+              "bg-surface-primary flex-shrink-0 overflow-hidden border-l",
+              // On coarse pointers the resize handle is a wider strip that draws the divider line
+              // on its right edge, where the tab strip's bottom border meets it.
+              "[@media(pointer:coarse)]:has-[[data-sidebar-resize-handle]]:border-l-0",
+            ]
       )}
       style={collapsed ? undefined : { width, maxWidth: "100%" }}
       role={role}
@@ -288,7 +293,7 @@ interface RightSidebarProps {
   /** Custom width in pixels (persisted per-tab, provided by AIView) */
   width?: number;
   /** Drag start handler for resize */
-  onStartResize?: (e: React.MouseEvent) => void;
+  onStartResize?: (e: React.PointerEvent) => void;
   /** Whether currently resizing */
   isResizing?: boolean;
   /** Callback when user adds a review note from Code Review tab */
@@ -382,7 +387,7 @@ interface RightSidebarTabsetNodeProps {
   setLayout: (updater: (prev: RightSidebarLayoutState) => RightSidebarLayoutState) => void;
   /** Handler to pop out a terminal tab to a separate window */
   onPopOutTerminal: (tab: TabType) => void;
-  /** Handler for the strip's "+" button: open (or show) this tabset's New tab */
+  /** The strip's New tab row (All tabs menu): open (or show) this tabset's New tab */
   onAddNewTab: (tabsetId: string) => void;
   /** Set only for the tabset whose strip shows the sidebar's collapse button */
   onCollapseSidebar?: () => void;
@@ -398,7 +403,7 @@ interface RightSidebarTabsetNodeProps {
   isOnlyTabset: boolean;
   /** Tools the New tab launcher offers, in order (already filtered for availability) */
   launcherTools: BaseTabType[];
-  /** Tabset whose New tab launcher should take focus once shown (after "+" or the shortcut) */
+  /** Tabset whose New tab launcher should take focus once shown (after its row or the shortcut) */
   launcherAutoFocusTabsetId: string | null;
   onLauncherAutoFocusConsumed: () => void;
   /** Handler to close a terminal tab */
@@ -589,6 +594,8 @@ const RightSidebarTabsetNode: React.FC<RightSidebarTabsetNodeProps> = (props) =>
     // with index + close/pop-out actions) — see `tabRegistry.tsx` for why
     // terminals stay outside the static registry.
     let label: React.ReactNode;
+    // The All tabs menu shows `label` unless it holds buttons (a menu row cannot nest them).
+    let menuLabel: React.ReactNode | undefined;
     if (isNewTab(tab)) {
       label = <NewTabLabel />;
     } else if (isBaseTabId(tab)) {
@@ -596,14 +603,16 @@ const RightSidebarTabsetNode: React.FC<RightSidebarTabsetNodeProps> = (props) =>
       label = <Label workspaceId={props.workspaceId} reviewStats={props.reviewStats} />;
     } else if (isTerminal) {
       const terminalIndex = props.terminalTabOrder.get(tab) ?? 0;
+      const dynamicTitle = props.terminalTitles.get(tab);
       label = (
         <TerminalTabLabel
-          dynamicTitle={props.terminalTitles.get(tab)}
+          dynamicTitle={dynamicTitle}
           terminalIndex={terminalIndex}
           onPopOut={() => props.onPopOutTerminal(tab)}
           onClose={() => props.onCloseTerminal(tab)}
         />
       );
+      menuLabel = <TerminalTabLabel dynamicTitle={dynamicTitle} terminalIndex={terminalIndex} />;
     } else if (getAppViewTabKey(tab) != null) {
       label = (
         <AppViewTabLabel workspaceId={props.workspaceId} toolCallId={appViewTabToolCallId(tab)} />
@@ -615,6 +624,7 @@ const RightSidebarTabsetNode: React.FC<RightSidebarTabsetNodeProps> = (props) =>
           onClose={() => props.onCloseSideChat(tab)}
         />
       );
+      menuLabel = <SideChatTabLabel workspaceId={sideChatWorkspaceId} />;
     } else {
       label = tab;
     }
@@ -626,6 +636,7 @@ const RightSidebarTabsetNode: React.FC<RightSidebarTabsetNodeProps> = (props) =>
         selected: props.node.activeTab === tab,
         onSelect: () => selectTab(tab),
         label,
+        menuLabel,
         tooltip,
         tab,
         // Every tab is closeable; terminal and side chat labels render their own X (closing
@@ -1151,7 +1162,8 @@ const RightSidebarComponent: React.FC<RightSidebarProps> = ({
     setReviewPanelStats(stats ? { total: stats.total, read: stats.read } : null);
   }, []);
 
-  // Tabset whose New tab launcher should focus its first row once shown ("+" or the shortcut).
+  // Tabset whose New tab launcher should focus its first row once shown (its strip's New tab row
+  // or the shortcut).
   const [launcherAutoFocusTabsetId, setLauncherAutoFocusTabsetId] = React.useState<string | null>(
     null
   );
@@ -2159,8 +2171,8 @@ const RightSidebarComponent: React.FC<RightSidebarProps> = ({
     [setLayout]
   );
 
-  // "+" in a strip (tabsetId) or the shortcut (focused tabset): show that tabset's New tab and
-  // move focus into its launcher.
+  // A strip's New tab row (tabsetId) or the shortcut (focused tabset): show that tabset's New
+  // tab and move focus into its launcher.
   const handleAddNewTab = React.useCallback(
     (tabsetId?: string) => {
       const targetId = tabsetId ?? getBaseLayout().focusedTabsetId;
@@ -2615,13 +2627,29 @@ const RightSidebarComponent: React.FC<RightSidebarProps> = ({
             {/* Resize handle (left edge); full-screen mode has nothing to resize. */}
             {onStartResize && !fullscreen && (
               <div
+                data-sidebar-resize-handle=""
                 className={cn(
-                  "w-0.5 flex-shrink-0 z-10 transition-[background] duration-150 cursor-col-resize",
-                  isResizing ? "bg-accent" : "bg-border-light hover:bg-accent"
+                  // touch-none: a touch drag on the handle resizes instead of panning the page.
+                  "group/resize z-10 flex w-0.5 flex-shrink-0 cursor-col-resize touch-none justify-center",
+                  // A 2px line is too thin to grab with a finger, and iPads report a coarse
+                  // pointer even with a trackpad: coarse pointers get a wider strip with a grip.
+                  // The sidebar's divider line moves to the strip's right edge (SidebarContainer
+                  // drops its own), so the tab strip's bottom border still meets it.
+                  "[@media(pointer:coarse)]:border-border-light [@media(pointer:coarse)]:w-3 [@media(pointer:coarse)]:border-r"
                 )}
-                // eslint-disable-next-line local/no-chained-type-assertions -- grandfathered when the rule was introduced; fix the underlying type instead of copying this pattern
-                onMouseDown={(e) => onStartResize(e as unknown as React.MouseEvent)}
-              />
+                onPointerDown={onStartResize}
+              >
+                <span
+                  aria-hidden="true"
+                  className={cn(
+                    "w-full transition-[background] duration-150",
+                    "[@media(pointer:coarse)]:my-auto [@media(pointer:coarse)]:h-10 [@media(pointer:coarse)]:w-1 [@media(pointer:coarse)]:rounded-full",
+                    isResizing
+                      ? "bg-accent"
+                      : "bg-border-light group-hover/resize:bg-accent [@media(pointer:coarse)]:bg-border-darker"
+                  )}
+                />
+              </div>
             )}
 
             <div className="flex min-h-0 min-w-0 flex-1 flex-col">
diff --git a/src/browser/features/RightSidebar/RightSidebarTabStrip.stories.tsx b/src/browser/features/RightSidebar/RightSidebarTabStrip.stories.tsx
index 608a5ab33e2..d9fb8277846 100644
--- a/src/browser/features/RightSidebar/RightSidebarTabStrip.stories.tsx
+++ b/src/browser/features/RightSidebar/RightSidebarTabStrip.stories.tsx
@@ -12,7 +12,11 @@ import {
 import { createWorkspace } from "@/browser/stories/mocks/workspaces";
 import { PIXEL_DISABLED } from "@/browser/stories/meta.js";
 import type { TabType } from "@/browser/types/rightSidebar";
-import { MOBILE_TOUCH_TARGET_PX } from "@/constants/layout";
+import {
+  MOBILE_TOUCH_TARGET_PX,
+  NARROW_VIEWPORT_MAX_WIDTH_PX,
+  TABLET_TOUCH_TARGET_PX,
+} from "@/constants/layout";
 import { RightSidebarTabStrip, type RightSidebarTabStripItem } from "./RightSidebarTabStrip";
 import {
   NewTabLabel,
@@ -37,19 +41,16 @@ const METADATA: WorkspaceMetadataContextValue = {
   loadError: null,
 };
 
-function StripFixture(props: { width: number; collapsible: boolean }) {
+function StripFixture(props: { width: number; collapsible: boolean; tabs?: TabType[] }) {
   const sensors = useSensors(useSensor(PointerSensor, { activationConstraint: { distance: 8 } }));
-  const [selected, setSelected] = useState<TabType>("new");
+  const [selected, setSelected] = useState<TabType>(props.tabs?.[0] ?? "new");
   const [closed, setClosed] = useState<TabType[]>([]);
-  const [order, setOrder] = useState<TabType[]>([
-    "new",
-    "instructions",
-    "side:side-title",
-    "terminal:long-title",
-  ]);
+  const [order, setOrder] = useState<TabType[]>(
+    props.tabs ?? ["new", "instructions", "side:side-title", "terminal:long-title"]
+  );
   const close = (tab: TabType) => setClosed((prev) => [...prev, tab]);
   const definitions: Array<
-    Pick<RightSidebarTabStripItem, "tab" | "label" | "tooltip" | "closeLabel">
+    Pick<RightSidebarTabStripItem, "tab" | "label" | "menuLabel" | "tooltip" | "closeLabel">
   > = [
     { tab: "new", label: <NewTabLabel />, tooltip: "Open a tool", closeLabel: "Close New tab" },
     {
@@ -66,6 +67,7 @@ function StripFixture(props: { width: number; collapsible: boolean }) {
           onClose={() => close("side:side-title")}
         />
       ),
+      menuLabel: <SideChatTabLabel workspaceId={SIDE_WORKSPACE.id} />,
       tooltip: <SideChatTabTitle workspaceId={SIDE_WORKSPACE.id} />,
     },
     {
@@ -78,6 +80,7 @@ function StripFixture(props: { width: number; collapsible: boolean }) {
           onClose={() => close("terminal:long-title")}
         />
       ),
+      menuLabel: <TerminalTabLabel dynamicTitle={LONG_TITLE} terminalIndex={0} />,
       tooltip: LONG_TITLE,
     },
   ];
@@ -119,7 +122,12 @@ function StripFixture(props: { width: number; collapsible: boolean }) {
               <RightSidebarTabStrip
                 items={items}
                 tabsetId="fixture"
-                onAddNewTab={() => setSelected("new")}
+                onAddNewTab={() => {
+                  // Like the sidebar: show the New tab, adding it first when the strip has none.
+                  setOrder((prev) => (prev.includes("new") ? prev : [...prev, "new"]));
+                  setClosed((prev) => prev.filter((tab) => tab !== "new"));
+                  setSelected("new");
+                }}
                 onCollapseSidebar={props.collapsible ? () => undefined : undefined}
               />
             </SortableContext>
@@ -175,12 +183,17 @@ async function checkStableControls(canvasElement: HTMLElement) {
     await expect(closeRect.bottom).toBeLessThanOrEqual(rowRect.bottom);
     // Pixel does not emulate touch. This contract also runs in a coarse-pointer browser at
     // phone and wide tablet widths: static/New targets must fit even beyond mobile CSS's cap.
+    // Phones get the 44px touch floor. Tablets keep desktop-height rows (44px rows made the
+    // strip far taller than the header), so their X only has to meet the 24px minimum.
     if (
       window.matchMedia("(pointer: coarse)").matches &&
       ["new", "instructions"].includes(tab.id)
     ) {
-      await expect(closeRect.width).toBeGreaterThanOrEqual(MOBILE_TOUCH_TARGET_PX);
-      await expect(closeRect.height).toBeGreaterThanOrEqual(MOBILE_TOUCH_TARGET_PX);
+      const minTarget = window.matchMedia(`(max-width: ${NARROW_VIEWPORT_MAX_WIDTH_PX}px)`).matches
+        ? MOBILE_TOUCH_TARGET_PX
+        : TABLET_TOUCH_TARGET_PX;
+      await expect(closeRect.width).toBeGreaterThanOrEqual(minTarget);
+      await expect(closeRect.height).toBeGreaterThanOrEqual(minTarget);
     }
     const text = label.querySelector("span.truncate") ?? label;
     await expect(text.getBoundingClientRect().right).toBeLessThanOrEqual(
@@ -201,20 +214,19 @@ async function checkStableControls(canvasElement: HTMLElement) {
   await expect(canvas.getAllByText(LONG_TITLE).length).toBeGreaterThanOrEqual(2);
 }
 
-/** "+" follows the last tab; tabs that overflow scroll in their row without pushing it away. */
-async function checkNewTabButton(canvasElement: HTMLElement, overflowing: boolean) {
+/** Tabs that overflow scroll in their row without pushing All tabs out of the strip. */
+async function checkAllTabsButton(canvasElement: HTMLElement, overflowing: boolean) {
   const canvas = within(canvasElement);
   const row = canvas.getByRole("tablist");
   const tabs = within(row).getAllByRole("tab");
-  const plusButton = canvas.getByRole("button", { name: "New tab" });
-  const plus = plusButton.getBoundingClientRect();
+  const menuButton = canvas.getByRole("button", { name: "All tabs" });
+  const menu = menuButton.getBoundingClientRect();
   const rowRect = row.getBoundingClientRect();
   await expect(row.scrollWidth > row.clientWidth).toBe(overflowing);
-  await expect(plus.left - rowRect.right).toBeGreaterThanOrEqual(0);
-  await expect(plus.left - rowRect.right).toBeLessThanOrEqual(8);
-  await expect(plus.right).toBeLessThanOrEqual(row.parentElement!.getBoundingClientRect().right);
-  const hit = document.elementFromPoint(plus.left + plus.width / 2, plus.top + plus.height / 2);
-  await expect(hit != null && plusButton.contains(hit)).toBe(true);
+  await expect(menu.left - rowRect.right).toBeGreaterThanOrEqual(0);
+  await expect(menu.right).toBeLessThanOrEqual(row.parentElement!.getBoundingClientRect().right);
+  const hit = document.elementFromPoint(menu.left + menu.width / 2, menu.top + menu.height / 2);
+  await expect(hit != null && menuButton.contains(hit)).toBe(true);
   if (!overflowing) {
     await expect(rowRect.right - tabs[tabs.length - 1].getBoundingClientRect().right).toBeLessThan(
       1
@@ -222,34 +234,125 @@ async function checkNewTabButton(canvasElement: HTMLElement, overflowing: boolea
   }
 }
 
+async function openTabListMenu(canvasElement: HTMLElement): Promise<HTMLElement> {
+  await userEvent.click(within(canvasElement).getByRole("button", { name: "All tabs" }));
+  // The menu renders in a portal, outside the canvas.
+  return within(document.body).findByRole("dialog", { name: "All tabs" });
+}
+
+async function waitForTabListMenuClosed() {
+  await waitFor(() =>
+    expect(within(document.body).queryByRole("dialog", { name: "All tabs" })).toBeNull()
+  );
+}
+
+async function expectFullyInRow(row: HTMLElement, tab: HTMLElement) {
+  await waitFor(async () => {
+    const bounds = row.getBoundingClientRect();
+    const rect = tab.getBoundingClientRect();
+    await expect(rect.left).toBeGreaterThanOrEqual(bounds.left - 0.5);
+    await expect(rect.right).toBeLessThanOrEqual(bounds.right + 0.5);
+  });
+}
+
+/** A tab scrolled out of the row is one pick away in the All tabs menu, and so is the New tab. */
+async function checkTabListMenu(canvasElement: HTMLElement) {
+  const canvas = within(canvasElement);
+  const row = canvas.getByRole("tablist");
+  const tabs = within(row).getAllByRole("tab");
+  const [newTab, target] = tabs;
+  await userEvent.click(tabs[tabs.length - 1]);
+  await waitFor(() =>
+    expect(target.getBoundingClientRect().right).toBeLessThanOrEqual(
+      row.getBoundingClientRect().left
+    )
+  );
+
+  let menu = await openTabListMenu(canvasElement);
+  // One row per tab but the New tab, which the last row stands for.
+  const rows = within(menu).getAllByRole("button");
+  await expect(rows).toHaveLength(tabs.length);
+  await expect(rows[rows.length - 1]).toHaveAccessibleName("New tab");
+  // It opens on the selected (last) tab's row, like a select, and arrow keys move between rows.
+  const selectedRow = rows[rows.length - 2];
+  await waitFor(() => expect(selectedRow).toHaveFocus());
+  await expect(selectedRow).toHaveAttribute("aria-current", "true");
+  await userEvent.keyboard("{ArrowUp}");
+  await expect(rows[rows.length - 3]).toHaveFocus();
+  await userEvent.keyboard("{ArrowDown}{ArrowDown}");
+  await expect(rows[rows.length - 1]).toHaveFocus();
+
+  await userEvent.click(rows[0]);
+  await waitForTabListMenuClosed();
+  await expect(target).toHaveAttribute("aria-selected", "true");
+  // Focus moves to the picked tab, not back to the menu button.
+  await expect(target).toHaveFocus();
+  await expectFullyInRow(row, target);
+
+  menu = await openTabListMenu(canvasElement);
+  await userEvent.click(within(menu).getByRole("button", { name: "New tab" }));
+  await waitForTabListMenuClosed();
+  await expect(newTab).toHaveAttribute("aria-selected", "true");
+  await expectFullyInRow(row, newTab);
+}
+
 export const Narrow: Story = {
   // No collapse button, like the phone full-screen strip (the test-runner swipes this one at
   // phone width, see .storybook/test-runner.ts).
   args: { width: 300, collapsible: false },
   play: async ({ canvasElement }) => {
     await checkStableControls(canvasElement);
-    await checkNewTabButton(canvasElement, true);
+    await checkAllTabsButton(canvasElement, true);
+    await checkTabListMenu(canvasElement);
+  },
+};
+export const SingleTab: Story = {
+  // All tabs stays with one tab: its menu holds the New tab.
+  args: { width: 300, collapsible: true, tabs: ["instructions"] },
+  play: async ({ canvasElement }) => {
+    const canvas = within(canvasElement);
+    await expect(canvas.getAllByRole("tab")).toHaveLength(1);
+    await expect(canvas.getByRole("button", { name: "Collapse sidebar" })).toBeVisible();
+    const menu = await openTabListMenu(canvasElement);
+    await expect(within(menu).getAllByRole("button")).toHaveLength(2);
+    await userEvent.click(within(menu).getByRole("button", { name: "New tab" }));
+    await waitForTabListMenuClosed();
+    await expect(canvas.getAllByRole("tab")).toHaveLength(2);
+    await expect(canvas.getByRole("tab", { name: /^New tab/ })).toHaveAttribute(
+      "aria-selected",
+      "true"
+    );
   },
 };
 export const Wide: Story = {
-  // Wide enough for every tab beside "+" and the collapse button.
+  // Wide enough for every tab beside All tabs and the collapse button.
   args: { width: 1000, collapsible: true },
   play: async ({ canvasElement }) => {
     await checkStableControls(canvasElement);
-    await checkNewTabButton(canvasElement, false);
-    // The collapse button holds the strip's right end, past the free space after "+".
+    await checkAllTabsButton(canvasElement, false);
+    // All tabs and the collapse button hold the strip's right end, past the free space after
+    // the tabs. They are its only buttons outside the tabs: New tab lives in the All tabs menu.
     const canvas = within(canvasElement);
-    const plus = canvas.getByRole("button", { name: "New tab" }).getBoundingClientRect();
+    const tablist = canvas.getByRole("tablist");
+    const stripButtons = within(tablist.parentElement!)
+      .getAllByRole("button")
+      .filter((button) => !tablist.contains(button))
+      .map((button) => button.getAttribute("aria-label"));
+    await expect(stripButtons).toEqual(["All tabs", "Collapse sidebar"]);
+    const row = tablist.getBoundingClientRect();
+    const allTabs = canvas.getByRole("button", { name: "All tabs" }).getBoundingClientRect();
     const collapse = canvas
       .getByRole("button", { name: "Collapse sidebar" })
       .getBoundingClientRect();
-    const strip = canvas.getByRole("tablist").parentElement!.getBoundingClientRect();
-    await expect(collapse.left - plus.right).toBeGreaterThan(8);
+    const strip = tablist.parentElement!.getBoundingClientRect();
+    await expect(allTabs.left - row.right).toBeGreaterThan(8);
+    await expect(collapse.left - allTabs.right).toBeGreaterThanOrEqual(0);
+    await expect(collapse.left - allTabs.right).toBeLessThanOrEqual(8);
     await expect(strip.right - collapse.right).toBeLessThanOrEqual(9);
   },
 };
 export const Cramped: Story = {
-  // A split pane at its minimum width (15% of a 300 px sidebar) has no room for both buttons.
+  // A split pane at its minimum width (15% of a 300 px sidebar) has no room for all buttons.
   args: { width: 45, collapsible: true },
   play: async ({ canvasElement }) => {
     const canvas = within(canvasElement);
diff --git a/src/browser/features/RightSidebar/RightSidebarTabStrip.tsx b/src/browser/features/RightSidebar/RightSidebarTabStrip.tsx
index fa157ee4eb5..1db8fcbf604 100644
--- a/src/browser/features/RightSidebar/RightSidebarTabStrip.tsx
+++ b/src/browser/features/RightSidebar/RightSidebarTabStrip.tsx
@@ -1,16 +1,18 @@
 import React from "react";
 import { cn } from "@/common/lib/utils";
+import { Popover, PopoverContent, PopoverTrigger } from "@/browser/components/Popover/Popover";
 import { Tooltip, TooltipContent, TooltipTrigger } from "@/browser/components/Tooltip/Tooltip";
 import { useSortable } from "@dnd-kit/sortable";
 import { CSS } from "@dnd-kit/utilities";
 import { useDroppable, useDndContext } from "@dnd-kit/core";
-import { PanelRightClose, Plus, X } from "lucide-react";
-import type { TabType } from "@/browser/types/rightSidebar";
-import { formatKeybind, KEYBINDS } from "@/browser/utils/ui/keybinds";
+import { Check, ChevronDown, PanelRightClose, X } from "lucide-react";
+import { isNewTab, type TabType } from "@/browser/types/rightSidebar";
+import { formatKeybind, formatKeybindForAria, KEYBINDS } from "@/browser/utils/ui/keybinds";
 import {
   isDesktopMode,
   DESKTOP_TITLEBAR_MIN_HEIGHT_CLASS,
 } from "@/browser/hooks/useDesktopTitlebar";
+import { NewTabLabel } from "./Tabs/TabLabels";
 
 // Re-export for consumers that import from this file
 export { getTabName } from "./Tabs";
@@ -39,6 +41,8 @@ export interface RightSidebarTabStripItem {
    * close button (terminal, side chat), so the tab never shows two.
    */
   closeLabel?: string;
+  /** Row content in the All tabs menu when `label` holds buttons of its own. Default: `label`. */
+  menuLabel?: React.ReactNode;
 }
 
 interface RightSidebarTabStripProps {
@@ -46,8 +50,8 @@ interface RightSidebarTabStripProps {
   ariaLabel?: string;
   /** Unique ID of this tabset (for drag/drop) */
   tabsetId: string;
-  /** Called when user clicks the "+" button to open (or show) this tabset's New tab */
-  onAddNewTab?: () => void;
+  /** The All tabs menu's New tab row: open (or show) this tabset's New tab */
+  onAddNewTab: () => void;
   /** Collapses the sidebar. Only the strip at the sidebar's top-right corner gets it. */
   onCollapseSidebar?: () => void;
 }
@@ -95,11 +99,12 @@ const SortableTab: React.FC<{
               "cursor-grab touch-pan-x active:cursor-grabbing",
               // Reserve the X's space even while hidden: hovering/focusing/selecting a tab must
               // neither cover its text nor change its label width (especially for long titles).
-              // Coarse pointers need the larger target even on tablets wide enough to show
-              // the sidebar; reserve matching row height/padding so it never clips or covers text.
+              // Phones reserve row height/padding for the 44px touch X. Tablets keep the desktop
+              // row height (44px rows made the strip far taller than the header) and reserve
+              // the X's 24px touch target.
               item.closeLabel != null &&
                 item.onClose &&
-                "pr-6 [@media(pointer:coarse)]:min-h-11 [@media(pointer:coarse)]:pr-12",
+                "pr-6 [@media(min-width:769px)_and_(pointer:coarse)]:pr-7 [@media(max-width:768px)_and_(pointer:coarse)]:min-h-11 [@media(max-width:768px)_and_(pointer:coarse)]:pr-12",
               item.selected
                 ? "bg-hover text-foreground"
                 : "bg-transparent text-muted hover:bg-hover/50 hover:text-foreground",
@@ -174,9 +179,10 @@ const TabCloseButton: React.FC<{
   <button
     type="button"
     className={cn(
-      // Touch grows the X to a 44px target. Its fill would then paint a 44px grey square beside
-      // every unselected tab label, so touch keeps the larger target but drops the fill.
-      "text-muted hover:text-foreground absolute right-1 top-1/2 flex -translate-y-1/2 items-center justify-center rounded p-0.5 [@media(pointer:coarse)]:min-h-11 [@media(pointer:coarse)]:min-w-11 [@media(pointer:coarse)]:bg-transparent",
+      // Touch grows the X to a 24px target (44px on phones, from the global phone floor). Its
+      // fill would then paint a grey square beside every unselected tab label, so touch keeps
+      // the larger target but drops the fill.
+      "text-muted hover:text-foreground absolute right-1 top-1/2 flex -translate-y-1/2 items-center justify-center rounded p-0.5 [@media(pointer:coarse)]:min-h-6 [@media(pointer:coarse)]:min-w-6 [@media(pointer:coarse)]:bg-transparent",
       props.selected
         ? "bg-hover"
         : "bg-hover invisible group-focus-within:visible group-hover:visible [@media(pointer:coarse)]:visible"
@@ -196,13 +202,21 @@ export function isSidebarControlTarget(target: EventTarget): boolean {
   return target instanceof Element && target.closest("[data-sidebar-control]") != null;
 }
 
-/** Icon button after the tabs ("+", collapse). */
+/**
+ * Icon buttons after the tabs (All tabs, collapse). Coarse pointers get a 24px target:
+ * tablets have no global touch floor (phones get 44px from it).
+ */
+function stripIconButtonClassName(isDesktop: boolean): string {
+  return cn(
+    "text-muted hover:bg-hover hover:text-foreground focus-visible:ring-accent flex shrink-0 items-center justify-center rounded-md p-1 transition-colors focus-visible:ring-1 [@media(pointer:coarse)]:min-h-6 [@media(pointer:coarse)]:min-w-6",
+    isDesktop && "titlebar-no-drag"
+  );
+}
+
 const StripIconButton: React.FC<{
   label: string;
-  shortcut?: string;
   isDesktop: boolean;
   sidebarControl?: boolean;
-  className?: string;
   onClick: () => void;
   children: React.ReactNode;
 }> = (props) => (
@@ -211,26 +225,165 @@ const StripIconButton: React.FC<{
       <button
         type="button"
         data-sidebar-control={props.sidebarControl ? "" : undefined}
-        className={cn(
-          "text-muted hover:bg-hover hover:text-foreground focus-visible:ring-accent flex shrink-0 items-center justify-center rounded-md p-1 transition-colors focus-visible:ring-1",
-          props.isDesktop && "titlebar-no-drag",
-          props.className
-        )}
+        className={stripIconButtonClassName(props.isDesktop)}
         onClick={props.onClick}
         aria-label={props.label}
       >
         {props.children}
       </button>
     </TooltipTrigger>
-    <TooltipContent side="bottom">
-      {props.label}
-      {props.shortcut != null && (
-        <span className="mobile-hide-shortcut-hints"> ({props.shortcut})</span>
-      )}
-    </TooltipContent>
+    <TooltipContent side="bottom">{props.label}</TooltipContent>
   </Tooltip>
 );
 
+const TAB_LIST_LABEL = "All tabs";
+
+/** Arrow keys move between the menu's rows, like a menu (Tab works too). */
+function handleTabListArrowKeys(event: React.KeyboardEvent<HTMLElement>): void {
+  if (event.key !== "ArrowDown" && event.key !== "ArrowUp") return;
+  event.preventDefault();
+  const rows = Array.from(event.currentTarget.querySelectorAll<HTMLElement>("button:enabled"));
+  const index = rows.findIndex((row) => row === document.activeElement);
+  const next = event.key === "ArrowDown" ? index + 1 : index - 1;
+  rows[Math.min(Math.max(next, 0), rows.length - 1)]?.focus();
+}
+
+/** A row of the All tabs menu; a check marks the selected tab. */
+const TabListMenuRow: React.FC<{
+  label: React.ReactNode;
+  selected: boolean;
+  disabled?: boolean;
+  keyShortcuts?: string;
+  onPick: () => void;
+  children?: React.ReactNode;
+}> = (props) => (
+  <button
+    type="button"
+    disabled={props.disabled}
+    aria-current={props.selected || undefined}
+    aria-keyshortcuts={props.keyShortcuts}
+    className="text-content-secondary hover:bg-hover focus:bg-hover flex w-full items-center gap-2 rounded-sm px-2 py-1.5 text-left text-xs outline-none disabled:opacity-50"
+    onClick={props.onPick}
+  >
+    <Check className={cn("h-3 w-3 shrink-0", !props.selected && "invisible")} />
+    <span className="flex min-w-0 items-center gap-1.5 truncate">{props.label}</span>
+    {props.children}
+  </button>
+);
+
+/**
+ * Lists every tab in the strip, so a tab scrolled out of the row is one pick away (a narrow
+ * pane shows only a tab or two, and touch users may not know the row scrolls). Its last row
+ * opens (or shows) the New tab, which therefore has no row among the tabs.
+ */
+const TabListMenu: React.FC<{
+  items: RightSidebarTabStripItem[];
+  isDesktop: boolean;
+  onAddNewTab: () => void;
+}> = (props) => {
+  const [open, setOpen] = React.useState(false);
+  const [tooltipOpen, setTooltipOpen] = React.useState(false);
+  const contentRef = React.useRef<HTMLDivElement>(null);
+
+  const tabRows = props.items.filter((item) => !isNewTab(item.tab));
+  const newTabSelected = props.items.some((item) => isNewTab(item.tab) && item.selected);
+
+  // A pick moves focus out of the menu (to the tab, or into the New tab's launcher), so Radix
+  // does not send it back to this button on close.
+  const pick = (item: RightSidebarTabStripItem) => {
+    setOpen(false);
+    item.onSelect();
+    // The strip scrolls the selected tab into view itself; focus() would also scroll the
+    // sidebar's overflow-hidden ancestors.
+    document.getElementById(item.id)?.focus({ preventScroll: true });
+  };
+  const pickNewTab = () => {
+    setOpen(false);
+    props.onAddNewTab();
+  };
+
+  return (
+    <Popover open={open} onOpenChange={setOpen}>
+      <Tooltip open={tooltipOpen && !open} onOpenChange={setTooltipOpen}>
+        <TooltipTrigger asChild>
+          <PopoverTrigger asChild>
+            <button
+              type="button"
+              className={stripIconButtonClassName(props.isDesktop)}
+              aria-label={TAB_LIST_LABEL}
+            >
+              <ChevronDown className="h-3.5 w-3.5" />
+            </button>
+          </PopoverTrigger>
+        </TooltipTrigger>
+        <TooltipContent side="bottom">{TAB_LIST_LABEL}</TooltipContent>
+      </Tooltip>
+      <PopoverContent
+        ref={contentRef}
+        side="bottom"
+        align="end"
+        aria-label={TAB_LIST_LABEL}
+        className="max-h-(--radix-popover-content-available-height) w-max max-w-[min(20rem,calc(100vw-1rem))] !min-w-[10rem] overflow-y-auto p-1"
+        onOpenAutoFocus={(event) => {
+          // Open on the selected tab's row, like a select.
+          event.preventDefault();
+          contentRef.current?.querySelector<HTMLElement>('[aria-current="true"]')?.focus();
+        }}
+        onKeyDown={handleTabListArrowKeys}
+      >
+        {tabRows.map((item) => (
+          <TabListMenuRow
+            key={item.id}
+            label={item.menuLabel ?? item.label}
+            selected={item.selected}
+            disabled={item.disabled}
+            onPick={() => pick(item)}
+          />
+        ))}
+        {tabRows.length > 0 && (
+          <div role="separator" className="border-separator-light my-1 border-t" />
+        )}
+        <TabListMenuRow
+          label={<NewTabLabel />}
+          selected={newTabSelected}
+          keyShortcuts={formatKeybindForAria(KEYBINDS.NEW_SIDEBAR_TAB)}
+          onPick={pickNewTab}
+        >
+          {/* Screen readers get it from aria-keyshortcuts. Phones have no keyboard: hidden. */}
+          <span
+            aria-hidden="true"
+            className="text-muted mobile-hide-shortcut-hints ml-auto shrink-0 pl-2 text-[10px]"
+          >
+            ({formatKeybind(KEYBINDS.NEW_SIDEBAR_TAB)})
+          </span>
+        </TabListMenuRow>
+      </PopoverContent>
+    </Popover>
+  );
+};
+
+/** The strip's right end, past the free space after the tabs: All tabs and the collapse button. */
+const StripEndControls: React.FC<{
+  items: RightSidebarTabStripItem[];
+  isDesktop: boolean;
+  onAddNewTab: () => void;
+  onCollapseSidebar?: () => void;
+}> = (props) => (
+  <div className="ml-auto flex shrink-0 items-center gap-1">
+    <TabListMenu items={props.items} isDesktop={props.isDesktop} onAddNewTab={props.onAddNewTab} />
+    {props.onCollapseSidebar && (
+      <StripIconButton
+        label="Collapse sidebar"
+        isDesktop={props.isDesktop}
+        sidebarControl
+        onClick={props.onCollapseSidebar}
+      >
+        <PanelRightClose className="h-3.5 w-3.5" />
+      </StripIconButton>
+    )}
+  </div>
+);
+
 /** Width of the `.scroll-fade-x` edge fade (scrollbar-none.css): a tab under it looks cut off. */
 const SCROLL_FADE_PX = 24;
 
@@ -247,14 +400,18 @@ function revealSelectedTab(row: HTMLElement): void {
   const tabStart = tabRect.left - rowRect.left + row.scrollLeft;
   const tabEnd = tabStart + tabRect.width;
   const maxScroll = row.scrollWidth - row.clientWidth;
+  // A tab too wide for both fade margins gets smaller ones, so it fits whole (its X included)
+  // when the row can hold it. A tab wider than the row keeps its start clear of the fade.
+  const spare = row.clientWidth - tabRect.width;
+  const margin = spare < 0 ? SCROLL_FADE_PX : Math.min(SCROLL_FADE_PX, spare / 2);
   let next = row.scrollLeft;
   // A fade only shows on a side with more content past it, so the first and last tabs need
   // no margin (the clamp below lets them reach the very edge).
-  if (tabEnd + SCROLL_FADE_PX > row.scrollLeft + row.clientWidth) {
-    next = tabEnd + SCROLL_FADE_PX - row.clientWidth;
+  if (tabEnd + margin > row.scrollLeft + row.clientWidth) {
+    next = tabEnd + margin - row.clientWidth;
   }
-  if (tabStart - SCROLL_FADE_PX < next) {
-    next = tabStart - SCROLL_FADE_PX;
+  if (tabStart - margin < next) {
+    next = tabStart - margin;
   }
   next = Math.max(0, Math.min(maxScroll, next));
   if (Math.abs(next - row.scrollLeft) >= 1) row.scrollLeft = next;
@@ -312,9 +469,9 @@ export const RightSidebarTabStrip: React.FC<RightSidebarTabStripProps> = ({
         // Capped inset: the tabs live in one scrolling row, so the full overlay inset on a
         // narrow pane would shrink that row to zero and hide every tab.
         "border-border-light titlebar-safe-right-capped titlebar-safe-right-gutter-2 flex min-w-0 items-center gap-1 border-b px-2 py-1.5 transition-colors",
-        // With the collapse button, a pane at its minimum width cannot fit both buttons: overflow
+        // With the collapse button, a pane at its minimum width cannot fit all buttons: overflow
         // on the left (the Panel clips it) so the collapse button stays visible. With room to
-        // spare, the collapse button's ml-auto takes the free space and this has no effect.
+        // spare, the right-end group's ml-auto takes the free space and this has no effect.
         "has-[[data-sidebar-control]]:justify-end",
         isDesktop && DESKTOP_TITLEBAR_MIN_HEIGHT_CLASS,
         showDropHighlight && "bg-accent/30",
@@ -323,9 +480,8 @@ export const RightSidebarTabStrip: React.FC<RightSidebarTabStripProps> = ({
         isDesktop && "titlebar-drag"
       )}
     >
-      {/* One row that never wraps: extra tabs scroll sideways (hidden scrollbar, faded edges).
-          It is only as wide as its tabs, so "+" follows the last tab; once they overflow, the
-          row shrinks and scrolls while "+", outside it, stays in view. */}
+      {/* One row that never wraps: extra tabs scroll sideways (hidden scrollbar, faded edges)
+          while the controls after it stay in view. */}
       <div
         ref={scrollRowRef}
         data-tab-scroll-row
@@ -343,28 +499,12 @@ export const RightSidebarTabStrip: React.FC<RightSidebarTabStripProps> = ({
           />
         ))}
       </div>
-      {onAddNewTab && (
-        <StripIconButton
-          label="New tab"
-          shortcut={formatKeybind(KEYBINDS.NEW_SIDEBAR_TAB)}
-          isDesktop={isDesktop}
-          onClick={onAddNewTab}
-        >
-          <Plus className="h-3.5 w-3.5" />
-        </StripIconButton>
-      )}
-      {onCollapseSidebar && (
-        <StripIconButton
-          label="Collapse sidebar"
-          isDesktop={isDesktop}
-          sidebarControl
-          // Above the phone breakpoint the global 44px touch floor does not apply.
-          className="ml-auto [@media(pointer:coarse)]:min-h-11 [@media(pointer:coarse)]:min-w-11"
-          onClick={onCollapseSidebar}
-        >
-          <PanelRightClose className="h-3.5 w-3.5" />
-        </StripIconButton>
-      )}
+      <StripEndControls
+        items={items}
+        isDesktop={isDesktop}
+        onAddNewTab={onAddNewTab}
+        onCollapseSidebar={onCollapseSidebar}
+      />
     </div>
   );
 };
diff --git a/src/browser/features/RightSidebar/Tabs/TabLabels.tsx b/src/browser/features/RightSidebar/Tabs/TabLabels.tsx
index 5c74478025f..cfa2193bbe3 100644
--- a/src/browser/features/RightSidebar/Tabs/TabLabels.tsx
+++ b/src/browser/features/RightSidebar/Tabs/TabLabels.tsx
@@ -375,32 +375,40 @@ export function SideChatTabTitle(props: { workspaceId: string }) {
   return <>{title != null && title.length > 0 ? title : SIDE_CHAT_INITIAL_TITLE}</>;
 }
 
-/** /side chats use their live chat title, just like regular chats; closing discards the chat. */
-export const SideChatTabLabel: React.FC<{ workspaceId: string; onClose: () => void }> = (props) => {
+/**
+ * /side chats use their live chat title, just like regular chats; closing discards the chat.
+ * Without onClose (the All tabs menu row) it renders no close button.
+ */
+export const SideChatTabLabel: React.FC<{ workspaceId: string; onClose?: () => void }> = (
+  props
+) => {
+  const onClose = props.onClose;
   return (
     <span className="inline-flex min-w-0 items-center gap-1">
       <MessagesSquare className="h-3 w-3 shrink-0" />
       <span className="min-w-0 truncate">
         <SideChatTabTitle workspaceId={props.workspaceId} />
       </span>
-      <Tooltip>
-        <TooltipTrigger asChild>
-          <button
-            type="button"
-            className="text-muted hover:text-destructive -my-0.5 shrink-0 rounded p-0.5 transition-colors"
-            onClick={(e) => {
-              e.stopPropagation();
-              props.onClose();
-            }}
-            aria-label="Close side chat"
-          >
-            <X className="h-3 w-3" />
-          </button>
-        </TooltipTrigger>
-        <TooltipContent side="bottom">
-          Close and discard side chat ({formatKeybind(KEYBINDS.CLOSE_TAB)})
-        </TooltipContent>
-      </Tooltip>
+      {onClose && (
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <button
+              type="button"
+              className="text-muted hover:text-destructive -my-0.5 shrink-0 rounded p-0.5 transition-colors"
+              onClick={(e) => {
+                e.stopPropagation();
+                onClose();
+              }}
+              aria-label="Close side chat"
+            >
+              <X className="h-3 w-3" />
+            </button>
+          </TooltipTrigger>
+          <TooltipContent side="bottom">
+            Close and discard side chat ({formatKeybind(KEYBINDS.CLOSE_TAB)})
+          </TooltipContent>
+        </Tooltip>
+      )}
     </span>
   );
 };
@@ -411,12 +419,15 @@ interface TerminalTabLabelProps {
   /** Terminal index (0-based) within the current tabset */
   terminalIndex: number;
   /** Callback when pop-out button is clicked */
-  onPopOut: () => void;
+  onPopOut?: () => void;
   /** Callback when close button is clicked */
-  onClose: () => void;
+  onClose?: () => void;
 }
 
-/** Terminal tab label with icon, dynamic title, and action buttons */
+/**
+ * Terminal tab label with icon, dynamic title, and action buttons. Without the callbacks (the
+ * All tabs menu row) it renders no buttons.
+ */
 export const TerminalTabLabel: React.FC<TerminalTabLabelProps> = ({
   dynamicTitle,
   terminalIndex,
@@ -429,40 +440,44 @@ export const TerminalTabLabel: React.FC<TerminalTabLabelProps> = ({
     <span className="inline-flex min-w-0 items-center gap-1">
       <TerminalIcon className="h-3 w-3 shrink-0" />
       <span className="max-w-[20ch] min-w-0 truncate">{displayName}</span>
-      <Tooltip>
-        <TooltipTrigger asChild>
-          <button
-            type="button"
-            className="text-muted hover:text-foreground -my-0.5 shrink-0 rounded p-0.5 transition-colors"
-            onClick={(e) => {
-              e.stopPropagation();
-              onPopOut();
-            }}
-            aria-label="Open terminal in new window"
-          >
-            <ExternalLink className="h-3 w-3" />
-          </button>
-        </TooltipTrigger>
-        <TooltipContent side="bottom">Open in new window</TooltipContent>
-      </Tooltip>
-      <Tooltip>
-        <TooltipTrigger asChild>
-          <button
-            type="button"
-            className="text-muted hover:text-destructive -my-0.5 shrink-0 rounded p-0.5 transition-colors"
-            onClick={(e) => {
-              e.stopPropagation();
-              onClose();
-            }}
-            aria-label="Close terminal"
-          >
-            <X className="h-3 w-3" />
-          </button>
-        </TooltipTrigger>
-        <TooltipContent side="bottom">
-          Close terminal ({formatKeybind(KEYBINDS.CLOSE_TAB)})
-        </TooltipContent>
-      </Tooltip>
+      {onPopOut && (
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <button
+              type="button"
+              className="text-muted hover:text-foreground -my-0.5 shrink-0 rounded p-0.5 transition-colors"
+              onClick={(e) => {
+                e.stopPropagation();
+                onPopOut();
+              }}
+              aria-label="Open terminal in new window"
+            >
+              <ExternalLink className="h-3 w-3" />
+            </button>
+          </TooltipTrigger>
+          <TooltipContent side="bottom">Open in new window</TooltipContent>
+        </Tooltip>
+      )}
+      {onClose && (
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <button
+              type="button"
+              className="text-muted hover:text-destructive -my-0.5 shrink-0 rounded p-0.5 transition-colors"
+              onClick={(e) => {
+                e.stopPropagation();
+                onClose();
+              }}
+              aria-label="Close terminal"
+            >
+              <X className="h-3 w-3" />
+            </button>
+          </TooltipTrigger>
+          <TooltipContent side="bottom">
+            Close terminal ({formatKeybind(KEYBINDS.CLOSE_TAB)})
+          </TooltipContent>
+        </Tooltip>
+      )}
     </span>
   );
 };
diff --git a/src/browser/hooks/useResizableSidebar.test.ts b/src/browser/hooks/useResizableSidebar.test.ts
index d5aef27b4b4..f987b8f8910 100644
--- a/src/browser/hooks/useResizableSidebar.test.ts
+++ b/src/browser/hooks/useResizableSidebar.test.ts
@@ -41,7 +41,7 @@ describe("resolveInitialResizableSidebarWidth", () => {
   });
 });
 
-describe("useResizableSidebar drag-to-collapse", () => {
+describe("useResizableSidebar drag", () => {
   let cleanupDom: (() => void) | null = null;
 
   beforeEach(() => {
@@ -68,13 +68,17 @@ describe("useResizableSidebar drag-to-collapse", () => {
       })
     );
     act(() => {
-      hook.result.current.startResize({ clientX: 1000 } as React.MouseEvent);
+      hook.result.current.startResize({ clientX: 1000, pointerId: 1 } as React.PointerEvent);
     });
-    const dragTo = (clientX: number) =>
+    const dragTo = (clientX: number, pointerId = 1) =>
       act(() => {
-        document.dispatchEvent(new window.MouseEvent("mousemove", { clientX }));
+        document.dispatchEvent(new window.PointerEvent("pointermove", { clientX, pointerId }));
       });
-    return { hook, dragTo };
+    const endDrag = (type: "pointerup" | "pointercancel", pointerId = 1) =>
+      act(() => {
+        document.dispatchEvent(new window.PointerEvent(type, { pointerId }));
+      });
+    return { hook, dragTo, endDrag };
   }
 
   test("snaps closed past half the minimum width and reopens when dragged back", () => {
@@ -104,4 +108,23 @@ describe("useResizableSidebar drag-to-collapse", () => {
     dragTo(1400);
     expect(hook.result.current.width).toBe(300);
   });
+
+  test("follows only the pointer that grabbed the handle", () => {
+    const { hook, dragTo, endDrag } = renderSidebar();
+    // A second finger moving or lifting elsewhere neither resizes nor ends the drag.
+    dragTo(900, 2);
+    endDrag("pointerup", 2);
+    expect(hook.result.current.width).toBe(400);
+    dragTo(900);
+    expect(hook.result.current.width).toBe(500);
+  });
+
+  test("a cancelled touch ends the drag", () => {
+    const { hook, dragTo, endDrag } = renderSidebar();
+    dragTo(950);
+    endDrag("pointercancel");
+    expect(hook.result.current.isResizing).toBe(false);
+    dragTo(800);
+    expect(hook.result.current.width).toBe(450);
+  });
 });
diff --git a/src/browser/hooks/useResizableSidebar.ts b/src/browser/hooks/useResizableSidebar.ts
index 243215854ee..61c1feef3db 100644
--- a/src/browser/hooks/useResizableSidebar.ts
+++ b/src/browser/hooks/useResizableSidebar.ts
@@ -2,8 +2,9 @@
  * useResizableSidebar - Custom hook for drag-based sidebar resizing
  *
  * Provides encapsulated resize logic without wrapping DOM elements, preserving
- * existing scroll container hierarchy. Uses global mouse listeners during drag
- * to track cursor position regardless of where the mouse moves.
+ * existing scroll container hierarchy. Uses global pointer listeners during drag
+ * to track the pointer regardless of where it moves. Pointer events (not mouse events) so a
+ * finger or pen can drag the handle too: touch drags never fire mousemove.
  *
  * Design principles:
  * - No interference with scroll containers or flex layout
@@ -60,8 +61,8 @@ interface UseResizableSidebarResult {
   width: number;
   /** Whether user is actively dragging the resize handle */
   isResizing: boolean;
-  /** Function to call on handle mouseDown to initiate resize */
-  startResize: (e: React.MouseEvent) => void;
+  /** Function to call on handle pointerDown to initiate resize */
+  startResize: (e: React.PointerEvent) => void;
   /** Placeholder for type compatibility (not used in render) */
   ResizeHandle: React.FC;
 }
@@ -112,6 +113,46 @@ function resolveResizeDrag(args: {
   };
 }
 
+/**
+ * While `active`, follows the pointer that started the drag anywhere on the page (document
+ * listeners), so the drag continues after the pointer leaves the handle. Other fingers on a touch
+ * screen neither move nor end the drag. The browser cancels a touch it takes over (e.g. a system
+ * gesture) and sends no pointerup, so pointercancel ends the drag too.
+ */
+function useResizeDragListeners(args: {
+  active: boolean;
+  pointerIdRef: React.RefObject<number | null>;
+  onMove: (event: PointerEvent) => void;
+  onEnd: () => void;
+}): void {
+  const { active, pointerIdRef, onMove, onEnd } = args;
+  useEffect(() => {
+    if (!active) return;
+
+    const handleMove = (event: PointerEvent) => {
+      if (event.pointerId === pointerIdRef.current) onMove(event);
+    };
+    const handleEnd = (event: PointerEvent) => {
+      if (event.pointerId === pointerIdRef.current) onEnd();
+    };
+    document.addEventListener("pointermove", handleMove);
+    document.addEventListener("pointerup", handleEnd);
+    document.addEventListener("pointercancel", handleEnd);
+
+    // Prevent text selection and show resize cursor globally during drag
+    document.body.style.userSelect = "none";
+    document.body.style.cursor = "col-resize";
+
+    return () => {
+      document.removeEventListener("pointermove", handleMove);
+      document.removeEventListener("pointerup", handleEnd);
+      document.removeEventListener("pointercancel", handleEnd);
+      document.body.style.userSelect = "";
+      document.body.style.cursor = "";
+    };
+  }, [active, pointerIdRef, onMove, onEnd]);
+}
+
 export function useResizableSidebar({
   enabled,
   defaultWidth,
@@ -156,7 +197,8 @@ export function useResizableSidebar({
   const [isResizing, setIsResizing] = useState(false);
 
   // Refs to track drag state without causing re-renders
-  const startXRef = useRef<number>(0); // Mouse X position when drag started
+  const pointerIdRef = useRef<number | null>(null); // Pointer that started the drag
+  const startXRef = useRef<number>(0); // Pointer X position when drag started
   const startWidthRef = useRef<number>(0); // Sidebar width when drag started
   // Whether the current drag has snapped the sidebar closed; reset on every drag start.
   const dragCollapsedRef = useRef(false);
@@ -248,17 +290,15 @@ export function useResizableSidebar({
   }, [isResizing, minWidth, resolveMaxWidthPx]);
 
   /**
-   * Handle mouse movement during drag.
-   * Calculates new width based on horizontal mouse delta from start position.
+   * Handle pointer movement during drag.
+   * Calculates new width based on horizontal pointer delta from start position.
    *
-   * Width grows as mouse moves:
+   * Width grows as the pointer moves:
    * - left for right-side sidebars
    * - right for left-side sidebars
    */
-  const handleMouseMove = useCallback(
-    (e: MouseEvent) => {
-      if (!isResizing) return;
-
+  const handlePointerMove = useCallback(
+    (e: PointerEvent) => {
       const deltaX =
         side === "right" ? startXRef.current - e.clientX : e.clientX - startXRef.current;
 
@@ -278,49 +318,34 @@ export function useResizableSidebar({
       // the size the user had, not the clamped minimum the drag passed through.
       setWidth(result.collapsed ? startWidthRef.current : result.width);
     },
-    [isResizing, minWidth, side, resolveMaxWidthPx]
+    [minWidth, side, resolveMaxWidthPx]
   );
 
   /**
-   * Handle mouse up to end drag session
+   * Handle pointer up (or a cancelled touch) to end drag session
    * Width is already persisted via useEffect, just need to clear drag state
    */
-  const handleMouseUp = useCallback(() => {
+  const handlePointerEnd = useCallback(() => {
     setIsResizing(false);
   }, []);
 
-  /**
-   * Attach/detach global mouse listeners during drag
-   * Using document-level listeners ensures we track mouse even if it leaves
-   * the resize handle area during drag (critical for smooth UX)
-   */
-  useEffect(() => {
-    if (!isResizing) return;
-
-    document.addEventListener("mousemove", handleMouseMove);
-    document.addEventListener("mouseup", handleMouseUp);
-
-    // Prevent text selection and show resize cursor globally during drag
-    document.body.style.userSelect = "none";
-    document.body.style.cursor = "col-resize";
-
-    return () => {
-      document.removeEventListener("mousemove", handleMouseMove);
-      document.removeEventListener("mouseup", handleMouseUp);
-      document.body.style.userSelect = "";
-      document.body.style.cursor = "";
-    };
-  }, [isResizing, handleMouseMove, handleMouseUp]);
+  useResizeDragListeners({
+    active: isResizing,
+    pointerIdRef,
+    onMove: handlePointerMove,
+    onEnd: handlePointerEnd,
+  });
 
   /**
    * Initiate drag session
-   * Called by resize handle's onMouseDown event
+   * Called by resize handle's onPointerDown event
    * Records starting position and width for delta calculations
    */
   const startResize = useCallback(
-    (e: React.MouseEvent) => {
+    (e: React.PointerEvent) => {
       if (!enabled) return;
       setIsResizing(true);
+      pointerIdRef.current = e.pointerId;
       startXRef.current = e.clientX;
       startWidthRef.current = width;
       dragCollapsedRef.current = false;
diff --git a/src/browser/stories/App.phoneSidebarFullscreen.stories.tsx b/src/browser/stories/App.phoneSidebarFullscreen.stories.tsx
index dc903272c0e..de68d72f60e 100644
--- a/src/browser/stories/App.phoneSidebarFullscreen.stories.tsx
+++ b/src/browser/stories/App.phoneSidebarFullscreen.stories.tsx
@@ -25,7 +25,7 @@ import { createAsyncMessageQueue } from "@/common/utils/asyncMessageQueue";
 import { setupSimpleChatStory } from "./helpers/chatSetup";
 import { appMeta, AppWithMocks, PIXEL_DISABLED, type AppStory } from "./meta.js";
 import { createAssistantMessage, createUserMessage } from "./mocks/messages";
-import { waitForChatInputAutofocusDone } from "./storyPlayHelpers.js";
+import { openSidebarNewTab, waitForChatInputAutofocusDone } from "./storyPlayHelpers.js";
 
 export default {
   ...appMeta,
@@ -166,7 +166,7 @@ export const FullScreenFromWorkspaceMenu: AppStory = {
     await expect(sidebar.contains(document.activeElement)).toBe(true);
 
     // Its New tab launcher opens the tools that have no tab yet, Browser among them.
-    await userEvent.click(within(sidebar).getByRole("button", { name: "New tab" }));
+    await openSidebarNewTab(sidebar);
     await userEvent.click(await within(sidebar).findByRole("button", { name: /^Browser/ }));
     await expect(within(sidebar).getByRole("tab", { name: /Browser/ })).toHaveAttribute(
       "aria-selected",
diff --git a/src/browser/stories/App.seededWorkspaceA11y.stories.tsx b/src/browser/stories/App.seededWorkspaceA11y.stories.tsx
index 5c9f009d5ba..ba1e3d9d8fd 100644
--- a/src/browser/stories/App.seededWorkspaceA11y.stories.tsx
+++ b/src/browser/stories/App.seededWorkspaceA11y.stories.tsx
@@ -85,7 +85,7 @@ async function expectOneMainLandmark(canvasElement: HTMLElement) {
   await expect(within(mains[0]).queryByRole("contentinfo")).toBeNull();
 }
 
-/** Space between the right sidebar's tabs and the "+" button. */
+/** Space between the right sidebar's tab row and the All tabs button. */
 const TAB_GAP_PX = 4;
 
 /** WCAG 2.2 target-size minimum (Lighthouse `target-size`). */
@@ -98,7 +98,7 @@ async function expectSeededPageAudits(canvasElement: HTMLElement) {
   const composer = await canvas.findByRole("textbox", { name: "Message" }, { timeout: 15_000 });
   await expect(composer).not.toHaveAttribute("aria-expanded");
 
-  // aria-required-children: the tablist owns only tabs. The "+" button stays next to it.
+  // aria-required-children: the tablist owns only tabs. The All tabs button stays next to it.
   const tablist = await canvas.findByRole("tablist", { name: "Sidebar views" });
   await expect(within(tablist).getAllByRole("tab").length).toBeGreaterThan(0);
   const nonTabChildren = Array.from(
@@ -109,18 +109,18 @@ async function expectSeededPageAudits(canvasElement: HTMLElement) {
   await expect(nonTabChildren).toEqual([]);
   const tabStrip = tablist.parentElement;
   if (!tabStrip) throw new Error("Tab strip not rendered");
-  const addTab = within(tabStrip).getByRole("button", { name: "New tab" });
-  // The launcher replaces direct terminal creation but must remain outside the tablist.
+  const allTabs = within(tabStrip).getByRole("button", { name: "All tabs" });
   // The sidebar fades in, so wait for it before checking visibility.
-  await waitFor(() => expect(addTab).toBeVisible());
+  await waitFor(() => expect(allTabs).toBeVisible());
   // The tablist renders its own box: Safari has dropped the role of `display: contents`
   // elements, which have no client rects (#5962).
   await expect(tablist.getClientRects().length).toBeGreaterThan(0);
-  // The launcher stays beside the scrolling row, not after an offscreen last tab.
+  // It stays beside the scrolling row, not after an offscreen last tab.
   const row = tablist.getBoundingClientRect();
-  const add = addTab.getBoundingClientRect();
-  await expect(Math.abs(add.left - (row.right + TAB_GAP_PX))).toBeLessThan(1);
-  await expect(Math.abs(add.top + add.height / 2 - (row.top + row.height / 2))).toBeLessThan(1);
+  const menu = allTabs.getBoundingClientRect();
+  await expect(menu.left).toBeGreaterThanOrEqual(row.right + TAB_GAP_PX - 1);
+  await expect(menu.right).toBeLessThanOrEqual(tabStrip.getBoundingClientRect().right);
+  await expect(Math.abs(menu.top + menu.height / 2 - (row.top + row.height / 2))).toBeLessThan(1);
 
   // button-name: icon-only and combobox triggers need a name of their own.
   await expect(await canvas.findByRole("button", { name: "Open in editor" })).toBeVisible();
@@ -152,8 +152,8 @@ export const Dark = contractStory("dark");
 
 /**
  * Narrowest right sidebar (#5962). The right sidebar is hidden at phone width, so its narrowest
- * real layout is the minimum sidebar width. Open tabs scroll within one row while "+" stays
- * visible beside it; neither the row nor the launcher may overflow the sidebar.
+ * real layout is the minimum sidebar width. Open tabs scroll within one row while All tabs stays
+ * visible beside it; neither may overflow the sidebar.
  */
 const NARROW_SIDEBAR_WIDTH_PX = 300;
 
@@ -195,26 +195,27 @@ const narrowSidebarStory = (theme: ThemeMode): AppStory => ({
     );
     await expect(tablist.getClientRects().length).toBeGreaterThan(0);
     const tabs = within(tablist).getAllByRole("tab");
-    const addTab = within(sidebar).getByRole("button", { name: "New tab" });
-    await waitFor(() => expect(addTab).toBeVisible());
+    const allTabs = within(sidebar).getByRole("button", { name: "All tabs" });
+    await waitFor(() => expect(allTabs).toBeVisible());
     const bounds = sidebar.getBoundingClientRect();
-    for (const element of [tablist, addTab]) {
+    for (const element of [tablist, allTabs]) {
       const rect = element.getBoundingClientRect();
       await expect(rect.left).toBeGreaterThanOrEqual(bounds.left);
       await expect(rect.right).toBeLessThanOrEqual(bounds.right);
     }
     await expect(tablist.scrollWidth).toBeGreaterThan(tablist.clientWidth);
     const rows = new Set(
-      [...tabs, addTab].map((element) => {
+      [...tabs, allTabs].map((element) => {
         const rect = element.getBoundingClientRect();
         return Math.round(rect.top + rect.height / 2);
       })
     );
     await expect(rows.size).toBe(1);
-    await expect(tablist).not.toContainElement(addTab);
+    await expect(tablist).not.toContainElement(allTabs);
+    // The overflowing row fills the strip up to All tabs.
     const row = tablist.getBoundingClientRect();
-    const add = addTab.getBoundingClientRect();
-    await expect(Math.abs(add.left - (row.right + TAB_GAP_PX))).toBeLessThan(1);
+    const menu = allTabs.getBoundingClientRect();
+    await expect(Math.abs(menu.left - (row.right + TAB_GAP_PX))).toBeLessThan(1);
   },
 });
 
diff --git a/src/browser/stories/storyPlayHelpers.ts b/src/browser/stories/storyPlayHelpers.ts
index e1e85bc172a..abaac53e4fe 100644
--- a/src/browser/stories/storyPlayHelpers.ts
+++ b/src/browser/stories/storyPlayHelpers.ts
@@ -1,5 +1,15 @@
 import { userEvent, waitFor, within } from "storybook/test";
 
+/**
+ * Open (or show) the New tab of the right sidebar pane inside `scope`: its strip offers it only
+ * as the last row of the All tabs menu, which renders in a portal outside `scope`.
+ */
+export async function openSidebarNewTab(scope: HTMLElement): Promise<void> {
+  await userEvent.click(await within(scope).findByRole("button", { name: "All tabs" }));
+  const menu = await within(scope.ownerDocument.body).findByRole("dialog", { name: "All tabs" });
+  await userEvent.click(within(menu).getByRole("button", { name: "New tab" }));
+}
+
 /**
  * Open Settings from the titlebar button and return the Settings dialog. The page behind the
  * modal stays mounted, so plays should query within the dialog rather than the whole canvas.
diff --git a/src/constants/layout.ts b/src/constants/layout.ts
index b4b7d3fded7..03be4e101f6 100644
--- a/src/constants/layout.ts
+++ b/src/constants/layout.ts
@@ -16,6 +16,10 @@ export const CHAT_DOCK_GUTTER_CLASS = "px-[15px]";
 // Minimum height globals.css gives touch targets on coarse-pointer viewports. Shared so tests can
 // reproduce that environment, which Storybook and Pixel cannot: neither emulates `pointer: coarse`.
 export const MOBILE_TOUCH_TARGET_PX = 44;
+// Touch target above the phone breakpoint (tablets), where globals.css sets no touch floor: the
+// WCAG 2.2 target-size minimum. The right sidebar tab strip's `[@media(pointer:coarse)]:min-h-6`
+// and `min-w-6` classes repeat this literal (Tailwind scans source text).
+export const TABLET_TOUCH_TARGET_PX = 24;
 
 // Width at or below which the app switches to its narrow layout (overlaying sidebar, PR badge in the
 // workspace header instead of the footer info bar). Tailwind arbitrary variants cannot read a TS
diff --git a/src/node/services/agentSkills/builtInSkillContent.generated.ts b/src/node/services/agentSkills/builtInSkillContent.generated.ts
index 62fd8bdc4c2..88bdfb909fa 100644
--- a/src/node/services/agentSkills/builtInSkillContent.generated.ts
+++ b/src/node/services/agentSkills/builtInSkillContent.generated.ts
@@ -4619,7 +4619,7 @@ export const BUILTIN_SKILL_FILES: Record<string, Record<string, string>> = {
       "| New right sidebar tab (lists the tools) | `Ctrl+Alt+N`   |",
       "| Close the right sidebar's active tab    | `Ctrl+W`       |",
       "",
-      "The right sidebar shows only the tabs you open. A new tab lists the tools it can show (Stats, Review, Instructions, Goal, Terminal, and more); pick one to open it in that tab's place.",
+      "The right sidebar shows only the tabs you open. A new tab lists the tools it can show (Stats, Review, Instructions, Goal, Terminal, and more); pick one to open it in that tab's place. The chevron at the right end of the tab strip lists your open tabs, with **New tab** at the bottom.",
       "",
       "### Command Palette",
       "",
diff --git a/tests/bugbash/repros/artifactsCloseFocus.e2e.ts b/tests/bugbash/repros/artifactsCloseFocus.e2e.ts
index e122561366b..2f987ad4127 100644
--- a/tests/bugbash/repros/artifactsCloseFocus.e2e.ts
+++ b/tests/bugbash/repros/artifactsCloseFocus.e2e.ts
@@ -16,7 +16,7 @@ test(
     await browser.keyboard.press("Control+Shift+K");
     await expect(screen.getByTestId("artifacts-panel")).toBeFocused();
 
-    // The issue's steps: Shift+Tab past the strip's Collapse sidebar and New tab buttons
+    // The issue's steps: Shift+Tab past the strip's Collapse sidebar and All tabs buttons
     // reaches the tab's X.
     await browser.keyboard.press("Shift+Tab");
     await browser.keyboard.press("Shift+Tab");
diff --git a/tests/bugbash/repros/phoneSidebarFullscreen.e2e.ts b/tests/bugbash/repros/phoneSidebarFullscreen.e2e.ts
index 87c159370d7..55bec0858ab 100644
--- a/tests/bugbash/repros/phoneSidebarFullscreen.e2e.ts
+++ b/tests/bugbash/repros/phoneSidebarFullscreen.e2e.ts
@@ -44,7 +44,8 @@ test(
     // sidebar, and its New tab launcher lists Side chat with the tools.
     await screen.getByRole("button", "Workspace actions").tap();
     await screen.getByRole("button", "Sidebar").tap();
-    await screen.getByRole("button", "New tab").tap();
+    await screen.getByRole("button", "All tabs").tap();
+    await screen.getByRole("dialog", "All tabs").getByRole("button", "New tab").tap();
     await expect(screen.getByRole("button", "Side chat")).toBeVisible();
   }
 );
diff --git a/tests/bugbash/repros/phoneStats.e2e.ts b/tests/bugbash/repros/phoneStats.e2e.ts
index 29f665727df..4725efb443b 100644
--- a/tests/bugbash/repros/phoneStats.e2e.ts
+++ b/tests/bugbash/repros/phoneStats.e2e.ts
@@ -1,6 +1,6 @@
 // #5767: at phone width the right sidebar is hidden, and with it the only way to open Stats.
 // Proves the workspace actions menu reaches Stats there: its Sidebar row shows the sidebar
-// full-screen, and the sidebar's New tab launcher opens Stats.
+// full-screen, and the sidebar's New tab launcher (from its All tabs menu) opens Stats.
 import { test } from "@e2e-dev/web";
 import { expect } from "e2e";
 import { openPlayground } from "./helpers";
@@ -16,7 +16,8 @@ test(
 
     await screen.getByRole("button", "Workspace actions").tap();
     await screen.getByRole("button", "Sidebar").tap();
-    await screen.getByRole("button", "New tab").tap();
+    await screen.getByRole("button", "All tabs").tap();
+    await screen.getByRole("dialog", "All tabs").getByRole("button", "New tab").tap();
     // The launcher row's name includes its description.
     await screen.getByRole("button", /^Stats\b/).tap();
     await expect(screen.getByRole("tab", /^Stats\b/)).toBeVisible();
diff --git a/tests/bugbash/repros/sidebarTabOrderReload.e2e.ts b/tests/bugbash/repros/sidebarTabOrderReload.e2e.ts
index ecffd18d3a3..a6a4e11ef76 100644
--- a/tests/bugbash/repros/sidebarTabOrderReload.e2e.ts
+++ b/tests/bugbash/repros/sidebarTabOrderReload.e2e.ts
@@ -17,11 +17,13 @@ test(
     const tablist = screen.getByRole("tablist", "Sidebar views");
     // The strip shows only opened tabs: open Artifacts, then Goal after it, from New tabs.
     for (const tool of ["Artifacts", "Goal"]) {
-      // The launcher button is a sibling of the tablist so the list owns only tabs.
+      // The All tabs button is a sibling of the tablist so the list owns only tabs. Its menu
+      // (a portal, outside the sidebar) ends with the New tab row.
       await screen
         .getByRole("complementary", "Workspace insights")
-        .getByRole("button", "New tab")
+        .getByRole("button", "All tabs")
         .tap();
+      await screen.getByRole("dialog", "All tabs").getByRole("button", "New tab").tap();
       await screen
         .getByRole("tabpanel", /^New tab/)
         .getByRole("button", tool)
diff --git a/tests/e2e/utils/ui.ts b/tests/e2e/utils/ui.ts
index 47c61fd73ed..562d56773d9 100644
--- a/tests/e2e/utils/ui.ts
+++ b/tests/e2e/utils/ui.ts
@@ -510,22 +510,25 @@ export function createWorkspaceUI(page: Page, context: DemoProjectConfig): Works
     },
   };
 
-  /** Open a tool from the right sidebar's New tab launcher ("+" first adds/shows the New tab). */
+  /**
+   * Open a tool from the right sidebar's New tab launcher. The New tab row at the bottom of the
+   * strip's All tabs menu first adds or shows the New tab.
+   */
   async function openFromNewTab(toolName: string): Promise<void> {
+    const sidebar = page.getByRole("complementary", { name: "Workspace insights" });
     // Tools are opt-in now: wait for either the collapsed expand action or the open strip.
     const expandButton = page.getByRole("button", { name: /^Expand (right )?sidebar$/ });
-    const addButton = page
-      .getByRole("complementary", { name: "Workspace insights" })
-      .getByRole("button", { name: "New tab", exact: true })
-      .first();
-    await expect(expandButton.or(addButton)).toBeVisible();
+    const menuButton = sidebar.getByRole("button", { name: "All tabs", exact: true }).first();
+    await expect(expandButton.or(menuButton)).toBeVisible();
     if (await expandButton.isVisible()) await expandButton.click();
-    await expect(addButton).toBeVisible();
-    await addButton.click();
-    const row = page
-      .getByRole("complementary", { name: "Workspace insights" })
-      .getByRole("tabpanel")
-      .getByRole("button", { name: toolName, exact: true });
+    await expect(menuButton).toBeVisible();
+    await menuButton.click();
+    // The menu renders in a portal, outside the sidebar.
+    await page
+      .getByRole("dialog", { name: "All tabs" })
+      .getByRole("button", { name: "New tab", exact: true })
+      .click();
+    const row = sidebar.getByRole("tabpanel").getByRole("button", { name: toolName, exact: true });
     await expect(row).toBeVisible();
     await row.click();
   }
@@ -550,7 +553,7 @@ export function createWorkspaceUI(page: Page, context: DemoProjectConfig): Works
     },
 
     async addTerminal(): Promise<void> {
-      // The sidebar's "+" opens a New tab; its launcher's Terminal row creates the terminal.
+      // A New tab's launcher (opened from the All tabs menu) has the Terminal row.
       await openFromNewTab("Terminal");
       // Wait for a terminal tab to appear (name may be "Terminal" or include cwd path)
       // and be selected. Only terminal tabs have a "Close terminal" button.
diff --git a/tests/ui/helpers.ts b/tests/ui/helpers.ts
index 01b2edc75ea..9889987d87b 100644
--- a/tests/ui/helpers.ts
+++ b/tests/ui/helpers.ts
@@ -27,6 +27,16 @@ export async function openAnalyticsDialog(container: HTMLElement): Promise<HTMLE
   return within(body).findByRole("dialog", { name: "Analytics" }, { timeout: 30000 });
 }
 
+/**
+ * Open (or show) the New tab of the right sidebar pane inside `scope`: its strip offers it only
+ * as the last row of the All tabs menu, which renders in a portal outside `scope`.
+ */
+export async function openSidebarNewTab(scope: HTMLElement): Promise<void> {
+  fireEvent.click(await within(scope).findByRole("button", { name: "All tabs" }));
+  const menu = await within(scope.ownerDocument.body).findByRole("dialog", { name: "All tabs" });
+  fireEvent.click(within(menu).getByRole("button", { name: "New tab" }));
+}
+
 // ═══════════════════════════════════════════════════════════════════════════════
 // REFRESH BUTTON HELPERS
 // ═══════════════════════════════════════════════════════════════════════════════
diff --git a/tests/ui/layout/leftSidebarResize.test.ts b/tests/ui/layout/leftSidebarResize.test.ts
index 62f4ef76195..88cb40991ae 100644
--- a/tests/ui/layout/leftSidebarResize.test.ts
+++ b/tests/ui/layout/leftSidebarResize.test.ts
@@ -68,9 +68,9 @@ describeIntegration("LeftSidebar (UI)", () => {
 
         expect(sidebar.style.width).toBe("288px");
 
-        fireEvent.mouseDown(handle, { clientX: 200 });
-        fireEvent.mouseMove(document, { clientX: 300 });
-        fireEvent.mouseUp(document);
+        fireEvent.pointerDown(handle, { clientX: 200 });
+        fireEvent.pointerMove(document, { clientX: 300 });
+        fireEvent.pointerUp(document);
 
         // +100px wider from default.
         await waitFor(() => expect(sidebar.style.width).toBe("388px"));
diff --git a/tests/ui/layout/rightSidebar.test.ts b/tests/ui/layout/rightSidebar.test.ts
index 2545244fc0f..c0883acc080 100644
--- a/tests/ui/layout/rightSidebar.test.ts
+++ b/tests/ui/layout/rightSidebar.test.ts
@@ -28,7 +28,7 @@ import type { FrontendWorkspaceMetadata } from "@/common/types/workspace";
 
 import { installDom } from "../dom";
 import { renderApp } from "../renderReviewPanel";
-import { cleanupView, setupWorkspaceView } from "../helpers";
+import { cleanupView, openSidebarNewTab, setupWorkspaceView } from "../helpers";
 import {
   RIGHT_SIDEBAR_COLLAPSED_KEY,
   RIGHT_SIDEBAR_TAB_KEY,
@@ -215,11 +215,9 @@ describeIntegration("RightSidebar (UI)", () => {
   const getTabs = (sidebar: HTMLElement) =>
     Array.from(sidebar.querySelectorAll<HTMLElement>('[role="tab"]'));
 
-  /** "+" opens the New tab; its launcher lists the tools. */
+  /** The All tabs menu's New tab row opens the New tab; its launcher lists the tools. */
   async function openLauncher(sidebar: HTMLElement): Promise<HTMLElement> {
-    fireEvent.click(
-      await findRequiredElement(sidebar, 'button[aria-label="New tab"]', "New tab button not found")
-    );
+    await openSidebarNewTab(sidebar);
     return findSidebarPanel(sidebar, "-panel-new");
   }
 
@@ -751,7 +749,7 @@ describeIntegration("RightSidebar (UI)", () => {
       fireEvent.click(reviewTab);
       await findSidebarPanel(sidebar, "review");
 
-      // Create a terminal via "+" (New tab) and its launcher, and verify its content
+      // Create a terminal from a New tab's launcher, and verify its content
       const terminalTab = await createTerminalTab(sidebar);
 
       await waitFor(() => {
@@ -799,9 +797,9 @@ describeIntegration("RightSidebar (UI)", () => {
       // Shrink slightly rather than grow so this test remains stable even when the initial
       // sidebar width is already clamped by the available shell width, while still keeping
       // the neighboring tabs visible.
-      fireEvent.mouseDown(resizeHandle, { clientX: 800 });
-      fireEvent.mouseMove(document, { clientX: 830 });
-      fireEvent.mouseUp(document);
+      fireEvent.pointerDown(resizeHandle, { clientX: 800 });
+      fireEvent.pointerMove(document, { clientX: 830 });
+      fireEvent.pointerUp(document);
 
       // Wait for width to change (resize should update inline style)
       await waitFor(() => {
@@ -873,9 +871,9 @@ describeIntegration("RightSidebar (UI)", () => {
       // Shrink slightly while on Review so the assertion is stable even when the sidebar
       // starts at the maximum width allowed by the current shell measurement, while still
       // leaving enough room for the tab strip itself.
-      fireEvent.mouseDown(resizeHandle, { clientX: 800 });
-      fireEvent.mouseMove(document, { clientX: 830 });
-      fireEvent.mouseUp(document);
+      fireEvent.pointerDown(resizeHandle, { clientX: 800 });
+      fireEvent.pointerMove(document, { clientX: 830 });
+      fireEvent.pointerUp(document);
 
       // Wait for width to change in UI
       await waitFor(() => {
@@ -908,9 +906,9 @@ describeIntegration("RightSidebar (UI)", () => {
       // Resize again on Costs tab (shrink).
       // The sidebar may already be clamped to its max width depending on the viewport,
       // so shrinking is the most reliable way to ensure a second drag produces a change.
-      fireEvent.mouseDown(resizeHandle, { clientX: 800 });
-      fireEvent.mouseMove(document, { clientX: 900 });
-      fireEvent.mouseUp(document);
+      fireEvent.pointerDown(resizeHandle, { clientX: 800 });
+      fireEvent.pointerMove(document, { clientX: 900 });
+      fireEvent.pointerUp(document);
 
       await waitFor(() => {
         const width = getSidebarWidth(sidebar);
@@ -951,10 +949,10 @@ describeIntegration("RightSidebar (UI)", () => {
       const chatMinWidthPx = 384; // ChatPane uses tailwind `min-w-96`
       const expectedMaxWidth = 900 - chatMinWidthPx;
 
-      fireEvent.mouseDown(resizeHandle, { clientX: 1000 });
+      fireEvent.pointerDown(resizeHandle, { clientX: 1000 });
       // Move far left to try to exceed max width.
-      fireEvent.mouseMove(document, { clientX: 0 });
-      fireEvent.mouseUp(document);
+      fireEvent.pointerMove(document, { clientX: 0 });
+      fireEvent.pointerUp(document);
 
       await waitFor(() => {
         const styleWidth = sidebar.style.width;
@@ -988,9 +986,9 @@ describeIntegration("RightSidebar (UI)", () => {
 
       // Moving the handle right by the sidebar's whole width asks for a 0px sidebar, far past
       // the snap point, so the sidebar collapses instead of holding at its minimum width.
-      fireEvent.mouseDown(resizeHandle, { clientX: 800 });
-      fireEvent.mouseMove(document, { clientX: 800 + widthBeforeDrag });
-      fireEvent.mouseUp(document);
+      fireEvent.pointerDown(resizeHandle, { clientX: 800 });
+      fireEvent.pointerMove(document, { clientX: 800 + widthBeforeDrag });
+      fireEvent.pointerUp(document);
 
       const card = await waitFor(() => {
         const element = view.container.querySelector<HTMLElement>(RIGHT_SIDEBAR_SELECTOR);
diff --git a/tests/ui/renderReviewPanel.tsx b/tests/ui/renderReviewPanel.tsx
index 636239b2b6b..22ec5d233c3 100644
--- a/tests/ui/renderReviewPanel.tsx
+++ b/tests/ui/renderReviewPanel.tsx
@@ -1,4 +1,4 @@
-import { render, type RenderResult, waitFor } from "@testing-library/react";
+import { render, type RenderResult, waitFor, within } from "@testing-library/react";
 
 import { AppLoader } from "@/browser/components/AppLoader/AppLoader";
 // App renders its pages through React.lazy (#6206), so the first page navigation of a test file
@@ -99,17 +99,23 @@ export function renderApp(props: RenderReviewPanelParams): RenderedApp {
             tabButton.click();
             return;
           }
-          // The strip holds only opened tabs: open the tool from a New tab's launcher, adding
-          // a New tab with "+" first when none is showing. The retry then selects the tab.
+          // The strip holds only opened tabs: open the tool from a New tab's launcher, opening
+          // a New tab from the All tabs menu (a portal) first when none is showing. The retry
+          // then selects the tab.
           const launcherRow = Array.from(
             result.container.querySelectorAll<HTMLElement>(
               '[role="tabpanel"][id*="-panel-new"] button'
             )
           ).find((row) => row.getAttribute("aria-label") === LAUNCHER_TOOL_NAMES[tab]);
+          const menu = document.querySelector<HTMLElement>(
+            '[role="dialog"][aria-label="All tabs"]'
+          );
           if (launcherRow) {
             launcherRow.click();
+          } else if (menu) {
+            within(menu).getByRole("button", { name: "New tab" }).click();
           } else {
-            result.container.querySelector<HTMLElement>('button[aria-label="New tab"]')?.click();
+            result.container.querySelector<HTMLElement>('button[aria-label="All tabs"]')?.click();
           }
           throw new Error(`Tab "${tab}" not open yet`);
         },
diff --git a/tests/ui/rightSidebar/sideChat.test.ts b/tests/ui/rightSidebar/sideChat.test.ts
index 95166d1c562..9f8b159a1a2 100644
--- a/tests/ui/rightSidebar/sideChat.test.ts
+++ b/tests/ui/rightSidebar/sideChat.test.ts
@@ -30,6 +30,7 @@ import type { WorkspaceChatMessage } from "@/common/orpc/types";
 import { preloadTestModules } from "../../ipc/setup";
 import { createStreamCollector } from "../../ipc/streamCollector";
 import { createAppHarness, type AppHarness } from "../harness";
+import { openSidebarNewTab } from "../helpers";
 
 const SIDE_PANE_SELECTOR = `[${SIDE_CHAT_PANE_ATTR}]`;
 const COMPOSER_SELECTOR = 'textarea[aria-label="Message"]';
@@ -194,7 +195,7 @@ describe("/side chat tab in the right sidebar (mock AI router)", () => {
       act(() => getDraftStore().setText({ kind: "workspace", workspaceId: firstId }, firstDraft));
       await waitFor(() => expect(getSideComposer(app, firstId).value).toBe(firstDraft));
 
-      fireEvent.click(within(pane).getByRole("button", { name: "New tab" }));
+      await openSidebarNewTab(pane);
       fireEvent.click(await within(pane).findByRole("button", { name: "Side chat" }));
       const secondId = await waitFor(
         async () => {
@@ -252,7 +253,7 @@ describe("/side chat tab in the right sidebar (mock AI router)", () => {
       const sidebar = app.view.container.querySelector<HTMLElement>(
         '[aria-label="Workspace insights"]'
       )!;
-      fireEvent.click(await within(sidebar).findByRole("button", { name: "New tab" }));
+      await openSidebarNewTab(sidebar);
       const row = await within(sidebar).findByRole("button", { name: "Side chat" });
       fireEvent.click(row);
       fireEvent.click(row);