fix(sessions): follow a handoff into the new session

A successful /handoff created the runtime's fresh session and the
sidebar indexed it, but the app stayed on the old route and the builtin
claimed it had "moved you". Confirming the gate now marks the pending
handoff, and the first session_upserted for a different session in that
project navigates to it - unless the viewer deliberately moved to
another session meanwhile, or two minutes have passed. Resolves #6.

Author: devswha

src/components/chat/hooks/useChatComposerState.ts

@@ -2,6 +2,7 @@ import { useCallback, useEffect, useRef, useState } from 'react';
 import type { ChangeEvent, ClipboardEvent, Dispatch, FormEvent, KeyboardEvent, MouseEvent, MutableRefObject, RefObject, SetStateAction, TouchEvent } from 'react';
 import { useDropzone } from 'react-dropzone';
 
+import { useAppShellStore } from '../../../stores/useAppShellStore';
 import { usePaletteOps } from '../../../stores/usePaletteOpsStore';
 import type { MarkSessionProcessing } from '../../../hooks/useSessionProtection';
 import type { CodeEditorDiffInfo, ChatMessage, PendingPermissionRequest, PermissionDecision, SessionEstablishedContext  } from '../types/types';
@@ -149,7 +150,12 @@ export function useChatComposerState(args: UseChatComposerStateArgs) {
   const editQueuedDraft = useCallback((index: number) => setQueuedDrafts((q) => { const item = q[index]; if (!item) return q; setInput(item.content); inputRef.current = item.content; setAttachedImages(item.images); textareaRef.current?.focus(); return q.filter((_, position) => position !== index); }), []);
   const deleteQueuedDraft = useCallback((index: number) => setQueuedDrafts((q) => q.filter((_, position) => position !== index)), []);
   const moveQueuedDraft = useCallback((from: number, to: number) => setQueuedDrafts((q) => reorderQueue(q, from, to)), []);
-  const confirmCommandGate = useCallback(() => { const gate = gateRef.current; if (!gate) return; announceGate(null); bypassGate.current = true; setInput(gate.text); inputRef.current = gate.text; void handleSubmit(syntheticSubmit()); }, [announceGate, handleSubmit]);
+  const confirmCommandGate = useCallback(() => { const gate = gateRef.current; if (!gate) return; announceGate(null); bypassGate.current = true;
+    // A confirmed handoff moves the runtime to a fresh session; the next
+    // session_upserted for a new id in this project is it, and the app should
+    // follow instead of staying on the old session (issue #6).
+    if (/^\/handoff\b/.test(gate.text.trim())) useAppShellStore.getState().setPendingHandoff({ fromSessionId: conversation, projectId, at: Date.now() });
+    setInput(gate.text); inputRef.current = gate.text; void handleSubmit(syntheticSubmit()); }, [announceGate, conversation, handleSubmit, projectId]);
   const cancelCommandGate = useCallback(() => { announceGate(null); bypassGate.current = false; }, [announceGate]);
   const handleClearInput = useCallback(() => { clearComposer(); textareaRef.current?.focus(); }, [clearComposer]);
   // The Changes tab's line comments arrive here: one new paragraph with the

src/hooks/useProjectsState.query.dom.bun.test.tsx

@@ -7,7 +7,7 @@ import { createElement } from 'react';
 
 import type { ServerEvent } from '../contexts/WebSocketContext';
 import type { Project } from '../types/app';
-import { resetAppShellStore } from '../stores/useAppShellStore';
+import { resetAppShellStore, useAppShellStore } from '../stores/useAppShellStore';
 
 import { useProjectsState } from './useProjectsState';
 
@@ -24,6 +24,8 @@ const project = (sessions: Project['sessions'] = []): Project => ({
 
 type HookState = ReturnType<typeof useProjectsState>;
 
+const navigations: string[] = [];
+
 type Harness = {
   getState: () => HookState;
   emit: (event: ServerEvent) => void;
@@ -41,7 +43,7 @@ const renderHarness = (): Harness => {
   const HarnessComponent = () => {
     const hookState = useProjectsState({
       sessionId: null,
-      navigate: (() => undefined) as never,
+      navigate: ((path: string) => { navigations.push(path); }) as never,
       subscribe: (nextListener) => {
         listener = nextListener;
         return () => {
@@ -231,6 +233,35 @@ test('deleting a session removes its row and the row stays removed', async () =>
   }
 });
 
+test('a confirmed handoff follows the new session when it is indexed; other upserts do not navigate', async () => {
+  const sessions = [{ id: 'session-old', summary: 'Before the handoff', __provider: 'gjc' as const }];
+  const fetch = installFetch([{ body: [project(sessions)] }]);
+  try {
+    const harness = renderHarness();
+    await waitFor(() => assert.deepEqual(harness.getState().projects[0]?.sessions?.length, 1));
+
+    // An upsert for the old session while pending: not the handoff's.
+    useAppShellStore.getState().setPendingHandoff({ fromSessionId: 'session-old', projectId: 'project-1', at: Date.now() });
+    act(() => harness.emit({
+      kind: 'session_upserted', sessionId: 'session-old', provider: 'gjc',
+      session: { summary: 'Before the handoff', updatedAt: '2026-01-01T00:01:00Z' },
+      project: { projectId: 'project-1' },
+    } as never));
+    assert.deepEqual(navigations, []);
+
+    // The handoff's new session arrives: follow it, once.
+    act(() => harness.emit({
+      kind: 'session_upserted', sessionId: 'session-new', provider: 'gjc',
+      session: { summary: 'Untitled gjc Session', updatedAt: '2026-01-01T00:02:00Z' },
+      project: { projectId: 'project-1' },
+    } as never));
+    assert.deepEqual(navigations, ['/session/session-new']);
+    assert.equal(useAppShellStore.getState().pendingHandoff, null, 'the flag is consumed');
+  } finally {
+    fetch.restore();
+  }
+});
+
 test('optimistic sessions survive a shorter refetch page', async () => {
   const fetch = installFetch([{ body: [project()] }, { body: [project()] }]);
   try {

src/hooks/useProjectsState.ts

@@ -205,6 +205,19 @@ export function useProjectsState({ sessionId, navigate, subscribe, isMobile, act
         return next;
       });
       if (alias && sessionId === alias) navigate(`/session/${update.sessionId}`);
+      // A confirmed /handoff moved the runtime to a fresh session: the first
+      // upsert for a different session in that project is it — follow, or the
+      // app stays on the old session while the backend moved on (issue #6).
+      const pending = useAppShellStore.getState().pendingHandoff;
+      if (pending
+        && Date.now() - pending.at < 120_000
+        && update.sessionId !== pending.fromSessionId
+        && (!pending.projectId || update.project?.projectId === pending.projectId)
+        // unless the viewer deliberately moved on to a different session meanwhile.
+        && (!pending.fromSessionId || !sessionId || sessionId === pending.fromSessionId)) {
+        useAppShellStore.getState().setPendingHandoff(null);
+        navigate(`/session/${update.sessionId}`);
+      }
     };
     return subscribe(receive);
   }, [client, navigate, sessionId, setSelectedProject, setSelectedSession, subscribe]);

src/stores/useAppShellStore.ts

@@ -14,6 +14,8 @@ export type AppShellState = {
   loadingProgress: LoadingProgress | null;
   /** The add-project dialog; opened from the sidebar and from the empty main pane alike. */
   newProjectOpen: boolean;
+  /** Set when a /handoff gate is confirmed; the next session_upserted for a new session in that project navigates there. */
+  pendingHandoff: { fromSessionId: string | null; projectId: string | undefined; at: number } | null;
   setSelectedProject: (next: Updater<Project | null>) => void;
   setSelectedSession: (next: Updater<ProjectSession | null>) => void;
   setActiveTab: (next: Updater<AppTab>) => void;
@@ -22,6 +24,7 @@ export type AppShellState = {
   setShowSettings: (next: Updater<boolean>) => void;
   setLoadingProgress: (next: Updater<LoadingProgress | null>) => void;
   setNewProjectOpen: (next: Updater<boolean>) => void;
+  setPendingHandoff: (next: AppShellState['pendingHandoff']) => void;
 };
 
 // 'shell'/'git'/'files' were removed as tabs (Files is a side panel now);
@@ -83,6 +86,7 @@ const createInitialState = (): AppShellState => ({
   settingsInitialTab: 'agents',
   loadingProgress: null,
   newProjectOpen: false,
+  pendingHandoff: null,
   setSelectedProject: () => undefined,
   setSelectedSession: () => undefined,
   setActiveTab: () => undefined,
@@ -91,6 +95,7 @@ const createInitialState = (): AppShellState => ({
   setShowSettings: () => undefined,
   setLoadingProgress: () => undefined,
   setNewProjectOpen: () => undefined,
+  setPendingHandoff: () => undefined,
 });
 
 export const useAppShellStore = create<AppShellState>()((set) => ({
@@ -131,6 +136,7 @@ export const useAppShellStore = create<AppShellState>()((set) => ({
   setNewProjectOpen: (next) => set((state) => ({
     newProjectOpen: resolve(next, state.newProjectOpen),
   })),
+  setPendingHandoff: (next) => set({ pendingHandoff: next }),
 }));
 
 export const resetAppShellStore = () => {
@@ -144,5 +150,6 @@ export const resetAppShellStore = () => {
     setShowSettings: useAppShellStore.getState().setShowSettings,
     setLoadingProgress: useAppShellStore.getState().setLoadingProgress,
     setNewProjectOpen: useAppShellStore.getState().setNewProjectOpen,
+    setPendingHandoff: useAppShellStore.getState().setPendingHandoff,
   }, true);
 };