diff --git a/client/src/App.tsx b/client/src/App.tsx
index d9d9eece..09759155 100644
--- a/client/src/App.tsx
+++ b/client/src/App.tsx
@@ -1,5 +1,5 @@
 import { Component, useState, useEffect, useCallback, useRef, type ReactNode } from "react";
-import { Archive, ArrowRight, Menu, Radar, X } from "lucide-react";
+import { Archive, ArrowRight, Menu, X } from "lucide-react";
 import {
   AlertDialog,
   AlertDialogAction,
@@ -15,15 +15,18 @@ import {
   archiveSession,
   fetchProjects,
   markSessionFocusDone,
-  pinSessionFocus,
   subscribeProjectEvents,
-  unpinSessionFocus,
   type Project,
   type ProjectEvent,
   type Worktree,
 } from "./api.ts";
 import type { ControllerLinkTarget } from "../../shared/conversation-links.ts";
-import { Sidebar, type FocusQueueItem } from "./components/sidebar.tsx";
+import {
+  Sidebar,
+  markFocusItemHandled,
+  sortFocusQueue,
+  type FocusQueueItem,
+} from "./components/sidebar.tsx";
 import { StatusBar } from "./components/StatusBar.tsx";
 import { ProjectSetup } from "./pages/ProjectSetup.tsx";
 import { EditProject } from "./pages/EditProject.tsx";
@@ -31,18 +34,21 @@ import { NewWorktree } from "./pages/NewWorktree.tsx";
 import { SessionView } from "./pages/SessionView.tsx";
 import { SettingsPage, type SettingsSection } from "./pages/Settings.tsx";
 import { useResizablePanel } from "./lib/useResizablePanel.ts";
-import { useControllerModeShortcuts } from "./lib/useControllerModeShortcuts.ts";
+import { useFocusShortcuts } from "./lib/useFocusShortcuts.ts";
 import {
   ShortcutBindingsProvider,
   useShortcutBindingsContext,
 } from "./lib/useShortcutBindings.tsx";
 import { FileIndexProvider } from "./lib/useFileIndex.tsx";
-import { FocusAdvanceToast } from "./components/focus-advance-toast.tsx";
-import { pickNextFocusItem } from "./lib/focus-advance.ts";
+import { pickFirstFocusItem } from "./lib/focus-advance.ts";
+import {
+  loadSavedVisitedAt,
+  persistVisitedAt,
+} from "./lib/focus-visited-storage.ts";
 
 /**
- * Time the focus-advance toast shows a "Moving to next..." countdown
- * before actually navigating. The countdown is what keeps the user
+ * Time the conversation panel shows its auto-advance countdown before
+ * navigating. The countdown is what keeps the user
  * from losing sight of the message they just sent: the in-flight
  * bubble stays on screen for at least this long, and they can
  * cancel the advance with the **Stay** button or Esc.
@@ -53,7 +59,6 @@ const FOCUS_ADVANCE_COUNTDOWN_MS = 4000;
 
 export interface PendingFocusAdvance {
   sentFromSessionId: string;
-  next: FocusQueueItem;
   /** Epoch ms when the advance was scheduled. */
   scheduledAt: number;
 }
@@ -132,16 +137,57 @@ function AppBody() {
     return saved.page === "session" ? saved.projectId : null;
   });
   const [sidebarOpen, setSidebarOpen] = useState(false);
-  const [controllerMode, setControllerMode] = useState(false);
   const [focusQueue, setFocusQueue] = useState<FocusQueueItem[]>([]);
   const [focusRefreshKey, setFocusRefreshKey] = useState(0);
+  // Per-session "last handled" timestamp. Updated only when the user
+  // advances past a session with Next or committed auto-advance. Drives
+  // the visited/unvisited split in `sortFocusQueue` — finished
+  // sessions the user has not handled sit at the top of the
+  // finished block ("triage pile"), and advancing past one sinks it below
+  // the unvisited pile so the user isn't bounced back to them on
+  // every cycle. The persisted key retains its historical "visited"
+  // name for backwards compatibility.
+  //
+  // Hydrated from localStorage on first paint and persisted on
+  // every update so the triage pile survives a reload. Without
+  // persistence, a reload re-surfaces every pinned session as
+  // "fresh" again and loses the user's triage progress.
+  const [visitedAt, setVisitedAt] = useState<Record<string, string>>(
+    () => loadSavedVisitedAt(window.localStorage),
+  );
+  // Write-through to localStorage whenever `visitedAt` changes. A
+  // dedicated effect is cleaner than wrapping the setter because
+  // Watching the state guarantees we persist exactly the value that
+  // just became canonical. Persistence failures are swallowed inside
+  // `persistVisitedAt`; the in-memory state still works.
+  useEffect(() => {
+    persistVisitedAt(window.localStorage, visitedAt);
+  }, [visitedAt]);
+  // Post-reply auto-advance countdown: on by default. When off,
+  // replies stay on the current session until the user hits Next,
+  // Mark Done, or re-enables the toggle. The Next chord always
+  // advances regardless of this setting (it's the manual escape
+  // hatch). Persisted to localStorage so a user who turns it off
+  // doesn't have to turn it off again on every reload.
+  const [autoAdvance, setAutoAdvance] = useState<boolean>(() => {
+    try {
+      const saved = window.localStorage.getItem(
+        "controller.focus.autoAdvance",
+      );
+      if (saved === "false") return false;
+    } catch {
+      // localStorage can throw in private-mode browsers; fall
+      // through to the default.
+    }
+    return true;
+  });
   // Live shortcut bindings shared with the Settings panel and the
-  // Controller Mode keyboard listener. Read here (top of AppBody) so
-  // both `handleFocusAdvanceAfterSend` and `useControllerModeShortcuts`
-  // can pass the same map into the toast and the keydown handler.
+  // Focus-queue keyboard listener. Read here (top of AppBody) so
+  // both the conversation panel and `useFocusShortcuts` can use the
+  // same configured chords.
   const shortcutBindings = useShortcutBindingsContext();
   // Scheduled "advance to the next focus item" while a 4-second
-  // countdown is showing in a toast. Set by
+  // countdown is showing in the conversation panel. Set by
   // `handleFocusAdvanceAfterSend` after a send, cleared either by the
   // timer firing (then we navigate) or by any of the cancel paths
   // (S, Esc, manual nav, unmount). See issue #104.
