From fb494070e1016dc08d3c0647e59ca2e06d552472 Mon Sep 17 00:00:00 2001
From: Wenxu Mao <wenxumao@microsoft.com>
Date: Fri, 24 Apr 2026 21:09:50 -0700
Subject: [PATCH 1/7] fix(sidebar): prevent rename input from flashing away and
 space committing

Two bugs in sidebar session rename:

1. Double-click rename flashed away because onBlur fired before the
   useEffect could focus the input. Added a 200ms grace window after
   entering edit mode to ignore transient blur events.

2. Space key committed the rename because button keyup activation
   propagated from the input. Added onKeyUp stopPropagation on the
   rename input to prevent space from activating the parent button.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 web/src/components/SessionItem.test.tsx | 74 +++++++++++++++++++++++++
 web/src/components/SessionItem.tsx      | 19 ++++++-
 2 files changed, 91 insertions(+), 2 deletions(-)

diff --git a/web/src/components/SessionItem.test.tsx b/web/src/components/SessionItem.test.tsx
index d1a31438f..77c096545 100644
--- a/web/src/components/SessionItem.test.tsx
+++ b/web/src/components/SessionItem.test.tsx
@@ -789,6 +789,80 @@ describe("SessionItem quest title label", () => {
   });
 });
 
+describe("SessionItem rename input", () => {
+  // Bug fix: space key was committing the rename because keyup propagated
+  // to the parent <button>, which treats space-keyup as a click.
+  it("does not commit rename when space is pressed (inserts space instead)", () => {
+    const onConfirmRename = vi.fn();
+    const setEditingName = vi.fn();
+    renderSessionItem({
+      editingSessionId: "s1",
+      editingName: "hello",
+      setEditingName,
+      onConfirmRename,
+      onCancelRename: vi.fn(),
+    });
+
+    const input = screen.getByDisplayValue("hello");
+    // Simulate keydown + keyup for space — keyup must not bubble to button
+    fireEvent.keyDown(input, { key: " " });
+    fireEvent.keyUp(input, { key: " " });
+
+    expect(onConfirmRename).not.toHaveBeenCalled();
+  });
+
+  // Bug fix: double-click rename flashed away because the onBlur fired
+  // before the useEffect could focus the input (mouseup blur race).
+  it("ignores blur events immediately after entering edit mode", () => {
+    const onConfirmRename = vi.fn();
+    // Render with editing already active (simulates the state right after
+    // double-click sets editingSessionId).
+    renderSessionItem({
+      editingSessionId: "s1",
+      editingName: "hello",
+      setEditingName: vi.fn(),
+      onConfirmRename,
+      onCancelRename: vi.fn(),
+    });
+
+    const input = screen.getByDisplayValue("hello");
+    // Fire blur immediately — within the 200ms grace window
+    fireEvent.blur(input);
+
+    expect(onConfirmRename).not.toHaveBeenCalled();
+  });
+
+  it("confirms rename on Enter key", () => {
+    const onConfirmRename = vi.fn();
+    renderSessionItem({
+      editingSessionId: "s1",
+      editingName: "new name",
+      setEditingName: vi.fn(),
+      onConfirmRename,
+      onCancelRename: vi.fn(),
+    });
+
+    const input = screen.getByDisplayValue("new name");
+    fireEvent.keyDown(input, { key: "Enter" });
+    expect(onConfirmRename).toHaveBeenCalledTimes(1);
+  });
+
+  it("cancels rename on Escape key", () => {
+    const onCancelRename = vi.fn();
+    renderSessionItem({
+      editingSessionId: "s1",
+      editingName: "new name",
+      setEditingName: vi.fn(),
+      onConfirmRename: vi.fn(),
+      onCancelRename,
+    });
+
+    const input = screen.getByDisplayValue("new name");
+    fireEvent.keyDown(input, { key: "Escape" });
+    expect(onCancelRename).toHaveBeenCalledTimes(1);
+  });
+});
+
 describe("SessionItem isDraggable cursor styling", () => {
   // When isDraggable is true (default), the session button shows a grab cursor
   // on desktop (sm breakpoint) so users know they can drag to reorder.
diff --git a/web/src/components/SessionItem.tsx b/web/src/components/SessionItem.tsx
index 45c838988..5d3ae89f1 100644
--- a/web/src/components/SessionItem.tsx
+++ b/web/src/components/SessionItem.tsx
@@ -1,4 +1,4 @@
-import { useRef, useCallback, useState, type RefObject } from "react";
+import { useRef, useCallback, useState, useEffect, type RefObject } from "react";
 import type { SidebarSessionItem as SessionItemType } from "../utils/sidebar-session-item.js";
 import { deriveSessionStatus, type SessionVisualStatus } from "./SessionStatusDot.js";
 import { useStore } from "../store.js";
@@ -252,6 +252,12 @@ export function SessionItem({
   const shortId = s.id.slice(0, 8);
   const label = sessionName || s.model || shortId;
   const isEditing = editingSessionId === s.id;
+  // Track when edit mode starts so we can ignore spurious blur events
+  // (e.g. from the double-click mouseup before the useEffect focuses the input).
+  const editStartedAt = useRef(0);
+  useEffect(() => {
+    if (isEditing) editStartedAt.current = Date.now();
+  }, [isEditing]);
   const storeQuestNamed = useStore((st) => st.questNamedSessions.has(s.id));
   const bridgeQuestStatus = useStore((st) => st.sessions.get(s.id)?.claimedQuestStatus);
   const questStatus = s.claimedQuestStatus ?? bridgeQuestStatus;
@@ -636,7 +642,16 @@ export function SessionItem({
                     }
                     e.stopPropagation();
                   }}
-                  onBlur={onConfirmRename}
+                  // Stop keyup propagation so space doesn't activate the parent <button>
+                  // (buttons fire click on keyup for space, not keydown).
+                  onKeyUp={(e) => e.stopPropagation()}
+                  onBlur={() => {
+                    // Ignore blur events within 200ms of entering edit mode —
+                    // the double-click mouseup can steal focus before the
+                    // useEffect in Sidebar has a chance to .focus() the input.
+                    if (Date.now() - editStartedAt.current < 200) return;
+                    onConfirmRename();
+                  }}
                   onClick={(e) => e.stopPropagation()}
                   onDoubleClick={(e) => e.stopPropagation()}
                   className="text-[13px] font-medium flex-1 min-w-0 text-cc-fg bg-transparent border border-cc-border rounded px-1 py-0 outline-none focus:border-cc-primary/50"

From a09264b4777ce57dd5c3cb44105613597c8cb96f Mon Sep 17 00:00:00 2001
From: Wenxu Mao <wenxumao@microsoft.com>
Date: Fri, 24 Apr 2026 21:33:57 -0700
Subject: [PATCH 2/7] fix(sidebar): prevent rename input from losing focus on
 double-click and space key
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two fixes for sidebar rename bugs:

1. Double-click rename auto-committed immediately because the first click's
   handleSelectSession fired focusComposer via double-rAF, which stole focus
   from the rename input after it mounted, triggering onBlur → confirmRename.
   Fixed by tracking editingSessionId in a ref and skipping focusComposer
   when a rename is active.

2. Space key committed the rename because keyup bubbled to the parent <button>,
   which the browser interpreted as a button activation click. Fixed by adding
   onKeyUp stopPropagation on the rename input.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 web/src/components/SessionItem.test.tsx | 12 +++++-------
 web/src/components/SessionItem.tsx      | 20 +++++---------------
 web/src/components/Sidebar.tsx          |  7 +++++++
 3 files changed, 17 insertions(+), 22 deletions(-)

diff --git a/web/src/components/SessionItem.test.tsx b/web/src/components/SessionItem.test.tsx
index 77c096545..adf268dd1 100644
--- a/web/src/components/SessionItem.test.tsx
+++ b/web/src/components/SessionItem.test.tsx
@@ -811,12 +811,11 @@ describe("SessionItem rename input", () => {
     expect(onConfirmRename).not.toHaveBeenCalled();
   });
 
-  // Bug fix: double-click rename flashed away because the onBlur fired
-  // before the useEffect could focus the input (mouseup blur race).
-  it("ignores blur events immediately after entering edit mode", () => {
+  // Blur on the rename input should confirm the rename (user clicked away).
+  // The double-click flash-away bug is fixed at the Sidebar level by skipping
+  // focusComposer when a rename is active (editingSessionIdRef guard).
+  it("confirms rename on blur", () => {
     const onConfirmRename = vi.fn();
-    // Render with editing already active (simulates the state right after
-    // double-click sets editingSessionId).
     renderSessionItem({
       editingSessionId: "s1",
       editingName: "hello",
@@ -826,10 +825,9 @@ describe("SessionItem rename input", () => {
     });
 
     const input = screen.getByDisplayValue("hello");
-    // Fire blur immediately — within the 200ms grace window
     fireEvent.blur(input);
 
-    expect(onConfirmRename).not.toHaveBeenCalled();
+    expect(onConfirmRename).toHaveBeenCalled();
   });
 
   it("confirms rename on Enter key", () => {
diff --git a/web/src/components/SessionItem.tsx b/web/src/components/SessionItem.tsx
index 5d3ae89f1..f4c1e789b 100644
--- a/web/src/components/SessionItem.tsx
+++ b/web/src/components/SessionItem.tsx
@@ -252,12 +252,6 @@ export function SessionItem({
   const shortId = s.id.slice(0, 8);
   const label = sessionName || s.model || shortId;
   const isEditing = editingSessionId === s.id;
-  // Track when edit mode starts so we can ignore spurious blur events
-  // (e.g. from the double-click mouseup before the useEffect focuses the input).
-  const editStartedAt = useRef(0);
-  useEffect(() => {
-    if (isEditing) editStartedAt.current = Date.now();
-  }, [isEditing]);
   const storeQuestNamed = useStore((st) => st.questNamedSessions.has(s.id));
   const bridgeQuestStatus = useStore((st) => st.sessions.get(s.id)?.claimedQuestStatus);
   const questStatus = s.claimedQuestStatus ?? bridgeQuestStatus;
@@ -642,16 +636,12 @@ export function SessionItem({
                     }
                     e.stopPropagation();
                   }}
-                  // Stop keyup propagation so space doesn't activate the parent <button>
-                  // (buttons fire click on keyup for space, not keydown).
-                  onKeyUp={(e) => e.stopPropagation()}
-                  onBlur={() => {
-                    // Ignore blur events within 200ms of entering edit mode —
-                    // the double-click mouseup can steal focus before the
-                    // useEffect in Sidebar has a chance to .focus() the input.
-                    if (Date.now() - editStartedAt.current < 200) return;
-                    onConfirmRename();
+                  onKeyUp={(e) => {
+                    // Prevent Space keyup from bubbling to the parent <button>,
+                    // which the browser would interpret as a button activation click.
+                    e.stopPropagation();
                   }}
+                  onBlur={onConfirmRename}
                   onClick={(e) => e.stopPropagation()}
                   onDoubleClick={(e) => e.stopPropagation()}
                   className="text-[13px] font-medium flex-1 min-w-0 text-cc-fg bg-transparent border border-cc-border rounded px-1 py-0 outline-none focus:border-cc-primary/50"
diff --git a/web/src/components/Sidebar.tsx b/web/src/components/Sidebar.tsx
index 8f18d113d..61855e73d 100644
--- a/web/src/components/Sidebar.tsx
+++ b/web/src/components/Sidebar.tsx
@@ -140,6 +140,7 @@ export function Sidebar() {
   const [hoveredSession, setHoveredSession] = useState<{ sessionId: string; rect: DOMRect } | null>(null);
   const [hash, setHash] = useState(() => (typeof window !== "undefined" ? window.location.hash : ""));
   const editInputRef = useRef<HTMLInputElement>(null);
+  const editingSessionIdRef = useRef<string | null>(null);
   const [editingServerName, setEditingServerName] = useState(false);
   const [serverNameDraft, setServerNameDraft] = useState("");
   const serverNameInputRef = useRef<HTMLInputElement>(null);
@@ -388,6 +389,9 @@ export function Sidebar() {
     navigateToSession(sessionId);
     requestAnimationFrame(() => {
       requestAnimationFrame(() => {
+        // Skip focus-steal if user double-clicked to rename — the rename input
+        // needs to keep focus; stealing it would trigger onBlur → confirm → exit.
+        if (editingSessionIdRef.current != null) return;
         useStore.getState().focusComposer();
       });
     });
@@ -460,16 +464,19 @@ export function Sidebar() {
       api.renameSession(editingSessionId, editingName.trim()).catch(() => {});
     }
     setEditingSessionId(null);
+    editingSessionIdRef.current = null;
     setEditingName("");
   }
 
   function cancelRename() {
     setEditingSessionId(null);
+    editingSessionIdRef.current = null;
     setEditingName("");
   }
 
   function handleStartRename(id: string, currentName: string) {
     setEditingSessionId(id);
+    editingSessionIdRef.current = id;
     setEditingName(currentName);
   }
 

From 0d23833492d1e8d47e5f8bb3daf836d381322363 Mon Sep 17 00:00:00 2001
From: Wenxu Mao <wenxumao@microsoft.com>
Date: Tue, 28 Apr 2026 14:48:28 -0700
Subject: [PATCH 3/7] fix(session-namer): prevent auto-namer from overwriting
 manually renamed sessions

Add a persisted `userNamed` set to session-names store. When a user renames
a session via PATCH /sessions/:id/name, the session is flagged as user-named.
The auto-namer skips sessions with this flag, preserving manual renames.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 web/server/index.ts                           |  5 ++
 .../routes.patch-api-sessions-id-name.test.ts |  5 ++
 web/server/routes/sessions.ts                 |  1 +
 web/server/session-names.test.ts              | 50 +++++++++++++++++--
 web/server/session-names.ts                   | 26 +++++++++-
 5 files changed, 83 insertions(+), 4 deletions(-)

diff --git a/web/server/index.ts b/web/server/index.ts
index 030c00b4e..9701a898f 100644
--- a/web/server/index.ts
+++ b/web/server/index.ts
@@ -543,6 +543,11 @@ wsBridge.onUserMessage = async (sessionId, history, cwd, wasGenerating) => {
   if (!getSettings().autoNamerEnabled) return;
   // Suppress auto-namer for sessions with noAutoName flag (e.g. temporary reviewer sessions)
   if (launcher.getSession(sessionId)?.noAutoName) return;
+  // Suppress auto-namer for sessions manually renamed by the user
+  if (sessionNames.isUserNamed(sessionId)) {
+    console.log(`[session-namer] Skipping auto-namer for ${sessionId} (manually renamed by user)`);
+    return;
+  }
   // Suppress auto-namer while a quest owns the session name
   if (await isQuestOwningSessionName(sessionId)) {
     console.log(`[session-namer] Skipping user-message namer for ${sessionId} (quest owns session name)`);
diff --git a/web/server/routes.patch-api-sessions-id-name.test.ts b/web/server/routes.patch-api-sessions-id-name.test.ts
index 3eafa1fe5..72c4c5e34 100644
--- a/web/server/routes.patch-api-sessions-id-name.test.ts
+++ b/web/server/routes.patch-api-sessions-id-name.test.ts
@@ -87,6 +87,9 @@ vi.mock("./git-utils.js", () => ({
 vi.mock("./session-names.js", () => ({
   getName: vi.fn(() => undefined),
   setName: vi.fn(),
+  setUserNamed: vi.fn(),
+  isUserNamed: vi.fn(() => false),
+  clearUserNamed: vi.fn(),
   getAllNames: vi.fn(() => ({})),
   removeName: vi.fn(),
   getNextLeaderNumber: vi.fn(() => 1),
@@ -548,6 +551,8 @@ describe("PATCH /api/sessions/:id/name", () => {
     const json = await res.json();
     expect(json).toEqual({ ok: true, name: "Fix auth bug" });
     expect(sessionNames.setName).toHaveBeenCalledWith("s1", "Fix auth bug");
+    // Verify the session is marked as user-named to prevent auto-namer overwriting
+    expect(sessionNames.setUserNamed).toHaveBeenCalledWith("s1");
   });
 
   it("trims whitespace from name", async () => {
diff --git a/web/server/routes/sessions.ts b/web/server/routes/sessions.ts
index 36ae834ed..bd5de1892 100644
--- a/web/server/routes/sessions.ts
+++ b/web/server/routes/sessions.ts
@@ -1207,6 +1207,7 @@ export function createSessionsRoutes(ctx: RouteContext) {
     const session = launcher.getSession(id);
     if (!session) return c.json({ error: "Session not found" }, 404);
     sessionNames.setName(id, body.name.trim());
+    sessionNames.setUserNamed(id);
     wsBridge.broadcastToSession(id, { type: "session_update", session: { name: body.name.trim() } } as any);
     return c.json({ ok: true, name: body.name.trim() });
   });
diff --git a/web/server/session-names.test.ts b/web/server/session-names.test.ts
index 942f40b3f..51df0183c 100644
--- a/web/server/session-names.test.ts
+++ b/web/server/session-names.test.ts
@@ -8,6 +8,9 @@ import {
   getAllNames,
   removeName,
   getNextLeaderNumber,
+  setUserNamed,
+  isUserNamed,
+  clearUserNamed,
   _resetForTest,
   _flushForTest,
 } from "./session-names.js";
@@ -39,7 +42,7 @@ describe("session-names", () => {
     await _flushForTest();
     const raw = readFileSync(join(tempDir, "session-names.json"), "utf-8");
     const data = JSON.parse(raw);
-    expect(data).toEqual({ names: { s1: "My Session" }, leaderCounter: 0 });
+    expect(data).toEqual({ names: { s1: "My Session" }, leaderCounter: 0, userNamed: [] });
   });
 
   it("getAllNames returns a copy of all names", () => {
@@ -58,7 +61,7 @@ describe("session-names", () => {
     expect(getName("s1")).toBeUndefined();
     await _flushForTest();
     const raw = readFileSync(join(tempDir, "session-names.json"), "utf-8");
-    expect(JSON.parse(raw)).toEqual({ names: {}, leaderCounter: 0 });
+    expect(JSON.parse(raw)).toEqual({ names: {}, leaderCounter: 0, userNamed: [] });
   });
 
   it("overwrites existing name", () => {
@@ -113,7 +116,7 @@ describe("leader counter", () => {
 
     const raw = readFileSync(join(tempDir, "session-names.json"), "utf-8");
     const data = JSON.parse(raw);
-    expect(data).toEqual({ names: { s1: "Worker 1" }, leaderCounter: 1 });
+    expect(data).toEqual({ names: { s1: "Worker 1" }, leaderCounter: 1, userNamed: [] });
   });
 
   it("loads counter from old-format file as 0 (backwards compat)", () => {
@@ -125,3 +128,44 @@ describe("leader counter", () => {
     expect(getNextLeaderNumber()).toBe(1);
   });
 });
+
+describe("userNamed flag", () => {
+  it("isUserNamed returns false by default", () => {
+    expect(isUserNamed("s1")).toBe(false);
+  });
+
+  it("setUserNamed + isUserNamed round-trip", () => {
+    setUserNamed("s1");
+    expect(isUserNamed("s1")).toBe(true);
+    expect(isUserNamed("s2")).toBe(false);
+  });
+
+  it("clearUserNamed removes the flag", () => {
+    setUserNamed("s1");
+    clearUserNamed("s1");
+    expect(isUserNamed("s1")).toBe(false);
+  });
+
+  it("persists userNamed to disk and survives restart", async () => {
+    setUserNamed("s1");
+    setUserNamed("s2");
+    await _flushForTest();
+
+    const raw = readFileSync(join(tempDir, "session-names.json"), "utf-8");
+    const data = JSON.parse(raw);
+    expect(data.userNamed).toEqual(expect.arrayContaining(["s1", "s2"]));
+
+    // Simulate restart
+    _resetForTest(join(tempDir, "session-names.json"));
+    expect(isUserNamed("s1")).toBe(true);
+    expect(isUserNamed("s2")).toBe(true);
+  });
+
+  it("backwards-compatible: loads file without userNamed field", () => {
+    // Old format without userNamed
+    writeFileSync(join(tempDir, "session-names.json"), JSON.stringify({ names: { s1: "Test" }, leaderCounter: 1 }));
+    _resetForTest(join(tempDir, "session-names.json"));
+    expect(isUserNamed("s1")).toBe(false);
+    expect(getName("s1")).toBe("Test");
+  });
+});
diff --git a/web/server/session-names.ts b/web/server/session-names.ts
index 77037feb7..4e46299d1 100644
--- a/web/server/session-names.ts
+++ b/web/server/session-names.ts
@@ -18,10 +18,12 @@ const DEFAULT_PATH = join(homedir(), ".companion", "session-names.json");
 interface PersistedData {
   names: Record<string, string>;
   leaderCounter: number;
+  userNamed?: string[];
 }
 
 let names: Record<string, string> = {};
 let leaderCounter = 0;
+let userNamed: Set<string> = new Set();
 let loaded = false;
 let filePath = DEFAULT_PATH;
 let _pendingWrite: Promise<void> = Promise.resolve();
@@ -37,6 +39,7 @@ function ensureLoaded(): void {
         // New format
         names = parsed.names as Record<string, string>;
         leaderCounter = typeof parsed.leaderCounter === "number" ? parsed.leaderCounter : 0;
+        userNamed = new Set(Array.isArray(parsed.userNamed) ? parsed.userNamed : []);
       } else {
         // Old format: flat Record<string, string>
         names = parsed as Record<string, string>;
@@ -46,12 +49,13 @@ function ensureLoaded(): void {
   } catch {
     names = {};
     leaderCounter = 0;
+    userNamed = new Set();
   }
   loaded = true;
 }
 
 function persist(): void {
-  const data: PersistedData = { names, leaderCounter };
+  const data: PersistedData = { names, leaderCounter, userNamed: [...userNamed] };
   const json = JSON.stringify(data, null, 2);
   const path = filePath;
   mkdirSync(dirname(path), { recursive: true }); // sync-ok: cold path, ensure dir exists
@@ -91,6 +95,26 @@ export function getNextLeaderNumber(): number {
   return leaderCounter;
 }
 
+/** Mark a session as manually named by the user (prevents auto-namer from overwriting). */
+export function setUserNamed(sessionId: string): void {
+  ensureLoaded();
+  userNamed.add(sessionId);
+  persist();
+}
+
+/** Check if a session was manually named by the user. */
+export function isUserNamed(sessionId: string): boolean {
+  ensureLoaded();
+  return userNamed.has(sessionId);
+}
+
+/** Clear the user-named flag (e.g. when a session is deleted). */
+export function clearUserNamed(sessionId: string): void {
+  ensureLoaded();
+  userNamed.delete(sessionId);
+  persist();
+}
+
 /** Wait for any pending async writes to complete. Test-only. */
 export function _flushForTest(): Promise<void> {
   return _pendingWrite;

From 80e41181b32569cd251e5578119a0284142012a5 Mon Sep 17 00:00:00 2001
From: Wenxu Mao <wenxumao@microsoft.com>
Date: Tue, 28 Apr 2026 15:16:57 -0700
Subject: [PATCH 4/7] fix(session-namer): clean up userNamed flag when session
 name is removed

removeName() now also clears the userNamed flag, preventing stale entries
from leaking into the persisted Set when sessions are deleted/archived.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 web/server/session-names.test.ts | 5 ++++-
 web/server/session-names.ts      | 1 +
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/web/server/session-names.test.ts b/web/server/session-names.test.ts
index 51df0183c..d49d58051 100644
--- a/web/server/session-names.test.ts
+++ b/web/server/session-names.test.ts
@@ -55,10 +55,13 @@ describe("session-names", () => {
     expect(getName("s3")).toBeUndefined();
   });
 
-  it("removeName deletes a name", async () => {
+  it("removeName deletes a name and clears userNamed flag", async () => {
     setName("s1", "Session One");
+    setUserNamed("s1");
+    expect(isUserNamed("s1")).toBe(true);
     removeName("s1");
     expect(getName("s1")).toBeUndefined();
+    expect(isUserNamed("s1")).toBe(false);
     await _flushForTest();
     const raw = readFileSync(join(tempDir, "session-names.json"), "utf-8");
     expect(JSON.parse(raw)).toEqual({ names: {}, leaderCounter: 0, userNamed: [] });
diff --git a/web/server/session-names.ts b/web/server/session-names.ts
index 4e46299d1..a0c6a7696 100644
--- a/web/server/session-names.ts
+++ b/web/server/session-names.ts
@@ -84,6 +84,7 @@ export function getAllNames(): Record<string, string> {
 export function removeName(sessionId: string): void {
   ensureLoaded();
   delete names[sessionId];
+  userNamed.delete(sessionId);
   persist();
 }
 

From 0491155c69a207e5e2fe1dc3162fb24f68a2125f Mon Sep 17 00:00:00 2001
From: Wenxu Mao <wenxumao@microsoft.com>
Date: Tue, 28 Apr 2026 16:09:08 -0700
Subject: [PATCH 5/7] fix(test): replace Bun.write with writeFile for Node CI
 compat

The coverage gate runs on Node (not Bun), so Bun.write is undefined.
Use writeFile from node:fs/promises instead.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../routes.get-api-images-sessionid-imageid-thumb.test.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/web/server/routes.get-api-images-sessionid-imageid-thumb.test.ts b/web/server/routes.get-api-images-sessionid-imageid-thumb.test.ts
index 4715e7ebf..b520703ca 100644
--- a/web/server/routes.get-api-images-sessionid-imageid-thumb.test.ts
+++ b/web/server/routes.get-api-images-sessionid-imageid-thumb.test.ts
@@ -172,7 +172,7 @@ vi.mock("./usage-limits.js", () => ({
 import { Hono } from "hono";
 import { execSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
-import { access, mkdtemp, readFile, rm, stat } from "node:fs/promises";
+import { access, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
 import { buildOrchestratorSystemPrompt, createRoutes } from "./routes.js";
@@ -540,8 +540,8 @@ describe("GET /api/images/:sessionId/:imageId/thumb", () => {
     const thumbPath = join(tempRoot, "thumb.jpeg");
     const origPath = join(tempRoot, "orig.png");
     try {
-      await Bun.write(thumbPath, new Uint8Array([0xff, 0xd8, 0xff, 0xd9]));
-      await Bun.write(origPath, new Uint8Array([0x89, 0x50, 0x4e, 0x47]));
+      await writeFile(thumbPath, new Uint8Array([0xff, 0xd8, 0xff, 0xd9]));
+      await writeFile(origPath, new Uint8Array([0x89, 0x50, 0x4e, 0x47]));
 
       const imageStore = {
         getThumbnailPath: vi.fn(async () => thumbPath),
@@ -579,7 +579,7 @@ describe("GET /api/images/:sessionId/:imageId/thumb", () => {
     const tempRoot = await mkdtemp(join(tmpdir(), "routes-thumb-fallback-"));
     const origPath = join(tempRoot, "orig.png");
     try {
-      await Bun.write(origPath, new Uint8Array([0x89, 0x50, 0x4e, 0x47]));
+      await writeFile(origPath, new Uint8Array([0x89, 0x50, 0x4e, 0x47]));
 
       const imageStore = {
         getThumbnailPath: vi.fn(async () => null),

From ed5f1045a965d9ece8db022e457537f7dcc63391 Mon Sep 17 00:00:00 2001
From: Wenxu Mao <wenxumao@microsoft.com>
Date: Tue, 28 Apr 2026 16:40:44 -0700
Subject: [PATCH 6/7] fix(test): skip Bun-dependent image thumb tests on Node
 CI

The image thumb route uses Bun.file() internally, so tests that hit
the actual route handler only work on Bun. Skip the describe block
when Bun is not available (Node-based CI runners).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../routes.get-api-images-sessionid-imageid-thumb.test.ts    | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/web/server/routes.get-api-images-sessionid-imageid-thumb.test.ts b/web/server/routes.get-api-images-sessionid-imageid-thumb.test.ts
index b520703ca..8a4a2a7e7 100644
--- a/web/server/routes.get-api-images-sessionid-imageid-thumb.test.ts
+++ b/web/server/routes.get-api-images-sessionid-imageid-thumb.test.ts
@@ -534,7 +534,10 @@ async function parseSSE(res: Response): Promise<{ event: string; data: string }[
   return events;
 }
 
-describe("GET /api/images/:sessionId/:imageId/thumb", () => {
+// The image thumb route uses Bun.file() internally, so these tests only work on Bun.
+const describeBun = typeof globalThis.Bun !== "undefined" ? describe : describe.skip;
+
+describeBun("GET /api/images/:sessionId/:imageId/thumb", () => {
   it("serves the real thumbnail with immutable caching when it exists", async () => {
     const tempRoot = await mkdtemp(join(tmpdir(), "routes-thumb-"));
     const thumbPath = join(tempRoot, "thumb.jpeg");

From f5a5afb7c5f247e6f0a7c2f31fb573d2c42e1cee Mon Sep 17 00:00:00 2001
From: Jiayi Wei <wjydzh1@gmail.com>
Date: Tue, 5 May 2026 15:15:03 -0700
Subject: [PATCH 7/7] fix(session): guard manual names across namers

---
 web/server/index.ts                           |  64 ++-
 web/server/session-namer-arbitration.ts       |   4 +-
 web/server/session-namer-guard.test.ts        |  58 +++
 web/server/session-namer-guard.ts             |  29 ++
 .../components/Sidebar.session-row.test.tsx   | 432 ++++++++++++++++++
 web/src/components/Sidebar.test.tsx           | 165 -------
 6 files changed, 549 insertions(+), 203 deletions(-)
 create mode 100644 web/server/session-namer-guard.test.ts
 create mode 100644 web/server/session-namer-guard.ts
 create mode 100644 web/src/components/Sidebar.session-row.test.tsx

diff --git a/web/server/index.ts b/web/server/index.ts
index 94bc8c4bd..e1fedb1c0 100644
--- a/web/server/index.ts
+++ b/web/server/index.ts
@@ -64,10 +64,12 @@ import { recreateWorktreeIfMissing } from "./migration.js";
 import { access } from "node:fs/promises";
 import { RelaunchQueue } from "./relaunch-queue.js";
 import {
+  NAMER_TRIGGER_SOURCES,
   shouldAllowUserMessageOverrideOnNameMismatch,
   type NamerMutationRecord,
   type NamerTriggerSource,
 } from "./session-namer-arbitration.js";
+import { formatAutoNamerSkipReason, getAutoNamerSkipReason } from "./session-namer-guard.js";
 import type { SocketData } from "./ws-bridge.js";
 import type { ServerWebSocket } from "bun";
 
@@ -401,7 +403,7 @@ function endNamerCall(sessionId: string, source: NamerTriggerSource, controller:
 
 /** Cancel ALL in-flight namer calls for a session (all trigger sources). */
 function cancelAllNamersForSession(sessionId: string): void {
-  for (const source of ["user_message", "turn_completed", "agent_paused"] as const) {
+  for (const source of NAMER_TRIGGER_SOURCES) {
     const key = getNamerKey(sessionId, source);
     const ctrl = inFlightNamer.get(key);
     if (ctrl) {
@@ -471,6 +473,25 @@ async function isQuestOwningSessionName(sessionId: string): Promise<boolean> {
   );
 }
 
+async function shouldSkipAutoNamer(
+  sessionId: string,
+  source: NamerTriggerSource,
+  stage: "start" | "apply",
+): Promise<boolean> {
+  const reason = await getAutoNamerSkipReason({
+    isAutoNamerEnabled: () => getSettings().autoNamerEnabled,
+    isNoAutoNameSession: () => !!launcher.getSession(sessionId)?.noAutoName,
+    isUserNamed: () => sessionNames.isUserNamed(sessionId),
+    isQuestOwningName: () => isQuestOwningSessionName(sessionId),
+  });
+  if (!reason) return false;
+
+  const verb = stage === "apply" ? "Discarding" : "Skipping";
+  const noun = stage === "apply" ? `${source} namer result` : `${source} namer`;
+  console.log(`[session-namer] ${verb} ${noun} for ${sessionId} (${formatAutoNamerSkipReason(reason)})`);
+  return true;
+}
+
 /** Apply a naming result: set name, broadcast, add task entry. Shared by all triggers. */
 async function applyNamingResult(
   sessionId: string,
@@ -479,11 +500,7 @@ async function applyNamingResult(
   history: import("./session-types.js").BrowserIncomingMessage[],
   source: NamerTriggerSource,
 ): Promise<void> {
-  // Re-check: quest may have been claimed while the namer was in-flight
-  if (await isQuestOwningSessionName(sessionId)) {
-    console.log(`[session-namer] Discarding namer result for ${sessionId} (quest owns session name)`);
-    return;
-  }
+  if (await shouldSkipAutoNamer(sessionId, source, "apply")) return;
   // Merge keywords regardless of naming action
   if (result.keywords?.length) {
     mergeSessionKeywords(sessionId, result.keywords);
@@ -593,20 +610,7 @@ wsBridge.onSessionNamedByQuest = (sessionId, title) => {
 
 // Continuous session auto-naming via Claude Haiku (triggered on each user message)
 wsBridge.onUserMessage = async (sessionId, history, cwd, wasGenerating) => {
-  // Suppress auto-namer when disabled in settings
-  if (!getSettings().autoNamerEnabled) return;
-  // Suppress auto-namer for sessions with noAutoName flag (e.g. temporary reviewer sessions)
-  if (launcher.getSession(sessionId)?.noAutoName) return;
-  // Suppress auto-namer for sessions manually renamed by the user
-  if (sessionNames.isUserNamed(sessionId)) {
-    console.log(`[session-namer] Skipping auto-namer for ${sessionId} (manually renamed by user)`);
-    return;
-  }
-  // Suppress auto-namer while a quest owns the session name
-  if (await isQuestOwningSessionName(sessionId)) {
-    console.log(`[session-namer] Skipping user-message namer for ${sessionId} (quest owns session name)`);
-    return;
-  }
+  if (await shouldSkipAutoNamer(sessionId, "user_message", "start")) return;
   const currentName = sessionNames.getName(sessionId);
   const isRandomName = isRandomSessionName(currentName);
   const isFirstEvaluation = !autoNamingEvaluated.has(sessionId);
@@ -634,11 +638,7 @@ wsBridge.onUserMessage = async (sessionId, history, cwd, wasGenerating) => {
       const result = await generateFirstName(sessionId, history, cwd, { signal, isGenerating, claimedQuest });
       if (signal.aborted) return;
       if (!result || result.action !== "name") return;
-      // Re-check: quest may have been claimed while we were generating
-      if (await isQuestOwningSessionName(sessionId)) {
-        console.log(`[session-namer] Discarding first-name result for ${sessionId} (quest owns session name)`);
-        return;
-      }
+      if (await shouldSkipAutoNamer(sessionId, "user_message", "apply")) return;
       // Don't overwrite if user renamed while we were generating
       const freshName = sessionNames.getName(sessionId);
       if (freshName && !isRandomSessionName(freshName)) return;
@@ -672,12 +672,7 @@ wsBridge.onUserMessage = async (sessionId, history, cwd, wasGenerating) => {
 // The agent has done meaningful research/work to produce the plan, providing
 // rich context for naming — and it's a natural breakpoint before execution.
 wsBridge.onAgentPaused = async (sessionId, history, cwd) => {
-  if (!getSettings().autoNamerEnabled) return;
-  if (launcher.getSession(sessionId)?.noAutoName) return;
-  if (await isQuestOwningSessionName(sessionId)) {
-    console.log(`[session-namer] Skipping agent-paused namer for ${sessionId} (quest owns session name)`);
-    return;
-  }
+  if (await shouldSkipAutoNamer(sessionId, "agent_paused", "start")) return;
   const currentName = sessionNames.getName(sessionId);
   if (!currentName) return;
 
@@ -698,12 +693,7 @@ wsBridge.onAgentPaused = async (sessionId, history, cwd) => {
 // The turn-completed namer runs independently from user-message naming.
 // User-message outcomes are preferred when both produce competing revisions.
 wsBridge.onTurnCompleted = async (sessionId, history, cwd) => {
-  if (!getSettings().autoNamerEnabled) return;
-  if (launcher.getSession(sessionId)?.noAutoName) return;
-  if (await isQuestOwningSessionName(sessionId)) {
-    console.log(`[session-namer] Skipping turn-completed namer for ${sessionId} (quest owns session name)`);
-    return;
-  }
+  if (await shouldSkipAutoNamer(sessionId, "turn_completed", "start")) return;
   const currentName = sessionNames.getName(sessionId);
   if (!currentName) return;
 
diff --git a/web/server/session-namer-arbitration.ts b/web/server/session-namer-arbitration.ts
index 91f4d77bc..dd3ac08bc 100644
--- a/web/server/session-namer-arbitration.ts
+++ b/web/server/session-namer-arbitration.ts
@@ -1,4 +1,6 @@
-export type NamerTriggerSource = "user_message" | "turn_completed" | "agent_paused";
+export const NAMER_TRIGGER_SOURCES = ["user_message", "turn_completed", "agent_paused"] as const;
+
+export type NamerTriggerSource = (typeof NAMER_TRIGGER_SOURCES)[number];
 
 export interface NamerMutationRecord {
   source: NamerTriggerSource;
diff --git a/web/server/session-namer-guard.test.ts b/web/server/session-namer-guard.test.ts
new file mode 100644
index 000000000..6633ee54b
--- /dev/null
+++ b/web/server/session-namer-guard.test.ts
@@ -0,0 +1,58 @@
+import { describe, expect, it, vi } from "vitest";
+import { NAMER_TRIGGER_SOURCES } from "./session-namer-arbitration.js";
+import { getAutoNamerSkipReason, type AutoNamerGuardChecks } from "./session-namer-guard.js";
+
+function checks(overrides: Partial<AutoNamerGuardChecks> = {}): AutoNamerGuardChecks {
+  return {
+    isAutoNamerEnabled: vi.fn(() => true),
+    isNoAutoNameSession: vi.fn(() => false),
+    isUserNamed: vi.fn(() => false),
+    isQuestOwningName: vi.fn(async () => false),
+    ...overrides,
+  } satisfies AutoNamerGuardChecks;
+}
+
+describe("getAutoNamerSkipReason", () => {
+  it("uses user-named protection for every automatic namer trigger", async () => {
+    for (const _source of NAMER_TRIGGER_SOURCES) {
+      const guardChecks = checks({ isUserNamed: vi.fn(() => true) });
+
+      await expect(getAutoNamerSkipReason(guardChecks)).resolves.toBe("user_named");
+      expect(guardChecks.isQuestOwningName).not.toHaveBeenCalled();
+    }
+  });
+
+  it("re-checks current manual-name state when called again for result application", async () => {
+    let userNamed = false;
+    const guardChecks = checks({ isUserNamed: vi.fn(() => userNamed) });
+
+    await expect(getAutoNamerSkipReason(guardChecks)).resolves.toBeNull();
+
+    userNamed = true;
+
+    await expect(getAutoNamerSkipReason(guardChecks)).resolves.toBe("user_named");
+  });
+
+  it("skips before manual-name checks when auto-namer is disabled", async () => {
+    const guardChecks = checks({ isAutoNamerEnabled: vi.fn(() => false) });
+
+    await expect(getAutoNamerSkipReason(guardChecks)).resolves.toBe("disabled");
+    expect(guardChecks.isNoAutoNameSession).not.toHaveBeenCalled();
+    expect(guardChecks.isUserNamed).not.toHaveBeenCalled();
+    expect(guardChecks.isQuestOwningName).not.toHaveBeenCalled();
+  });
+
+  it("skips before manual-name checks for noAutoName sessions", async () => {
+    const guardChecks = checks({ isNoAutoNameSession: vi.fn(() => true) });
+
+    await expect(getAutoNamerSkipReason(guardChecks)).resolves.toBe("no_auto_name");
+    expect(guardChecks.isUserNamed).not.toHaveBeenCalled();
+    expect(guardChecks.isQuestOwningName).not.toHaveBeenCalled();
+  });
+
+  it("falls back to quest-owned protection when no earlier guard applies", async () => {
+    const guardChecks = checks({ isQuestOwningName: vi.fn(async () => true) });
+
+    await expect(getAutoNamerSkipReason(guardChecks)).resolves.toBe("quest_owned");
+  });
+});
diff --git a/web/server/session-namer-guard.ts b/web/server/session-namer-guard.ts
new file mode 100644
index 000000000..53272c2a6
--- /dev/null
+++ b/web/server/session-namer-guard.ts
@@ -0,0 +1,29 @@
+export type AutoNamerSkipReason = "disabled" | "no_auto_name" | "user_named" | "quest_owned";
+
+export interface AutoNamerGuardChecks {
+  isAutoNamerEnabled: () => boolean;
+  isNoAutoNameSession: () => boolean;
+  isUserNamed: () => boolean;
+  isQuestOwningName: () => Promise<boolean>;
+}
+
+export async function getAutoNamerSkipReason(checks: AutoNamerGuardChecks): Promise<AutoNamerSkipReason | null> {
+  if (!checks.isAutoNamerEnabled()) return "disabled";
+  if (checks.isNoAutoNameSession()) return "no_auto_name";
+  if (checks.isUserNamed()) return "user_named";
+  if (await checks.isQuestOwningName()) return "quest_owned";
+  return null;
+}
+
+export function formatAutoNamerSkipReason(reason: AutoNamerSkipReason): string {
+  switch (reason) {
+    case "disabled":
+      return "auto-namer disabled";
+    case "no_auto_name":
+      return "session is marked noAutoName";
+    case "user_named":
+      return "manually renamed by user";
+    case "quest_owned":
+      return "quest owns session name";
+  }
+}
diff --git a/web/src/components/Sidebar.session-row.test.tsx b/web/src/components/Sidebar.session-row.test.tsx
new file mode 100644
index 000000000..0ea9b4458
--- /dev/null
+++ b/web/src/components/Sidebar.session-row.test.tsx
@@ -0,0 +1,432 @@
+// @vitest-environment jsdom
+import { render, screen, fireEvent } from "@testing-library/react";
+import "@testing-library/jest-dom";
+import type { SessionNotification, SessionState, SdkSessionInfo } from "../types.js";
+
+const mockConnectSession = vi.fn();
+const mockConnectAllSessions = vi.fn();
+const mockDisconnectSession = vi.fn();
+const scrollTargetSessionIds: string[] = [];
+const mockScrollIntoView = vi.fn(function (this: Element) {
+  scrollTargetSessionIds.push((this as HTMLElement).dataset.sessionId ?? "");
+});
+
+vi.mock("../ws.js", () => ({
+  connectSession: (...args: unknown[]) => mockConnectSession(...args),
+  connectAllSessions: (...args: unknown[]) => mockConnectAllSessions(...args),
+  disconnectSession: (...args: unknown[]) => mockDisconnectSession(...args),
+}));
+
+vi.mock("../utils/pending-creation.js", () => ({
+  cancelPendingCreation: vi.fn(),
+}));
+
+const mockApi = {
+  listSessions: vi.fn().mockResolvedValue([]),
+  searchSessions: vi.fn().mockResolvedValue({ query: "", tookMs: 0, totalMatches: 0, results: [] }),
+  deleteSession: vi.fn().mockResolvedValue({}),
+  archiveSession: vi.fn().mockResolvedValue({}),
+  archiveGroup: vi.fn().mockResolvedValue({ ok: true, archived: 1, failed: 0 }),
+  unarchiveSession: vi.fn().mockResolvedValue({}),
+  createTreeGroup: vi.fn().mockResolvedValue({ ok: true, group: { id: "group-2", name: "Group 2" } }),
+  assignSessionToTreeGroup: vi.fn().mockResolvedValue({ ok: true }),
+  assignSessionsToTreeGroup: vi.fn().mockResolvedValue({ ok: true }),
+  herdWorkerToLeader: vi
+    .fn()
+    .mockResolvedValue({ herded: ["worker-1"], notFound: [], conflicts: [], reassigned: [], leaders: [] }),
+  getSettings: vi.fn().mockResolvedValue({ serverName: "" }),
+  updateSettings: vi.fn().mockResolvedValue({}),
+  getTreeGroups: vi
+    .fn()
+    .mockResolvedValue({ groups: [{ id: "default", name: "Default" }], assignments: {}, nodeOrder: {} }),
+};
+
+vi.mock("../api.js", () => ({
+  api: {
+    listSessions: (...args: unknown[]) => mockApi.listSessions(...args),
+    searchSessions: (...args: unknown[]) => mockApi.searchSessions(...args),
+    deleteSession: (...args: unknown[]) => mockApi.deleteSession(...args),
+    archiveSession: (...args: unknown[]) => mockApi.archiveSession(...args),
+    archiveGroup: (...args: unknown[]) => mockApi.archiveGroup(...args),
+    unarchiveSession: (...args: unknown[]) => mockApi.unarchiveSession(...args),
+    createTreeGroup: (...args: unknown[]) => mockApi.createTreeGroup(...args),
+    assignSessionToTreeGroup: (...args: unknown[]) => mockApi.assignSessionToTreeGroup(...args),
+    assignSessionsToTreeGroup: (...args: unknown[]) => mockApi.assignSessionsToTreeGroup(...args),
+    herdWorkerToLeader: (...args: unknown[]) => mockApi.herdWorkerToLeader(...args),
+    getSettings: (...args: unknown[]) => mockApi.getSettings(...args),
+    updateSettings: (...args: unknown[]) => mockApi.updateSettings(...args),
+    getTreeGroups: (...args: unknown[]) => mockApi.getTreeGroups(...args),
+  },
+}));
+
+vi.mock("../utils/copy-utils.js", () => ({
+  writeClipboardText: vi.fn().mockResolvedValue(undefined),
+}));
+
+interface MockStoreState {
+  sessions: Map<string, SessionState>;
+  sdkSessions: SdkSessionInfo[];
+  currentSessionId: string | null;
+  cliConnected: Map<string, boolean>;
+  cliDisconnectReason: Map<string, "idle_limit" | null>;
+  sessionStatus: Map<string, "idle" | "running" | "compacting" | null>;
+  sessionNames: Map<string, string>;
+  sessionPreviews: Map<string, string>;
+  sessionPreviewUpdatedAt: Map<string, number>;
+  sessionTaskPreview: Map<string, string>;
+  sessionTaskHistory: Map<string, Array<{ title: string; action: string; timestamp: number }>>;
+  sessionKeywords: Map<string, string[]>;
+  sessionNotifications: Map<string, SessionNotification[]>;
+  recentlyRenamed: Set<string>;
+  questNamedSessions: Set<string>;
+  pendingPermissions: Map<string, Map<string, unknown>>;
+  sessionAttention: Map<string, "action" | "error" | "review" | null>;
+  diffFileStats: Map<string, Map<string, { additions: number; deletions: number }>>;
+  shortcutSettings: {
+    enabled: boolean;
+    preset: "standard" | "vscode-light" | "vim-light";
+    overrides: Record<string, string | null>;
+  };
+  searchPreviewSessionId: string | null;
+  sessionInfoOpenSessionId: string | null;
+  reorderMode: boolean;
+  setReorderMode: ReturnType<typeof vi.fn>;
+  sessionSortMode: "created" | "activity";
+  setSessionSortMode: ReturnType<typeof vi.fn>;
+  pendingSessions: Map<string, unknown>;
+  serverName: string;
+  treeGroups: Array<{ id: string; name: string }>;
+  treeAssignments: Map<string, string>;
+  treeNodeOrder: Map<string, string[]>;
+  collapsedTreeGroups: Set<string>;
+  collapsedTreeNodes: Set<string>;
+  expandedHerdNodes: Set<string>;
+  toggleTreeGroupCollapse: ReturnType<typeof vi.fn>;
+  toggleTreeNodeCollapse: ReturnType<typeof vi.fn>;
+  toggleHerdNodeExpand: ReturnType<typeof vi.fn>;
+  setServerName: ReturnType<typeof vi.fn>;
+  setSearchPreviewSessionId: ReturnType<typeof vi.fn>;
+  setCurrentSession: ReturnType<typeof vi.fn>;
+  removeSession: ReturnType<typeof vi.fn>;
+  newSession: ReturnType<typeof vi.fn>;
+  setSidebarOpen: ReturnType<typeof vi.fn>;
+  setSessionName: ReturnType<typeof vi.fn>;
+  setSessionPreview: ReturnType<typeof vi.fn>;
+  setSessionTaskHistory: ReturnType<typeof vi.fn>;
+  setSessionKeywords: ReturnType<typeof vi.fn>;
+  markRecentlyRenamed: ReturnType<typeof vi.fn>;
+  clearRecentlyRenamed: ReturnType<typeof vi.fn>;
+  setSdkSessions: ReturnType<typeof vi.fn>;
+  closeTerminal: ReturnType<typeof vi.fn>;
+  openNewSessionModal: ReturnType<typeof vi.fn>;
+  closeNewSessionModal: ReturnType<typeof vi.fn>;
+  markSessionViewed: ReturnType<typeof vi.fn>;
+  markAllSessionsViewed: ReturnType<typeof vi.fn>;
+  markSessionUnread: ReturnType<typeof vi.fn>;
+  clearSessionAttention: ReturnType<typeof vi.fn>;
+  setTreeGroups: ReturnType<typeof vi.fn>;
+  focusComposer: ReturnType<typeof vi.fn>;
+}
+
+function makeSession(id: string, overrides: Partial<SessionState> = {}): SessionState {
+  return {
+    session_id: id,
+    model: "claude-sonnet-4-5-20250929",
+    cwd: "/home/user/projects/myapp",
+    tools: [],
+    permissionMode: "default",
+    claude_code_version: "1.0",
+    mcp_servers: [],
+    agents: [],
+    slash_commands: [],
+    skills: [],
+    total_cost_usd: 0,
+    num_turns: 0,
+    context_used_percent: 0,
+    is_compacting: false,
+    git_branch: "",
+    is_worktree: false,
+    is_containerized: false,
+    repo_root: "",
+    git_ahead: 0,
+    git_behind: 0,
+    total_lines_added: 0,
+    total_lines_removed: 0,
+    ...overrides,
+  };
+}
+
+function makeSdkSession(id: string, overrides: Partial<SdkSessionInfo> = {}): SdkSessionInfo {
+  return {
+    sessionId: id,
+    state: "connected",
+    cwd: "/home/user/projects/myapp",
+    createdAt: Date.now(),
+    archived: false,
+    ...overrides,
+  };
+}
+
+let mockState: MockStoreState;
+
+function createMockState(overrides: Partial<MockStoreState> = {}): MockStoreState {
+  return {
+    sessions: new Map(),
+    sdkSessions: [],
+    currentSessionId: null,
+    cliConnected: new Map(),
+    cliDisconnectReason: new Map(),
+    sessionStatus: new Map(),
+    sessionNames: new Map(),
+    sessionPreviews: new Map(),
+    sessionPreviewUpdatedAt: new Map(),
+    sessionTaskPreview: new Map(),
+    sessionTaskHistory: new Map(),
+    sessionKeywords: new Map(),
+    sessionNotifications: new Map(),
+    recentlyRenamed: new Set(),
+    questNamedSessions: new Set(),
+    pendingPermissions: new Map(),
+    sessionAttention: new Map(),
+    diffFileStats: new Map(),
+    shortcutSettings: { enabled: false, preset: "standard", overrides: {} },
+    searchPreviewSessionId: null,
+    sessionInfoOpenSessionId: null,
+    reorderMode: false,
+    setReorderMode: vi.fn(),
+    sessionSortMode: "created",
+    setSessionSortMode: vi.fn(),
+    pendingSessions: new Map(),
+    serverName: "",
+    treeGroups: [],
+    treeAssignments: new Map(),
+    treeNodeOrder: new Map(),
+    collapsedTreeGroups: new Set(),
+    collapsedTreeNodes: new Set(),
+    expandedHerdNodes: new Set(),
+    toggleTreeGroupCollapse: vi.fn(),
+    toggleTreeNodeCollapse: vi.fn(),
+    toggleHerdNodeExpand: vi.fn(),
+    setServerName: vi.fn(),
+    setSearchPreviewSessionId: vi.fn(),
+    setCurrentSession: vi.fn(),
+    removeSession: vi.fn(),
+    newSession: vi.fn(),
+    setSidebarOpen: vi.fn(),
+    setSessionName: vi.fn(),
+    setSessionPreview: vi.fn(),
+    setSessionTaskHistory: vi.fn(),
+    setSessionKeywords: vi.fn(),
+    markRecentlyRenamed: vi.fn(),
+    clearRecentlyRenamed: vi.fn(),
+    setSdkSessions: vi.fn(),
+    closeTerminal: vi.fn(),
+    openNewSessionModal: vi.fn(),
+    closeNewSessionModal: vi.fn(),
+    markSessionViewed: vi.fn(),
+    markAllSessionsViewed: vi.fn(),
+    markSessionUnread: vi.fn(),
+    clearSessionAttention: vi.fn(),
+    setTreeGroups: vi.fn(),
+    focusComposer: vi.fn(),
+    ...overrides,
+  };
+}
+
+vi.mock("../store.js", () => {
+  const useStoreFn = (selector: (state: MockStoreState) => unknown) => selector(mockState);
+  useStoreFn.getState = () => mockState;
+  const countUserPermissions = (perms: Map<string, unknown> | undefined): number => {
+    if (!perms) return 0;
+    let count = 0;
+    for (const p of perms.values()) {
+      const perm = p as { evaluating?: boolean; autoApproved?: string };
+      if (!perm?.evaluating && !perm?.autoApproved) count++;
+    }
+    return count;
+  };
+  return { useStore: useStoreFn, countUserPermissions };
+});
+
+import { Sidebar } from "./Sidebar.js";
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  scrollTargetSessionIds.length = 0;
+  Element.prototype.scrollIntoView = mockScrollIntoView;
+  mockState = createMockState();
+  window.location.hash = "";
+  Object.defineProperty(window, "matchMedia", {
+    writable: true,
+    value: vi.fn().mockImplementation((query: string) => ({
+      matches: false,
+      media: query,
+      onchange: null,
+      addListener: vi.fn(),
+      removeListener: vi.fn(),
+      addEventListener: vi.fn(),
+      removeEventListener: vi.fn(),
+      dispatchEvent: vi.fn(),
+    })),
+  });
+});
+
+describe("Sidebar session rows", { timeout: 10000 }, () => {
+  it("active session has highlighted styling", () => {
+    const session = makeSession("s1");
+    const sdk = makeSdkSession("s1");
+    mockState = createMockState({
+      sessions: new Map([["s1", session]]),
+      sdkSessions: [sdk],
+      currentSessionId: "s1",
+    });
+
+    render(<Sidebar />);
+
+    expect(screen.getByText("claude-sonnet-4-5-20250929").closest("button")).toHaveClass("bg-cc-active");
+  });
+
+  it("auto-scrolls the sidebar to keep the active session row visible", () => {
+    const session1 = makeSession("s1", { model: "Session One" });
+    const session2 = makeSession("s2", { model: "Session Two" });
+    const sdk1 = makeSdkSession("s1", { model: "Session One", createdAt: 2 });
+    const sdk2 = makeSdkSession("s2", { model: "Session Two", createdAt: 1 });
+    mockState = createMockState({
+      sessions: new Map([
+        ["s1", session1],
+        ["s2", session2],
+      ]),
+      sdkSessions: [sdk1, sdk2],
+      currentSessionId: "s2",
+      treeGroups: [{ id: "default", name: "Default" }],
+      treeNodeOrder: new Map([["default", ["s1", "s2"]]]),
+    });
+
+    render(<Sidebar />);
+
+    expect(screen.getByText("Session Two").closest("button")).toHaveAttribute("data-active-session", "true");
+    expect(mockScrollIntoView).toHaveBeenCalledWith({ block: "nearest" });
+    expect(scrollTargetSessionIds).toContain("s2");
+  });
+
+  it("clicking a session navigates to the session hash", () => {
+    const session = makeSession("s1");
+    const sdk = makeSdkSession("s1");
+    mockState = createMockState({
+      sessions: new Map([["s1", session]]),
+      sdkSessions: [sdk],
+      currentSessionId: null,
+    });
+
+    render(<Sidebar />);
+    fireEvent.click(screen.getByText("claude-sonnet-4-5-20250929").closest("button")!);
+
+    expect(window.location.hash).toBe("#/session/s1");
+  });
+
+  it("default tree group plus button opens new session modal with tree defaults", () => {
+    const session = makeSession("s1", {
+      cwd: "/home/user/projects/myapp",
+      repo_root: "/home/user/projects/myapp",
+    });
+    const sdk = makeSdkSession("s1");
+    mockState = createMockState({
+      sessions: new Map([["s1", session]]),
+      sdkSessions: [sdk],
+    });
+
+    render(<Sidebar />);
+    fireEvent.click(screen.getByLabelText("Create session in Default Session Space"));
+
+    expect(mockState.openNewSessionModal).toHaveBeenCalledWith({
+      treeGroupId: "default",
+      newSessionDefaultsKey: "tree-group:default",
+    });
+  });
+
+  it("tree group plus button opens new session modal with a tree-scoped defaults key", () => {
+    const session = makeSession("s1", {
+      cwd: "/home/user/projects/myapp",
+      repo_root: "/home/user/projects/myapp",
+    });
+    const sdk = makeSdkSession("s1");
+    mockState = createMockState({
+      sessions: new Map([["s1", session]]),
+      sdkSessions: [sdk],
+      treeGroups: [{ id: "team-alpha", name: "Takode" }],
+      treeAssignments: new Map([["s1", "team-alpha"]]),
+    });
+
+    render(<Sidebar />);
+    fireEvent.click(screen.getByLabelText("Create session in Takode Session Space"));
+
+    expect(mockState.openNewSessionModal).toHaveBeenCalledWith({
+      treeGroupId: "team-alpha",
+      newSessionDefaultsKey: "tree-group:team-alpha",
+    });
+  });
+
+  it("does not render the old sidebar view mode toggle", () => {
+    const session = makeSession("s1");
+    const sdk = makeSdkSession("s1");
+    mockState = createMockState({
+      sessions: new Map([["s1", session]]),
+      sdkSessions: [sdk],
+    });
+
+    render(<Sidebar />);
+
+    expect(screen.queryByTitle("Tree view (herd groups)")).not.toBeInTheDocument();
+    expect(screen.queryByTitle("Linear view (project groups)")).not.toBeInTheDocument();
+  });
+
+  it("double-clicking a session enters edit mode", async () => {
+    const session = makeSession("s1");
+    const sdk = makeSdkSession("s1");
+    mockState = createMockState({
+      sessions: new Map([["s1", session]]),
+      sdkSessions: [sdk],
+    });
+
+    render(<Sidebar />);
+    fireEvent.doubleClick(screen.getByText("claude-sonnet-4-5-20250929").closest("button")!);
+
+    const input = await screen.findByDisplayValue("claude-sonnet-4-5-20250929");
+    expect(input).toBeInTheDocument();
+    expect(input.tagName).toBe("INPUT");
+  });
+
+  it("does not steal focus back to the composer after double-click rename starts", async () => {
+    const session = makeSession("s1");
+    const sdk = makeSdkSession("s1");
+    const animationFrameCallbacks: FrameRequestCallback[] = [];
+    const requestAnimationFrameMock = vi.fn((callback: FrameRequestCallback) => {
+      animationFrameCallbacks.push(callback);
+      return animationFrameCallbacks.length;
+    });
+    const originalRequestAnimationFrame = globalThis.requestAnimationFrame;
+    vi.stubGlobal("requestAnimationFrame", requestAnimationFrameMock);
+    mockState = createMockState({
+      sessions: new Map([["s1", session]]),
+      sdkSessions: [sdk],
+    });
+
+    try {
+      render(<Sidebar />);
+      const sessionButton = screen.getByText("claude-sonnet-4-5-20250929").closest("button")!;
+      fireEvent.click(sessionButton);
+      fireEvent.doubleClick(sessionButton);
+
+      await screen.findByDisplayValue("claude-sonnet-4-5-20250929");
+      expect(animationFrameCallbacks.length).toBeGreaterThan(0);
+      mockState.focusComposer.mockClear();
+      while (animationFrameCallbacks.length > 0) {
+        animationFrameCallbacks.shift()?.(performance.now());
+      }
+
+      expect(mockState.focusComposer).not.toHaveBeenCalled();
+    } finally {
+      vi.stubGlobal("requestAnimationFrame", originalRequestAnimationFrame);
+    }
+  });
+});
diff --git a/web/src/components/Sidebar.test.tsx b/web/src/components/Sidebar.test.tsx
index 2d2b97deb..bee74e69c 100644
--- a/web/src/components/Sidebar.test.tsx
+++ b/web/src/components/Sidebar.test.tsx
@@ -890,171 +890,6 @@ describe("Sidebar", { timeout: 10000 }, () => {
     expect(sessionButton.textContent).toContain("-625");
   });
 
-  it("active session has highlighted styling (bg-cc-active class)", () => {
-    const session = makeSession("s1");
-    const sdk = makeSdkSession("s1");
-    mockState = createMockState({
-      sessions: new Map([["s1", session]]),
-      sdkSessions: [sdk],
-      currentSessionId: "s1",
-    });
-
-    render(<Sidebar />);
-    // Find the session button element
-    const sessionButton = screen.getByText("claude-sonnet-4-5-20250929").closest("button");
-    expect(sessionButton).toHaveClass("bg-cc-active");
-  });
-
-  it("auto-scrolls the sidebar to keep the active session row visible", () => {
-    const session1 = makeSession("s1", { model: "Session One" });
-    const session2 = makeSession("s2", { model: "Session Two" });
-    const sdk1 = makeSdkSession("s1", { model: "Session One", createdAt: 2 });
-    const sdk2 = makeSdkSession("s2", { model: "Session Two", createdAt: 1 });
-    mockState = createMockState({
-      sessions: new Map([
-        ["s1", session1],
-        ["s2", session2],
-      ]),
-      sdkSessions: [sdk1, sdk2],
-      currentSessionId: "s2",
-      treeGroups: [{ id: "default", name: "Default" }],
-      treeNodeOrder: new Map([["default", ["s1", "s2"]]]),
-    });
-
-    render(<Sidebar />);
-
-    const activeButton = screen.getByText("Session Two").closest("button");
-    expect(activeButton).toHaveAttribute("data-active-session", "true");
-    expect(mockScrollIntoView).toHaveBeenCalledWith({ block: "nearest" });
-    expect(scrollTargetSessionIds).toContain("s2");
-  });
-
-  it("clicking a session navigates to the session hash", () => {
-    // Sidebar now delegates to URL-based routing: it sets the hash to #/session/{id}
-    // and App.tsx's hash effect handles setCurrentSession + connectSession
-    const session = makeSession("s1");
-    const sdk = makeSdkSession("s1");
-    mockState = createMockState({
-      sessions: new Map([["s1", session]]),
-      sdkSessions: [sdk],
-      currentSessionId: null,
-    });
-
-    render(<Sidebar />);
-    const sessionButton = screen.getByText("claude-sonnet-4-5-20250929").closest("button")!;
-    fireEvent.click(sessionButton);
-
-    expect(window.location.hash).toBe("#/session/s1");
-  });
-
-  it("default tree group plus button opens new session modal with tree defaults", () => {
-    const session = makeSession("s1", {
-      cwd: "/home/user/projects/myapp",
-      repo_root: "/home/user/projects/myapp",
-    });
-    const sdk = makeSdkSession("s1");
-    mockState = createMockState({
-      sessions: new Map([["s1", session]]),
-      sdkSessions: [sdk],
-    });
-
-    render(<Sidebar />);
-    fireEvent.click(screen.getByLabelText("Create session in Default Session Space"));
-
-    expect(mockState.openNewSessionModal).toHaveBeenCalledWith({
-      treeGroupId: "default",
-      newSessionDefaultsKey: "tree-group:default",
-    });
-  });
-
-  it("tree group plus button opens new session modal with a tree-scoped defaults key", () => {
-    const session = makeSession("s1", {
-      cwd: "/home/user/projects/myapp",
-      repo_root: "/home/user/projects/myapp",
-    });
-    const sdk = makeSdkSession("s1");
-    mockState = createMockState({
-      sessions: new Map([["s1", session]]),
-      sdkSessions: [sdk],
-      treeGroups: [{ id: "team-alpha", name: "Takode" }],
-      treeAssignments: new Map([["s1", "team-alpha"]]),
-    });
-
-    render(<Sidebar />);
-    fireEvent.click(screen.getByLabelText("Create session in Takode Session Space"));
-
-    expect(mockState.openNewSessionModal).toHaveBeenCalledWith({
-      treeGroupId: "team-alpha",
-      newSessionDefaultsKey: "tree-group:team-alpha",
-    });
-  });
-
-  it("does not render the old sidebar view mode toggle", () => {
-    const session = makeSession("s1");
-    const sdk = makeSdkSession("s1");
-    mockState = createMockState({
-      sessions: new Map([["s1", session]]),
-      sdkSessions: [sdk],
-    });
-
-    render(<Sidebar />);
-
-    expect(screen.queryByTitle("Tree view (herd groups)")).not.toBeInTheDocument();
-    expect(screen.queryByTitle("Linear view (project groups)")).not.toBeInTheDocument();
-  });
-
-  it("double-clicking a session enters edit mode", async () => {
-    const session = makeSession("s1");
-    const sdk = makeSdkSession("s1");
-    mockState = createMockState({
-      sessions: new Map([["s1", session]]),
-      sdkSessions: [sdk],
-    });
-
-    render(<Sidebar />);
-    const sessionButton = screen.getByText("claude-sonnet-4-5-20250929").closest("button")!;
-    fireEvent.doubleClick(sessionButton);
-
-    // After double-click, an input should appear for renaming
-    const input = await screen.findByDisplayValue("claude-sonnet-4-5-20250929");
-    expect(input).toBeInTheDocument();
-    expect(input.tagName).toBe("INPUT");
-  });
-
-  it("does not steal focus back to the composer after double-click rename starts", async () => {
-    const session = makeSession("s1");
-    const sdk = makeSdkSession("s1");
-    const animationFrameCallbacks: FrameRequestCallback[] = [];
-    const requestAnimationFrameMock = vi.fn((callback: FrameRequestCallback) => {
-      animationFrameCallbacks.push(callback);
-      return animationFrameCallbacks.length;
-    });
-    const originalRequestAnimationFrame = globalThis.requestAnimationFrame;
-    vi.stubGlobal("requestAnimationFrame", requestAnimationFrameMock);
-    mockState = createMockState({
-      sessions: new Map([["s1", session]]),
-      sdkSessions: [sdk],
-    });
-
-    try {
-      render(<Sidebar />);
-      const sessionButton = screen.getByText("claude-sonnet-4-5-20250929").closest("button")!;
-      fireEvent.click(sessionButton);
-      fireEvent.doubleClick(sessionButton);
-
-      await screen.findByDisplayValue("claude-sonnet-4-5-20250929");
-      expect(animationFrameCallbacks.length).toBeGreaterThan(0);
-      mockState.focusComposer.mockClear();
-      while (animationFrameCallbacks.length > 0) {
-        animationFrameCallbacks.shift()?.(performance.now());
-      }
-
-      expect(mockState.focusComposer).not.toHaveBeenCalled();
-    } finally {
-      vi.stubGlobal("requestAnimationFrame", originalRequestAnimationFrame);
-    }
-  });
-
   it("archive button exists in the DOM for session items", () => {
     const session = makeSession("s1");
     const sdk = makeSdkSession("s1");