@@ -155,16 +201,19 @@ function AppBody() {
     { added: number; deleted: number } | null
   >(null);
   const pendingFocusAdvanceRef = useRef<PendingFocusAdvance | null>(null);
+  const focusQueueRef = useRef<FocusQueueItem[]>([]);
+  const visitedAtRef = useRef(visitedAt);
   const advanceTimerRef = useRef<number | null>(null);
-  const advanceToastIdRef = useRef<string | number | null>(null);
   // The view to return to when settings is closed (the last non-settings view).
   const preSettingsViewRef = useRef<View>({ page: "empty" });
 
-  const dismissAdvanceToast = () => {
-    if (advanceToastIdRef.current === null) return;
-    toast.dismiss(advanceToastIdRef.current);
-    advanceToastIdRef.current = null;
-  };
+  useEffect(() => {
+    focusQueueRef.current = focusQueue;
+  }, [focusQueue]);
+
+  useEffect(() => {
+    visitedAtRef.current = visitedAt;
+  }, [visitedAt]);
 
   const setView = (v: View) => {
     // Entering settings: remember the view we're leaving so closing returns there.
@@ -181,15 +230,29 @@ function AppBody() {
       advanceTimerRef.current = null;
     }
     pendingFocusAdvanceRef.current = null;
-    dismissAdvanceToast();
     setPendingFocusAdvance((current) => (current ? null : current));
   };
 
   const closeSidebar = () => setSidebarOpen(false);
 
-  const handleFocusQueueChange = useCallback((queue: FocusQueueItem[]) => {
-    setFocusQueue(queue);
-  }, []);
+  const handleFocusQueueChange = useCallback(
+    (queue: FocusQueueItem[]) => {
+      // Overlay the per-session handled timestamps onto the items the
+      // sidebar emitted, then sort via the shared helper. The sidebar
+      // builds the raw items (it owns the runtime / projectData
+      // fetches); App owns the visit tracking and the canonical
+      // ordering.
+      const withVisits = queue.map((item) => {
+        const visited = visitedAtRef.current[item.session.id];
+        if (visited === item.lastVisitedAt) return item;
+        return { ...item, lastVisitedAt: visited };
+      });
+      const sorted = sortFocusQueue(withVisits);
+      focusQueueRef.current = sorted;
+      setFocusQueue(sorted);
+    },
+    [],
+  );
 
   /**
    * Open a pinned focus item by switching the view to its session
@@ -208,9 +271,48 @@ function AppBody() {
   }, []);
 
   /**
-   * Commit a scheduled focus advance: navigate to the target session
-   * and clear the pending state. Safe to call when nothing is pending
-   * (it just no-ops).
+   * Advance past a session in two explicit steps: first mark and
+   * re-sort the current item, then open the new first queue item.
+   * Resolving the destination after the mutation keeps navigation
+   * aligned with exactly what the sidebar displays.
+   */
+  const advancePastFocusItem = useCallback(
+    (sessionId: string) => {
+      const currentQueue = focusQueueRef.current;
+      const isPinned = currentQueue.some(
+        (item) => item.session.id === sessionId,
+      );
+      let reordered = currentQueue;
+
+      if (isPinned) {
+        const handledAt = new Date().toISOString();
+        const nextVisitedAt = {
+          ...visitedAtRef.current,
+          [sessionId]: handledAt,
+        };
+        visitedAtRef.current = nextVisitedAt;
+        setVisitedAt(nextVisitedAt);
+
+        reordered = markFocusItemHandled(
+          currentQueue,
+          sessionId,
+          handledAt,
+        );
+        focusQueueRef.current = reordered;
+        setFocusQueue(reordered);
+      }
+
+      const next = pickFirstFocusItem(reordered, sessionId);
+      if (next) openFocusItem(next);
+    },
+    [openFocusItem],
+  );
+
+  /**
+   * Commit a scheduled focus advance: reorder the originating session,
+   * then navigate to the queue's new first row. The target is resolved
+   * here rather than when the countdown starts, so live queue changes
+   * during those four seconds are respected.
    */
   const commitPendingAdvance = useCallback(() => {
     const pending = pendingFocusAdvanceRef.current;
@@ -221,9 +323,8 @@ function AppBody() {
       window.clearTimeout(advanceTimerRef.current);
       advanceTimerRef.current = null;
     }
-    dismissAdvanceToast();
-    openFocusItem(pending.next);
-  }, [openFocusItem]);
+    advancePastFocusItem(pending.sentFromSessionId);
+  }, [advancePastFocusItem]);
 
   /**
    * Cancel a scheduled focus advance: clear the pending state and
@@ -236,7 +337,6 @@ function AppBody() {
       window.clearTimeout(advanceTimerRef.current);
       advanceTimerRef.current = null;
     }
-    dismissAdvanceToast();
   }, []);
 
   // Clear the countdown on unmount so a stale timer doesn't fire
@@ -248,7 +348,6 @@ function AppBody() {
         advanceTimerRef.current = null;
       }
       pendingFocusAdvanceRef.current = null;
-      dismissAdvanceToast();
     };
   }, []);
 
@@ -297,44 +396,6 @@ function AppBody() {
     };
   }, [activeProjectId, scheduleEventsRefetch]);
 
-  const handleControllerModeToggle = useCallback(() => {
-    if (controllerMode) {
-      setControllerMode(false);
-      cancelPendingAdvance();
-      return;
-    }
-    const firstItem = focusQueue[0];
-    if (!firstItem) {
-      toast.info("Add a session to On radar to use Controller Mode");
-      return;
-    }
-    setControllerMode(true);
-    openFocusItem(firstItem);
-  }, [controllerMode, focusQueue, openFocusItem, cancelPendingAdvance]);
-
-  const handleControllerModeEnter = useCallback(() => {
-    const firstItem = focusQueue[0];
-    if (!firstItem) {
-      toast.info("Add a session to On radar to use Controller Mode");
-      return;
-    }
-    setControllerMode(true);
-    openFocusItem(firstItem);
-  }, [focusQueue, openFocusItem]);
-
-  const handleControllerModeExit = useCallback(() => {
-    setControllerMode(false);
-    // Exiting controller mode also cancels any pending advance — the
-    // target session is no longer relevant once controller mode is off.
-    if (advanceTimerRef.current !== null) {
-      window.clearTimeout(advanceTimerRef.current);
-      advanceTimerRef.current = null;
-    }
-    pendingFocusAdvanceRef.current = null;
-    dismissAdvanceToast();
-    setPendingFocusAdvance(null);
-  }, []);
-
   const handleSelectProject = (projectId: string) => {
     setActiveProjectId(projectId);
     setView({ page: "session", projectId });
@@ -425,14 +486,34 @@ function AppBody() {
     setMobileDiffSummary(null);
   }, [activeView.page === "session" ? activeView.sessionId : null]);
 
-  const focusPosition =
-    currentFocusIndex >= 0
-      ? { current: currentFocusIndex + 1, total: focusQueue.length }
-      : controllerMode
-        ? { current: 0, total: focusQueue.length }
-        : undefined;
-  const currentFocusItem = currentFocusIndex >= 0 ? focusQueue[currentFocusIndex] : null;
+  // When handled timestamps change, re-sort the queue so handled items
+  // sink below the unvisited triage pile. Avoid an infinite loop
+  // by checking that the timestamps are actually different before
+  // triggering the sort.
+  useEffect(() => {
+    setFocusQueue((current) => {
+      const withVisits = current.map((item) => {
+        const visited = visitedAt[item.session.id];
+        if (visited === item.lastVisitedAt) return item;
+        return { ...item, lastVisitedAt: visited };
+      });
+      const sorted = sortFocusQueue(withVisits);
+      // Bail if nothing actually changed (same array reference,
+      // same item references). `sortFocusQueue` returns a fresh
+      // array even when order is unchanged, so we compare items.
+      if (
+        sorted.length === current.length &&
+        sorted.every((item, i) => item === current[i])
+      ) {
+        focusQueueRef.current = current;
+        return current;
+      }
+      focusQueueRef.current = sorted;
+      return sorted;
+    });
+  }, [visitedAt]);
 
+  const currentFocusItem = currentFocusIndex >= 0 ? focusQueue[currentFocusIndex] : null;
   const handleFocusSkip = () => {
     // If a countdown is already scheduled, `N` (and the **Next**
     // button) commit it immediately rather than skipping to a
@@ -442,31 +523,36 @@ function AppBody() {
       return;
     }
     if (focusQueue.length === 0) {
-      setControllerMode(false);
       toast.info("Focus queue is empty");
       return;
     }
-    const nextIndex =
-      currentFocusIndex >= 0 ? (currentFocusIndex + 1) % focusQueue.length : 0;
-    openFocusItem(focusQueue[nextIndex]);
+    const sentFromId =
+      currentFocusItem?.session.id ?? activeView.sessionId ?? "";
+    advancePastFocusItem(sentFromId);
   };
 
-  const handleToggleCurrentSessionPin = async () => {
-    if (activeView.page !== "session" || !activeView.sessionId) return;
-    const { projectId, worktreeId, sessionId } = activeView;
-    const pinned = currentFocusIndex >= 0;
-
+  // Toggle the post-reply auto-advance countdown. Persists to
+  // localStorage so the choice survives reloads. Next, Stay, and Mark
+  // Done are unaffected — they always work regardless of this
+  // setting (Next is the manual escape hatch).
+  //
+  // Toggling OFF also cancels any in-flight countdown: the user has
+  // just said "I want to stay on this session," so honoring a
+  // 4-second-old auto-advance schedule contradicts that intent.
+  const handleToggleAutoAdvance = useCallback(() => {
+    const nextValue = !autoAdvance;
+    setAutoAdvance(nextValue);
     try {
-      if (pinned) {
-        await unpinSessionFocus(projectId, sessionId, worktreeId);
-      } else {
-        await pinSessionFocus(projectId, sessionId, worktreeId);
-      }
-      setFocusRefreshKey((key) => key + 1);
-    } catch (err) {
-      toast.error(err instanceof Error ? err.message : "Failed to update focus queue");
+      window.localStorage.setItem(
+        "controller.focus.autoAdvance",
+        nextValue ? "true" : "false",
+      );
+    } catch {
+      // localStorage can throw in private-mode browsers; the
+      // in-memory state still flips for the rest of the session.
     }
-  };
+    if (!nextValue) cancelPendingAdvance();
+  }, [autoAdvance, cancelPendingAdvance]);
 
   const handleArchiveCurrentSession = () => {
     if (activeView.page !== "session" || !activeView.sessionId) return;
@@ -514,76 +600,66 @@ function AppBody() {
             item.session.id === sessionId
           )
       );
+      focusQueueRef.current = nextQueue;
       setFocusQueue(nextQueue);
       setFocusRefreshKey((key) => key + 1);
 
       if (nextQueue.length === 0) {
-        setControllerMode(false);
         toast.success("Focus queue complete");
         return;
       }
 
-      const nextIndex =
-        currentFocusIndex >= 0
-          ? currentFocusIndex % nextQueue.length
-          : 0;
-      openFocusItem(nextQueue[nextIndex]);
+      openFocusItem(nextQueue[0]);
     } catch (err) {
       toast.error(err instanceof Error ? err.message : "Failed to update focus queue");
     }
   };
 
-  // After the user sends a message in controller mode, schedule an
-  // advance to the next focus item rather than navigating
-  // immediately. The user just committed a message, and bouncing
-  // them away from the originating session before the in-flight
-  // user bubble can render is what made the message look "lost"
-  // (issue #104). The countdown gives them FOCUS_ADVANCE_COUNTDOWN_MS
-  // to see the bubble, with the **Stay** chord (default ⌃S / Ctrl+S)
-  // or Esc for cancelling.
+  // After the user sends a message, schedule an advance to the next
+  // focus item rather than navigating immediately. The user just
+  // committed a message, and bouncing them away from the originating
+  // session before the in-flight user bubble can render is what made
+  // the message look "lost" (issue #104). The countdown gives them
+  // FOCUS_ADVANCE_COUNTDOWN_MS to see the bubble, with the **Stay**
+  // chord (default ⌃S / Ctrl+S) or Esc for cancelling.
   //
   // The "sent from" session id is passed in so we can apply the
   // stay-put rule when the only pinned item is the one the user
   // just replied to (queue-of-one, no-op).
+  //
+  // When `autoAdvance` is off, replies stay on the current session —
+  // the user has to hit Next (manual skip), Mark Done (removes from
+  // queue), or re-enable the toggle. Staying does not reorder it.
   const handleFocusAdvanceAfterSend = useCallback(
     (sentFromSessionId: string) => {
-      if (!controllerMode) return;
-      const next = pickNextFocusItem(focusQueue, sentFromSessionId);
-      if (!next) return;
+      if (!autoAdvance) return;
+      // Only schedule when another row exists, but deliberately do not
+      // cache which row it is. The commit resolves the new first item
+      // after demoting the current session and applying any live queue
+      // updates that arrived during the countdown.
+      if (!pickFirstFocusItem(focusQueueRef.current, sentFromSessionId)) return;
       // Replace any existing pending advance (the user sent again
       // before the previous countdown finished). The new origin
       // session is what matters; we restart the clock.
       if (advanceTimerRef.current !== null) {
         window.clearTimeout(advanceTimerRef.current);
       }
-      dismissAdvanceToast();
       const pendingAdvance = {
         sentFromSessionId,
-        next,
         scheduledAt: Date.now(),
       };
       pendingFocusAdvanceRef.current = pendingAdvance;
       setPendingFocusAdvance(pendingAdvance);
-      advanceToastIdRef.current = toast.custom(
-        () => (
-          <FocusAdvanceToast
-            scheduledAt={pendingAdvance.scheduledAt}
-            durationMs={FOCUS_ADVANCE_COUNTDOWN_MS}
-            bindings={shortcutBindings.bindings}
-            onCancel={cancelPendingAdvance}
-          />
-        ),
-        {
-          duration: Infinity,
-          position: "top-right",
-          unstyled: true,
-        },
-      );
       advanceTimerRef.current = window.setTimeout(() => {
         commitPendingAdvance();
       }, FOCUS_ADVANCE_COUNTDOWN_MS);
     },
-    [controllerMode, focusQueue, commitPendingAdvance, cancelPendingAdvance, shortcutBindings.bindings],
+    [
+      autoAdvance,
+      commitPendingAdvance,
+      cancelPendingAdvance,
+      shortcutBindings.bindings,
+    ],
   );
 
   // Sidebar resizing
@@ -594,22 +670,20 @@ function AppBody() {
     maxWidth: 480,
   });
 
-  // Controller Mode keyboard shortcuts (defaults: ⌃T toggle, ⌃N next,
-  // ⌃D done, ⌃S stay; ⌃ on macOS, Ctrl off-mac). We default to Ctrl
-  // rather than Cmd because Cmd collides with too many macOS system
-  // shortcuts (Cmd+W, Cmd+Q, Cmd+R, Cmd+T, …). The chord for each
-  // action is read from `useShortcutBindings`, so users can rebind
-  // them in Settings (issue #235). The matcher is strict per-platform:
-  // a stored "ctrl-n" only fires on ⌃N on macOS, never on ⌘N. Esc
-  // still blurs and (when not in an editable) cancels a pending
-  // advance.
-  useControllerModeShortcuts({
+  // Focus-queue keyboard shortcuts (defaults: ⌃N next, ⌃D done, ⌃S
+  // stay, ⌃T toggle auto-advance; ⌃ on macOS, Ctrl off-mac). We
+  // default to Ctrl rather than Cmd because Cmd collides with too
+  // many macOS system shortcuts (Cmd+W, Cmd+Q, Cmd+R, …). The chord
+  // for each action is read from `useShortcutBindings`, so users can
+  // rebind them in Settings (issue #235). The matcher is strict
+  // per-platform: a stored "ctrl-n" only fires on ⌃N on macOS, never
+  // on ⌘N. Esc still blurs and (when not in an editable) cancels a
+  // pending advance.
+  useFocusShortcuts({
     bindings: shortcutBindings.bindings,
-    controllerMode,
     onSkip: handleFocusSkip,
     onDone: handleFocusDone,
-    onEnter: handleControllerModeEnter,
-    onExit: handleControllerModeExit,
+    onToggleAutoAdvance: handleToggleAutoAdvance,
     onCancelAdvance: pendingFocusAdvance ? cancelPendingAdvance : undefined,
     onCommitAdvance: pendingFocusAdvance ? commitPendingAdvance : undefined,
   });
@@ -668,9 +742,7 @@ function AppBody() {
             closeSidebar();
           }}
           onFocusQueueChange={handleFocusQueueChange}
-          controllerMode={controllerMode}
-          onControllerModeToggle={handleControllerModeToggle}
-          shortcutBindings={shortcutBindings.bindings}
+          focusQueue={focusQueue}
           focusRefreshKey={focusRefreshKey}
           eventsRefreshKey={eventsRefreshKey}
         />
@@ -705,19 +777,6 @@ function AppBody() {
               <span className="text-red-400/90">-{mobileDiffSummary.deleted}</span>
             </span>
           )}
-          {activeView.page === "session" && activeView.sessionId && (
-            <button
-              onClick={handleToggleCurrentSessionPin}
-              className={`shrink-0 rounded-md p-1.5 transition-colors ${
-                currentFocusIndex >= 0
-                  ? "bg-blue-500/15 text-blue-300 hover:bg-blue-500/25 hover:text-blue-200"
-                  : "text-muted-foreground hover:bg-accent hover:text-foreground"
-              }`}
-              title={currentFocusIndex >= 0 ? "Remove from Radar" : "Add to Radar"}
-            >
-              <Radar className="h-4 w-4" />
-            </button>
-          )}
           {activeView.page === "session" && activeView.sessionId && (
             <button
               onClick={handleArchiveCurrentSession}
@@ -792,12 +851,11 @@ function AppBody() {
               loadProjects();
             }}
             onOpenConversation={handleOpenConversation}
-            controllerMode={controllerMode}
             shortcutBindings={shortcutBindings.bindings}
-            focusPosition={focusPosition}
+            autoAdvance={autoAdvance}
+            onToggleAutoAdvance={handleToggleAutoAdvance}
             onFocusDone={handleFocusDone}
             onFocusSkip={handleFocusSkip}
-            onFocusExit={handleControllerModeExit}
             onFocusPinnedChange={() => setFocusRefreshKey((key) => key + 1)}
             onTitleChange={() => setFocusRefreshKey((key) => key + 1)}
             onArchive={handleArchiveCurrentSession}
@@ -806,11 +864,9 @@ function AppBody() {
             focusAdvanceCountdown={
               pendingFocusAdvance
                 ? {
-                    // SessionView only needs the origin to preserve
-                    // the pending message and cancel if the user
-                    // starts typing there again. The visible
-                    // countdown lives in the toast.
                     sentFromSessionId: pendingFocusAdvance.sentFromSessionId,
+                    scheduledAt: pendingFocusAdvance.scheduledAt,
+                    durationMs: FOCUS_ADVANCE_COUNTDOWN_MS,
                     onCancel: cancelPendingAdvance,
                   }
                 : null
diff --git a/client/src/api.ts b/client/src/api.ts
index 63599d82..983d4494 100644
--- a/client/src/api.ts
+++ b/client/src/api.ts
@@ -122,6 +122,13 @@ export interface SessionRuntimeEntry {
   provider?: string;
   projectId?: string;
   worktreeId?: string;
+  /**
+   * True when the agent has paused on a user-input request OR has at
+   * least one pending tool approval. The focus-queue sidebar uses
+   * this as the highest-priority "needs your attention" signal
+   * regardless of the session's `active` state.
+   */
+  awaitingInput?: boolean;
 }
 
 export interface AgentEvent {
diff --git a/client/src/components/__tests__/focus-advance-toast.test.tsx b/client/src/components/__tests__/focus-advance-toast.test.tsx
deleted file mode 100644
index ddfede7c..00000000
--- a/client/src/components/__tests__/focus-advance-toast.test.tsx
+++ /dev/null
@@ -1,96 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { renderToStaticMarkup } from "react-dom/server";
-import {
-  DEFAULT_SHORTCUT_BINDINGS,
-  type ShortcutBindings,
-} from "../../../../shared/shortcuts.ts";
-import { formatChord, isMacPlatform } from "../../lib/shortcut-match.ts";
-import { FocusAdvanceToast } from "../focus-advance-toast.tsx";
-
-/*
- * Regression test for the focus-advance countdown toast (issue
- * follow-up to #235).
- *
- * Background: issue #235 moved every Controller Mode shortcut to a
- * modifier-based chord so it fires regardless of focus (default
- * `Ctrl+S` for stay, `Ctrl+N` for continue). The toast copy was left
- * untouched, advertising "Press S to stay · N to continue" — strings
- * that no longer match the keys the listener honours.
- *
- * This test asserts the toast surfaces the actual chords:
- *
- *   - With `bindings === null` (first paint, before the server fetch
- *     resolves) it falls back to the bundled defaults so the copy is
- *     never the stale single-letter "S" / "N".
- *   - With a custom `bindings` map (e.g. user rebound next to
- *     `cmd-shift-n` in Settings) the toast reflects that binding
- *     verbatim so the visible chip and the live chord stay in sync.
- *
- * We mirror the toast's `formatChord(chord, isMacPlatform())` call
- * here so the expected labels track the platform the test runs on
- * (macOS renders ⌃S, Linux/Windows render Ctrl+S) without
- * duplicating formatter logic.
- *
- * `renderToStaticMarkup` is enough — we don't need DOM effects for
- * the chip text, and the countdown timer isn't under test here.
- */
-
-const NOOP = () => {};
-
-function render(bindings: ShortcutBindings | null): string {
-  return renderToStaticMarkup(
-    <FocusAdvanceToast
-      scheduledAt={Date.now()}
-      durationMs={4000}
-      bindings={bindings}
-      onCancel={NOOP}
-    />,
-  );
-}
-
-function labelFor(chord: string): string {
-  return formatChord(chord, isMacPlatform());
-}
-
-test("toast falls back to default stay / next chips when bindings are null", () => {
-  const html = render(null);
-  const stayDefault = labelFor(DEFAULT_SHORTCUT_BINDINGS.controllerModeStay);
-  const nextDefault = labelFor(DEFAULT_SHORTCUT_BINDINGS.controllerModeNext);
-  assert.ok(
-    html.includes(`>${stayDefault}</span> to stay`),
-    `expected toast to render default stay label "${stayDefault}", got: ${html}`,
-  );
-  assert.ok(
-    html.includes(`>${nextDefault}</span> to continue`),
-    `expected toast to render default next label "${nextDefault}", got: ${html}`,
-  );
-  // And — critically — the stale single-letter copy must not be present.
-  assert.ok(
-    !/>S<\/span> to stay/.test(html),
-    "stale single-letter 'S' chip must be gone",
-  );
-  assert.ok(
-    !/>N<\/span> to continue/.test(html),
-    "stale single-letter 'N' chip must be gone",
-  );
-});
-
-test("toast surfaces the rebound chord when the user customises it in Settings", () => {
-  const rebound: ShortcutBindings = {
-    ...DEFAULT_SHORTCUT_BINDINGS,
-    controllerModeStay: "ctrl-shift-s",
-    controllerModeNext: "ctrl-shift-n",
-  };
-  const html = render(rebound);
-  const stayLabel = labelFor(rebound.controllerModeStay);
-  const nextLabel = labelFor(rebound.controllerModeNext);
-  assert.ok(
-    html.includes(`>${stayLabel}</span> to stay`),
-    `expected rebound stay label "${stayLabel}", got: ${html}`,
-  );
-  assert.ok(
-    html.includes(`>${nextLabel}</span> to continue`),
-    `expected rebound next label "${nextLabel}", got: ${html}`,
-  );
-});
\ No newline at end of file
diff --git a/client/src/components/__tests__/focus-conversation-controls.test.tsx b/client/src/components/__tests__/focus-conversation-controls.test.tsx
new file mode 100644
index 00000000..b07f6cb1
--- /dev/null
+++ b/client/src/components/__tests__/focus-conversation-controls.test.tsx
@@ -0,0 +1,96 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { renderToStaticMarkup } from "react-dom/server";
+import { FocusConversationControls } from "../focus-conversation-controls.tsx";
+
+function render(
+  variant: "mobile" | "desktop",
+  options: {
+    isOnRadar?: boolean;
+    countdown?: boolean;
+    autoAdvance?: boolean;
+  } = {},
+) {
+  return renderToStaticMarkup(
+    <FocusConversationControls
+      variant={variant}
+      bindings={null}
+      isOnRadar={options.isOnRadar ?? true}
+      autoAdvance={options.autoAdvance ?? true}
+      onNext={() => {}}
+      onDone={() => {}}
+      onAddToRadar={() => {}}
+      onToggleAutoAdvance={() => {}}
+      countdown={options.countdown ? {
+        scheduledAt: Date.now(),
+        durationMs: 4000,
+        onStay: () => {},
+      } : null}
+    />,
+  );
+}
+
+test("mobile controls restore the compact radar row with Next and Done", () => {
+  const html = render("mobile");
+  assert.match(html, /focus-conversation-controls-mobile/);
+  assert.match(html, /md:hidden/);
+  assert.match(html, />Next</);
+  assert.match(html, />Done</);
+  assert.match(html, /Auto advance/);
+  assert.match(html, /Auto-advance/);
+  assert.doesNotMatch(html, /On radar \d/);
+});
+
+test("desktop controls render as a top-right floating panel", () => {
+  const html = render("desktop");
+  assert.match(html, /focus-conversation-controls-desktop/);
+  assert.match(html, /absolute right-4 top-4/);
+  assert.match(html, /hidden/);
+  assert.match(html, /md:flex/);
+  assert.match(html, /flex-col items-stretch/);
+  assert.match(html, />Next</);
+  assert.match(html, />Done</);
+});
+
+test("an unpinned session keeps the panel with Next and Add to radar", () => {
+  const html = render("desktop", { isOnRadar: false });
+  assert.match(html, /Add to radar/);
+  assert.match(html, />Next</);
+  assert.doesNotMatch(html, />Done</);
+});
+
+test("the panel owns the auto-advance switch state", () => {
+  const enabledHtml = render("desktop");
+  assert.match(enabledHtml, /data-checked=""/);
+  assert.match(enabledHtml, /Ctrl\+T|⌃T/);
+  assert.match(
+    render("desktop", { autoAdvance: false }),
+    /data-unchecked=""/,
+  );
+});
+
+test("the panel replaces normal actions with the auto-advance countdown", () => {
+  const html = render("desktop", { countdown: true });
+  assert.match(html, /Advancing in 4s/);
+  assert.match(html, />Stay</);
+  assert.match(html, /lucide-pause/);
+  assert.match(html, />Next</);
+  assert.match(html, /Ctrl\+S|⌃S/);
+  assert.match(html, /flex-col items-stretch/);
+  assert.doesNotMatch(html, />Done</);
+});
+
+test("the mobile countdown keeps only the plain Stay action", () => {
+  const html = render("mobile", { countdown: true });
+  assert.match(html, /Advancing in 4s/);
+  assert.match(html, />Stay</);
+  assert.match(html, /lucide-pause/);
+  assert.doesNotMatch(html, />Next</);
+  assert.doesNotMatch(html, /Ctrl\+S|⌃S/);
+});
+
+test("mobile normal controls do not expose shortcut chips or tooltips", () => {
+  const html = render("mobile");
+  assert.doesNotMatch(html, /Ctrl\+[NSTD]|⌃[NSTD]/);
+  assert.doesNotMatch(html, /data-slot="kbd"/);
+});
diff --git a/client/src/components/__tests__/sidebar-sort-focus-queue.test.tsx b/client/src/components/__tests__/sidebar-sort-focus-queue.test.tsx
new file mode 100644
index 00000000..0d90f385
--- /dev/null
+++ b/client/src/components/__tests__/sidebar-sort-focus-queue.test.tsx
@@ -0,0 +1,314 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  markFocusItemHandled,
+  sortFocusQueue,
+  type FocusQueueItem,
+} from "../sidebar.tsx";
+
+function item(
+  id: string,
+  lastActiveAt: string,
+  active: boolean,
+  lastVisitedAt?: string,
+): FocusQueueItem {
+  // The sort only inspects `session.lastActiveAt`, `active`, and
+  // `lastVisitedAt`; the rest of the fields are filler so the
+  // resulting type matches `FocusQueueItem`.
+  return {
+    projectId: "p",
+    projectName: "P",
+    worktreeId: "w",
+    worktreeName: "W",
+    session: {
+      id,
+      workingDirectory: "/tmp",
+      worktreeId: "w",
+      model: "test",
+      messages: [],
+      createdAt: lastActiveAt,
+      lastActiveAt,
+      status: "idle",
+    },
+    active,
+    lastVisitedAt,
+  };
+}
+
+function ids(items: FocusQueueItem[]): string[] {
+  return items.map((item) => item.session.id);
+}
+
+test("all-finished: oldest-arrival at the top of the finished block (FIFO)", () => {
+  // Finished items are ordered by `lastActiveAt` ascending, so the
+  // user walks them in arrival order — the oldest one first.
+  const result = sortFocusQueue([
+    item("newest-arrival", "2024-01-03T00:00:00.000Z", false),
+    item("oldest-arrival", "2024-01-01T00:00:00.000Z", false),
+    item("middle-arrival", "2024-01-02T00:00:00.000Z", false),
+  ]);
+  assert.deepEqual(ids(result), [
+    "oldest-arrival",
+    "middle-arrival",
+    "newest-arrival",
+  ]);
+});
+
+test("all-running: oldest running at the top, newest at the bottom", () => {
+  const result = sortFocusQueue([
+    item("newest", "2024-01-03T00:00:00.000Z", true),
+    item("oldest", "2024-01-01T00:00:00.000Z", true),
+    item("middle", "2024-01-02T00:00:00.000Z", true),
+  ]);
+  assert.deepEqual(ids(result), ["oldest", "middle", "newest"]);
+});
+
+test("mixed: finished block (oldest first) sits above the running block", () => {
+  const result = sortFocusQueue([
+    item("running-newest", "2024-01-10T00:00:00.000Z", true),
+    item("finished-oldest-arrival", "2024-01-01T00:00:00.000Z", false),
+    item("running-oldest", "2024-01-05T00:00:00.000Z", true),
+    item("finished-newest-arrival", "2024-01-04T00:00:00.000Z", false),
+  ]);
+  assert.deepEqual(ids(result), [
+    "finished-oldest-arrival",
+    "finished-newest-arrival",
+    "running-oldest",
+    "running-newest",
+  ]);
+});
+
+test("ties on lastActiveAt fall back to array order within each bucket", () => {
+  // Array#sort is stable (Node ≥ 12), so equal timestamps keep their
+  // original relative order. The acceptance criteria explicitly allow
+  // this fallback.
+  const result = sortFocusQueue([
+    item("a", "2024-01-01T00:00:00.000Z", false),
+    item("b", "2024-01-01T00:00:00.000Z", false),
+    item("c", "2024-01-01T00:00:00.000Z", false),
+  ]);
+  assert.deepEqual(ids(result), ["a", "b", "c"]);
+});
+
+test("a freshly-finished running session appends to the bottom of the finished block", () => {
+  // Two running sessions ("running-newer" is the most recently started,
+  // so it sits at the bottom of the running bucket) and one finished
+  // session that arrived a long time ago.
+  const before = sortFocusQueue([
+    item("finished-old-arrival", "2024-01-01T00:00:00.000Z", false),
+    item("running-older", "2024-01-02T00:00:00.000Z", true),
+    item("running-newer", "2024-01-05T00:00:00.000Z", true),
+  ]);
+  assert.deepEqual(ids(before), [
+    "finished-old-arrival",
+    "running-older",
+    "running-newer",
+  ]);
+
+  // "running-newer" finishes in the same render. Its `lastActiveAt`
+  // is the most recent of the finished pile, so it lands at the
+  // bottom of the finished block (newest-arrival there), just above
+  // the running sessions.
+  const after = sortFocusQueue([
+    item("finished-old-arrival", "2024-01-01T00:00:00.000Z", false),
+    item("running-older", "2024-01-02T00:00:00.000Z", true),
+    item("running-newer", "2024-01-05T00:00:00.000Z", false),
+  ]);
+  assert.deepEqual(ids(after), [
+    "finished-old-arrival",
+    "running-newer",
+    "running-older",
+  ]);
+});
+
+test("does not mutate the input array", () => {
+  const input: FocusQueueItem[] = [
+    item("running", "2024-01-02T00:00:00.000Z", true),
+    item("finished", "2024-01-01T00:00:00.000Z", false),
+  ];
+  const snapshot = ids(input);
+  sortFocusQueue(input);
+  assert.deepEqual(ids(input), snapshot);
+});
+
+// ---------------------------------------------------------------------------
+// Awaiting-input priority (issue #333 follow-up).
+// ---------------------------------------------------------------------------
+
+function awaitingItem(
+  id: string,
+  lastActiveAt: string,
+  active: boolean,
+): FocusQueueItem {
+  return {
+    ...item(id, lastActiveAt, active),
+    awaitingInput: true,
+  };
+}
+
+test("awaiting-input: surfaces at the top of the queue regardless of `active`", () => {
+  // Claude's structured-input pause kills the child (active: false)
+  // but the session still needs the user. The flag wins.
+  const result = sortFocusQueue([
+    awaitingItem("paused", "2024-01-05T00:00:00.000Z", false),
+    item("running-oldest", "2024-01-01T00:00:00.000Z", true),
+    item("running-newest", "2024-01-02T00:00:00.000Z", true),
+  ]);
+  assert.deepEqual(ids(result), [
+    "paused",
+    "running-oldest",
+    "running-newest",
+  ]);
+});
+
+test("awaiting-input: wins over a recently-finished item with a fresher timestamp", () => {
+  // The finished item arrived after the awaiting one. The awaiting
+  // one still wins because the user owes a reply to it.
+  const result = sortFocusQueue([
+    item("finished-just-now", "2024-01-10T00:00:00.000Z", false),
+    awaitingItem("awaiting", "2024-01-05T00:00:00.000Z", false),
+  ]);
+  assert.deepEqual(ids(result), ["awaiting", "finished-just-now"]);
+});
+
+test("awaiting-input: multiple awaiting sessions are ordered oldest-arrival first", () => {
+  const result = sortFocusQueue([
+    awaitingItem("awaiting-newest-arrival", "2024-01-05T00:00:00.000Z", false),
+    awaitingItem("awaiting-oldest-arrival", "2024-01-01T00:00:00.000Z", false),
+    item("running", "2024-01-02T00:00:00.000Z", true),
+  ]);
+  assert.deepEqual(ids(result), [
+    "awaiting-oldest-arrival",
+    "awaiting-newest-arrival",
+    "running",
+  ]);
+});
+
+test("awaiting-input: bucket sits above the finished bucket sits above the running bucket", () => {
+  const result = sortFocusQueue([
+    item("running-newest", "2024-01-10T00:00:00.000Z", true),
+    item("finished-oldest-arrival", "2024-01-01T00:00:00.000Z", false),
+    item("running-oldest", "2024-01-02T00:00:00.000Z", true),
+    awaitingItem("awaiting", "2024-01-06T00:00:00.000Z", false),
+    item("finished-newest-arrival", "2024-01-04T00:00:00.000Z", false),
+  ]);
+  assert.deepEqual(ids(result), [
+    "awaiting",
+    "finished-oldest-arrival",
+    "finished-newest-arrival",
+    "running-oldest",
+    "running-newest",
+  ]);
+});
+
+// ---------------------------------------------------------------------------
+// Visited vs unvisited split (issue #333 follow-up).
+//
+// The finished block is split into "triage pile" (never visited by
+// the user) and "already seen" (visited at some point). The unvisited
+// pile stays at the top of the finished block; once a session is
+// visited (skipped, replied to, etc.), it sinks to the visited
+// sub-block so the user isn't bounced back to it on every cycle.
+// ---------------------------------------------------------------------------
+
+test("finished, unvisited: oldest-arrival first at the top of the finished block", () => {
+  // No items visited yet — pure triage pile, sorted oldest-first.
+  const result = sortFocusQueue([
+    item("finished-newest-arrival", "2024-01-05T00:00:00.000Z", false),
+    item("finished-oldest-arrival", "2024-01-01T00:00:00.000Z", false),
+    item("finished-middle-arrival", "2024-01-03T00:00:00.000Z", false),
+  ]);
+  assert.deepEqual(ids(result), [
+    "finished-oldest-arrival",
+    "finished-middle-arrival",
+    "finished-newest-arrival",
+  ]);
+});
+
+test("a session that finishes after it was handled returns to the unvisited pile", () => {
+  const result = sortFocusQueue([
+    item(
+      "finished-again",
+      "2024-01-05T00:00:00.000Z",
+      false,
+      "2024-01-04T00:00:00.000Z",
+    ),
+    item(
+      "already-handled",
+      "2024-01-01T00:00:00.000Z",
+      false,
+      "2024-01-06T00:00:00.000Z",
+    ),
+  ]);
+  assert.deepEqual(ids(result), ["finished-again", "already-handled"]);
+});
+
+test("finished, visited: sinks below the unvisited triage pile", () => {
+  // Mixing visited and unvisited. Unvisited stays at the top of
+  // the finished block; visited sinks below.
+  const result = sortFocusQueue([
+    item("visited-newer", "2024-01-05T00:00:00.000Z", false, "2024-01-10T00:00:00.000Z"),
+    item("unvisited-oldest", "2024-01-01T00:00:00.000Z", false),
+    item("visited-older", "2024-01-02T00:00:00.000Z", false, "2024-01-08T00:00:00.000Z"),
+    item("unvisited-newer", "2024-01-04T00:00:00.000Z", false),
+  ]);
+  assert.deepEqual(ids(result), [
+    "unvisited-oldest",
+    "unvisited-newer",
+    "visited-older",
+    "visited-newer",
+  ]);
+});
+
+test("finished, visited: most-recently-visited at the very bottom of the visited sub-block", () => {
+  // Within the visited sub-block, items are sorted by
+  // lastVisitedAt asc — the freshest visit sits closest to the
+  // running pile below.
+  const result = sortFocusQueue([
+    item("visited-fresh", "2024-01-01T00:00:00.000Z", false, "2024-01-10T00:00:00.000Z"),
+    item("visited-stale", "2024-01-05T00:00:00.000Z", false, "2024-01-08T00:00:00.000Z"),
+    item("visited-middle", "2024-01-03T00:00:00.000Z", false, "2024-01-09T00:00:00.000Z"),
+  ]);
+  assert.deepEqual(ids(result), [
+    "visited-stale",
+    "visited-middle",
+    "visited-fresh",
+  ]);
+});
+
+test("advancing past a finished session sinks it before choosing the new first row", () => {
+  // The "before" state has A as unvisited (top of finished).
+  // Marking A handled and re-sorting is step one of advance.
+  const before = sortFocusQueue([
+    item("a", "2024-01-01T00:00:00.000Z", false),
+    item("b", "2024-01-02T00:00:00.000Z", false),
+  ]);
+  assert.deepEqual(ids(before), ["a", "b"]);
+
+  const after = markFocusItemHandled(
+    before,
+    "a",
+    "2024-01-05T00:00:00.000Z",
+  );
+  assert.deepEqual(ids(after), ["b", "a"]);
+  assert.equal(after[0].session.id, "b");
+});
+
+test("full queue with visits: awaiting → unvisited → visited → running", () => {
+  const result = sortFocusQueue([
+    item("running-newest", "2024-01-10T00:00:00.000Z", true),
+    awaitingItem("awaiting", "2024-01-06T00:00:00.000Z", false),
+    item("finished-visited", "2024-01-01T00:00:00.000Z", false, "2024-01-09T00:00:00.000Z"),
+    item("finished-unvisited-newer", "2024-01-04T00:00:00.000Z", false),
+    item("finished-unvisited-older", "2024-01-02T00:00:00.000Z", false),
+    item("running-oldest", "2024-01-05T00:00:00.000Z", true),
+  ]);
+  assert.deepEqual(ids(result), [
+    "awaiting",
+    "finished-unvisited-older",
+    "finished-unvisited-newer",
+    "finished-visited",
+    "running-oldest",
+    "running-newest",
+  ]);
+});
diff --git a/client/src/components/focus-advance-toast.tsx b/client/src/components/focus-advance-toast.tsx
deleted file mode 100644
index fe92e460..00000000
--- a/client/src/components/focus-advance-toast.tsx
+++ /dev/null
@@ -1,111 +0,0 @@
-import { useEffect, useState } from "react";
-import { ArrowRight } from "lucide-react";
-import {
-  DEFAULT_SHORTCUT_BINDINGS,
-  type ShortcutBindings,
-} from "../../../shared/shortcuts.ts";
-import { formatChord, isMacPlatform } from "../lib/shortcut-match.ts";
-
-/**
- * Toast that counts down a pending focus-queue advance (issue #104)
- * and surfaces the user's actual stay / continue chord chips so the
- * visible shortcut matches the binding the listener fires.
- *
- * Background: the original copy read "Press S to stay · N to
- * continue" and worked when Controller Mode used single-letter
- * shortcuts. Issue #235 moved every shortcut to a modifier-based
- * chord (default `Ctrl+S` / `Ctrl+N`) so it fires regardless of
- * focus — but the toast copy was never updated, leaving the chips
- * misleading. This component reads the live `bindings` map so the
- * chips always reflect what the listener actually accepts, including
- * any user rebind from Settings.
- *
- * Kept in its own file (rather than inside `App.tsx`) so the
- * regression test in `client/src/components/__tests__/focus-advance-toast.test.tsx`
- * can render it without pulling in the xterm CSS that `App.tsx`
- * transitively imports.
- */
-export function FocusAdvanceToast({
-  scheduledAt,
-  durationMs,
-  bindings,
-  onCancel,
-}: {
-  scheduledAt: number;
-  durationMs: number;
-  /**
-   * Live shortcut bindings. Used to render the actual stay / continue
-   * chord chips so the toast matches the keys the user has bound in
-   * Settings (default `Ctrl+S` / `Ctrl+N`). Falls back to the bundled
-   * defaults while the bindings fetch is still in flight so the
-   * chips are never the stale single-letter "S" / "N".
-   */
-  bindings: ShortcutBindings | null;
-  onCancel: () => void;
-}) {
-  const [now, setNow] = useState(() => Date.now());
-
-  useEffect(() => {
-    const interval = window.setInterval(() => setNow(Date.now()), 250);
-    return () => window.clearInterval(interval);
-  }, []);
-
-  const elapsedMs = Math.max(0, now - scheduledAt);
-  const progress = Math.min(1, elapsedMs / durationMs);
-  const remainingProgress = Math.max(0, 1 - progress);
-  const secondsRemaining = Math.max(0, Math.ceil((durationMs - elapsedMs) / 1000));
-
-  // Render the user's actual stay / continue chord. We fall back to
-  // the bundled defaults if bindings haven't loaded yet so the chips
-  // never read "Press S to stay" — that string is misleading because
-  // the listener only fires on the modifier-based chord. `isMacPlatform`
-  // matches the rest of the Controller Mode UI.
-  const stayChord =
-    bindings?.controllerModeStay ??
-    DEFAULT_SHORTCUT_BINDINGS.controllerModeStay;
-  const nextChord =
-    bindings?.controllerModeNext ??
-    DEFAULT_SHORTCUT_BINDINGS.controllerModeNext;
-  const onMac = isMacPlatform();
-  const stayLabel = formatChord(stayChord, onMac);
-  const nextLabel = formatChord(nextChord, onMac);
-
-  return (
-    <div className="w-80 overflow-hidden rounded-lg border border-blue-400/20 bg-[#151922] text-slate-100 shadow-xl shadow-black/35">
-      <div className="p-3">
-        <div className="flex items-start gap-2">
-          <div className="mt-0.5 rounded-md border border-blue-400/15 bg-blue-400/10 p-1 text-blue-300">
-            <ArrowRight className="h-3.5 w-3.5" />
-          </div>
-          <div className="min-w-0 flex-1">
-            <div className="text-sm font-medium text-slate-50">
-              Advancing to next conversation
-            </div>
-            <div className="mt-0.5 text-xs text-slate-400">
-              <span className="hidden md:inline">
-                Press <span className="font-medium text-slate-200">{stayLabel}</span> to stay ·{" "}
-                <span className="font-medium text-slate-200">{nextLabel}</span> to continue ·{" "}
-              </span>
-              <span>{secondsRemaining}s</span>
-            </div>
-          </div>
-        </div>
-        <div className="mt-3 flex justify-end md:hidden">
-          <button
-            type="button"
-            onClick={onCancel}
-            className="rounded-md px-2 py-1 text-xs font-medium text-slate-300 transition-colors hover:bg-white/5 hover:text-slate-100"
-          >
-            Stay
-          </button>
-        </div>
-      </div>
-      <div className="h-1 bg-slate-700/80">
-        <div
-          className="h-full bg-blue-400 transition-[width] duration-200 ease-linear"
-          style={{ width: `${remainingProgress * 100}%` }}
-        />
-      </div>
-    </div>
-  );
-}
\ No newline at end of file
diff --git a/client/src/components/focus-conversation-controls.tsx b/client/src/components/focus-conversation-controls.tsx
new file mode 100644
index 00000000..ad9ceef1
--- /dev/null
+++ b/client/src/components/focus-conversation-controls.tsx
@@ -0,0 +1,171 @@
+import { useEffect, useState } from "react";
+import { ArrowRight, CheckCircle2, Pause, Plus, StepForward } from "lucide-react";
+import { Kbd } from "@/components/ui/kbd";
+import { Switch } from "@/components/ui/switch";
+import { cn } from "@/lib/utils";
+import { formatChord, isMacPlatform } from "@/lib/shortcut-match";
+import type { ShortcutBindings } from "../../../shared/shortcuts.ts";
+
+interface FocusConversationControlsProps {
+  variant: "mobile" | "desktop";
+  bindings: ShortcutBindings | null;
+  isOnRadar: boolean;
+  autoAdvance: boolean;
+  onNext: () => void;
+  onDone: () => void;
+  onAddToRadar: () => void;
+  onToggleAutoAdvance: () => void;
+  countdown?: {
+    scheduledAt: number;
+    durationMs: number;
+    onStay: () => void;
+  } | null;
+}
+
+export function FocusConversationControls({
+  variant,
+  bindings,
+  isOnRadar,
+  autoAdvance,
+  onNext,
+  onDone,
+  onAddToRadar,
+  onToggleAutoAdvance,
+  countdown = null,
+}: FocusConversationControlsProps) {
+  const nextChord = formatChord(
+    bindings?.focusAdvanceNext ?? "ctrl-n",
+    isMacPlatform(),
+  );
+  const doneChord = formatChord(
+    bindings?.focusDone ?? "ctrl-d",
+    isMacPlatform(),
+  );
+  const autoAdvanceChord = formatChord(
+    bindings?.focusAutoAdvance ?? "ctrl-t",
+    isMacPlatform(),
+  );
+  const stayChord = formatChord(
+    bindings?.focusStay ?? "ctrl-s",
+    isMacPlatform(),
+  );
+  const [now, setNow] = useState(() => Date.now());
+
+  useEffect(() => {
+    if (!countdown) return;
+    setNow(Date.now());
+    const interval = window.setInterval(() => setNow(Date.now()), 250);
+    return () => window.clearInterval(interval);
+  }, [countdown?.scheduledAt]);
+
+  const elapsedMs = countdown
+    ? Math.max(0, now - countdown.scheduledAt)
+    : 0;
+  const remainingProgress = countdown
+    ? Math.max(0, 1 - elapsedMs / countdown.durationMs)
+    : 0;
+  const secondsRemaining = countdown
+    ? Math.max(0, Math.ceil((countdown.durationMs - elapsedMs) / 1000))
+    : 0;
+
+  return (
+    <div
+      data-testid={`focus-conversation-controls-${variant}`}
+      className={cn(
+        "gap-2 overflow-hidden border-blue-500/20 bg-background/95 backdrop-blur",
+        variant === "mobile"
+          ? "relative flex shrink-0 items-center justify-between border-b px-2 py-2 md:hidden"
+          : "absolute right-4 top-4 z-20 hidden flex-col items-stretch rounded-lg border px-3 py-2 shadow-lg md:flex",
+      )}
+    >
+      {countdown ? (
+        <div className="flex min-w-0 items-center gap-2 text-xs text-muted-foreground">
+          <ArrowRight className="h-3.5 w-3.5 shrink-0 text-blue-500" />
+          <span className="truncate">Advancing in {secondsRemaining}s</span>
+        </div>
+      ) : (
+        <label
+          className={cn(
+            "flex shrink-0 items-center gap-2 px-1 text-xs text-muted-foreground",
+            variant === "desktop" && "w-full justify-between",
+          )}
+          title={
+            variant === "desktop"
+              ? `Toggle auto-advance (${autoAdvanceChord})`
+              : undefined
+          }
+        >
+          <span className="flex items-center gap-1.5">
+            Auto-advance
+            {variant === "desktop" ? <Kbd>{autoAdvanceChord}</Kbd> : null}
+          </span>
+          <Switch
+            checked={autoAdvance}
+            onCheckedChange={onToggleAutoAdvance}
+            aria-label="Auto advance"
+            className="scale-90"
+          />
+        </label>
+      )}
+      <div
+        className={cn(
+          "flex shrink-0 items-center gap-1",
+          variant === "desktop" && "w-full justify-end",
+        )}
+      >
+        {countdown ? (
+          <button
+            type="button"
+            onClick={countdown.onStay}
+            className="flex items-center gap-1.5 rounded-md px-2 py-1.5 text-xs font-medium text-blue-700 transition-colors hover:bg-blue-500/15 hover:text-blue-600 dark:text-blue-300 dark:hover:text-blue-200"
+            title={variant === "desktop" ? `Stay (${stayChord})` : undefined}
+          >
+            <Pause className="h-3.5 w-3.5" />
+            Stay
+            {variant === "desktop" ? <Kbd>{stayChord}</Kbd> : null}
+          </button>
+        ) : isOnRadar ? (
+          <button
+            type="button"
+            onClick={onDone}
+            className="flex items-center gap-1.5 rounded-md px-2 py-1.5 text-xs font-medium text-blue-700 transition-colors hover:bg-blue-500/15 hover:text-blue-600 dark:text-blue-300 dark:hover:text-blue-200"
+            title={variant === "desktop" ? `Mark done (${doneChord})` : undefined}
+          >
+            <CheckCircle2 className="h-3.5 w-3.5" />
+            Done
+            {variant === "desktop" ? <Kbd>{doneChord}</Kbd> : null}
+          </button>
+        ) : (
+          <button
+            type="button"
+            onClick={onAddToRadar}
+            className="flex items-center gap-1.5 rounded-md px-2 py-1.5 text-xs font-medium text-blue-700 transition-colors hover:bg-blue-500/15 hover:text-blue-600 dark:text-blue-300 dark:hover:text-blue-200"
+          >
+            <Plus className="h-3.5 w-3.5" />
+            Add to radar
+          </button>
+        )}
+        {!countdown || variant === "desktop" ? (
+          <button
+            type="button"
+            onClick={onNext}
+            className="flex items-center gap-1.5 rounded-md px-2 py-1.5 text-xs font-medium text-blue-700 transition-colors hover:bg-blue-500/15 hover:text-blue-600 dark:text-blue-300 dark:hover:text-blue-200"
+            title={variant === "desktop" ? `Next (${nextChord})` : undefined}
+          >
+            <StepForward className="h-3.5 w-3.5" />
+            Next
+            {variant === "desktop" ? <Kbd>{nextChord}</Kbd> : null}
+          </button>
+        ) : null}
+      </div>
+      {countdown ? (
+        <div className="absolute inset-x-0 bottom-0 h-0.5 bg-muted">
+          <div
+            className="h-full bg-blue-500 transition-[width] duration-200 ease-linear"
+            style={{ width: `${remainingProgress * 100}%` }}
+          />
+        </div>
+      ) : null}
+    </div>
+  );
+}
diff --git a/client/src/components/shortcuts-section.tsx b/client/src/components/shortcuts-section.tsx
index 46a38729..dc5da8b4 100644
--- a/client/src/components/shortcuts-section.tsx
+++ b/client/src/components/shortcuts-section.tsx
@@ -22,7 +22,7 @@ import {
 } from "../../../shared/shortcuts.ts";
 
 /*
- * Settings panel for Controller Mode keyboard shortcuts.
+ * Settings panel for focus-queue keyboard shortcuts.
  *
  * Each action shows its current chord and a "Record" button. Clicking
  * Record waits for the next key chord, then auto-saves it (no separate
@@ -181,9 +181,10 @@ function Recorder({
   //
   // We also set the `recordingChord` module flag while recording so the
   // global App-level listener (registered on window capture too) skips
-  // its handler — otherwise Ctrl+T / Ctrl+N / Ctrl+D / Ctrl+S would
-  // actually toggle / navigate / mark-done instead of being captured
-  // for the new binding (issue #235 P2 review).
+  // its handler — otherwise Ctrl+N / Ctrl+D / Ctrl+S / Ctrl+T would
+  // actually navigate / mark-done / cancel / toggle-auto-advance
+  // instead of being captured for the new binding (issue #235 P2
+  // review).
   useEffect(() => {
     setRecordingChord(true);
     return () => setRecordingChord(false);
diff --git a/client/src/components/sidebar.tsx b/client/src/components/sidebar.tsx
index cde5e25f..ccb57ffa 100644
--- a/client/src/components/sidebar.tsx
+++ b/client/src/components/sidebar.tsx
@@ -16,7 +16,6 @@ import {
   CheckCircle2,
   RotateCw,
   AlertTriangle,
-  Play,
   HelpCircle,
 } from "lucide-react";
 import { cn } from "@/lib/utils";
@@ -61,8 +60,6 @@ import { ScrollArea } from "@/components/ui/scroll-area";
 import { Separator } from "@/components/ui/separator";
 import { canonicalProviderId } from "@/lib/provider-id";
 import { DOCS_URL } from "@/lib/links";
-import { formatChord, isMacPlatform } from "@/lib/shortcut-match";
-import type { ShortcutBindings } from "../../../shared/shortcuts.ts";
 
 const SESSION_BATCH_SIZE = 5;
 
@@ -83,15 +80,16 @@ interface SidebarProps {
   onNewWorktree: (projectId: string) => void;
   onProjectsChanged: () => void;
   onSettings: () => void;
-  onFocusQueueChange?: (queue: FocusQueueItem[]) => void;
-  controllerMode?: boolean;
-  onControllerModeToggle?: () => void;
   /**
-   * Effective Controller Mode shortcut bindings. Used to render the
-   * correct chord in the sidebar's Controller Mode button tooltip.
-   * See issue #235.
+   * The canonical sorted focus queue, owned by App (which overlays
+   * per-session handled timestamps and runs `sortFocusQueue`). The
+   * sidebar uses this for rendering and App uses its first row for
+   * navigation. The sidebar still emits a *raw* version
+   * of this via `onFocusQueueChange` so App can apply its visit
+   * overlay in one place.
    */
-  shortcutBindings?: ShortcutBindings | null;
+  focusQueue?: FocusQueueItem[];
+  onFocusQueueChange?: (queue: FocusQueueItem[]) => void;
   focusRefreshKey?: number;
   // Bumped by the App's project-event subscription when an out-of-band
   // lifecycle change lands (worktree added/removed, session added,
@@ -117,6 +115,128 @@ export interface FocusQueueItem {
   worktreeName: string;
   session: SessionSummary;
   active: boolean;
+  /**
+   * True when the agent has paused on a user-input request or has
+   * a pending tool approval. Drives the highest-priority bucket in
+   * `sortFocusQueue` and the priority preference in
+   * `pickNextFocusItem`. Independent of `active`: Claude's
+   * structured-input pause kills the child so the session shows as
+   * inactive but still owes the user a reply.
+   */
+  awaitingInput?: boolean;
+  /**
+   * ISO timestamp of the last time the user explicitly advanced past
+   * this session with Next or auto-advance. Drives the
+   * visited/unvisited split in `sortFocusQueue` — finished sessions
+   * the user has not handled since their latest completion sit at the top
+   * ("triage pile"), and advancing past one sinks it below the unvisited
+   * pile so the user isn't bounced back to them on every cycle.
+   * Independent of `lastActiveAt`, which still tracks agent
+   * activity and ordering within the unfinished queue.
+   */
+  lastVisitedAt?: string;
+}
+
+/**
+ * Order radar (focus-pinned) sessions into priority buckets so the
+ * most urgent items float to the top:
+ *
+ *   1. **Awaiting input** — items whose agent has paused on a
+ *      `user.input_requested` prompt or has at least one pending
+ *      tool approval. The user owes a reply to these; they sit at
+ *      the very top, oldest-arrival first (`lastActiveAt` asc).
+ *      The `active` flag doesn't matter here — Claude's
+ *      structured-input pause kills the child so a session can be
+ *      inactive and still awaiting.
+ *   2. **Finished, unvisited** — the triage pile. Items whose agent
+ *      finished and the user has not yet explicitly advanced past that
+ *      completion. A new completion after a prior visit returns here.
+ *      Merely opening one does not change its position. Oldest-arrival first
+ *      (`lastActiveAt` asc) so the user walks the pile in the
+ *      order the agents finished. Advancing past a session sinks it
+ *      into the next bucket so the user isn't bounced back to it
+ *      on every cycle.
+ *   3. **Finished, visited** — items the user has already handled.
+ *      Most-recently-handled at the very bottom of this
+ *      sub-bucket (`lastVisitedAt` asc, ties on array order) so
+ *      the freshest look sits closest to the running pile below.
+ *   4. **Running (active)** — sessions where the agent is still
+ *      working. Oldest-running first, so the most recently
+ *      started running session lands at the very bottom of the
+ *      queue (`lastActiveAt` asc).
+ *
+ * Within each bucket, ties on the sort key fall back to the
+ * caller's array order (Array#sort is stable).
+ *
+ * Pure: does not mutate the input.
+ */
+export function sortFocusQueue(items: FocusQueueItem[]): FocusQueueItem[] {
+  const hasUnseenCompletion = (item: FocusQueueItem) => {
+    if (!item.lastVisitedAt) return true;
+    return (
+      new Date(item.session.lastActiveAt).getTime() >
+      new Date(item.lastVisitedAt).getTime()
+    );
+  };
+
+  const awaiting = items
+    .filter((item) => item.awaitingInput)
+    .sort(
+      (a, b) =>
+        new Date(a.session.lastActiveAt).getTime() -
+        new Date(b.session.lastActiveAt).getTime(),
+    );
+
+  const finishedUnvisited = items
+    .filter(
+      (item) =>
+        !item.awaitingInput && !item.active && hasUnseenCompletion(item),
+    )
+    .sort(
+      (a, b) =>
+        new Date(a.session.lastActiveAt).getTime() -
+        new Date(b.session.lastActiveAt).getTime(),
+    );
+
+  const finishedVisited = items
+    .filter(
+      (item) =>
+        !item.awaitingInput && !item.active && !hasUnseenCompletion(item),
+    )
+    .sort(
+      (a, b) =>
+        new Date(a.lastVisitedAt!).getTime() -
+        new Date(b.lastVisitedAt!).getTime(),
+    );
+
+  const running = items
+    .filter((item) => !item.awaitingInput && item.active)
+    .sort(
+      (a, b) =>
+        new Date(a.session.lastActiveAt).getTime() -
+        new Date(b.session.lastActiveAt).getTime(),
+    );
+
+  return [...awaiting, ...finishedUnvisited, ...finishedVisited, ...running];
+}
+
+/**
+ * Mark one queue item as handled, then return the queue in its new
+ * canonical order. Navigation intentionally happens after this step
+ * so Next and auto-advance always open the new first row.
+ */
+export function markFocusItemHandled(
+  items: FocusQueueItem[],
+  sessionId: string,
+  handledAt: string,
+): FocusQueueItem[] {
+  return sortFocusQueue(
+    items.map((item) =>
+      item.session.id === sessionId
+        ? { ...item, lastVisitedAt: handledAt }
+        : item,
+    ),
+  );
 }
 
 function CodexLogo({ className }: { className?: string }) {
@@ -262,10 +382,8 @@ export function Sidebar({
   onNewWorktree,
   onProjectsChanged,
   onSettings,
+  focusQueue: focusQueueProp,
   onFocusQueueChange,
-  controllerMode = false,
-  onControllerModeToggle,
-  shortcutBindings = null,
   focusRefreshKey,
   eventsRefreshKey,
 }: SidebarProps) {
@@ -274,6 +392,15 @@ export function Sidebar({
   const [activeSessionIds, setActiveSessionIds] = useState<Set<string>>(
     new Set(),
   );
+  // Sessions whose agent has paused on a user-input request or has
+  // at least one pending tool approval. The runtime map reports this
+  // independently of `active` (Claude's structured-input pause kills
+  // the child process, so the session is `active: false` but still
+  // needs the user's attention). Surfaced at the very top of the
+  // focus queue.
+  const [awaitingInputSessionIds, setAwaitingInputSessionIds] = useState<
+    Set<string>
+  >(new Set());
   const [visibleSessionCounts, setVisibleSessionCounts] = useState<
     Record<string, number>
   >({});
@@ -327,36 +454,43 @@ export function Sidebar({
   } | null>(null);
   const setupRunCancelRef = useRef<(() => void) | null>(null);
 
-  const focusQueue = useMemo<FocusQueueItem[]>(() => {
-    return projectData
-      .flatMap((project) =>
-        project.worktrees.flatMap((worktree) =>
-          worktree.sessions
-            .filter((session) => Boolean(session.focusPinnedAt))
-            .map((session) => ({
-              projectId: project.id,
-              projectName: project.name,
-              worktreeId: worktree.id,
-              worktreeName: worktree.name,
-              session,
-              active: activeSessionIds.has(session.id),
-            })),
-        ),
-      )
-      .sort((a, b) => {
-        const aTime = new Date(
-          a.session.focusPinnedAt ?? a.session.createdAt,
-        ).getTime();
-        const bTime = new Date(
-          b.session.focusPinnedAt ?? b.session.createdAt,
-        ).getTime();
-        return aTime - bTime;
-      });
-  }, [activeSessionIds, projectData]);
+  // Raw focus items: project/worktree/session metadata plus the
+  // runtime flags (active, awaitingInput). Computed here because
+  // the sidebar owns the projectData / runtime fetches. App applies
+  // the visit-timestamp overlay and runs the canonical sort; the
+  // sorted queue comes back via `focusQueueProp` and is what we
+  // render.
+  const rawFocusItems = useMemo<FocusQueueItem[]>(() => {
+    return projectData.flatMap((project) =>
+      project.worktrees.flatMap((worktree) =>
+        worktree.sessions
+          .filter((session) => Boolean(session.focusPinnedAt))
+          .map((session) => ({
+            projectId: project.id,
+            projectName: project.name,
+            worktreeId: worktree.id,
+            worktreeName: worktree.name,
+            session,
+            active: activeSessionIds.has(session.id),
+            awaitingInput: awaitingInputSessionIds.has(session.id) || undefined,
+          })),
+      ),
+    );
+  }, [activeSessionIds, awaitingInputSessionIds, projectData]);
+
+  // The canonical, sorted queue lives in App (it has the visit
+  // overlay + final sort). On the very first paint (before App has
+  // emitted its first sorted value) fall back to a local sort using
+  // the raw items so the sidebar has something to render.
+  const fallbackQueue = useMemo(
+    () => sortFocusQueue(rawFocusItems),
+    [rawFocusItems],
+  );
+  const focusQueue = focusQueueProp ?? fallbackQueue;
 
   useEffect(() => {
-    onFocusQueueChange?.(focusQueue);
-  }, [focusQueue, onFocusQueueChange]);
+    onFocusQueueChange?.(rawFocusItems);
+  }, [rawFocusItems, onFocusQueueChange]);
 
   const refreshActiveSessions = useCallback(async () => {
     // One bulk request replaces the previous per-session /runtime polling loop
@@ -365,6 +499,13 @@ export function Sidebar({
     setActiveSessionIds(
       new Set(entries.filter((entry) => entry.active).map((entry) => entry.sessionId)),
     );
+    setAwaitingInputSessionIds(
+      new Set(
+        entries
+          .filter((entry) => entry.awaitingInput)
+          .map((entry) => entry.sessionId),
+      ),
+    );
   }, []);
 
   const loadAll = useCallback(async () => {
@@ -410,12 +551,12 @@ export function Sidebar({
   }, [loadAll, focusRefreshKey, eventsRefreshKey]);
 
   useEffect(() => {
-    if (activeSessionIds.size === 0) return;
+    if (activeSessionIds.size === 0 && awaitingInputSessionIds.size === 0) return;
     const interval = window.setInterval(() => {
       refreshActiveSessions().catch(() => {});
     }, 2000);
     return () => window.clearInterval(interval);
-  }, [activeSessionIds, refreshActiveSessions]);
+  }, [activeSessionIds, awaitingInputSessionIds, refreshActiveSessions]);
 
   const toggleProject = (id: string) => {
     setProjectData((prev) =>
@@ -757,35 +898,10 @@ export function Sidebar({
   return (
     <aside className="flex h-full flex-col border-r border-border bg-sidebar" style={{ width: "100%" }}>
       <ScrollArea className="flex-1 overflow-hidden px-3">
-        <div className="flex items-center justify-between py-3">
+        <div className="flex items-center justify-between gap-2 py-3">
           <span className="text-xs font-medium uppercase tracking-wider text-muted-foreground">
             On radar
           </span>
-          {focusQueue.length > 0 ? (
-            <button
-              type="button"
-              onClick={onControllerModeToggle}
-              className={cn(
-                "inline-flex items-center gap-1.5 rounded-md px-2 py-1 text-xs font-medium transition-colors",
-                controllerMode
-                  ? "bg-blue-500/15 text-blue-300 ring-1 ring-inset ring-blue-400/30 hover:bg-blue-500/25 hover:text-blue-200"
-                  : "text-muted-foreground hover:bg-sidebar-accent hover:text-sidebar-foreground",
-              )}
-              title={
-                controllerMode
-                  ? `Exit Controller Mode (${formatChord(shortcutBindings?.controllerModeToggle ?? "ctrl-t", isMacPlatform())})`
-                  : `Start Controller Mode (${formatChord(shortcutBindings?.controllerModeToggle ?? "ctrl-t", isMacPlatform())})`
-              }
-            >
-              <Play
-                className={cn(
-                  "h-3.5 w-3.5",
-                  controllerMode ? "text-blue-300" : "text-muted-foreground",
-                )}
-              />
-              <span>Controller Mode</span>
-            </button>
-          ) : null}
         </div>
 
         <div className="flex flex-col gap-1 pb-3">
@@ -1063,6 +1179,18 @@ export function Sidebar({
                                               provider={session.provider}
                                               className="h-3.5 w-3.5 shrink-0 text-muted-foreground"
                                             />
+                                            {/* Awaiting-input dot: the agent has paused on
+                                                a user-input request or has a pending
+                                                approval. Most urgent state — surfaced
+                                                at the top of the queue with a coloured
+                                                dot so the user can spot it at a glance. */}
+                                            {awaitingInputSessionIds.has(session.id) ? (
+                                              <span
+                                                className="h-2 w-2 shrink-0 rounded-full bg-amber-400"
+                                                title="Awaiting your input"
+                                                aria-label="Awaiting your input"
+                                              />
+                                            ) : null}
                                             <span className="truncate">
                                               {session.title ||
                                                 session.id.slice(0, 8)}
diff --git a/client/src/lib/__tests__/focus-visited-storage.test.ts b/client/src/lib/__tests__/focus-visited-storage.test.ts
new file mode 100644
index 00000000..25e40395
--- /dev/null
+++ b/client/src/lib/__tests__/focus-visited-storage.test.ts
@@ -0,0 +1,151 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  loadSavedVisitedAt,
+  persistVisitedAt,
+  VISITED_AT_STORAGE_KEY,
+  VISITED_AT_TTL_MS,
+} from "../focus-visited-storage.ts";
+
+/**
+ * Minimal in-memory Storage mock. The helpers only call getItem/setItem,
+ * so we don't need the real thing. Throwing wrappers are used in the
+ * "storage failure" tests to confirm the helpers don't propagate.
+ */
+function memoryStorage(
+  initial: Record<string, string> = {},
+  options: { throwOnGet?: boolean; throwOnSet?: boolean } = {},
+): Pick<Storage, "getItem" | "setItem"> {
+  const store = new Map(Object.entries(initial));
+  return {
+    getItem(key) {
+      if (options.throwOnGet) throw new Error("blocked");
+      return store.has(key) ? store.get(key)! : null;
+    },
+    setItem(key, value) {
+      if (options.throwOnSet) throw new Error("quota");
+      store.set(key, value);
+    },
+  };
+}
+
+test("loadSavedVisitedAt returns {} when no entry exists", () => {
+  assert.deepEqual(loadSavedVisitedAt(memoryStorage()), {});
+});
+
+test("loadSavedVisitedAt returns {} when storage.getItem throws", () => {
+  assert.deepEqual(
+    loadSavedVisitedAt(memoryStorage({}, { throwOnGet: true })),
+    {},
+  );
+});
+
+test("loadSavedVisitedAt returns {} when the stored JSON is malformed", () => {
+  const storage = memoryStorage({
+    [VISITED_AT_STORAGE_KEY]: "not-json-at-all",
+  });
+  assert.deepEqual(loadSavedVisitedAt(storage), {});
+});
+
+test("loadSavedVisitedAt returns {} when the stored JSON is not an object", () => {
+  // Array root: technically valid JSON but not the shape we expect.
+  const storage = memoryStorage({
+    [VISITED_AT_STORAGE_KEY]: JSON.stringify(["a", "b"]),
+  });
+  assert.deepEqual(loadSavedVisitedAt(storage), {});
+});
+
+test("loadSavedVisitedAt drops entries with non-string values", () => {
+  const now = new Date().toISOString();
+  const storage = memoryStorage({
+    [VISITED_AT_STORAGE_KEY]: JSON.stringify({
+      "valid-id": now,
+      "number-id": 12345,
+      "null-id": null,
+      "object-id": { foo: "bar" },
+    }),
+  });
+  assert.deepEqual(loadSavedVisitedAt(storage), { "valid-id": now });
+});
+
+test("loadSavedVisitedAt drops entries with malformed timestamp strings", () => {
+  const storage = memoryStorage({
+    [VISITED_AT_STORAGE_KEY]: JSON.stringify({
+      "bad-id": "not-a-real-iso-string",
+    }),
+  });
+  assert.deepEqual(loadSavedVisitedAt(storage), {});
+});
+
+test("loadSavedVisitedAt drops entries older than the TTL", () => {
+  const now = Date.now();
+  const recent = new Date(now - 60_000).toISOString(); // 1 min ago — fresh
+  const stale = new Date(now - (VISITED_AT_TTL_MS + 60_000)).toISOString(); // > TTL — drop
+  const storage = memoryStorage({
+    [VISITED_AT_STORAGE_KEY]: JSON.stringify({
+      "recent-id": recent,
+      "stale-id": stale,
+    }),
+  });
+  const result = loadSavedVisitedAt(storage);
+  assert.ok("recent-id" in result);
+  assert.ok(!("stale-id" in result));
+});
+
+test("loadSavedVisitedAt keeps entries right at the boundary of the TTL", () => {
+  const cutoff = Date.now() - VISITED_AT_TTL_MS;
+  const justInside = new Date(cutoff + 1_000).toISOString();
+  const justOutside = new Date(cutoff - 1_000).toISOString();
+  const storage = memoryStorage({
+    [VISITED_AT_STORAGE_KEY]: JSON.stringify({
+      "inside-id": justInside,
+      "outside-id": justOutside,
+    }),
+  });
+  const result = loadSavedVisitedAt(storage);
+  assert.ok("inside-id" in result);
+  assert.ok(!("outside-id" in result));
+});
+
+test("loadSavedVisitedAt preserves the original timestamp string verbatim", () => {
+  // We store ISO strings on disk; reloads shouldn't re-stringify
+  // them (a re-stringified timestamp with the same instant would be
+  // considered a different value by the visit-effect's
+  // `current[id] !== next` check). The hydration must pass through.
+  const ts = "2026-09-04T03:18:42.123Z";
+  const storage = memoryStorage({
+    [VISITED_AT_STORAGE_KEY]: JSON.stringify({ "session-1": ts }),
+  });
+  const result = loadSavedVisitedAt(storage);
+  assert.equal(result["session-1"], ts);
+});
+
+test("persistVisitedAt writes through to storage", () => {
+  const storage = memoryStorage();
+  persistVisitedAt(storage, { "session-1": "2026-09-04T03:18:42.123Z" });
+  assert.deepEqual(
+    JSON.parse(storage.getItem(VISITED_AT_STORAGE_KEY)!),
+    { "session-1": "2026-09-04T03:18:42.123Z" },
+  );
+});
+
+test("persistVisitedAt swallows quota errors", () => {
+  // No exception should escape; the in-memory state still works
+  // for the session. The next successful write will heal the
+  // disk state.
+  const storage = memoryStorage({}, { throwOnSet: true });
+  assert.doesNotThrow(() =>
+    persistVisitedAt(storage, { "session-1": "2026-09-04T03:18:42.123Z" }),
+  );
+});
+
+test("round-trip: persist then load returns the same map", () => {
+  const storage = memoryStorage();
+  const sample = {
+    "session-a": "2026-09-04T03:18:42.123Z",
+    "session-b": "2026-09-04T04:00:00.000Z",
+    "session-c": "2026-09-05T01:23:45.678Z",
+  };
+  persistVisitedAt(storage, sample);
+  assert.deepEqual(loadSavedVisitedAt(storage), sample);
+});
diff --git a/client/src/lib/focus-advance.test.ts b/client/src/lib/focus-advance.test.ts
index 15b5039f..8f996113 100644
--- a/client/src/lib/focus-advance.test.ts
+++ b/client/src/lib/focus-advance.test.ts
@@ -1,13 +1,18 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import {
+  pickFirstFocusItem,
   pickNextFocusItem,
   type FocusQueueItemLike,
 } from "./focus-advance.ts";
 
-function item(id: string, overrides: Partial<FocusQueueItemLike> = {}): FocusQueueItemLike {
+function item(
+  id: string,
+  lastActiveAt: string,
+  overrides: Partial<Omit<FocusQueueItemLike, "session">> = {},
+): FocusQueueItemLike {
   return {
-    session: { id },
+    session: { id, lastActiveAt },
     projectId: "proj-1",
     worktreeId: "wt-1",
     projectName: "Test",
@@ -17,44 +22,523 @@ function item(id: string, overrides: Partial<FocusQueueItemLike> = {}): FocusQue
 }
 
 test("pickNextFocusItem returns null for an empty queue", () => {
-  assert.equal(pickNextFocusItem([], "any"), null);
+  assert.equal(pickNextFocusItem([], "any", 0), null);
+});
+
+test("pickFirstFocusItem selects the top row when the current session is last", () => {
+  const queue = [
+    item("first", "2024-01-01T00:00:00.000Z"),
+    item("second", "2024-01-02T00:00:00.000Z"),
+    item("current", "2024-01-03T00:00:00.000Z"),
+  ];
+  assert.equal(pickFirstFocusItem(queue, "current")?.session.id, "first");
+});
+
+test("pickFirstFocusItem selects the top row when the current session is second-to-last", () => {
+  const queue = [
+    item("first", "2024-01-01T00:00:00.000Z"),
+    item("current", "2024-01-02T00:00:00.000Z"),
+    item("last", "2024-01-03T00:00:00.000Z"),
+  ];
+  assert.equal(pickFirstFocusItem(queue, "current")?.session.id, "first");
+});
+
+test("pickFirstFocusItem skips the current session when it is the top row", () => {
+  const queue = [
+    item("current", "2024-01-01T00:00:00.000Z"),
+    item("second", "2024-01-02T00:00:00.000Z"),
+  ];
+  assert.equal(pickFirstFocusItem(queue, "current")?.session.id, "second");
+  assert.equal(pickFirstFocusItem([queue[0]], "current"), null);
 });
 
 test("pickNextFocusItem stays put on a queue of one (sent-from IS the only item)", () => {
   // The single-item queue. Sending from the only pinned session
   // should NOT navigate — the user would just get bounced.
-  const queue = [item("s1")];
-  assert.equal(pickNextFocusItem(queue, "s1"), null);
+  const queue = [item("s1", "2024-01-01T00:00:00.000Z")];
+  assert.equal(pickNextFocusItem(queue, "s1", 0), null);
 });
 
-test("pickNextFocusItem advances to the next index in a multi-item queue", () => {
-  const s1 = item("s1");
-  const s2 = item("s2");
-  const s3 = item("s3");
+test("pickNextFocusItem advances circularly when there are no recently-finished items", () => {
+  // `lastInteractionAt = 0` means "never interacted yet" — the
+  // recently-finished bucket is empty and we fall through to plain
+  // circular advance.
+  const s1 = item("s1", "2024-01-01T00:00:00.000Z");
+  const s2 = item("s2", "2024-01-02T00:00:00.000Z");
+  const s3 = item("s3", "2024-01-03T00:00:00.000Z");
   const queue = [s1, s2, s3];
   // Sent from s1 -> s2
-  assert.equal(pickNextFocusItem(queue, "s1"), s2);
+  assert.equal(pickNextFocusItem(queue, "s1", 0), s2);
   // Sent from s2 -> s3
-  assert.equal(pickNextFocusItem(queue, "s2"), s3);
+  assert.equal(pickNextFocusItem(queue, "s2", 0), s3);
   // Sent from s3 (last) -> wraps to s1
-  assert.equal(pickNextFocusItem(queue, "s3"), s1);
+  assert.equal(pickNextFocusItem(queue, "s3", 0), s1);
 });
 
 test("pickNextFocusItem treats sent-from-not-in-queue as 'before index 0'", () => {
   // User manually navigated to an unpinned session "external" and
   // sent a message from it. We should still advance, starting from
-  // index 0. This is the case that bit the user in the report.
-  const queue = [item("s1"), item("s2")];
-  const next = pickNextFocusItem(queue, "external");
+  // index 0.
+  const queue = [
+    item("s1", "2024-01-01T00:00:00.000Z"),
+    item("s2", "2024-01-02T00:00:00.000Z"),
+  ];
+  const next = pickNextFocusItem(queue, "external", 0);
   assert.equal(next?.session.id, "s1");
 });
 
+test("pickNextFocusItem surfaces the recently-finished bucket before plain circular advance", () => {
+  // The user last interacted at t1. Hello 1 finished at t2 (after
+  // the previous interaction), so it's a fresh finish that should be
+  // answered first. The queue also has older running sessions below
+  // it. Hello 1 is *visited* (the user already saw this finish),
+  // so it falls into the recently-finished bucket, not the
+  // unvisited triage pile.
+  const queue = [
+    item("running-oldest", "2024-01-01T00:00:00.000Z", { active: true }),
+    item("hello-1", "2024-01-05T00:00:00.000Z", {
+      lastVisitedAt: "2024-01-05T00:01:00.000Z",
+    }), // finished at t2 > t1, visited
+    item("running-newest", "2024-01-02T00:00:00.000Z", { active: true }),
+  ];
+  // Pretend the user is on an external session. They want to land on
+  // the freshest finished (Hello 1) before resuming the running ones.
+  const next = pickNextFocusItem(queue, "external", Date.parse("2024-01-04T00:00:00.000Z"));
+  assert.equal(next?.session.id, "hello-1");
+});
+
+test("pickNextFocusItem walks recently-finished FIFO", () => {
+  // Two items finished since the watermark; the algorithm should
+  // return the OLDEST-arrival one first. Because the queue is
+  // already sorted by `sortFocusQueue` (oldest-arrival at the top of
+  // the finished block), a linear scan in array order naturally
+  // surfaces the oldest-arrival first. Both items are *visited* so
+  // they fall into the recently-finished bucket, not the unvisited
+  // triage pile.
+  const queue = [
+    item("finished-older", "2024-01-05T00:00:00.000Z", {
+      lastVisitedAt: "2024-01-05T00:01:00.000Z",
+    }), // finished after watermark, oldest-arrival, visited
+    item("finished-newer", "2024-01-06T00:00:00.000Z", {
+      lastVisitedAt: "2024-01-06T00:01:00.000Z",
+    }), // finished after watermark, newer-arrival, visited
+    item("running", "2024-01-01T00:00:00.000Z", { active: true }),
+  ];
+  // First advance: walks the older of the two fresh finishes.
+  const first = pickNextFocusItem(queue, "external", Date.parse("2024-01-04T00:00:00.000Z"));
+  assert.equal(first?.session.id, "finished-older");
+  // After the user interacts (watermark bumped past finished-older),
+  // the next freshest is finished-newer.
+  const second = pickNextFocusItem(queue, "finished-older", Date.parse("2024-01-05T00:01:00.000Z"));
+  assert.equal(second?.session.id, "finished-newer");
+});
+
+test("pickNextFocusItem excludes active sessions from recently-finished", () => {
+  const queue = [
+    item("finished", "2024-01-05T00:00:00.000Z", {
+      lastVisitedAt: "2024-01-05T00:01:00.000Z",
+    }),
+    item("running-fresh", "2024-01-06T00:00:00.000Z", {
+      active: true,
+    }),
+    item("sent-from", "2024-01-03T00:00:00.000Z", {
+      lastVisitedAt: "2024-01-03T00:01:00.000Z",
+    }),
+  ];
+  const next = pickNextFocusItem(
+    queue,
+    "sent-from",
+    Date.parse("2024-01-04T00:00:00.000Z"),
+  );
+  assert.equal(next?.session.id, "finished");
+});
+
+test("pickNextFocusItem skips the sent-from session in the recently-finished bucket", () => {
+  // The user is currently on a session that's also the only
+  // recently-finished item. We must NOT bounce them back to it.
+  const queue = [
+    item("fresh", "2024-01-05T00:00:00.000Z"), // finished after watermark
+    item("running", "2024-01-01T00:00:00.000Z", { active: true }),
+  ];
+  const next = pickNextFocusItem(queue, "fresh", Date.parse("2024-01-04T00:00:00.000Z"));
+  // No unvisited finished, no other fresh finished. Plain circular
+  // from "fresh" (index 0) -> index 1 -> "running".
+  assert.equal(next?.session.id, "running");
+});
+
+test("pickNextFocusItem falls through to plain circular when the recently-finished bucket is exhausted", () => {
+  // The recently-finished item is also the sent-from session. After
+  // we skip it, no other fresh finished exists, so we wrap around
+  // to the next item in queue order (the running one).
+  const queue = [
+    item("fresh-sent-from", "2024-01-05T00:00:00.000Z"),
+    item("running-oldest", "2024-01-01T00:00:00.000Z", { active: true }),
+    item("running-newest", "2024-01-02T00:00:00.000Z", { active: true }),
+  ];
+  const next = pickNextFocusItem(queue, "fresh-sent-from", Date.parse("2024-01-04T00:00:00.000Z"));
+  // No unvisited finished (running items skip the unvisited
+  // bucket). No other fresh finished. Plain circular from
+  // "fresh-sent-from" (not in queue) -> index 0 -> "fresh-sent-from",
+  // but that's sent-from so we move on -> index 1 -> "running-oldest".
+  assert.equal(next?.session.id, "running-oldest");
+});
+
 test("pickNextFocusItem wraps when the only item also matches sent-from", () => {
   // Defensive: if the queue somehow contains the same id the user
   // sent from but other items exist (shouldn't happen with the
   // current dedupe rules, but stay safe), we still skip past it.
-  const queue = [item("s1"), item("s2"), item("s1")];
-  const next = pickNextFocusItem(queue, "s1");
+  const queue = [
+    item("s1", "2024-01-01T00:00:00.000Z"),
+    item("s2", "2024-01-02T00:00:00.000Z"),
+    item("s1", "2024-01-03T00:00:00.000Z"),
+  ];
+  const next = pickNextFocusItem(queue, "s1", 0);
   // startIndex is 0 (first match), nextIndex wraps to 1
   assert.equal(next?.session.id, "s2");
 });
+
+// ---------------------------------------------------------------------------
+// Awaiting-input priority (issue #333 follow-up).
+//
+// Sessions whose agent has paused on a `user.input_requested` prompt
+// or has a pending tool approval are the most urgent items on the
+// radar and must win over the recently-finished bucket. The flag is
+// independent of `active`: Claude's structured-input pause kills the
+// child so the session can be inactive and still awaiting.
+// ---------------------------------------------------------------------------
+
+test("awaiting-input bucket wins over the recently-finished bucket", () => {
+  // A finished item is in the recently-finished bucket; an awaiting
+  // item is fresh and active. The awaiting one wins regardless of
+  // `lastInteractionAt`.
+  const queue = [
+    item("finished", "2024-01-05T00:00:00.000Z", { awaitingInput: false }),
+    item("awaiting", "2024-01-04T00:00:00.000Z", { awaitingInput: true }),
+  ];
+  const next = pickNextFocusItem(queue, "external", Date.parse("2024-01-04T00:00:00.000Z"));
+  assert.equal(next?.session.id, "awaiting");
+});
+
+test("awaiting-input wins even when the user just interacted (lastInteractionAt = now)", () => {
+  // The freshly-finished item finished at t > lastInteractionAt, so
+  // it's in the recently-finished bucket. The awaiting item is
+  // older-arrival but still wins.
+  const queue = [
+    item("finished-just-now", "2024-01-05T00:00:00.000Z", {
+      awaitingInput: false,
+    }),
+    item("awaiting", "2024-01-01T00:00:00.000Z", { awaitingInput: true }),
+  ];
+  const next = pickNextFocusItem(queue, "external", Date.parse("2024-01-04T00:00:00.000Z"));
+  assert.equal(next?.session.id, "awaiting");
+});
+
+test("awaiting-input is independent of active: a paused (inactive) session can still await", () => {
+  // Claude's structured-input pause kills the child, so the runtime
+  // reports `active: false` but the user still owes a reply. The
+  // sort and advance logic both treat the flag as a separate
+  // signal, so this session still wins.
+  const queue = [
+    item("finished", "2024-01-05T00:00:00.000Z", { awaitingInput: false }),
+    item("paused-awaiting-input", "2024-01-04T00:00:00.000Z", {
+      active: false,
+      awaitingInput: true,
+    }),
+  ];
+  const next = pickNextFocusItem(queue, "external", Date.parse("2024-01-04T00:00:00.000Z"));
+  assert.equal(next?.session.id, "paused-awaiting-input");
+});
+
+test("the awaiting-input bucket is skipped when the only awaiting item IS the sent-from session", () => {
+  // The user is currently looking at a paused session awaiting
+  // input. They hit Next expecting to move on, but there's nothing
+  // else awaiting. Fall through to recently-finished, then plain
+  // circular — the running one is the natural next stop.
+  const queue = [
+    item("paused-awaiting-input", "2024-01-04T00:00:00.000Z", {
+      active: false,
+      awaitingInput: true,
+    }),
+    item("finished", "2024-01-05T00:00:00.000Z", { awaitingInput: false }),
+    item("running", "2024-01-01T00:00:00.000Z", { active: true }),
+  ];
+  const next = pickNextFocusItem(queue, "paused-awaiting-input", Date.parse("2024-01-04T00:00:00.000Z"));
+  // No other awaiting item, no fresh finished. Plain circular from
+  // "paused-awaiting-input" (index 0) -> index 1 -> "finished".
+  // That's the natural next stop in the user's queue — but the
+  // "finished" bucket item is older than the watermark so the
+  // recently-finished check misses it. So fall through to plain
+  // circular -> "finished" -> next wrap -> "running" -> wrap -> self.
+  // startIndex = 0, nextIndex = 1 -> "finished", id !== sent-from,
+  // return "finished".
+  assert.equal(next?.session.id, "finished");
+});
+
+test("multiple awaiting-input sessions are walked in array order", () => {
+  // sortFocusQueue is responsible for the *array* order (oldest
+  // arrival first within the awaiting bucket); the algorithm just
+  // returns the first match.
+  const queue = [
+    item("awaiting-newer", "2024-01-05T00:00:00.000Z", {
+      awaitingInput: true,
+    }),
+    item("awaiting-older", "2024-01-04T00:00:00.000Z", {
+      awaitingInput: true,
+    }),
+  ];
+  const next = pickNextFocusItem(queue, "external", 0);
+  assert.equal(next?.session.id, "awaiting-newer");
+});
+
+// ---------------------------------------------------------------------------
+// Unvisited-finished bucket priority (issue #333 follow-up #2).
+//
+// When the user presses Next from any session, the queue should
+// re-surface the top of the *unvisited triage pile* (finished but
+// never opened) before walking through the visited/finished or
+// running blocks. Without this priority, plain circular advance
+// walks the array in order — unvisited → visited → running — and
+// lands on the second-to-last item when the user is on a visited
+// session in the middle of the visited block.
+// ---------------------------------------------------------------------------
+
+test("unvisited-finished bucket wins when sent-from is on a visited-finished session", () => {
+  // The user is on a visited-finished session in the middle of the
+  // visited block. They press Next. The expected behavior is to
+  // jump to the top of the unvisited triage pile, NOT to the next
+  // item in array order (which would be the next visited session).
+  const queue = [
+    item("unvisited-top", "2024-01-01T00:00:00.000Z"), // unvisited, top of queue
+    item("unvisited-mid", "2024-01-02T00:00:00.000Z"), // unvisited
+    item("visited-sent-from", "2024-01-05T00:00:00.000Z", {
+      lastVisitedAt: "2024-01-06T00:00:00.000Z",
+    }),
+    item("visited-next", "2024-01-04T00:00:00.000Z", {
+      lastVisitedAt: "2024-01-07T00:00:00.000Z",
+    }),
+    item("visited-last", "2024-01-03T00:00:00.000Z", {
+      lastVisitedAt: "2024-01-08T00:00:00.000Z",
+    }),
+  ];
+  const next = pickNextFocusItem(queue, "visited-sent-from", 0);
+  assert.equal(next?.session.id, "unvisited-top");
+});
+
+test("unvisited-finished bucket wins when sent-from is on a running session", () => {
+  // The user is currently on a running session. Pressing Next
+  // should re-surface the unvisited triage pile rather than
+  // bouncing between running sessions.
+  const queue = [
+    item("unvisited", "2024-01-01T00:00:00.000Z"),
+    item("running-sent-from", "2024-01-05T00:00:00.000Z", { active: true }),
+    item("running-other", "2024-01-06T00:00:00.000Z", { active: true }),
+  ];
+  const next = pickNextFocusItem(queue, "running-sent-from", 0);
+  assert.equal(next?.session.id, "unvisited");
+});
+
+test("unvisited-finished bucket skips the sent-from session", () => {
+  // The user is on the top unvisited item. Pressing Next should
+  // skip them and land on the next unvisited, or fall through if
+  // they're the only one.
+  const queue = [
+    item("only-unvisited-sent-from", "2024-01-01T00:00:00.000Z"),
+    item("visited", "2024-01-02T00:00:00.000Z", {
+      lastVisitedAt: "2024-01-05T00:00:00.000Z",
+    }),
+  ];
+  const next = pickNextFocusItem(queue, "only-unvisited-sent-from", 0);
+  // Skip sent-from, no other unvisited, no recently-finished
+  // (watermark=0), plain circular -> visited.
+  assert.equal(next?.session.id, "visited");
+});
+
+test("unvisited-finished bucket walks in array order (FIFO)", () => {
+  // sortFocusQueue puts oldest-arrival first within the unvisited
+  // bucket; the algorithm walks in array order.
+  const queue = [
+    item("u-oldest", "2024-01-01T00:00:00.000Z"),
+    item("u-newest", "2024-01-05T00:00:00.000Z"),
+  ];
+  const next = pickNextFocusItem(queue, "external", 0);
+  assert.equal(next?.session.id, "u-oldest");
+});
+
+test("unvisited-finished bucket is skipped when sent-from is the only unvisited", () => {
+  // The user is on the only unvisited finished session. They press
+  // Next — should not bounce back to themselves. Falls through to
+  // plain circular.
+  const queue = [
+    item("only-unvisited", "2024-01-01T00:00:00.000Z"),
+    item("visited-1", "2024-01-02T00:00:00.000Z", {
+      lastVisitedAt: "2024-01-03T00:00:00.000Z",
+    }),
+    item("visited-2", "2024-01-03T00:00:00.000Z", {
+      lastVisitedAt: "2024-01-04T00:00:00.000Z",
+    }),
+  ];
+  const next = pickNextFocusItem(queue, "only-unvisited", 0);
+  // No unvisited (only one, skipped). No recently-finished
+  // (watermark=0). Plain circular from index 0 -> 1 -> "visited-1".
+  assert.equal(next?.session.id, "visited-1");
+});
+
+test("awaiting wins over unvisited-finished (the most urgent triage item wins)", () => {
+  // Awaiting-input is the most urgent state. The unvisited
+  // triage pile is also urgent but a session awaiting the user's
+  // reply needs the user's attention *right now*. Awaiting wins.
+  const queue = [
+    item("unvisited", "2024-01-01T00:00:00.000Z"),
+    item("awaiting", "2024-01-02T00:00:00.000Z", {
+      awaitingInput: true,
+      active: false,
+    }),
+  ];
+  const next = pickNextFocusItem(queue, "external", 0);
+  assert.equal(next?.session.id, "awaiting");
+});
+
+test("user's bug: Next from the second-to-last visited session lands on top of unvisited", () => {
+  // The exact scenario from the bug report: after visiting two
+  // sessions ("I want to update" then "I have a session" — or
+  // vice versa), the visited block sits at the bottom of the
+  // queue and the user lands on the second-to-last item. Plain
+  // circular advance would walk to the last item (the most
+  // recently visited) — but the user expects Next to jump to the
+  // top of the unvisited triage pile.
+  //
+  // Pre-fix: actual = "visited-last" (the second-to-last entry,
+  // which the user described as "next to last" / "penúltimo").
+  // Post-fix: actual = "unvisited-top".
+  const queue = [
+    item("unvisited-top", "2024-01-01T00:00:00.000Z"),
+    item("unvisited-mid", "2024-01-02T00:00:00.000Z"),
+    item("unvisited-third", "2024-01-03T00:00:00.000Z"),
+    item("unvisited-fourth", "2024-01-04T00:00:00.000Z"),
+    // visited block (older-lastVisitedAt first, since FIFO within
+    // the visited block in sortFocusQueue).
+    item("visited-second", "2024-01-06T00:00:00.000Z", {
+      lastVisitedAt: "2024-01-09T00:00:00.000Z",
+    }), // user is here (second-to-last = penúltimo)
+    item("visited-newest", "2024-01-05T00:00:00.000Z", {
+      lastVisitedAt: "2024-01-10T00:00:00.000Z",
+    }), // last in array
+  ];
+  const next = pickNextFocusItem(queue, "visited-second", 0);
+  assert.equal(next?.session.id, "unvisited-top");
+});
+
+test("user's bug: Next from the running session at the bottom lands on top of unvisited", () => {
+  // The running session (Controller - Redesign queue) is at the
+  // bottom of the user's queue. Pressing Next from it should
+  // jump to the top of unvisited, NOT wrap to idx 0's next-in-
+  // array-order neighbor (which would be the second visited).
+  const queue = [
+    item("unvisited-top", "2024-01-01T00:00:00.000Z"),
+    item("unvisited-mid", "2024-01-02T00:00:00.000Z"),
+    item("unvisited-third", "2024-01-03T00:00:00.000Z"),
+    item("unvisited-fourth", "2024-01-04T00:00:00.000Z"),
+    item("visited-first", "2024-01-05T00:00:00.000Z", {
+      lastVisitedAt: "2024-01-09T00:00:00.000Z",
+    }),
+    item("visited-second", "2024-01-06T00:00:00.000Z", {
+      lastVisitedAt: "2024-01-10T00:00:00.000Z",
+    }),
+    item("running", "2024-01-07T00:00:00.000Z", { active: true }), // user is here
+  ];
+  const next = pickNextFocusItem(queue, "running", 0);
+  assert.equal(next?.session.id, "unvisited-top");
+});
+
+test("Next from a visited session walks forward when the just-visited session reshuffles to the visited bucket", () => {
+  // After visiting u0 and u1, the queue is:
+  //   unvisited: [u2, u3, u4]
+  //   visited:   [u0, u1] (sorted by lastVisitedAt asc)
+  // User is on u1 (just visited, idx 4 in the reshuffled queue).
+  // My fix should walk forward to u2 (the next oldest-arrival
+  // unvisited), NOT jump back to u0.
+  const queue = [
+    item("u2", "2024-01-01T00:00:00.000Z"), // oldest-arrival unvisited
+    item("u3", "2024-01-02T00:00:00.000Z"),
+    item("u4", "2024-01-03T00:00:00.000Z"),
+    item("u0", "2024-01-04T00:00:00.000Z", {
+      lastVisitedAt: "2024-01-09T00:00:00.000Z",
+    }), // visited first
+    item("u1", "2024-01-05T00:00:00.000Z", {
+      lastVisitedAt: "2024-01-10T00:00:00.000Z",
+    }), // user is here (just visited)
+    item("v0", "2024-01-06T00:00:00.000Z", {
+      lastVisitedAt: "2024-01-07T00:00:00.000Z",
+    }),
+    item("v1", "2024-01-07T00:00:00.000Z", {
+      lastVisitedAt: "2024-01-08T00:00:00.000Z",
+    }),
+  ];
+  const next = pickNextFocusItem(queue, "u1", 0);
+  assert.equal(next?.session.id, "u2");
+});
+test("starting fresh (sentFromSessionId = '') ignores persisted visited state on the first click", () => {
+  // After a reload, `visitedAt` is hydrated from localStorage. Every
+  // pinned session looks visited, so the unvisited bucket is empty
+  // and the algorithm falls through to plain circular — which
+  // returns the visually-first item (idx 0) anyway, but only as a
+  // happy accident. The user expects "click Next from the empty
+  // state = start triaging from the visual top," so we make the
+  // fresh-start case explicit: ignore the visited filter when
+  // `sentFromSessionId === ""`.
+  //
+  // The fresh-start exemption also fixes the case where the
+  // visually-first item is a running session (skipped by the
+  // active filter) — we land on the first non-running item
+  // instead. Subsequent clicks have a non-empty sent-from and
+  // respect the visited state normally.
+  const queue = [
+    item("u0", "2024-01-01T00:00:00.000Z", {
+      lastVisitedAt: "2024-01-09T00:00:00.000Z",
+    }), // visited from the previous session
+    item("u1", "2024-01-02T00:00:00.000Z", {
+      lastVisitedAt: "2024-01-10T00:00:00.000Z",
+    }), // visited from the previous session
+    item("u2", "2024-01-03T00:00:00.000Z"), // truly unvisited
+  ];
+  const next = pickNextFocusItem(queue, "", 0);
+  assert.equal(next?.session.id, "u0");
+});
+
+test("starting fresh skips a running session at the visual top", () => {
+  // If the visually-first item is currently running (e.g. the user
+  // just got back from lunch and a fresh agent is working), we
+  // shouldn't bounce them into it on the first Next. Skip
+  // running items even on fresh start.
+  const queue = [
+    item("running-top", "2024-01-01T00:00:00.000Z", { active: true }),
+    item("running-other", "2024-01-02T00:00:00.000Z", { active: true }),
+    item("u2", "2024-01-03T00:00:00.000Z"),
+  ];
+  const next = pickNextFocusItem(queue, "", 0);
+  assert.equal(next?.session.id, "u2");
+});
+
+test("after the fresh-start click, subsequent clicks respect the visited state", () => {
+  // Once the user has clicked Next once from the empty state,
+  // `sentFromSessionId` is the session they landed on (non-empty).
+  // From then on, the visited-state filter applies as before:
+  // pressing Next from a visited middle item jumps to the top of
+  // unvisited, not the visually-first item.
+  //
+  // Here the user has just landed on "u0" (the fresh-start top,
+  // visited via the just-completed click). The next click should
+  // walk forward to "u1" — *not* return to "u0" because the
+  // fresh-start exemption no longer applies.
+  const queue = [
+    item("u0", "2024-01-01T00:00:00.000Z", {
+      lastVisitedAt: "2024-02-01T00:00:00.000Z",
+    }), // visited just now
+    item("u1", "2024-01-02T00:00:00.000Z", {
+      lastVisitedAt: "2024-02-02T00:00:00.000Z",
+    }), // visited previously
+    item("u2", "2024-01-03T00:00:00.000Z"), // truly unvisited
+  ];
+  const next = pickNextFocusItem(queue, "u0", Date.now());
+  assert.equal(next?.session.id, "u2");
+});
diff --git a/client/src/lib/focus-advance.ts b/client/src/lib/focus-advance.ts
index 84985c9c..531d1ff9 100644
--- a/client/src/lib/focus-advance.ts
+++ b/client/src/lib/focus-advance.ts
@@ -2,34 +2,183 @@
  * Pure focus-queue navigation math, isolated from React so it can be
  * unit-tested with the existing `node --import tsx --test` runner.
  *
- * Rules (preserved from the original in-line handler in `App.tsx`):
+ * Rules (priority order):
  *
- *  - The queue is circular. Sending from index N advances to the next
- *    index, wrapping back to 0 after the last item.
- *  - If the sent-from session isn't in the queue at all, treat it as
- *    "before the queue" and advance to the first item.
- *  - If the resulting `next` is the same session the user just sent
- *    to, return `null` so the caller can stay put. This covers both
- *    the queue-of-one case and the (rare) wrap-to-self edge case
- *    where a single-item queue happens to match the sent-from id.
+ *  - **Awaiting input** — sessions whose agent has paused on a
+ *    `user.input_requested` prompt or has a pending tool approval.
+ *    These are the most urgent items and always win, even over
+ *    recently-finished sessions. The user owes a reply to these;
+ *    `awaitingInput` is independent of the session's `active` flag
+ *    (Claude's structured-input pause kills the child, so the
+ *    session can be inactive and still awaiting). When multiple
+ *    sessions are awaiting, the queue's array order picks the
+ *    winner (sortFocusQueue puts oldest-arrival first within the
+ *    awaiting bucket).
+ *  - **Unvisited finished** — finished sessions the user has never
+ *    opened (no `lastVisitedAt`). These are the "triage pile." When
+ *    the user presses Next from *any* session (running, visited,
+ *    or another unvisited), the algorithm re-surfaces the top of
+ *    this pile so they walk the unfinished triage in arrival order.
+ *    Without this priority, plain circular advance walks the
+ *    *current* array order — unvisited → visited → running — and
+ *    lands on the second-to-last item when the user is on a
+ *    visited session in the middle of the visited block. The scan
+ *    starts at `sentIndex + 1` and wraps around, so the user also
+ *    walks *forward* through the unvisited pile after visiting one
+ *    (on index 0 → next unvisited is index 1, not a re-visit of
+ *    index 0). Issue #333 follow-up.
+ *  - **Recently finished** — items that finished at or after the
+ *    user's previous interaction timestamp. Fresh finishes the
+ *    user hasn't answered yet; the algorithm walks the finished
+ *    pile in arrival order (oldest first), so the first match in
+ *    array order is the oldest such fresh item. Falls through here
+ *    only when the unvisited triage pile is exhausted (so it
+ *    doesn't matter whether the item is visited or not).
+ *  - **Plain circular advance** — sending from index N advances to
+ *    N+1, wrapping back to 0 after the last item. If the sent-from
+ *    session isn't in the queue, treat it as "before index 0" and
+ *    advance to the first item.
+ *  - If the resulting `next` is the same session the user just
+ *    sent from, return `null` so the caller can stay put. This
+ *    covers both the queue-of-one case and the (rare) wrap-to-self
+ *    edge case where a single-item queue happens to match the
+ *    sent-from id.
  */
 export interface FocusQueueItemLike {
-  session: { id: string };
+  session: { id: string; lastActiveAt: string };
   projectId: string;
   worktreeId: string;
   projectName: string;
   worktreeName: string;
+  /**
+   * Highest-priority flag. When true, the algorithm returns this
+   * session (or the oldest-arrival one of multiple awaiting
+   * sessions) before checking the recently-finished bucket. The
+   * sent-from session is skipped so the user doesn't get bounced
+   * back to the prompt they're already looking at.
+   */
+  awaitingInput?: boolean;
+  /**
+   * Set when the session is currently running (the agent is
+   * processing a turn). Used by `pickNextFocusItem` to skip
+   * running sessions when looking for the next triage target
+   * — the user pressing Next while on a running session means
+   * "I'm done with this, move on," and we should re-surface the
+   * unvisited triage pile rather than bouncing between running
+   * sessions.
+   */
+  active?: boolean;
+  /**
+   * ISO timestamp of the last time the user landed on this
+   * session via any navigation (Next, auto-advance, mark-done
+   * follow-up, sidebar click, conversation link). Items with no
+   * `lastVisitedAt` are the "triage pile" — finished sessions the
+   * user has never opened. Items with a `lastVisitedAt` are
+   * visited. The unvisited-finished bucket in
+   * `pickNextFocusItem` always wins when there's any unvisited
+   * finished item (so the user can resume the triage pile from
+   * any session), and the recently-finished bucket falls through
+   * to plain circular only when the triage pile is exhausted.
+   */
+  lastVisitedAt?: string;
+}
+
+export function pickFirstFocusItem<
+  T extends FocusQueueItemLike,
+>(focusQueue: T[], currentSessionId: string): T | null {
+  return (
+    focusQueue.find((item) => item.session.id !== currentSessionId) ?? null
+  );
 }
 
 export function pickNextFocusItem<
   T extends FocusQueueItemLike,
->(focusQueue: T[], sentFromSessionId: string): T | null {
+>(
+  focusQueue: T[],
+  sentFromSessionId: string,
+  lastInteractionAt: number,
+): T | null {
   if (focusQueue.length === 0) return null;
+
+  // 1. Awaiting-input bucket: items whose agent is blocked on the
+  //    user (structured-input prompt or pending approval). Always
+  //    wins, regardless of when the user last interacted. Skip the
+  //    sent-from session — they're already looking at it.
+  for (const item of focusQueue) {
+    if (item.awaitingInput !== true) continue;
+    if (item.session.id === sentFromSessionId) continue;
+    return item;
+  }
+
+  // 2. Unvisited-finished bucket: the "triage pile." Finished
+  //    sessions the user has never visited sit at the top of the
+  //    queue in `sortFocusQueue`. When the user presses Next from
+  //    *any* session (running, visited, or another unvisited), the
+  //    queue should re-surface the top of this pile so they walk the
+  //    unfinished triage in arrival order. Without this priority,
+  //    plain circular advance walks the *current* array order —
+  //    which is unvisited-finished → visited-finished → running —
+  //    and lands on the second-to-last item when the user is on a
+  //    visited-finished session in the middle of the visited block.
+  //
+  //    The scan starts at `sentIndex + 1` and wraps around so the
+  //    user can also walk *forward* through the unvisited pile
+  //    after visiting one (e.g. on index 0 -> next unvisited is
+  //    index 1, not a re-visit of index 0). Issue #333 follow-up.
+  //
+  //    **Fresh-start exemption**: when `sentFromSessionId === ""`
+  //    (the user is on the empty state — no active session, e.g.
+  //    after a reload), the persisted `visitedAt` map makes every
+  //    item look visited and the unvisited bucket comes back empty.
+  //    That's not what the user wants: clicking Next from the empty
+  //    state means "start triaging from the visual top." In that
+  //    case we ignore the visited-state filter so the first click
+  //    lands on the visually-first non-running item. Subsequent
+  //    clicks (where `sentFromSessionId` is non-empty) respect the
+  //    visited state and walk the triage pile in arrival order.
+  const len = focusQueue.length;
   const sentIndex = focusQueue.findIndex(
     (item) => item.session.id === sentFromSessionId,
   );
-  const startIndex = sentIndex >= 0 ? sentIndex : -1;
-  const nextIndex = (startIndex + 1 + focusQueue.length) % focusQueue.length;
+  const scanStart = sentIndex >= 0 ? (sentIndex + 1) % len : 0;
+  const startingFresh = sentFromSessionId === "";
+  for (let offset = 0; offset < len; offset++) {
+    const item = focusQueue[(scanStart + offset) % len];
+    if (item.session.id === sentFromSessionId) continue;
+    if (item.awaitingInput === true) continue; // handled in step 1
+    if (item.active === true) continue; // skip running — user is here to triage
+    // When starting fresh (empty active view), ignore the persisted
+    // visited state so the first Next click lands on the
+    // visually-first item, not on whatever the algorithm fell
+    // through to after the empty unvisited bucket.
+    if (!startingFresh && item.lastVisitedAt !== undefined) continue;
+    return item;
+  }
+
+  // 3. Recently-finished bucket: items that finished at or after the
+  //    user's previous interaction. The finished pile is sorted
+  //    oldest-arrival first within each visited/unvisited sub-bucket,
+  //    so the first match in array order is the oldest-arrival such
+  //    item. Skip the sent-from session. Falls through to this only
+  //    when there are no unvisited items (so it doesn't matter
+  //    whether the item is visited or not).
+  if (lastInteractionAt > 0) {
+    for (let offset = 0; offset < len; offset++) {
+      const item = focusQueue[(scanStart + offset) % len];
+      if (item.session.id === sentFromSessionId) continue;
+      if (item.active === true) continue;
+      const finishedAt = new Date(item.session.lastActiveAt).getTime();
+      if (finishedAt >= lastInteractionAt) {
+        return item;
+      }
+    }
+  }
+
+  // 4. No awaiting-input and no unvisited/recently-finished items:
+  //    plain circular advance. This kicks in when the user has
+  //    visited every triage item and is now cycling through visited
+  //    sessions and running sessions.
+  const nextIndex = (scanStart) % len;
   const next = focusQueue[nextIndex];
   if (next.session.id === sentFromSessionId) return null;
   return next;
diff --git a/client/src/lib/focus-conversation-countdown.test.ts b/client/src/lib/focus-conversation-countdown.test.ts
new file mode 100644
index 00000000..cc7ea159
--- /dev/null
+++ b/client/src/lib/focus-conversation-countdown.test.ts
@@ -0,0 +1,24 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { getConversationCountdown } from "./focus-conversation-countdown.ts";
+
+test("new-session view does not dereference a missing countdown", () => {
+  assert.equal(getConversationCountdown(null, undefined), null);
+});
+
+test("countdown is only exposed in its originating session", () => {
+  const onCancel = () => {};
+  const countdown = {
+    sentFromSessionId: "session-a",
+    scheduledAt: 123,
+    durationMs: 4_000,
+    onCancel,
+  };
+
+  assert.equal(getConversationCountdown(countdown, "session-b"), null);
+  assert.deepEqual(getConversationCountdown(countdown, "session-a"), {
+    scheduledAt: 123,
+    durationMs: 4_000,
+    onStay: onCancel,
+  });
+});
diff --git a/client/src/lib/focus-conversation-countdown.ts b/client/src/lib/focus-conversation-countdown.ts
new file mode 100644
index 00000000..ce2a4a9c
--- /dev/null
+++ b/client/src/lib/focus-conversation-countdown.ts
@@ -0,0 +1,27 @@
+export interface FocusAdvanceCountdown {
+  sentFromSessionId: string;
+  scheduledAt: number;
+  durationMs: number;
+  onCancel: () => void;
+}
+
+export interface ConversationCountdown {
+  scheduledAt: number;
+  durationMs: number;
+  onStay: () => void;
+}
+
+export function getConversationCountdown(
+  countdown: FocusAdvanceCountdown | null,
+  sessionId?: string,
+): ConversationCountdown | null {
+  if (!countdown || !sessionId || countdown.sentFromSessionId !== sessionId) {
+    return null;
+  }
+
+  return {
+    scheduledAt: countdown.scheduledAt,
+    durationMs: countdown.durationMs,
+    onStay: countdown.onCancel,
+  };
+}
diff --git a/client/src/lib/focus-visited-storage.ts b/client/src/lib/focus-visited-storage.ts
new file mode 100644
index 00000000..bfc95dda
--- /dev/null
+++ b/client/src/lib/focus-visited-storage.ts
@@ -0,0 +1,68 @@
+/**
+ * Persisted handled timestamps for the focus queue.
+ *
+ * The timestamps that drive `sortFocusQueue`'s handled/unhandled
+ * split live in App's React state, but they have to survive a reload
+ * — otherwise every page refresh re-surfaces every pinned session as
+ * "fresh." The storage key and API retain their historical `visitedAt`
+ * names for backwards compatibility, but simply opening a session no
+ * longer writes them.
+ *
+ * Storage layout: a single localStorage entry holding a JSON object
+ * `{ [sessionId]: <ISO timestamp of last advance> }`. Entries older
+ * than `VISITED_AT_TTL_MS` are dropped on load so stale triage state
+ * does not survive indefinitely.
+ *
+ * Storage failures (private-mode browsers, quota exceeded, malformed
+ * JSON) fall back to an empty in-memory map and try to write through
+ * on every change so the next successful write heals the state.
+ *
+ * Extracted from `App.tsx` so it can be unit-tested without a React
+ * renderer — the helpers are pure functions over a `Storage`-shaped
+ * object.
+ */
+
+export const VISITED_AT_STORAGE_KEY = "controller.focus.visitedAt";
+export const VISITED_AT_TTL_MS = 7 * 24 * 60 * 60 * 1000; // 7 days.
+
+export function loadSavedVisitedAt(storage: Pick<Storage, "getItem">): Record<string, string> {
+  let raw: string | null = null;
+  try {
+    raw = storage.getItem(VISITED_AT_STORAGE_KEY);
+  } catch {
+    return {};
+  }
+  if (!raw) return {};
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return {};
+  }
+  if (!parsed || typeof parsed !== "object") return {};
+
+  const cutoff = Date.now() - VISITED_AT_TTL_MS;
+  const result: Record<string, string> = {};
+  for (const [id, value] of Object.entries(parsed as Record<string, unknown>)) {
+    if (typeof value !== "string") continue;
+    const ts = Date.parse(value);
+    if (Number.isNaN(ts)) continue;
+    if (ts < cutoff) continue; // stale; treat as never-visited
+    result[id] = value;
+  }
+  return result;
+}
+
+export function persistVisitedAt(
+  storage: Pick<Storage, "setItem">,
+  value: Record<string, string>,
+): void {
+  try {
+    storage.setItem(VISITED_AT_STORAGE_KEY, JSON.stringify(value));
+  } catch {
+    // Quota exceeded, private mode, etc. — the in-memory state
+    // still works for the rest of the session; the next successful
+    // write will heal the on-disk state.
+  }
+}
diff --git a/client/src/lib/mobile-composer.test.ts b/client/src/lib/mobile-composer.test.ts
new file mode 100644
index 00000000..5f4942c6
--- /dev/null
+++ b/client/src/lib/mobile-composer.test.ts
@@ -0,0 +1,28 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { getComposerLayout } from "./mobile-composer.ts";
+
+test("mobile composer is one line without details until focused", () => {
+  assert.deepEqual(getComposerLayout(true, false, 5), {
+    showDetails: false,
+    showCompactActions: true,
+    maxLines: 1,
+    autoFocusOnSessionChange: false,
+  });
+
+  assert.deepEqual(getComposerLayout(true, true, 5), {
+    showDetails: true,
+    showCompactActions: false,
+    maxLines: 5,
+    autoFocusOnSessionChange: false,
+  });
+});
+
+test("desktop composer remains expanded and keyboard-ready", () => {
+  assert.deepEqual(getComposerLayout(false, false, 5), {
+    showDetails: true,
+    showCompactActions: false,
+    maxLines: 5,
+    autoFocusOnSessionChange: true,
+  });
+});
diff --git a/client/src/lib/mobile-composer.ts b/client/src/lib/mobile-composer.ts
new file mode 100644
index 00000000..2ac6b0e7
--- /dev/null
+++ b/client/src/lib/mobile-composer.ts
@@ -0,0 +1,27 @@
+export const MOBILE_COMPOSER_MEDIA_QUERY = "(max-width: 767px)";
+
+export interface ComposerLayout {
+  showDetails: boolean;
+  showCompactActions: boolean;
+  maxLines: number;
+  autoFocusOnSessionChange: boolean;
+}
+
+/**
+ * Desktop keeps the existing composer at all times. On mobile the idle
+ * composer is a single real textarea and expands only while focus is within
+ * the composer.
+ */
+export function getComposerLayout(
+  isMobileViewport: boolean,
+  hasFocus: boolean,
+  expandedMaxLines: number,
+): ComposerLayout {
+  const showDetails = !isMobileViewport || hasFocus;
+  return {
+    showDetails,
+    showCompactActions: isMobileViewport && !hasFocus,
+    maxLines: showDetails ? expandedMaxLines : 1,
+    autoFocusOnSessionChange: !isMobileViewport,
+  };
+}
diff --git a/client/src/lib/shortcut-match.ts b/client/src/lib/shortcut-match.ts
index df240e6d..20e4d0fe 100644
--- a/client/src/lib/shortcut-match.ts
+++ b/client/src/lib/shortcut-match.ts
@@ -213,12 +213,12 @@ function prettyKey(key: string): string {
  * Bindings map action-id → chord-string. We resolve each chord to a
  * parsed form and return the first match.
  *
- * Note: in practice we don't use this — `useControllerModeShortcuts`
- * matches against each action's chord directly so the host can decide
- * priority (e.g. the `controllerModeNext` chord matches even while a
- * countdown is pending, taking precedence over `controllerModeStay`).
- * Exposed for future chords and for the settings UI's "what fires for
- * this chord?" lookup.
+ * Note: in practice we don't use this — `useFocusShortcuts` matches
+ * against each action's chord directly so the host can decide
+ * priority (e.g. the `focusAdvanceNext` chord matches even while a
+ * countdown is pending, taking precedence over `focusStay`). Exposed
+ * for future chords and for the settings UI's "what fires for this
+ * chord?" lookup.
  */
 export function findMatchingAction(
   bindings: Record<string, string>,
diff --git a/client/src/lib/useFilePanelShortcuts.ts b/client/src/lib/useFilePanelShortcuts.ts
index 803b49a3..934f216b 100644
--- a/client/src/lib/useFilePanelShortcuts.ts
+++ b/client/src/lib/useFilePanelShortcuts.ts
@@ -18,7 +18,7 @@ import { isRecordingChord } from "./useShortcutBindings.tsx";
  *     finder overlay scoped to the active worktree.
  *
  * Both chords follow the same suppression rules as
- * `useControllerModeShortcuts` (issue #235):
+ * `useFocusShortcuts` (issue #235):
  *   - Skipped while the Settings recorder is mid-capture so the
  *     recorded key isn't double-handled.
  *   - Skipped on auto-repeat.
@@ -34,9 +34,9 @@ import { isRecordingChord } from "./useShortcutBindings.tsx";
  *     the shortcut. The composer needs `Cmd+B` / `Cmd+P` for text
  *     formatting and clipboard respectively, and the chat
  *     composer's own handlers win the race anyway. Note this is the
- *     one place the rules diverge from `useControllerModeShortcuts`:
- *     controller-mode chords fire even inside the composer because
- *     they're the only way to escape a stuck focus-mode loop; the
+ *     one place the rules diverge from `useFocusShortcuts`:
+ *     focus-queue chords fire even inside the composer because
+ *     they're the only way to escape a stuck focus loop; the
  *     files-panel chords are convenience bindings and shouldn't
  *     clobber text editing.
  *
diff --git a/client/src/lib/useControllerModeShortcuts.ts b/client/src/lib/useFocusShortcuts.ts
similarity index 63%
rename from client/src/lib/useControllerModeShortcuts.ts
rename to client/src/lib/useFocusShortcuts.ts
index 42cc681d..bf639776 100644
--- a/client/src/lib/useControllerModeShortcuts.ts
+++ b/client/src/lib/useFocusShortcuts.ts
@@ -11,27 +11,31 @@ import {
 import { isRecordingChord } from "./useShortcutBindings.tsx";
 
 /**
- * Global keyboard shortcuts that drive the controller-mode loop from the
- * keyboard. Bindings are sourced from the shared `useShortcutBindings`
- * hook so the user can rebind them in Settings (issue #235).
+ * Global keyboard shortcuts that drive the focus-queue triage loop.
+ * Bindings are sourced from the shared `useShortcutBindings` hook so
+ * the user can rebind them in Settings (issue #235).
  *
  * Default actions (strict per-platform: ⌃ on macOS, Ctrl elsewhere):
- *   - `Ctrl+T`       → toggle controller mode (enter if off, exit if on).
- *   - `Ctrl+N`       → next pinned session. If a controller-mode advance
- *                      countdown is pending, this commits it immediately to
- *                      continue to the next session. The commit path fires
- *                      even while the composer is focused.
- *   - `Ctrl+D`       → mark current session done. Fires regardless of
- *                      Controller Mode state; no-op when no session is
- *                      open.
- *   - `Ctrl+S`       → cancel a pending controller-mode advance countdown
- *                      and stay on the current session. Fires even while
+ *   - `Ctrl+N`       → next pinned session. If a focus-advance
+ *                      countdown is pending, this commits it
+ *                      immediately to continue to the next session.
+ *                      The commit path fires even while the composer
+ *                      is focused.
+ *   - `Ctrl+D`       → mark current session done. No-op when no
+ *                      session is open.
+ *   - `Ctrl+S`       → cancel a pending focus-advance countdown and
+ *                      stay on the current session. Fires even while
  *                      the composer is focused so the user can dismiss
  *                      the toast without blurring first.
+ *   - `Ctrl+T`       → toggle the post-reply auto-advance countdown
+ *                      on or off. Independent of `Next` (which always
+ *                      advances regardless of this setting) and of
+ *                      `Stay` (only meaningful while a countdown is
+ *                      pending). Issue #333 follow-up.
  *   - `Esc`          → blurs the currently-focused input/textarea/
- *                      contenteditable. If no countdown is pending, it's
- *                      a no-op. Intentionally a no-op inside dialogs and
- *                      the embedded terminal.
+ *                      contenteditable. If no countdown is pending,
+ *                      it's a no-op. Intentionally a no-op inside
+ *                      dialogs and the embedded terminal.
  *
  * Defaults use Ctrl (not Cmd) because Cmd collides with too many macOS
  * system shortcuts (Cmd+W, Cmd+Q, Cmd+R, …) and the matcher is strict
@@ -44,27 +48,31 @@ import { isRecordingChord } from "./useShortcutBindings.tsx";
  * one exception: it still blurs an editable element so the user can
  * resume typing without their keys being intercepted.
  *
- * Shortcuts are suppressed inside dialogs (role="dialog" / <dialog>), the
- * embedded terminal, or when an auto-repeat fires.
+ * Shortcuts are suppressed inside dialogs (role="dialog" / <dialog>),
+ * the embedded terminal, or when an auto-repeat fires.
  */
-export interface UseControllerModeShortcutsOptions {
+export interface UseFocusShortcutsOptions {
   bindings: ShortcutBindings | null;
-  controllerMode: boolean;
   onSkip: () => void;
   onDone: () => void;
-  onEnter: () => void;
-  onExit: () => void;
+  /**
+   * Optional. Toggle the post-reply auto-advance countdown on or off.
+   * Fired by the `focusAutoAdvance` chord (default Ctrl+T). The
+   * caller owns the boolean; the hook just calls back with the
+   * current state for the user to flip.
+   */
+  onToggleAutoAdvance?: () => void;
   /**
    * Optional. Called when the user invokes the "stay" chord while a
-   * controller-mode advance countdown is pending. Issue #104.
+   * focus-advance countdown is pending. Issue #104.
    */
   onCancelAdvance?: () => void;
   /**
    * Optional. Called when the user invokes the "next" chord while a
-   * controller-mode advance countdown is pending, committing it
-   * immediately to continue to the next session. Set only when a
-   * countdown is pending so the early `N` path (which fires even while
-   * the composer is focused) is a no-op otherwise.
+   * focus-advance countdown is pending, committing it immediately to
+   * continue to the next session. Set only when a countdown is
+   * pending so the early `N` path (which fires even while the
+   * composer is focused) is a no-op otherwise.
    */
   onCommitAdvance?: () => void;
 }
@@ -103,53 +111,38 @@ function getParsedChord(
   return parseChord(bindings[action]);
 }
 
-export function useControllerModeShortcuts({
+export function useFocusShortcuts({
   bindings,
-  controllerMode,
   onSkip,
   onDone,
-  onEnter,
-  onExit,
+  onToggleAutoAdvance,
   onCancelAdvance,
   onCommitAdvance,
-}: UseControllerModeShortcutsOptions): void {
+}: UseFocusShortcutsOptions): void {
   // Keep handler refs in sync so the keydown listener doesn't have to
   // re-attach on every render of the host component.
-  const controllerModeRef = useRef(controllerMode);
   const onSkipRef = useRef(onSkip);
   const onDoneRef = useRef(onDone);
-  const onEnterRef = useRef(onEnter);
-  const onExitRef = useRef(onExit);
+  const onToggleAutoAdvanceRef = useRef(onToggleAutoAdvance);
   const onCancelAdvanceRef = useRef(onCancelAdvance);
   const onCommitAdvanceRef = useRef(onCommitAdvance);
   const bindingsRef = useRef(bindings);
 
   useEffect(() => {
-    controllerModeRef.current = controllerMode;
     onSkipRef.current = onSkip;
     onDoneRef.current = onDone;
-    onEnterRef.current = onEnter;
-    onExitRef.current = onExit;
+    onToggleAutoAdvanceRef.current = onToggleAutoAdvance;
     onCancelAdvanceRef.current = onCancelAdvance;
     onCommitAdvanceRef.current = onCommitAdvance;
     bindingsRef.current = bindings;
-  }, [
-    controllerMode,
-    onSkip,
-    onDone,
-    onEnter,
-    onExit,
-    onCancelAdvance,
-    onCommitAdvance,
-    bindings,
-  ]);
+  }, [onSkip, onDone, onToggleAutoAdvance, onCancelAdvance, onCommitAdvance, bindings]);
 
   useEffect(() => {
     function handleKeyDown(event: KeyboardEvent) {
       // While the Settings recorder is mid-capture, the App-level
       // listener must stay out of the way — otherwise a recorded
-      // Ctrl+T / Ctrl+N / Ctrl+D / Ctrl+S would actually toggle /
-      // navigate / mark-done instead of being captured for the new
+      // Ctrl+N / Ctrl+D / Ctrl+S would actually navigate /
+      // mark-done / cancel instead of being captured for the new
       // binding (issue #235 P2 review).
       if (isRecordingChord()) return;
       if (event.repeat) return;
@@ -158,10 +151,10 @@ export function useControllerModeShortcuts({
 
       // Esc handling has two paths:
       //   1. Focus is in an editable element: blur it so the user can
-      //      drive the controller-mode loop from the keyboard after
+      //      drive the focus-queue loop from the keyboard after
       //      typing.
-      //   2. Focus is elsewhere: if a controller-mode advance countdown
-      //      is pending, cancel it (matches the **Stay** chord).
+      //   2. Focus is elsewhere: if a focus-advance countdown is
+      //      pending, cancel it (matches the **Stay** chord).
       // Suppressed inside dialogs (let them close) and the terminal
       // (let it forward the key to the running process).
       if (event.key === "Escape") {
@@ -178,18 +171,17 @@ export function useControllerModeShortcuts({
 
       const currentBindings = bindingsRef.current;
       if (!currentBindings) return;
-      const inControllerMode = controllerModeRef.current;
 
-      // All Controller Mode chords (default Ctrl+T / Ctrl+N / Ctrl+D /
-      // Ctrl+S) fire regardless of where focus is — that's the whole
-      // reason the issue switched them to modifier-based (issue #235).
+      // All focus-queue chords (default Ctrl+N / Ctrl+D / Ctrl+S)
+      // fire regardless of where focus is — that's the whole reason
+      // the issue switched them to modifier-based (issue #235).
       // preventDefault keeps the literal character out of the textarea
       // when one is focused. Esc is intentionally not in this group
       // because the user still wants Esc to blur the input.
 
       // The "stay" chord (default Ctrl+S) only matters while an
       // advance is pending; no-op otherwise.
-      const stayChord = getParsedChord(currentBindings, "controllerModeStay");
+      const stayChord = getParsedChord(currentBindings, "focusStay");
       if (
         stayChord &&
         onCancelAdvanceRef.current &&
@@ -203,7 +195,7 @@ export function useControllerModeShortcuts({
       // "Next" while a countdown is pending commits the advance
       // immediately. When no countdown is pending the regular next
       // handler below takes over.
-      const nextChord = getParsedChord(currentBindings, "controllerModeNext");
+      const nextChord = getParsedChord(currentBindings, "focusAdvanceNext");
       if (
         nextChord &&
         onCommitAdvanceRef.current &&
@@ -214,34 +206,36 @@ export function useControllerModeShortcuts({
         return;
       }
 
-      // Toggle chord (default Ctrl+T) is the unified enter/exit
-      // binding. Runs before the controller-mode gate so the user can
-      // leave controller mode even if they're typing in the composer.
-      const toggleChord = getParsedChord(currentBindings, "controllerModeToggle");
-      if (toggleChord && matchesEvent(toggleChord, event)) {
-        event.preventDefault();
-        if (inControllerMode) {
-          onExitRef.current();
-        } else {
-          onEnterRef.current();
-        }
-        return;
-      }
-
-      // "Mark done" (default Ctrl+D) fires regardless of Controller
-      // Mode — the user wants to be able to clear a pinned session
-      // from the radar without first toggling Controller Mode on.
-      // `handleFocusDone` no-ops when no session is active, so an
+      // "Mark done" (default Ctrl+D) fires regardless of focus. The
+      // host handler is a no-op when no session is active, so an
       // un-focused Ctrl+D is harmless.
-      const doneChord = getParsedChord(currentBindings, "controllerModeDone");
+      const doneChord = getParsedChord(currentBindings, "focusDone");
       if (doneChord && matchesEvent(doneChord, event)) {
         event.preventDefault();
         onDoneRef.current();
         return;
       }
 
-      if (!inControllerMode) return;
+      // "Toggle auto-advance" (default Ctrl+T) fires regardless of
+      // focus. The host flips its own boolean; Next and Stay keep
+      // working as before.
+      const toggleAutoAdvanceChord = getParsedChord(
+        currentBindings,
+        "focusAutoAdvance",
+      );
+      if (
+        toggleAutoAdvanceChord &&
+        onToggleAutoAdvanceRef.current &&
+        matchesEvent(toggleAutoAdvanceChord, event)
+      ) {
+        event.preventDefault();
+        onToggleAutoAdvanceRef.current();
+        return;
+      }
 
+      // "Next" with no countdown pending — skip to the next pinned
+      // session. If there's nothing to skip to, the host handler is a
+      // no-op.
       if (nextChord && matchesEvent(nextChord, event)) {
         event.preventDefault();
         onSkipRef.current();
@@ -268,10 +262,10 @@ export function labelForAction(
   // shared defaults is enforced by the DEFAULT_SHORTCUT_BINDINGS test
   // in shortcut-match.test.ts.
   const fallback = {
-    controllerModeToggle: "ctrl-t",
-    controllerModeNext: "ctrl-n",
-    controllerModeDone: "ctrl-d",
-    controllerModeStay: "ctrl-s",
+    focusAdvanceNext: "ctrl-n",
+    focusStay: "ctrl-s",
+    focusDone: "ctrl-d",
+    focusAutoAdvance: "ctrl-t",
     filesPanelToggle: "cmd-b",
     filesPanelSearch: "cmd-p",
   }[action];
diff --git a/client/src/lib/useShortcutBindings.tsx b/client/src/lib/useShortcutBindings.tsx
index 8057b3a6..4677a595 100644
--- a/client/src/lib/useShortcutBindings.tsx
+++ b/client/src/lib/useShortcutBindings.tsx
@@ -19,15 +19,15 @@ import {
 } from "../../../shared/shortcuts.ts";
 
 /**
- * Single source of truth for Controller Mode shortcut bindings.
+ * Single source of truth for focus-queue shortcut bindings.
  *
  * The provider lives near the root of the app (in `App.tsx`); every
- * consumer — the global keyboard listener, the `<Kbd>` chips in the
- * Controller Mode bar, the sidebar tooltip, and the Settings panel —
- * reads from the same shared state via `useShortcutBindingsContext()`.
- * That way a rebind in Settings is visible everywhere immediately
- * (issue #235 P2 review: previously Settings had its own `useState`,
- * so saved changes only took effect after a full reload).
+ * consumer — the global keyboard listener, the toast chip text, and
+ * the Settings panel — reads from the same shared state via
+ * `useShortcutBindingsContext()`. That way a rebind in Settings is
+ * visible everywhere immediately (issue #235 P2 review: previously
+ * Settings had its own `useState`, so saved changes only took effect
+ * after a full reload).
  *
  * Until the first fetch resolves, `bindings` is `null`; consumers
  * fall back to the bundled defaults.
@@ -114,9 +114,9 @@ export function bindingFor(
 /**
  * Module-level flag the App-level keyboard listener checks before
  * handling a chord. The Settings recorder sets this while the user is
- * mid-recording so a Ctrl+T / Ctrl+N / Ctrl+D / Ctrl+S press
- * captured by the recorder doesn't also fire the global handler and
- * toggle controller mode / navigate / mark done (issue #235 P2
+ * mid-recording so a Ctrl+N / Ctrl+D / Ctrl+S / Ctrl+T press captured
+ * by the recorder doesn't also fire the global handler and navigate /
+ * mark done / cancel an advance / toggle auto-advance (issue #235 P2
  * review).
  *
  * Using a module variable rather than context because the recorder
diff --git a/client/src/pages/SessionView.tsx b/client/src/pages/SessionView.tsx
index 5c6c1c4e..d77f1980 100644
--- a/client/src/pages/SessionView.tsx
+++ b/client/src/pages/SessionView.tsx
@@ -1,6 +1,6 @@
 import { memo, useCallback, useMemo, useState, useEffect, useLayoutEffect, useRef, createContext, useContext } from "react";
 import { diffLines } from "diff";
-import { ArrowUp, Loader2, Copy, Check, ChevronDown, ChevronRight, TerminalSquare, MessageSquare, Square, Diff, PanelRight, Zap, Plus, X, Paperclip, FileText, FileCode, Folder, FolderOpen, CheckCircle2, StepForward, LogOut, Radar, Play, Sparkles, Globe2, RefreshCw, Pencil, Archive } from "lucide-react";
+import { ArrowUp, Loader2, Copy, Check, ChevronDown, ChevronRight, TerminalSquare, MessageSquare, Square, Diff, PanelRight, Zap, Plus, X, Paperclip, FileText, FileCode, Folder, FolderOpen, StepForward, Play, Sparkles, Globe2, RefreshCw, Pencil, Archive } from "lucide-react";
 import hljs from "highlight.js/lib/core";
 import bash from "highlight.js/lib/languages/bash";
 import css from "highlight.js/lib/languages/css";
@@ -44,6 +44,7 @@ import { Badge } from "@/components/ui/badge";
 import { Kbd } from "@/components/ui/kbd";
 import { Terminal, type TerminalHandle } from "@/components/terminal";
 import { TerminalMobileControls } from "@/components/terminal-mobile-controls";
+import { FocusConversationControls } from "@/components/focus-conversation-controls";
 import { useResizablePanel } from "@/lib/useResizablePanel";
 import { isControllerAvailable } from "@/lib/controller";
 import { formatChord, matchesEvent, parseChord } from "@/lib/shortcut-match";
@@ -138,6 +139,11 @@ import {
 import { describeApprovalInput } from "../lib/describe-approval-input.ts";
 import { getLatestPendingToolApproval } from "../lib/pending-tool-approval.ts";
 import { extractFilesFromClipboard } from "../lib/clipboard-files.ts";
+import {
+  getComposerLayout,
+  MOBILE_COMPOSER_MEDIA_QUERY,
+} from "../lib/mobile-composer.ts";
+import { getConversationCountdown } from "../lib/focus-conversation-countdown.ts";
 
 interface SessionViewProps {
   projectId: string;
@@ -150,18 +156,17 @@ interface SessionViewProps {
   // the transcript. Resolves the short form (session-only) to its owning
   // project/worktree before navigating. No-op if the parent doesn't provide it.
   onOpenConversation?: (target: ControllerLinkTarget) => void;
-  controllerMode?: boolean;
   /**
-   * Effective shortcut bindings for Controller Mode chords. `null` while
-   * the settings hook is still loading. SessionView reads these so the
-   * `<Kbd>` chips and the inline "press S to stay" listener reflect the
-   * user's rebinds. See issue #235.
+   * Effective shortcut bindings for the focus-queue chords (Next /
+   * Stay / Done). `null` while the settings hook is still loading.
+   * SessionView reads these so the inline "press Ctrl+S to stay"
+   * listener matches the user's rebinds. See issue #235.
    */
   shortcutBindings?: import("../../../shared/shortcuts.ts").ShortcutBindings | null;
-  focusPosition?: { current: number; total: number };
+  autoAdvance?: boolean;
+  onToggleAutoAdvance?: () => void;
   onFocusDone?: () => void;
   onFocusSkip?: () => void;
-  onFocusExit?: () => void;
   onFocusPinnedChange?: () => void;
   // Opens the archive confirmation dialog for the current session.
   // Owned by the parent because it shares its `archiveConfirmOpen`
@@ -180,21 +185,24 @@ interface SessionViewProps {
   // other views (sidebar, focus queue) that cache the title separately.
   onTitleChange?: () => void;
   // Fires right after the user sends a message (or answers an agent
-  // prompt) in controller mode, with the id of the session the message
-  // was sent from. The parent can use this to advance to the next
-  // focus item. See issue #81 follow-up: "respond and advance to the
-  // next conversation".
+  // prompt), with the id of the session the message was sent from.
+  // The parent can use this to advance to the next focus item. See
+  // issue #81 follow-up: "respond and advance to the next
+  // conversation".
   onFocusAdvanceAfterSend?: (sessionId: string) => void;
   /**
-   * When non-null, a controller-mode advance has been scheduled after
+   * When non-null, a focus-advance countdown has been scheduled after
    * a send. While this is set, SessionView preserves the in-flight
    * user-message bubble in the originating session (we skip the
    * session-change cleanup that would otherwise wipe it) so the user
-   * always has time to see the message they just sent. Typing in the
-   * originating composer cancels the pending advance.
+   * always has time to see the message they just sent. The conversation
+   * controls render the countdown and Stay action; typing in the
+   * originating composer also cancels it.
    */
   focusAdvanceCountdown?: {
     sentFromSessionId: string;
+    scheduledAt: number;
+    durationMs: number;
     onCancel: () => void;
   } | null;
 }
@@ -294,7 +302,6 @@ const IS_TOUCH_DEVICE =
   typeof window !== "undefined" &&
   typeof window.matchMedia === "function" &&
   window.matchMedia("(pointer: coarse)").matches;
-
 function supportsAttachments(provider: string): boolean {
   return provider === "anita" || provider === "codex" || provider === "claude";
 }
@@ -2898,12 +2905,11 @@ export function SessionView({
   onSessionCreated,
   onBackgroundComplete,
   onOpenConversation,
-  controllerMode = false,
   shortcutBindings = null,
-  focusPosition,
+  autoAdvance = true,
+  onToggleAutoAdvance,
   onFocusDone,
   onFocusSkip,
-  onFocusExit,
   onFocusPinnedChange,
   onTitleChange,
   onFocusAdvanceAfterSend,
@@ -2924,6 +2930,18 @@ export function SessionView({
     []
   );
   const [message, setMessage] = useState(initialComposerDraft.text);
+  const [composerHasFocus, setComposerHasFocus] = useState(false);
+  const [isMobileComposerViewport, setIsMobileComposerViewport] = useState(
+    () =>
+      typeof window !== "undefined" &&
+      typeof window.matchMedia === "function" &&
+      window.matchMedia(MOBILE_COMPOSER_MEDIA_QUERY).matches,
+  );
+  const composerLayout = getComposerLayout(
+    isMobileComposerViewport,
+    composerHasFocus,
+    COMPOSER_MAX_LINES,
+  );
   const [pendingMessage, setPendingMessage] = useState<string | null>(null);
   const [pendingAttachments, setPendingAttachments] = useState<SessionAttachment[]>([]);
   const [composerAttachments, setComposerAttachments] = useState<ComposerAttachment[]>([]);
@@ -3104,6 +3122,7 @@ export function SessionView({
   const terminalRefs = useRef<Record<string, TerminalHandle | null>>({});
   const terminalTabsSavePendingRef = useRef(false);
   const textareaRef = useRef<HTMLTextAreaElement>(null);
+  const composerRef = useRef<HTMLDivElement>(null);
   const hadVisibleFocusAdvanceRef = useRef(false);
   const fileInputRef = useRef<HTMLInputElement>(null);
   const modelPickerRef = useRef<HTMLDivElement>(null);
@@ -3376,6 +3395,34 @@ export function SessionView({
     streamingRef.current = streaming;
   }, [streaming]);
 
+  useEffect(() => {
+    const mediaQuery = window.matchMedia(MOBILE_COMPOSER_MEDIA_QUERY);
+    const syncViewport = () => setIsMobileComposerViewport(mediaQuery.matches);
+    syncViewport();
+    mediaQuery.addEventListener("change", syncViewport);
+    return () => mediaQuery.removeEventListener("change", syncViewport);
+  }, []);
+
+  // Mobile taps do not reliably populate a blur event's `relatedTarget`.
+  // Collapsing from onBlur could therefore unmount an agent/model picker
+  // between pointer-down and click. Treat the entire composer as one
+  // interaction surface and collapse only on an explicit tap outside it.
+  useEffect(() => {
+    if (!isMobileComposerViewport || !composerHasFocus) return;
+    const handlePointerDown = (event: PointerEvent) => {
+      const target = event.target;
+      if (target instanceof Node && composerRef.current?.contains(target)) return;
+      setComposerHasFocus(false);
+      setSkillPopoverOpen(false);
+      setMentionPopoverOpen(false);
+      setShowProviderPicker(false);
+      setShowReasoningEffortPicker(false);
+      setShowModelPicker(false);
+    };
+    document.addEventListener("pointerdown", handlePointerDown, true);
+    return () => document.removeEventListener("pointerdown", handlePointerDown, true);
+  }, [composerHasFocus, isMobileComposerViewport]);
+
   useEffect(() => {
     debugSessionIsolation("view.mounted", { projectId, worktreeId, sessionId });
     return () => {
@@ -3383,18 +3430,20 @@ export function SessionView({
     };
   }, [projectId, worktreeId, sessionId]);
 
-  // While controller mode is active, drop the user straight into the composer
-  // whenever the active session changes (entering controller mode, skipping to
-  // the next pinned session, or marking the current one done). This keeps
-  // the controller-mode triage loop keyboard-driven: the user can `Esc` out
-  // of the input to fire a shortcut and is placed back at the keyboard the
-  // moment the new session is ready.
+  // Drop desktop users straight into the composer whenever the active
+  // session changes. Mobile intentionally starts with the compact one-line
+  // composer and waits for a tap before expanding it and opening the keyboard.
   useEffect(() => {
-    if (!controllerMode || !sessionId) return;
+    if (!sessionId) return;
     const textarea = textareaRef.current;
     if (!textarea || textarea.disabled) return;
+    if (!composerLayout.autoFocusOnSessionChange) {
+      textarea.blur();
+      setComposerHasFocus(false);
+      return;
+    }
     textarea.focus();
-  }, [sessionId, controllerMode]);
+  }, [composerLayout.autoFocusOnSessionChange, sessionId]);
 
   useEffect(() => {
     const isOriginatingCountdown =
@@ -3412,7 +3461,7 @@ export function SessionView({
 
     if (
       hadVisibleFocusAdvanceRef.current &&
-      controllerMode &&
+      !isMobileComposerViewport &&
       sessionId &&
       textarea &&
       !textarea.disabled
@@ -3420,7 +3469,7 @@ export function SessionView({
       textarea.focus();
     }
     hadVisibleFocusAdvanceRef.current = false;
-  }, [focusAdvanceCountdown, controllerMode, sessionId]);
+  }, [focusAdvanceCountdown, isMobileComposerViewport, sessionId]);
 
   useEffect(() => {
     const isOriginatingCountdown =
@@ -3428,13 +3477,13 @@ export function SessionView({
       focusAdvanceCountdown?.sentFromSessionId === sessionId;
     if (!isOriginatingCountdown || !focusAdvanceCountdown) return;
 
-    // Mirror the central `useControllerModeShortcuts` "stay" chord so the
+    // Mirror the central `useFocusShortcuts` "stay" chord so the
     // user can cancel a pending advance with their (possibly rebound)
     // Cmd/Ctrl+S even when focus is inside this session's composer. The
     // central hook also fires this path, but stopping propagation here
     // keeps the textarea free of literal `s` characters in case the
     // event reaches us first. See issue #235.
-    const stayChord = parseChord(shortcutBindings?.controllerModeStay ?? "ctrl-s");
+    const stayChord = parseChord(shortcutBindings?.focusStay ?? "ctrl-s");
 
     const handleStayShortcut = (event: KeyboardEvent) => {
       if (event.repeat) return;
@@ -3464,14 +3513,14 @@ export function SessionView({
     const paddingHeight =
       Number.parseFloat(computedStyle.paddingTop) +
       Number.parseFloat(computedStyle.paddingBottom);
-    const maxHeight =
-      lineHeight * COMPOSER_MAX_LINES + paddingHeight + borderHeight;
+    const maxLines = composerLayout.maxLines;
+    const maxHeight = lineHeight * maxLines + paddingHeight + borderHeight;
     const nextHeight = Math.min(textarea.scrollHeight, maxHeight);
 
     textarea.style.height = `${nextHeight}px`;
     textarea.style.overflowY =
-      textarea.scrollHeight > maxHeight ? "auto" : "hidden";
-  }, [message]);
+      maxLines > 1 && textarea.scrollHeight > maxHeight ? "auto" : "hidden";
+  }, [composerLayout.maxLines, message]);
 
   // Mirror the composer draft (text + skill chips) to localStorage on change.
   // Skip while a steer is in flight: the composer is disabled and `message` is
@@ -4535,15 +4584,15 @@ export function SessionView({
       return false;
     }
 
-    // In controller mode, signal the parent to advance to the next focus
-    // item as soon as the user commits to a message. The parent owns
-    // the navigation logic and the "stay put if the only pinned item
-    // is the one we just sent to" rule (issue #81 follow-up).
-    // Continuations (queued replay / emulated steer) never advance focus.
-    // For an existing session we can advance immediately; for a send from
+    // Signal the parent to advance to the next focus item as soon as
+    // the user commits to a message. The parent owns the navigation
+    // logic and the "stay put if the only pinned item is the one we
+    // just sent to" rule (issue #81 follow-up). Continuations
+    // (queued replay / emulated steer) never advance focus. For an
+    // existing session we can advance immediately; for a send from
     // the new-thread composer (no `sessionId` yet) we defer until the
     // stream attaches and the new session id is known (issue #120).
-    if (controllerMode && onFocusAdvanceAfterSend && !runOverrides) {
+    if (onFocusAdvanceAfterSend && !runOverrides) {
       if (sessionId) {
         onFocusAdvanceAfterSend(sessionId);
       } else {
@@ -5543,11 +5592,11 @@ export function SessionView({
         .then(setEvents)
         .catch(() => {});
       // Submitting the structured-input form is the "I'm done with this
-      // session for now" moment in Controller Mode, same as sending a
-      // message: schedule the focus-advance countdown. Dismiss
+      // session for now" moment, same as sending a message: schedule
+      // the focus-advance countdown. Dismiss
       // (handleStructuredUserInputDismiss) is the explicit stay signal
       // and is intentionally not wired to advance (issue #277).
-      if (controllerMode && onFocusAdvanceAfterSend) {
+      if (onFocusAdvanceAfterSend) {
         if (targetSessionId) {
           onFocusAdvanceAfterSend(targetSessionId);
         } else {
@@ -5646,11 +5695,11 @@ export function SessionView({
         .then(setEvents)
         .catch(() => {});
       // Resolving an approval card is the same "I'm done with this session
-      // for now" moment in Controller Mode as sending a message: schedule
-      // the focus-advance countdown so the user doesn't have to hit
-      // Next manually. Deny is the explicit "I want to stay and
-      // reconsider" signal, so it doesn't advance (issue #277).
-      if (controllerMode && onFocusAdvanceAfterSend && decision !== "deny") {
+      // for now" moment as sending a message: schedule the focus-advance
+      // countdown so the user doesn't have to hit Next manually. Deny
+      // is the explicit "I want to stay and reconsider" signal, so it
+      // doesn't advance (issue #277).
+      if (onFocusAdvanceAfterSend && decision !== "deny") {
         if (targetSessionId) {
           onFocusAdvanceAfterSend(targetSessionId);
         } else {
@@ -5718,6 +5767,81 @@ export function SessionView({
     events,
     pendingMessage
   );
+  const showComposerDetails = composerLayout.showDetails;
+  const composerPlaceholder = steerInProgress
+    ? "Steering…"
+    : streaming
+      ? IS_TOUCH_DEVICE
+        ? "Send to queue"
+        : `Enter to queue · ${STEER_KEY_LABEL} to steer`
+      : availableSkills.length > 0
+        ? "Describe what you want to build… type / for a skill, @ to mention a file"
+        : sessionId
+          ? "Ask for follow-up changes — type @ to mention a file"
+          : "Describe what you want to build… type @ to mention a file";
+  const renderComposerActions = (expanded: boolean) => (
+    <div
+      className={`flex shrink-0 items-center justify-end gap-2 ${
+        expanded ? "self-end sm:self-auto" : ""
+      }`}
+    >
+      {!streaming && canAttachMore && (
+        <button
+          type="button"
+          onClick={() => fileInputRef.current?.click()}
+          title={
+            !providerSupportsAttachments
+              ? `${selectedProvider} does not support attachments`
+              : !modelSupportsAttachments
+                ? "Selected model does not support attachments"
+                : "Attach files"
+          }
+          className="flex h-8 w-8 items-center justify-center rounded-full border border-border text-muted-foreground transition-colors hover:bg-accent hover:text-foreground"
+        >
+          <Paperclip className="h-3.5 w-3.5" />
+        </button>
+      )}
+      {streaming && (
+        <button
+          type="button"
+          onClick={handleStop}
+          title="Stop"
+          className="flex h-8 w-8 items-center justify-center rounded-full border border-border text-muted-foreground hover:bg-accent hover:text-foreground transition-colors"
+        >
+          <Square className="h-3.5 w-3.5" />
+        </button>
+      )}
+      <Button
+        type="submit"
+        size="icon"
+        title={
+          streaming &&
+          !message.trim() &&
+          composerAttachments.length === 0 &&
+          queue.length > 0
+            ? "Send queued message (interrupt)"
+            : streaming
+              ? "Queue for next run"
+              : "Send"
+        }
+        disabled={
+          steerInProgress ||
+          (!message.trim() &&
+            composerAttachments.length === 0 &&
+            !(streaming && queue.length > 0)) ||
+          !providerReady ||
+          (streaming && !(activeStreamSessionId ?? sessionId))
+        }
+        className="h-8 w-8 rounded-full"
+      >
+        {streaming ? (
+          <Plus className="h-4 w-4" />
+        ) : (
+          <ArrowUp className="h-4 w-4" />
+        )}
+      </Button>
+    </div>
+  );
   const waitingForStructuredInput = Boolean(latestStructuredInputRequest);
   // Live approvals render inline as stream items; this covers the reload case
   // where only persisted events exist and an approval is still pending.
@@ -5757,54 +5881,26 @@ export function SessionView({
       toast.error(err instanceof Error ? err.message : "Failed to update focus queue");
     }
   };
+  const conversationFocusCountdown = getConversationCountdown(
+    focusAdvanceCountdown,
+    sessionId,
+  );
 
   return (
     <>
-      {controllerMode && (
-        <div className="flex shrink-0 flex-wrap items-center justify-between gap-2 border-b border-blue-500/20 bg-blue-500/15 px-3 py-2 text-blue-200 md:px-4">
-          <div className="min-w-0 text-xs text-blue-200/80">
-            <span className="font-medium text-blue-200">Controller Mode</span>
-            <span className="ml-2">
-              {focusPosition && focusPosition.total > 0
-                ? `${focusPosition.current || 1} / ${focusPosition.total}`
-                : "No sessions on radar"}
-            </span>
-          </div>
-          <div className="flex items-center gap-1.5">
-            <button
-              type="button"
-              onClick={onFocusSkip}
-              className="flex items-center gap-1.5 rounded-md px-2.5 py-1.5 text-xs font-medium text-blue-200/80 transition-colors hover:bg-blue-500/20 hover:text-blue-100 disabled:pointer-events-none disabled:opacity-50"
-              title={`Next (${formatChord(shortcutBindings?.controllerModeNext ?? "ctrl-n", IS_MAC)})`}
-            >
-              <StepForward className="h-3.5 w-3.5" />
-              Next
-              <Kbd>{formatChord(shortcutBindings?.controllerModeNext ?? "ctrl-n", IS_MAC)}</Kbd>
-            </button>
-            <button
-              type="button"
-              onClick={onFocusDone}
-              disabled={!sessionId}
-              className="flex items-center gap-1.5 rounded-md px-2.5 py-1.5 text-xs font-medium text-blue-200/80 transition-colors hover:bg-blue-500/20 hover:text-blue-100 disabled:pointer-events-none disabled:opacity-50"
-              title={`Mark done (${formatChord(shortcutBindings?.controllerModeDone ?? "ctrl-d", IS_MAC)})`}
-            >
-              <CheckCircle2 className="h-3.5 w-3.5" />
-              Done
-              <Kbd>{formatChord(shortcutBindings?.controllerModeDone ?? "ctrl-d", IS_MAC)}</Kbd>
-            </button>
-            <button
-              type="button"
-              onClick={onFocusExit}
-              className="flex items-center gap-1.5 rounded-md px-2.5 py-1.5 text-xs font-medium text-blue-200/80 transition-colors hover:bg-blue-500/20 hover:text-blue-100"
-              title={`Exit Controller Mode (${formatChord(shortcutBindings?.controllerModeToggle ?? "ctrl-t", IS_MAC)})`}
-            >
-              <LogOut className="h-3.5 w-3.5" />
-              Exit
-              <Kbd>{formatChord(shortcutBindings?.controllerModeToggle ?? "ctrl-t", IS_MAC)}</Kbd>
-            </button>
-          </div>
-        </div>
-      )}
+      {sessionId && onFocusSkip && onFocusDone && onToggleAutoAdvance ? (
+        <FocusConversationControls
+          variant="mobile"
+          bindings={shortcutBindings}
+          isOnRadar={isFocusPinned}
+          autoAdvance={autoAdvance}
+          onNext={onFocusSkip}
+          onDone={onFocusDone}
+          onAddToRadar={handleHeaderFocusPin}
+          onToggleAutoAdvance={onToggleAutoAdvance}
+          countdown={conversationFocusCountdown}
+        />
+      ) : null}
 
       {/* Header */}
       <header className={`${sessionId ? "flex" : "hidden md:flex"} h-12 md:h-14 shrink-0 items-center justify-end md:justify-between border-b border-border bg-background px-3 md:px-4`}>
@@ -5917,20 +6013,6 @@ export function SessionView({
             );
           })()}
           <div className="ml-3 flex items-center gap-1">
-            {sessionId && (
-              <button
-                type="button"
-                onClick={handleHeaderFocusPin}
-                className={`rounded-md p-1.5 transition-colors ${
-                  isFocusPinned
-                    ? "bg-blue-500/15 text-blue-300 hover:bg-blue-500/25 hover:text-blue-200"
-                    : "text-muted-foreground hover:bg-accent hover:text-foreground"
-                }`}
-                title={isFocusPinned ? "Remove from Radar" : "Add to Radar"}
-              >
-                <Radar className="h-4 w-4" />
-              </button>
-            )}
             {sessionId && onArchive && (
               <button
                 type="button"
@@ -6014,9 +6096,23 @@ export function SessionView({
       {/* Main content area: chat + terminal side by side on desktop, tabbed on mobile */}
       <div className="flex flex-1 min-h-0">
         {/* Chat panel — hidden on mobile when terminal or changes tab is active */}
-        <div className={`flex-col min-h-0 min-w-0 w-full ${
+        <div className={`relative flex-col min-h-0 min-w-0 w-full ${
           sessionId && mobilePanel !== "agent" ? "hidden md:flex" : "flex"
         } flex-1`}>
+          {sessionId && onFocusSkip && onFocusDone && onToggleAutoAdvance ? (
+            <FocusConversationControls
+              variant="desktop"
+              bindings={shortcutBindings}
+              isOnRadar={isFocusPinned}
+              autoAdvance={autoAdvance}
+              onNext={onFocusSkip}
+              onDone={onFocusDone}
+              onAddToRadar={handleHeaderFocusPin}
+              onToggleAutoAdvance={onToggleAutoAdvance}
+              countdown={conversationFocusCountdown}
+            />
+          ) : null}
+
           {/* Messages / Events area */}
           <div
             ref={scrollContainerRef}
@@ -6401,7 +6497,35 @@ export function SessionView({
                 }}
               >
                 <div
-                  className="rounded-xl border border-border bg-input p-3"
+                  ref={composerRef}
+                  data-testid="session-composer"
+                  data-mobile-collapsed={
+                    isMobileComposerViewport && !composerHasFocus ? "true" : undefined
+                  }
+                  className={`rounded-xl border border-border bg-input transition-[padding] md:p-3 ${
+                    showComposerDetails ? "p-3" : "p-2.5"
+                  }`}
+                  onBlurCapture={(event) => {
+                    // Mobile focus transitions around touch controls are not
+                    // stable enough to drive visibility: a tapped button can
+                    // blur again after its click and unmount its own picker.
+                    // The document-level outside-pointer handler above owns
+                    // mobile collapse instead.
+                    if (isMobileComposerViewport) return;
+                    if (
+                      event.currentTarget.contains(
+                        event.relatedTarget as Node | null,
+                      )
+                    ) {
+                      return;
+                    }
+                    setComposerHasFocus(false);
+                    setSkillPopoverOpen(false);
+                    setMentionPopoverOpen(false);
+                    setShowProviderPicker(false);
+                    setShowReasoningEffortPicker(false);
+                    setShowModelPicker(false);
+                  }}
                   onDragOver={(event) => {
                     if (!canAttachMore) return;
                     event.preventDefault();
@@ -6434,12 +6558,15 @@ export function SessionView({
                     className="hidden"
                     accept={attachmentAcceptMimeTypes.join(",")}
                     onChange={(event) => {
-                      if (event.target.files) addComposerFiles(event.target.files);
+                      if (event.target.files?.length) {
+                        if (isMobileComposerViewport) setComposerHasFocus(true);
+                        addComposerFiles(event.target.files);
+                      }
                       event.currentTarget.value = "";
                     }}
                   />
-                  {activeSkills.length > 0 && !skillPopoverOpen && (
-                    <div className="mb-2 flex flex-wrap items-center gap-1.5">
+                  {showComposerDetails && activeSkills.length > 0 && !skillPopoverOpen && (
+                    <div key="composer-skills" className="mb-2 flex flex-wrap items-center gap-1.5">
                       {activeSkills.map((skill, index) => (
                         <span
                           key={skill.name}
@@ -6470,8 +6597,8 @@ export function SessionView({
                       )}
                     </div>
                   )}
-                  {activeMentions.length > 0 && !mentionPopoverOpen && (
-                    <div className="mb-2 flex flex-wrap items-center gap-1.5">
+                  {showComposerDetails && activeMentions.length > 0 && !mentionPopoverOpen && (
+                    <div key="composer-mentions" className="mb-2 flex flex-wrap items-center gap-1.5">
                       {activeMentions.map((mention, index) => (
                         <span
                           key={`${mention.path}-${index}`}
@@ -6506,10 +6633,11 @@ export function SessionView({
                       )}
                     </div>
                   )}
-                  <div className="relative">
+                  <div key="composer-input" className="relative flex min-w-0 items-center gap-2">
                     <textarea
                       ref={textareaRef}
                       value={message}
+                      onFocus={() => setComposerHasFocus(true)}
                       onChange={(e) => {
                         setMessage(e.target.value);
                         setCaretPos(e.target.selectionStart ?? e.target.value.length);
@@ -6535,25 +6663,14 @@ export function SessionView({
                       onSelect={(e) =>
                         setCaretPos(e.currentTarget.selectionStart ?? 0)
                       }
-                      placeholder={
-                        steerInProgress
-                          ? "Steering…"
-                          : streaming
-                          ? IS_TOUCH_DEVICE
-                            ? "Send to queue"
-                            : `Enter to queue · ${STEER_KEY_LABEL} to steer`
-                          : availableSkills.length > 0
-                          ? "Describe what you want to build… type / for a skill, @ to mention a file"
-                          : sessionId
-                          ? "Ask for follow-up changes — type @ to mention a file"
-                          : "Describe what you want to build… type @ to mention a file"
-                      }
+                      placeholder={composerPlaceholder}
                       rows={1}
                       disabled={steerInProgress}
-                      className="w-full resize-none overflow-y-auto bg-transparent text-sm text-foreground placeholder:text-muted-foreground focus:outline-none disabled:opacity-50"
+                      className="min-w-0 flex-1 resize-none overflow-y-auto bg-transparent text-sm text-foreground placeholder:text-muted-foreground focus:outline-none disabled:opacity-50"
                       style={{ maxHeight: "calc(1.25rem * 5)" }}
                     />
-                    {skillPopoverOpen && filteredSkills.length > 0 && (
+                    {composerLayout.showCompactActions && renderComposerActions(false)}
+                    {showComposerDetails && skillPopoverOpen && filteredSkills.length > 0 && (
                       <div
                         role="listbox"
                         aria-label="Skills"
@@ -6622,7 +6739,7 @@ export function SessionView({
                         </div>
                       </div>
                     )}
-                    {mentionPopoverOpen && (
+                    {showComposerDetails && mentionPopoverOpen && (
                       <div
                         role="listbox"
                         aria-label="Files"
@@ -6711,7 +6828,7 @@ export function SessionView({
                       </div>
                     )}
                   </div>
-                  {composerAttachments.length > 0 && (
+                  {showComposerDetails && composerAttachments.length > 0 && (
                     <div className="mt-2 flex flex-wrap gap-2">
                       {composerAttachments.map((attachment) => {
                         const fileName = getFileDisplayName(attachment.file);
@@ -6748,12 +6865,12 @@ export function SessionView({
                       })}
                     </div>
                   )}
-                  {attachmentError && (
+                  {showComposerDetails && attachmentError && (
                     <div className="mt-2 rounded-md border border-destructive/30 bg-destructive/10 px-3 py-2 text-xs text-destructive">
                       {attachmentError}
                     </div>
                   )}
-                  {providerStatusMessage && (
+                  {showComposerDetails && providerStatusMessage && (
                     <div className="mt-2 flex items-center justify-between gap-3 rounded-md border border-destructive/30 bg-destructive/10 px-3 py-2 text-xs text-destructive">
                       <span className="min-w-0">{providerStatusMessage}</span>
                       <button
@@ -6766,6 +6883,7 @@ export function SessionView({
                       </button>
                     </div>
                   )}
+                  {showComposerDetails && (
                   <div className="mt-2 flex items-center gap-2 sm:justify-between">
                     <div className="flex min-w-0 flex-1 flex-wrap items-center gap-1.5 sm:gap-2">
                       {/* Agent provider + run-option pickers. */}
@@ -7000,64 +7118,9 @@ export function SessionView({
                           </div>
                     </>)}
                     </div>
-                    <div className="flex shrink-0 items-center justify-end gap-2 self-end sm:self-auto">
-                      {!streaming && canAttachMore && (
-                        <button
-                          type="button"
-                          onClick={() => fileInputRef.current?.click()}
-                          title={
-                            !providerSupportsAttachments
-                              ? `${selectedProvider} does not support attachments`
-                              : !modelSupportsAttachments
-                              ? "Selected model does not support attachments"
-                              : "Attach files"
-                          }
-                          className="flex h-8 w-8 items-center justify-center rounded-full border border-border text-muted-foreground transition-colors hover:bg-accent hover:text-foreground"
-                        >
-                          <Paperclip className="h-3.5 w-3.5" />
-                        </button>
-                      )}
-                      {streaming && (
-                        <button
-                          type="button"
-                          onClick={handleStop}
-                          title="Stop"
-                          className="flex h-8 w-8 items-center justify-center rounded-full border border-border text-muted-foreground hover:bg-accent hover:text-foreground transition-colors"
-                        >
-                          <Square className="h-3.5 w-3.5" />
-                        </button>
-                      )}
-                      <Button
-                        type="submit"
-                        size="icon"
-                        title={
-                          streaming &&
-                          !message.trim() &&
-                          composerAttachments.length === 0 &&
-                          queue.length > 0
-                            ? "Send queued message (interrupt)"
-                            : streaming
-                              ? "Queue for next run"
-                              : "Send"
-                        }
-                        disabled={
-                          steerInProgress ||
-                          (!message.trim() &&
-                            composerAttachments.length === 0 &&
-                            !(streaming && queue.length > 0)) ||
-                          !providerReady ||
-                          (streaming && !(activeStreamSessionId ?? sessionId))
-                        }
-                        className="h-8 w-8 rounded-full"
-                      >
-                        {streaming ? (
-                          <Plus className="h-4 w-4" />
-                        ) : (
-                          <ArrowUp className="h-4 w-4" />
-                        )}
-                      </Button>
-                    </div>
+                    {renderComposerActions(true)}
                   </div>
+                  )}
                 </div>
               </form>
             </div>
diff --git a/client/src/pages/Settings.tsx b/client/src/pages/Settings.tsx
index f58f7a9f..18e9bc45 100644
--- a/client/src/pages/Settings.tsx
+++ b/client/src/pages/Settings.tsx
@@ -43,7 +43,7 @@ const SECTIONS: SectionSpec[] = [
     id: "shortcuts",
     label: "Shortcuts",
     shortLabel: "Shortcuts",
-    description: "Customise Controller Mode keyboard shortcuts.",
+    description: "Customise focus-queue keyboard shortcuts.",
   },
   {
     id: "schedules",
diff --git a/docs/content/docs/controller-mode.mdx b/docs/content/docs/controller-mode.mdx
index ba73eb1d..7a01a5ae 100644
--- a/docs/content/docs/controller-mode.mdx
+++ b/docs/content/docs/controller-mode.mdx
@@ -1,43 +1,41 @@
 ---
-title: Controller Mode
-description: The always-on overlay for steering long agent runs with keyboard shortcuts.
+title: Focus navigation
+description: Triage sessions with On radar, Next, Done, and optional auto-advance.
 ---
 
-**Controller Mode** is an always-on overlay designed for long agent runs.
-Instead of watching a single chat scroll by, it keeps the controls you need to
-steer the agent within reach while it works.
+**Focus navigation** helps you triage several agent sessions without losing
+your place. Add important conversations to **On radar**, then use the controls
+beside the conversation to move through the queue.
 
 ## When to use it
 
-- **Use Controller Mode** for long, multi-step runs where you want to advance,
-  stay, or redirect the agent without hunting through the UI — keyboard-first
-  steering over an extended session.
-- **Use plain chat mode** for quick, conversational back-and-forth where you're
-  reading and replying to each response as it lands.
+- Put long-running or attention-heavy sessions **On radar**.
+- Use **Next** to mark the current session handled and open the queue's new
+  first item.
+- Use **Done** when a session no longer belongs on radar.
+- Turn on **Auto-advance** to start a short countdown after you reply or resolve
+  an input request. Choose **Stay** to cancel it.
+
+The focus panel remains available for conversations that are not on radar, so
+you can jump to the next queued session or add the current conversation.
 
 ## Keyboard shortcuts
 
-Controller Mode is modifier-based and **user-customizable**. Shortcuts are
-chords built on a modifier (**Ctrl** on Linux, **⌘** on macOS) plus a key, so
-they don't collide with the agent's own typing. You can remap them to keys that
-suit your keyboard.
+Desktop focus actions have **user-customizable** keyboard shortcuts. The panel
+shows the current bindings for **Next**, **Stay**, **Done**, and
+**Auto-advance**. Mobile keeps the controls compact and does not show shortcut
+chips.
 
-## The stay / continue chord
+## Auto-advance
 
-When the agent reaches a point where it's about to advance focus, Controller
-shows a **focus-advance toast**. The toast displays the live **stay /
-continue** chord so you can decide in the moment:
+When auto-advance is enabled and a countdown starts, the same focus panel shows
+the remaining time and the controls you need:
 
 - **Stay** — hold focus where it is.
-- **Continue** — let the agent advance.
-
-The chord shown on the toast is the live, current binding, so it always matches
-whatever you've configured — no need to remember the mapping.
+- **Next** — advance immediately.
 
 The countdown is scheduled whenever you're "done with the current session for
-now" in Controller Mode: after sending a message, after clicking **Allow** on a
-tool-approval card (and **Deny** does *not* advance — it's the explicit
-"stay and reconsider" signal), and after submitting answers to a structured
-user-input prompt. If you resolve a prompt while a countdown is already in
-flight, the clock restarts on the new origin session rather than stacking a
-second toast.
+now": after sending a message, clicking **Allow** on a tool-approval card, or
+submitting structured input. **Deny** keeps you on the current session. If
+another qualifying action happens during a countdown, the timer restarts
+instead of creating a second countdown.
diff --git a/docs/content/docs/first-project.mdx b/docs/content/docs/first-project.mdx
index 4f538298..4ab04a3d 100644
--- a/docs/content/docs/first-project.mdx
+++ b/docs/content/docs/first-project.mdx
@@ -63,7 +63,7 @@ tour](/docs/sidebar) for the full layout.
 
 ## Next steps
 
-- Keep an eye on a long agent run with [Controller Mode](/docs/controller-mode).
+- Triage long agent runs with [Focus navigation](/docs/controller-mode).
 - Give each session an isolated dev server and ports with
   [Controller scripts](/docs/controller-scripts) and
   [worktrees](/docs/worktrees).
diff --git a/docs/content/docs/sidebar.mdx b/docs/content/docs/sidebar.mdx
index 34b87ae6..bbb58a8a 100644
--- a/docs/content/docs/sidebar.mdx
+++ b/docs/content/docs/sidebar.mdx
@@ -5,13 +5,14 @@ description: Find your way around Controller — radar, projects, worktrees, ses
 
 The sidebar is the main way you navigate Controller. From top to bottom:
 
-## Radar and Controller Mode
+## On radar
 
-The top of the sidebar is your **radar** — the sessions you're actively keeping
+The top of the sidebar is **On radar** — the sessions you're actively keeping
 an eye on, each showing its provider icon and a spinner while the agent is
-working. Alongside it sits the **Controller Mode** toggle, which turns on the
-always-on overlay for steering long runs. See [Controller
-Mode](/docs/controller-mode).
+working. Sessions that need your input rise to the top, followed by completed
+sessions you have not handled yet and then running sessions. Opening a
+conversation does not reorder this list; **Next** marks the current session as
+handled and opens the new first item. See [Focus navigation](/docs/controller-mode).
 
 ## Projects
 
diff --git a/server/index.ts b/server/index.ts
index ffb2a53a..ca4d7422 100644
--- a/server/index.ts
+++ b/server/index.ts
@@ -14,6 +14,7 @@ import { agentsRouter } from "./routes/agents.js";
 import { skillsRouter } from "./routes/skills.js";
 import { getAvailableAgentProviders } from "./lib/agents.js";
 import { listSessionRuntimes } from "./lib/session-runtime.js";
+import { listPersistedAttentionSessionIds } from "./lib/session-attention.js";
 import { getProject } from "./lib/projects.js";
 import { resolveWorktree } from "./lib/worktrees.js";
 import { ptyManager } from "./lib/pty-manager.js";
@@ -90,9 +91,11 @@ app.get("/api/agent-providers", async (_req, res) => {
 
 // Bulk session runtime snapshot — replaces the per-session /runtime polling
 // the sidebar and SessionView were doing. One request returns the active
-// state for every session currently known to the runtime map.
-app.get("/api/runtimes", (_req, res) => {
-  res.json({ sessions: listSessionRuntimes() });
+// state for every session currently known to the runtime map, plus unresolved
+// prompts reconstructed from persisted events after a server restart.
+app.get("/api/runtimes", async (_req, res) => {
+  const persistedAttention = await listPersistedAttentionSessionIds();
+  res.json({ sessions: listSessionRuntimes(persistedAttention) });
 });
 
 const shouldServeClient =
diff --git a/server/lib/__tests__/session-attention-routes.test.ts b/server/lib/__tests__/session-attention-routes.test.ts
new file mode 100644
index 00000000..f3204aa8
--- /dev/null
+++ b/server/lib/__tests__/session-attention-routes.test.ts
@@ -0,0 +1,81 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import express from "express";
+import http from "node:http";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+test("dismissing user input clears the runtime attention flag", async () => {
+  const homeDir = await fs.mkdtemp(path.join(os.tmpdir(), "session-attention-"));
+  const previousHome = process.env.CONTROLLER_HOME;
+  process.env.CONTROLLER_HOME = homeDir;
+  const projectId = "project-attention-dismiss";
+  const sessionId = "session-attention-dismiss";
+  const projectPath = path.join(homeDir, "source");
+  await fs.mkdir(projectPath, { recursive: true });
+  await fs.writeFile(
+    path.join(homeDir, "projects.json"),
+    JSON.stringify([
+      {
+        id: projectId,
+        name: "demo",
+        path: projectPath,
+        createdAt: new Date().toISOString(),
+      },
+    ]),
+  );
+
+  const { getProjectWorktrees } = await import("../worktrees.js");
+  const [worktree] = await getProjectWorktrees(projectId);
+  assert.ok(worktree);
+
+  const { saveSession } = await import("../sessions.js");
+  await saveSession(projectPath, {
+    id: sessionId,
+    workingDirectory: projectPath,
+    worktreeId: worktree.id,
+    model: "test-model",
+    provider: "claude",
+    messages: [],
+    createdAt: new Date().toISOString(),
+    lastActiveAt: new Date().toISOString(),
+    status: "active",
+  });
+
+  const {
+    listSessionRuntimes,
+    markSessionActive,
+    markSessionInactive,
+    setSessionAwaitingUserInput,
+  } = await import("../session-runtime.js");
+  markSessionActive(sessionId, { provider: "claude" });
+  setSessionAwaitingUserInput(sessionId, true);
+  markSessionInactive(sessionId);
+
+  const { sessionsRouter } = await import("../../routes/sessions.js");
+  const app = express();
+  app.use(express.json());
+  app.use("/api/projects", sessionsRouter);
+  const server = http.createServer(app);
+  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+
+  try {
+    const address = server.address();
+    assert.ok(address && typeof address !== "string");
+    const response = await fetch(
+      `http://127.0.0.1:${address.port}/api/projects/${projectId}/sessions/${sessionId}/user-input/dismiss?worktreeId=${worktree.id}`,
+      { method: "POST" },
+    );
+    assert.equal(response.status, 200);
+    const runtime = listSessionRuntimes().find(
+      (entry) => entry.sessionId === sessionId,
+    );
+    assert.equal(runtime?.awaitingInput, undefined);
+  } finally {
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+    if (previousHome === undefined) delete process.env.CONTROLLER_HOME;
+    else process.env.CONTROLLER_HOME = previousHome;
+    await fs.rm(homeDir, { recursive: true, force: true });
+  }
+});
diff --git a/server/lib/__tests__/session-attention.test.ts b/server/lib/__tests__/session-attention.test.ts
new file mode 100644
index 00000000..44f136dc
--- /dev/null
+++ b/server/lib/__tests__/session-attention.test.ts
@@ -0,0 +1,69 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import {
+  hasPendingSessionAttention,
+  listPersistedAttentionSessionIds,
+} from "../session-attention.js";
+import type { AgentEvent } from "../sessions.js";
+
+function event(type: string, data: Record<string, unknown> = {}): AgentEvent {
+  return {
+    id: `${type}-id`,
+    sessionId: "session-1",
+    timestamp: new Date().toISOString(),
+    type,
+    data,
+  };
+}
+
+test("reconstructs unresolved user input from persisted events", () => {
+  assert.equal(
+    hasPendingSessionAttention([event("user_input_requested")]),
+    true,
+  );
+  assert.equal(
+    hasPendingSessionAttention([
+      event("user_input_requested"),
+      event("user_input_response"),
+    ]),
+    false,
+  );
+});
+
+test("reconstructs unresolved approvals and clears them on terminal events", () => {
+  assert.equal(
+    hasPendingSessionAttention([event("tool_approval_requested")]),
+    true,
+  );
+  assert.equal(
+    hasPendingSessionAttention([
+      event("tool_approval_requested"),
+      event("run.completed"),
+    ]),
+    false,
+  );
+});
+
+test("discovers unresolved attention from event logs after a cold start", async () => {
+  const homeDir = await fs.mkdtemp(path.join(os.tmpdir(), "persisted-attention-"));
+  const previousHome = process.env.CONTROLLER_HOME;
+  process.env.CONTROLLER_HOME = homeDir;
+  const eventsDir = path.join(homeDir, "projects", "demo-store", "events");
+  await fs.mkdir(eventsDir, { recursive: true });
+  await fs.writeFile(
+    path.join(eventsDir, "waiting-session.jsonl"),
+    `${JSON.stringify(event("user_input_requested"))}\n`,
+  );
+
+  try {
+    const pending = await listPersistedAttentionSessionIds();
+    assert.deepEqual([...pending], ["waiting-session"]);
+  } finally {
+    if (previousHome === undefined) delete process.env.CONTROLLER_HOME;
+    else process.env.CONTROLLER_HOME = previousHome;
+    await fs.rm(homeDir, { recursive: true, force: true });
+  }
+});
diff --git a/server/lib/__tests__/session-runtime.test.ts b/server/lib/__tests__/session-runtime.test.ts
new file mode 100644
index 00000000..718a8410
--- /dev/null
+++ b/server/lib/__tests__/session-runtime.test.ts
@@ -0,0 +1,48 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  consumePendingApproval,
+  listSessionRuntimes,
+  markSessionActive,
+  markSessionInactive,
+  recordSessionAttentionEvent,
+  setSessionAwaitingUserInput,
+} from "../session-runtime.js";
+
+function runtimeSummary(sessionId: string) {
+  return listSessionRuntimes().find((entry) => entry.sessionId === sessionId);
+}
+
+test("user-input attention survives inactivity and clears after response", () => {
+  const sessionId = "runtime-user-input";
+  markSessionActive(sessionId, { provider: "codex" });
+  recordSessionAttentionEvent(sessionId, {
+    type: "user.input_requested",
+    id: "input-1",
+    questions: [],
+  });
+
+  assert.equal(runtimeSummary(sessionId)?.awaitingInput, true);
+  markSessionInactive(sessionId);
+  assert.equal(runtimeSummary(sessionId)?.awaitingInput, true);
+
+  setSessionAwaitingUserInput(sessionId, false);
+  assert.equal(runtimeSummary(sessionId)?.awaitingInput, undefined);
+});
+
+test("approval attention clears when the response consumes the request", () => {
+  const sessionId = "runtime-approval";
+  markSessionActive(sessionId, { provider: "codex" });
+  recordSessionAttentionEvent(sessionId, {
+    type: "tool.approval_requested",
+    id: "approval-1",
+    toolUseId: "tool-1",
+    toolName: "Shell",
+    input: { command: "pwd" },
+    suggestions: [],
+  });
+
+  assert.equal(runtimeSummary(sessionId)?.awaitingInput, true);
+  assert.ok(consumePendingApproval(sessionId, "approval-1"));
+  assert.equal(runtimeSummary(sessionId)?.awaitingInput, undefined);
+});
diff --git a/server/lib/__tests__/shortcut-settings.test.ts b/server/lib/__tests__/shortcut-settings.test.ts
index 4ede958c..868b4924 100644
--- a/server/lib/__tests__/shortcut-settings.test.ts
+++ b/server/lib/__tests__/shortcut-settings.test.ts
@@ -1,6 +1,7 @@
 /*
  * Tests for the persisted shortcut overrides in
- * `server/lib/shortcut-settings.ts` (issue #235).
+ * `server/lib/shortcut-settings.ts` (issue #235 + the
+ * Controller-Mode-removal migration in #333 follow-up).
  *
  * Strategy: point `CONTROLLER_HOME` at a temp directory so the JSON
  * file lives somewhere we can wipe between cases without touching
@@ -9,7 +10,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
@@ -18,6 +19,7 @@ import {
   DEFAULT_SHORTCUT_BINDINGS,
   getShortcutBindings,
   setShortcutBindings,
+  shortcutBindingsFile,
   type ShortcutBindings,
 } from "../shortcut-settings.js";
 
@@ -42,14 +44,14 @@ test("returns bundled defaults when no overrides exist", async () => {
 test("setShortcutBindings persists a subset of overrides", async () => {
   await withTempHome(async () => {
     const next = await setShortcutBindings({
-      controllerModeToggle: "cmd-shift-t",
+      focusStay: "cmd-shift-s",
     });
-    assert.equal(next.controllerModeToggle, "cmd-shift-t");
-    assert.equal(next.controllerModeNext, DEFAULT_SHORTCUT_BINDINGS.controllerModeNext);
+    assert.equal(next.focusStay, "cmd-shift-s");
+    assert.equal(next.focusAdvanceNext, DEFAULT_SHORTCUT_BINDINGS.focusAdvanceNext);
 
     // Re-read to confirm disk persistence.
     const reread = await getShortcutBindings();
-    assert.equal(reread.controllerModeToggle, "cmd-shift-t");
+    assert.equal(reread.focusStay, "cmd-shift-s");
   });
 });
 
@@ -60,21 +62,21 @@ test("setShortcutBindings ignores unknown action ids", async () => {
     await setShortcutBindings({
       // @ts-expect-error — intentionally bad id
       nope: "cmd-x",
-      controllerModeDone: "cmd-shift-d",
+      focusDone: "cmd-shift-d",
     });
     const bindings = await getShortcutBindings();
     assert.equal("nope" in bindings, false);
-    assert.equal(bindings.controllerModeDone, "cmd-shift-d");
+    assert.equal(bindings.focusDone, "cmd-shift-d");
   });
 });
 
 test("setShortcutBindings normalises case and whitespace", async () => {
   await withTempHome(async () => {
     await setShortcutBindings({
-      controllerModeStay: "  CMD+Shift+S  ",
+      focusStay: "  CMD+Shift+S  ",
     });
     const bindings = await getShortcutBindings();
-    assert.equal(bindings.controllerModeStay, "cmd-shift-s");
+    assert.equal(bindings.focusStay, "cmd-shift-s");
   });
 });
 
@@ -82,19 +84,19 @@ test("setShortcutBindings drops non-string values", async () => {
   await withTempHome(async () => {
     await setShortcutBindings({
       // @ts-expect-error — intentionally bad value
-      controllerModeNext: 42,
+      focusAdvanceNext: 42,
       // @ts-expect-error — empty string should also be dropped
-      controllerModeDone: "",
+      focusDone: "",
     });
     const bindings = await getShortcutBindings();
-    assert.equal(bindings.controllerModeNext, DEFAULT_SHORTCUT_BINDINGS.controllerModeNext);
-    assert.equal(bindings.controllerModeDone, DEFAULT_SHORTCUT_BINDINGS.controllerModeDone);
+    assert.equal(bindings.focusAdvanceNext, DEFAULT_SHORTCUT_BINDINGS.focusAdvanceNext);
+    assert.equal(bindings.focusDone, DEFAULT_SHORTCUT_BINDINGS.focusDone);
   });
 });
 
 test("clearShortcutBindings wipes all overrides and returns defaults", async () => {
   await withTempHome(async () => {
-    await setShortcutBindings({ controllerModeNext: "cmd-shift-n" });
+    await setShortcutBindings({ focusAdvanceNext: "cmd-shift-n" });
     const cleared = await clearShortcutBindings();
     assert.deepEqual(cleared, DEFAULT_SHORTCUT_BINDINGS);
 
@@ -106,16 +108,136 @@ test("clearShortcutBindings wipes all overrides and returns defaults", async ()
 test("getShortcutBindings merges overrides over defaults in canonical order", async () => {
   await withTempHome(async () => {
     await setShortcutBindings({
-      controllerModeToggle: "cmd-shift-t",
-      controllerModeStay: "cmd-shift-s",
+      focusStay: "cmd-shift-s",
+      focusDone: "cmd-shift-d",
     });
     const bindings: ShortcutBindings = await getShortcutBindings();
     // Every action id must be present, even ones the user didn't override.
     for (const id of Object.keys(DEFAULT_SHORTCUT_BINDINGS)) {
       assert.ok(id in bindings, `${id} should be in merged bindings`);
     }
-    assert.equal(bindings.controllerModeToggle, "cmd-shift-t");
-    assert.equal(bindings.controllerModeStay, "cmd-shift-s");
-    assert.equal(bindings.controllerModeNext, DEFAULT_SHORTCUT_BINDINGS.controllerModeNext);
+    assert.equal(bindings.focusStay, "cmd-shift-s");
+    assert.equal(bindings.focusDone, "cmd-shift-d");
+    assert.equal(bindings.focusAdvanceNext, DEFAULT_SHORTCUT_BINDINGS.focusAdvanceNext);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Controller-Mode → focus-queue migration (issue #333 follow-up).
+//
+// When the user upgrades across the rename, their persisted overrides
+// file may still contain `controllerMode*` keys. The server should
+// translate them to the new ids in-memory AND rewrite the file so
+// future reads see the cleaned shape.
+// ---------------------------------------------------------------------------
+
+function writeLegacyOverrides(home: string, overrides: Record<string, string>) {
+  // Mirror the on-disk shape — flat JSON object of action-id -> chord.
+  mkdirSync(home, { recursive: true });
+  writeFileSync(
+    shortcutBindingsFile(),
+    JSON.stringify(overrides, null, 2),
+  );
+}
+
+test("legacy controllerMode* ids are translated to the new ids on read", async () => {
+  await withTempHome(async (home) => {
+    writeLegacyOverrides(home, {
+      controllerModeNext: "cmd-shift-n",
+      controllerModeStay: "cmd-shift-s",
+      controllerModeDone: "cmd-shift-d",
+    });
+
+    const bindings = await getShortcutBindings();
+    // Each legacy chord lands on its renamed equivalent.
+    assert.equal(bindings.focusAdvanceNext, "cmd-shift-n");
+    assert.equal(bindings.focusStay, "cmd-shift-s");
+    assert.equal(bindings.focusDone, "cmd-shift-d");
+    // The legacy keys themselves don't leak through.
+    assert.equal("controllerModeNext" in bindings, false);
+    assert.equal("controllerModeStay" in bindings, false);
+    assert.equal("controllerModeDone" in bindings, false);
+  });
+});
+
+test("legacy migration rewrites the on-disk file in the new shape", async () => {
+  await withTempHome(async (home) => {
+    writeLegacyOverrides(home, {
+      controllerModeNext: "cmd-shift-n",
+      controllerModeStay: "cmd-shift-s",
+    });
+
+    // Trigger the migration by reading.
+    await getShortcutBindings();
+
+    // The file should now have only the new keys.
+    const onDisk = JSON.parse(readFileSync(shortcutBindingsFile(), "utf-8"));
+    assert.deepEqual(Object.keys(onDisk).sort(), [
+      "focusAdvanceNext",
+      "focusStay",
+    ]);
+    assert.equal(onDisk.focusAdvanceNext, "cmd-shift-n");
+    assert.equal(onDisk.focusStay, "cmd-shift-s");
+    // controllerModeDone was not overridden, so it must not appear
+    // (the file only stores overrides, not defaults).
+    assert.equal("controllerModeDone" in onDisk, false);
+  });
+});
+
+test("controllerModeToggle (no longer a real action) is dropped on migration", async () => {
+  await withTempHome(async (home) => {
+    writeLegacyOverrides(home, {
+      controllerModeToggle: "cmd-shift-t",
+    });
+
+    const bindings = await getShortcutBindings();
+    // Nothing gets remapped to a real action.
+    assert.deepEqual(bindings, DEFAULT_SHORTCUT_BINDINGS);
+
+    // The file is rewritten without the orphaned key.
+    const onDisk = JSON.parse(readFileSync(shortcutBindingsFile(), "utf-8"));
+    assert.equal("controllerModeToggle" in onDisk, false);
+  });
+});
+
+test("a new-id override beats a legacy alias for the same action", async () => {
+  // The user saved a chord under the new id and later (or earlier)
+  // an old version of the file has a legacy id with a different chord.
+  // We must not clobber the new-id value with the older one — the
+  // user's most recent choice wins.
+  await withTempHome(async (home) => {
+    writeLegacyOverrides(home, {
+      focusStay: "ctrl-shift-s",
+      controllerModeStay: "cmd-shift-s",
+    });
+
+    const bindings = await getShortcutBindings();
+    // The current focusStay override wins; the legacy alias is
+    // migrated but discarded because the slot was already filled.
+    assert.equal(bindings.focusStay, "ctrl-shift-s");
+
+    // After the migration rewrites the file, only the new key
+    // survives.
+    const onDisk = JSON.parse(readFileSync(shortcutBindingsFile(), "utf-8"));
+    assert.deepEqual(Object.keys(onDisk).sort(), ["focusStay"]);
+    assert.equal(onDisk.focusStay, "ctrl-shift-s");
+  });
+});
+
+test("unknown ids in the legacy file are dropped, not migrated", async () => {
+  // Defensive: a future-removal or a typo in the file shouldn't crash
+  // the reader. Unknown ids (not in the alias map) are dropped.
+  await withTempHome(async (home) => {
+    writeLegacyOverrides(home, {
+      controllerModeNext: "cmd-shift-n",
+      someRandomKey: "ctrl-x",
+      filesPanelToggle: "cmd-alt-b",
+    });
+
+    const bindings = await getShortcutBindings();
+    assert.equal(bindings.focusAdvanceNext, "cmd-shift-n");
+    assert.equal(bindings.filesPanelToggle, "cmd-alt-b");
+    // someRandomKey isn't a current or legacy id, so it's dropped.
+    assert.equal("someRandomKey" in bindings, false);
   });
 });
\ No newline at end of file
diff --git a/server/lib/paths.ts b/server/lib/paths.ts
index 359949d3..b0fa7fb5 100644
--- a/server/lib/paths.ts
+++ b/server/lib/paths.ts
@@ -222,7 +222,7 @@ export function sessionQueueFile(sessionId: string): string {
 // --- Shortcut Bindings ---
 
 /**
- * Persisted keyboard shortcut overrides for Controller Mode. Lives in the
+ * Persisted keyboard shortcut overrides for the focus-queue. Lives in the
  * Controller home so it survives across browsers on the same machine
  * (issue #235). The defaults are baked into the client; this file only
  * stores user overrides keyed by action id.
diff --git a/server/lib/session-attention.ts b/server/lib/session-attention.ts
new file mode 100644
index 00000000..9e9403df
--- /dev/null
+++ b/server/lib/session-attention.ts
@@ -0,0 +1,107 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { orchestratorHome } from "./paths.js";
+import type { AgentEvent } from "./sessions.js";
+
+const APPROVAL_SETTLED_TYPES = new Set([
+  "tool_approval_response",
+  "run.completed",
+  "run.failed",
+  "run.cancelled",
+  "run_cancelled",
+]);
+
+/** Rebuild whether a persisted transcript still contains an unresolved prompt. */
+export function hasPendingSessionAttention(events: AgentEvent[]): boolean {
+  let pendingUserInput = false;
+  let pendingApproval = false;
+
+  for (const event of events) {
+    if (event.type === "user_input_requested") pendingUserInput = true;
+    else if (event.type === "user_input_response") pendingUserInput = false;
+
+    if (event.type === "tool_approval_requested") pendingApproval = true;
+    else if (APPROVAL_SETTLED_TYPES.has(event.type)) pendingApproval = false;
+  }
+
+  return pendingUserInput || pendingApproval;
+}
+
+interface CachedAttention {
+  mtimeMs: number;
+  size: number;
+  pending: boolean;
+  sessionId: string;
+}
+
+const cache = new Map<string, CachedAttention>();
+
+/**
+ * Discover unresolved prompts from Controller's persisted JSONL event logs.
+ * File mtimes keep the polling path cheap: transcripts are reparsed only when
+ * they change, while a cold server still reconstructs attention after restart.
+ */
+export async function listPersistedAttentionSessionIds(): Promise<Set<string>> {
+  const storesRoot = path.join(orchestratorHome(), "projects");
+  let stores: string[];
+  try {
+    stores = await fs.readdir(storesRoot);
+  } catch {
+    return new Set();
+  }
+
+  const seen = new Set<string>();
+  await Promise.all(
+    stores.map(async (store) => {
+      const eventsDir = path.join(storesRoot, store, "events");
+      let files: string[];
+      try {
+        files = await fs.readdir(eventsDir);
+      } catch {
+        return;
+      }
+
+      await Promise.all(
+        files.filter((file) => file.endsWith(".jsonl")).map(async (file) => {
+          const filePath = path.join(eventsDir, file);
+          seen.add(filePath);
+          try {
+            const stat = await fs.stat(filePath);
+            const cached = cache.get(filePath);
+            if (cached?.mtimeMs === stat.mtimeMs && cached.size === stat.size) return;
+            const content = await fs.readFile(filePath, "utf8");
+            const events = content
+              .trim()
+              .split("\n")
+              .filter(Boolean)
+              .flatMap((line) => {
+                try {
+                  return [JSON.parse(line) as AgentEvent];
+                } catch {
+                  return [];
+                }
+              });
+            cache.set(filePath, {
+              mtimeMs: stat.mtimeMs,
+              size: stat.size,
+              pending: hasPendingSessionAttention(events),
+              sessionId: path.basename(file, ".jsonl"),
+            });
+          } catch {
+            cache.delete(filePath);
+          }
+        }),
+      );
+    }),
+  );
+
+  for (const filePath of cache.keys()) {
+    if (!seen.has(filePath)) cache.delete(filePath);
+  }
+
+  return new Set(
+    [...cache.values()]
+      .filter((entry) => entry.pending)
+      .map((entry) => entry.sessionId),
+  );
+}
diff --git a/server/lib/session-runtime.ts b/server/lib/session-runtime.ts
index 79a2a709..d3c62ad2 100644
--- a/server/lib/session-runtime.ts
+++ b/server/lib/session-runtime.ts
@@ -1,5 +1,5 @@
 import type { ChildProcess } from "node:child_process";
-import type { ClaudeApprovalRequest } from "./agents.js";
+import type { AgentStreamEvent, ClaudeApprovalRequest } from "./agents.js";
 
 export interface SessionRuntimeMetadata {
   projectId: string;
@@ -17,6 +17,16 @@ export interface SessionRuntimeState {
    * immediately without racing the async persistence of the request event.
    */
   pendingApprovals?: Map<string, ClaudeApprovalRequest>;
+  /**
+   * True when the agent has paused on a `user.input_requested` event
+   * and is waiting for the user to answer. Some providers end the
+   * process at that point, so the session can be inactive while it
+   * still needs the user's attention.
+   *
+   * Cleared whenever a new stream starts (`markSessionActive`) so a
+   * resumed run doesn't carry the flag forward.
+   */
+  awaitingUserInput?: boolean;
 }
 
 const runtimes = new Map<string, SessionRuntimeState>();
@@ -25,7 +35,13 @@ export function markSessionActive(
   sessionId: string,
   runtime: Omit<SessionRuntimeState, "active"> = {}
 ) {
-  runtimes.set(sessionId, { active: true, ...runtime });
+  runtimes.set(sessionId, {
+    active: true,
+    ...runtime,
+    // A new stream is a fresh run; the previous turn's "waiting on the
+    // user" pause can't carry over.
+    awaitingUserInput: undefined,
+  });
 }
 
 export function markSessionInactive(sessionId: string) {
@@ -33,6 +49,9 @@ export function markSessionInactive(sessionId: string) {
   if (runtime) {
     // The process is gone, so any approvals it was blocked on can no longer be
     // answered — drop them so a stale decision can't target a dead child.
+    // `awaitingUserInput` is preserved: the user still owes the answer
+    // even though the child is dead (e.g. Claude's structured-input
+    // pause kills the child but the prompt is still on screen).
     runtimes.set(sessionId, {
       ...runtime,
       active: false,
@@ -61,6 +80,38 @@ export function recordPendingApproval(
   runtime.pendingApprovals.set(request.requestId, request);
 }
 
+export function recordSessionAttentionEvent(
+  sessionId: string,
+  event: AgentStreamEvent
+) {
+  if (event.type === "user.input_requested") {
+    setSessionAwaitingUserInput(sessionId, true);
+    return;
+  }
+  if (event.type === "tool.approval_requested") {
+    recordPendingApproval(sessionId, {
+      requestId: event.id,
+      toolName: event.toolName,
+      input: event.input,
+      suggestions: event.suggestions,
+    });
+  }
+}
+
+/**
+ * Mark the session as paused on a user-input request. The flag survives
+ * an inactive transition for providers that end the process at the
+ * request boundary.
+ */
+export function setSessionAwaitingUserInput(
+  sessionId: string,
+  awaiting: boolean
+) {
+  const runtime = runtimes.get(sessionId);
+  if (!runtime) return;
+  runtime.awaitingUserInput = awaiting;
+}
+
 /** Remove and return a pending approval once the user has decided. */
 export function consumePendingApproval(
   sessionId: string,
@@ -80,6 +131,13 @@ export interface SessionRuntimeSummary {
   provider?: string;
   projectId?: string;
   worktreeId?: string;
+  /**
+   * True when the agent is paused on a user-input request OR has at
+   * least one pending tool approval.
+   * The focus-queue sidebar uses this as the highest-priority
+   * "needs your attention" signal regardless of `active` state.
+   */
+  awaitingInput?: boolean;
 }
 
 /**
@@ -87,17 +145,28 @@ export interface SessionRuntimeSummary {
  * single request. Sessions without metadata (e.g. populated by an older
  * server build) are returned without `projectId`/`worktreeId`.
  */
-export function listSessionRuntimes(): SessionRuntimeSummary[] {
+export function listSessionRuntimes(
+  persistedAwaitingInput: ReadonlySet<string> = new Set(),
+): SessionRuntimeSummary[] {
   const summaries: SessionRuntimeSummary[] = [];
   for (const [sessionId, state] of runtimes) {
+    const awaitingInput =
+      state.awaitingUserInput === true ||
+      (state.pendingApprovals?.size ?? 0) > 0 ||
+      persistedAwaitingInput.has(sessionId);
     summaries.push({
       sessionId,
       active: state.active,
+      awaitingInput: awaitingInput || undefined,
       provider: state.provider,
       projectId: state.metadata?.projectId,
       worktreeId: state.metadata?.worktreeId,
     });
   }
+  for (const sessionId of persistedAwaitingInput) {
+    if (runtimes.has(sessionId)) continue;
+    summaries.push({ sessionId, active: false, awaitingInput: true });
+  }
   return summaries;
 }
 
diff --git a/server/lib/shortcut-settings.ts b/server/lib/shortcut-settings.ts
index a7e5969d..f7e51fb4 100644
--- a/server/lib/shortcut-settings.ts
+++ b/server/lib/shortcut-settings.ts
@@ -8,35 +8,35 @@ import { shortcutBindingsFile, ensureOrchestratorHome } from "./paths.js";
 // want the build layout to drift.
 
 type ShortcutActionId =
-  | "controllerModeToggle"
-  | "controllerModeNext"
-  | "controllerModeDone"
-  | "controllerModeStay"
+  | "focusAdvanceNext"
+  | "focusStay"
+  | "focusDone"
+  | "focusAutoAdvance"
   | "filesPanelToggle"
   | "filesPanelSearch";
 
 type ShortcutBindings = Record<ShortcutActionId, string>;
 
 const ACTION_IDS: ReadonlySet<ShortcutActionId> = new Set([
-  "controllerModeToggle",
-  "controllerModeNext",
-  "controllerModeDone",
-  "controllerModeStay",
+  "focusAdvanceNext",
+  "focusStay",
+  "focusDone",
+  "focusAutoAdvance",
   "filesPanelToggle",
   "filesPanelSearch",
 ]);
 
 const DEFAULT_BINDINGS: Readonly<Record<ShortcutActionId, string>> = {
-  controllerModeToggle: "ctrl-t",
-  controllerModeNext: "ctrl-n",
-  controllerModeDone: "ctrl-d",
-  controllerModeStay: "ctrl-s",
+  focusAdvanceNext: "ctrl-n",
+  focusStay: "ctrl-s",
+  focusDone: "ctrl-d",
+  focusAutoAdvance: "ctrl-t",
   filesPanelToggle: "cmd-b",
   filesPanelSearch: "cmd-p",
 };
 
 /**
- * Persisted user overrides for Controller Mode keyboard shortcuts.
+ * Persisted user overrides for focus-queue keyboard shortcuts.
  *
  * The file lives in the Controller home directory (see `paths.ts` and
  * issue #235) so overrides survive across browsers on the same machine
@@ -50,11 +50,38 @@ const DEFAULT_BINDINGS: Readonly<Record<ShortcutActionId, string>> = {
 
 type StoredOverrides = Partial<Record<ShortcutActionId, string>>;
 
+/**
+ * One-shot migration: action ids renamed when Controller Mode was
+ * dropped in favour of the always-on focus-queue triage loop (issue
+ * #333 follow-up). The user-facing chord the user picked is
+ * preserved — we only translate the key. `controllerModeToggle` is
+ * not mapped because the action was removed entirely; any saved
+ * override for it is silently dropped.
+ */
+const LEGACY_ACTION_ALIASES: Record<string, ShortcutActionId> = {
+  controllerModeNext: "focusAdvanceNext",
+  controllerModeStay: "focusStay",
+  controllerModeDone: "focusDone",
+};
+
 async function readStore(): Promise<StoredOverrides> {
   try {
     const content = await fs.readFile(shortcutBindingsFile(), "utf-8");
     const parsed = JSON.parse(content) as unknown;
-    return normalizeStore(parsed);
+    const [store, migrated] = normalizeStore(parsed);
+    if (migrated) {
+      // Self-heal: rewrite the file in the new shape so a future
+      // upgrade doesn't have to re-apply the migration. Best-effort —
+      // if the disk write fails (e.g. read-only home), the in-memory
+      // translation still holds for the rest of this process.
+      try {
+        await writeStore(store);
+      } catch {
+        // Ignore — the translated overrides are still in effect for
+        // this request. The file will be retried on the next read.
+      }
+    }
+    return store;
   } catch {
     return {};
   }
@@ -72,17 +99,49 @@ function normalizeChord(value: string): string {
     .join("-");
 }
 
-function normalizeStore(parsed: unknown): StoredOverrides {
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+/**
+ * Returns the cleaned overrides map and a flag indicating whether any
+ * legacy `controllerMode*` keys were translated. When the flag is set
+ * the caller should write the cleaned map back to disk so the file
+ * doesn't carry orphaned ids forever.
+ *
+ * Translation rules:
+ *   - Known current ids pass through unchanged.
+ *   - Legacy ids are mapped to their new equivalents **only when** the
+ *     user hasn't already set the new id — otherwise the existing
+ *     new-id value wins (no clobbering).
+ *   - Anything else is dropped.
+ */
+function normalizeStore(
+  parsed: unknown,
+): [StoredOverrides, boolean] {
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return [{}, false];
+  }
   const store: StoredOverrides = {};
-  for (const [id, value] of Object.entries(parsed as Record<string, unknown>)) {
-    if (!ACTION_IDS.has(id as ShortcutActionId)) continue;
+  let migrated = false;
+  for (const [rawId, value] of Object.entries(parsed as Record<string, unknown>)) {
     if (typeof value !== "string") continue;
     const normalized = normalizeChord(value);
     if (!normalized) continue;
-    store[id as ShortcutActionId] = normalized;
+    if (ACTION_IDS.has(rawId as ShortcutActionId)) {
+      store[rawId as ShortcutActionId] = normalized;
+      continue;
+    }
+    const aliased = LEGACY_ACTION_ALIASES[rawId];
+    if (aliased) {
+      // Don't clobber an existing new-id override with an older one
+      // — the user's most recent choice wins.
+      if (store[aliased] === undefined) {
+        store[aliased] = normalized;
+      }
+    }
+    // Any unknown / legacy id (mapped or removed) is a signal that
+    // the file is stale. Mark for rewrite so future reads start from
+    // the cleaned shape. The cleaned shape won't include this id.
+    migrated = true;
   }
-  return store;
+  return [store, migrated];
 }
 
 async function writeStore(store: StoredOverrides): Promise<void> {
@@ -93,6 +152,11 @@ async function writeStore(store: StoredOverrides): Promise<void> {
 /** Bundled defaults — re-exported for tests so they don't depend on shared/. */
 export const DEFAULT_SHORTCUT_BINDINGS = DEFAULT_BINDINGS;
 
+// Re-exported so tests can write directly to the on-disk file when
+// simulating a legacy or corrupted overrides shape (e.g. the
+// Controller-Mode → focus-queue migration in #333 follow-up).
+export { shortcutBindingsFile };
+
 export type { ShortcutActionId, ShortcutBindings };
 
 /**
diff --git a/server/routes/sessions.ts b/server/routes/sessions.ts
index 4b312fd4..69f799aa 100644
--- a/server/routes/sessions.ts
+++ b/server/routes/sessions.ts
@@ -63,7 +63,8 @@ import {
   getSessionRuntime,
   markSessionActive,
   markSessionInactive,
-  recordPendingApproval,
+  recordSessionAttentionEvent,
+  setSessionAwaitingUserInput,
   stopSessionRuntime,
 } from "../lib/session-runtime.js";
 import {
@@ -1399,15 +1400,8 @@ export async function handleSessionStream(
                   runTerminated = true;
                   runCancelled = event.type === "run.cancelled";
                 }
-                // Stash the pending approval in memory before the client sees
-                // it, so a decision can be answered without racing disk I/O.
-                if (event.type === "tool.approval_requested" && streamSessionId) {
-                  recordPendingApproval(streamSessionId, {
-                    requestId: event.id,
-                    toolName: event.toolName,
-                    input: event.input,
-                    suggestions: event.suggestions,
-                  });
+                if (streamSessionId) {
+                  recordSessionAttentionEvent(streamSessionId, event);
                 }
                 sseSend({ type: "anita_event", event });
               })
@@ -1471,6 +1465,9 @@ export async function handleSessionStream(
                 runTerminated = true;
                 runCancelled = event.type === "run.cancelled";
               }
+              if (streamSessionId) {
+                recordSessionAttentionEvent(streamSessionId, event);
+              }
               sseSend({ type: "anita_event", event });
               if (providerId === "claude" && event.type === "user.input_requested") {
                 pausedForClaudeUserInput = true;
@@ -1953,6 +1950,10 @@ async function streamCodexPlanSession(
           await persistAgentEvent(event);
         }
 
+        if (streamSessionId) {
+          recordSessionAttentionEvent(streamSessionId, event);
+        }
+
         sseSend({ type: "anita_event", event });
 
         if (event.type === "run.completed" || event.type === "run.failed") {
@@ -2228,6 +2229,7 @@ sessionsRouter.post(
         type: "user_input_response",
         data: { dismissed: true },
       });
+      setSessionAwaitingUserInput(req.params.sessionId, false);
 
       const existing = await getSession(worktree.path, req.params.sessionId);
       if (existing) {
@@ -2280,6 +2282,7 @@ sessionsRouter.post(
           type: "user_input_response",
           data: { answers },
         });
+        setSessionAwaitingUserInput(req.params.sessionId, false);
 
         if (session) {
           session.lastActiveAt = new Date().toISOString();
@@ -2291,6 +2294,7 @@ sessionsRouter.post(
       }
 
       await codexAppServerManager.submitUserInput(req.params.sessionId, answers);
+      setSessionAwaitingUserInput(req.params.sessionId, false);
       await appendEvent(worktree.path, req.params.sessionId, {
         id: randomUUID(),
         sessionId: req.params.sessionId,
@@ -2976,6 +2980,7 @@ sessionsRouter.post(
           requestId,
           decision
         );
+        consumePendingApproval(req.params.sessionId, requestId);
       } catch (error) {
         res.status(404).json({
           error: error instanceof Error ? error.message : String(error),
@@ -3000,6 +3005,7 @@ sessionsRouter.post(
           .json({ error: "The session process is no longer accepting input." });
         return;
       }
+      consumePendingApproval(req.params.sessionId, requestId);
     } else {
       if (!runtime.child) {
         res
diff --git a/server/routes/shortcuts.ts b/server/routes/shortcuts.ts
index 66452056..7802c65f 100644
--- a/server/routes/shortcuts.ts
+++ b/server/routes/shortcuts.ts
@@ -10,7 +10,7 @@ import {
 import type { ShortcutActionId } from "../lib/shortcut-settings.js";
 
 /**
- * Controller Mode keyboard shortcut bindings.
+ * Focus-queue keyboard shortcut bindings.
  *
  * GET  /api/shortcuts       → effective bindings (defaults merged with overrides)
  * PUT  /api/shortcuts       → replace override map
diff --git a/shared/shortcuts.ts b/shared/shortcuts.ts
index ea29e3db..42ff45e6 100644
--- a/shared/shortcuts.ts
+++ b/shared/shortcuts.ts
@@ -21,10 +21,10 @@
  */
 
 export type ShortcutActionId =
-  | "controllerModeToggle"
-  | "controllerModeNext"
-  | "controllerModeDone"
-  | "controllerModeStay"
+  | "focusAdvanceNext"
+  | "focusStay"
+  | "focusDone"
+  | "focusAutoAdvance"
   | "filesPanelToggle"
   | "filesPanelSearch";
 
@@ -38,26 +38,27 @@ export interface ShortcutActionSpec {
 
 export const SHORTCUT_ACTIONS: ShortcutActionSpec[] = [
   {
-    id: "controllerModeToggle",
-    label: "Toggle Controller Mode",
-    description: "Enter or exit Controller Mode for the focus queue.",
-  },
-  {
-    id: "controllerModeNext",
+    id: "focusAdvanceNext",
     label: "Next session",
     description:
       "Advance to the next focus-queue session. While an advance countdown is pending, this commits the advance immediately instead of waiting.",
   },
   {
-    id: "controllerModeDone",
+    id: "focusStay",
+    label: "Stay on session",
+    description: "Cancel a pending focus-queue advance countdown.",
+  },
+  {
+    id: "focusDone",
     label: "Mark session done",
     description:
-      "Remove the active session from the focus queue. Works whether or not Controller Mode is active — no-op when no session is open.",
+      "Remove the active session from the focus queue. No-op when no session is open.",
   },
   {
-    id: "controllerModeStay",
-    label: "Stay on session",
-    description: "Cancel a pending focus-queue advance countdown.",
+    id: "focusAutoAdvance",
+    label: "Toggle auto-advance",
+    description:
+      "Toggle the post-reply auto-advance countdown on or off. When off, replies stay on the current session until you hit Next or Mark Done manually. Next always advances regardless of this setting.",
   },
   {
     id: "filesPanelToggle",
@@ -90,10 +91,10 @@ export const SHORTCUT_ACTIONS: ShortcutActionSpec[] = [
  * the same `cmd-b` chord fires on Ctrl+B.
  */
 export const DEFAULT_SHORTCUT_BINDINGS: Record<ShortcutActionId, string> = {
-  controllerModeToggle: "ctrl-t",
-  controllerModeNext: "ctrl-n",
-  controllerModeDone: "ctrl-d",
-  controllerModeStay: "ctrl-s",
+  focusAdvanceNext: "ctrl-n",
+  focusStay: "ctrl-s",
+  focusDone: "ctrl-d",
+  focusAutoAdvance: "ctrl-t",
   filesPanelToggle: "cmd-b",
   filesPanelSearch: "cmd-p",
 };