Preserve SessionsList filters across screen switches (#107)

## Summary
- move SessionsList filter text, filter mode, and scope mode into the
Zustand session store
- keep repo-aware scope initialization so switching screens does not
reset the current filter state
- add store tests covering the new filter and scope behavior

## Testing
- ./bun run check

---------

Co-authored-by: Ox Agent <ox@tigerdata.com>

Author: murrayju

src/components/SessionsList.tsx

@@ -24,7 +24,11 @@ import {
 import { useBackgroundTaskStore } from '../stores/backgroundTaskStore';
 import { useRepoStore } from '../stores/repoStore.ts';
 import { useRouterStore } from '../stores/routerStore.ts';
-import { useSessionStore } from '../stores/sessionStore';
+import {
+  type FilterMode,
+  type ScopeMode,
+  useSessionStore,
+} from '../stores/sessionStore';
 import { useSessionWorkflowStore } from '../stores/sessionWorkflowStore.ts';
 import { useTheme } from '../stores/themeStore';
 import { useToastStore } from '../stores/toastStore';
@@ -37,9 +41,6 @@ import { SessionDetailPanel } from './SessionDetailPanel.tsx';
 /** Cache TTL in milliseconds (60 seconds) */
 const PR_CACHE_TTL = 60_000;
 
-export type FilterMode = 'all' | 'running' | 'completed';
-export type ScopeMode = 'local' | 'global';
-
 const FILTER_LABELS: Record<FilterMode, string> = {
   all: 'All',
   running: 'Running',
@@ -69,6 +70,13 @@ export function SessionsList() {
     clearPrCache,
     addPendingDelete,
     removePendingDelete,
+    filterText,
+    setFilterText,
+    filterMode,
+    setFilterMode,
+    scopeMode,
+    setScopeMode,
+    syncScopeModeWithRepo,
   } = useSessionStore();
   const [sessions, setSessions] = useState<OxSession[]>([]);
   // Ref to hold the latest sessions list so callbacks/effects can read it
@@ -79,12 +87,6 @@ export function SessionsList() {
   // Null until the first load completes (avoids false notifications on startup).
   const prevSessionStatusesRef = useRef<Map<string, string> | null>(null);
   const [loading, setLoading] = useState(true);
-  const [filterText, setFilterText] = useState('');
-  const [filterMode, setFilterMode] = useState<FilterMode>('all');
-  // Default to 'local' if in a repo, otherwise 'global'
-  const [scopeMode, setScopeMode] = useState<ScopeMode>(
-    currentRepo ? 'local' : 'global',
-  );
   const [deleteModal, setDeleteModal] = useState<OxSession | null>(null);
   const [stopModal, setStopModal] = useState<OxSession | null>(null);
   const [actionInProgress, setActionInProgress] = useState(false);
@@ -115,6 +117,10 @@ export function SessionsList() {
   );
   const containerStats = useContainerStats(runningIds, getStats);
 
+  useEffect(() => {
+    syncScopeModeWithRepo(!!currentRepo);
+  }, [currentRepo, syncScopeModeWithRepo]);
+
   // Filter sessions: first by scope/mode, then fuzzy text search
   const filteredSessions = useMemo(() => {
     // Pre-filter by scope and mode (boolean filters)
@@ -233,14 +239,14 @@ export function SessionsList() {
     const nextIdx = (currentIdx + 1) % FILTER_ORDER.length;
     const nextMode = FILTER_ORDER[nextIdx];
     if (nextMode) setFilterMode(nextMode);
-  }, [filterMode]);
+  }, [filterMode, setFilterMode]);
 
   const toggleScope = useCallback(() => {
     const currentIdx = SCOPE_ORDER.indexOf(scopeMode);
     const nextIdx = (currentIdx + 1) % SCOPE_ORDER.length;
     const nextScope = SCOPE_ORDER[nextIdx];
     if (nextScope) setScopeMode(nextScope);
-  }, [scopeMode]);
+  }, [scopeMode, setScopeMode]);
 
   // Delete session handler
   const handleDelete = useCallback(() => {

src/stores/sessionStore.test.ts

@@ -1,6 +1,17 @@
 import { afterEach, describe, expect, test } from 'bun:test';
 import { useSessionStore } from './sessionStore';
 
+afterEach(() => {
+  useSessionStore.setState({
+    selectedSessionId: null,
+    filterText: '',
+    filterMode: 'all',
+    scopeMode: 'global',
+    prCache: {},
+    pendingDeletes: new Set(),
+  });
+});
+
 describe('sessionStore - pendingDeletes', () => {
   afterEach(() => {
     // Reset pendingDeletes
@@ -42,3 +53,43 @@ describe('sessionStore - pendingDeletes', () => {
     expect(useSessionStore.getState().isPendingDelete('c')).toBe(true);
   });
 });
+
+describe('sessionStore - filters', () => {
+  test('stores filter text', () => {
+    useSessionStore.getState().setFilterText('bugfix');
+    expect(useSessionStore.getState().filterText).toBe('bugfix');
+  });
+
+  test('composes consecutive filter text updates from the latest state', () => {
+    const { setFilterText } = useSessionStore.getState();
+
+    setFilterText((prev) => `${prev}a`);
+    setFilterText((prev) => `${prev}b`);
+
+    expect(useSessionStore.getState().filterText).toBe('ab');
+  });
+
+  test('stores filter mode', () => {
+    useSessionStore.getState().setFilterMode('running');
+    expect(useSessionStore.getState().filterMode).toBe('running');
+  });
+
+  test('syncScopeModeWithRepo defaults to local when entering a repo', () => {
+    useSessionStore.getState().syncScopeModeWithRepo(true);
+    expect(useSessionStore.getState().scopeMode).toBe('local');
+  });
+
+  test('syncScopeModeWithRepo resets to global when leaving a repo', () => {
+    const store = useSessionStore.getState();
+    store.setScopeMode('local');
+    store.syncScopeModeWithRepo(false);
+    expect(useSessionStore.getState().scopeMode).toBe('global');
+  });
+
+  test('syncScopeModeWithRepo preserves explicit local scope in a repo', () => {
+    const store = useSessionStore.getState();
+    store.setScopeMode('local');
+    store.syncScopeModeWithRepo(true);
+    expect(useSessionStore.getState().scopeMode).toBe('local');
+  });
+});

src/stores/sessionStore.ts

@@ -9,6 +9,10 @@ import type { PrInfo } from '../services/github';
 // Types
 // ============================================================================
 
+export type FilterMode = 'all' | 'running' | 'completed';
+export type ScopeMode = 'local' | 'global';
+type StateUpdater<T> = T | ((prev: T) => T);
+
 export interface PrCacheEntry {
   prInfo: PrInfo | null;
   lastChecked: number; // Date.now() timestamp
@@ -25,6 +29,27 @@ export interface SessionState {
   /** Set the selected session ID */
   setSelectedSessionId: (id: string | null) => void;
 
+  /** Free-text filter applied to the sessions list */
+  filterText: string;
+
+  /** Set the free-text filter */
+  setFilterText: (text: StateUpdater<string>) => void;
+
+  /** Status filter applied to the sessions list */
+  filterMode: FilterMode;
+
+  /** Set the status filter */
+  setFilterMode: (mode: FilterMode) => void;
+
+  /** Repo scope applied to the sessions list */
+  scopeMode: ScopeMode;
+
+  /** Set the repo scope */
+  setScopeMode: (mode: ScopeMode) => void;
+
+  /** Initialize scope based on whether a repo is currently active */
+  syncScopeModeWithRepo: (hasCurrentRepo: boolean) => void;
+
   /** PR info cache keyed by session ID (containerId) */
   prCache: Record<string, PrCacheEntry>;
 
@@ -52,12 +77,41 @@ export interface SessionState {
 
 export const useSessionStore = create<SessionState>()((set, get) => ({
   selectedSessionId: null,
+  filterText: '',
+  filterMode: 'all',
+  scopeMode: 'global',
   prCache: {},
 
   setSelectedSessionId: (id: string | null) => {
     set({ selectedSessionId: id });
   },
 
+  setFilterText: (text: StateUpdater<string>) => {
+    set((state) => ({
+      filterText:
+        typeof text === 'function'
+          ? (text as (prev: string) => string)(state.filterText)
+          : text,
+    }));
+  },
+
+  setFilterMode: (mode: FilterMode) => {
+    set({ filterMode: mode });
+  },
+
+  setScopeMode: (mode: ScopeMode) => {
+    set({ scopeMode: mode });
+  },
+
+  syncScopeModeWithRepo: (hasCurrentRepo: boolean) => {
+    const { scopeMode } = get();
+    if (hasCurrentRepo && scopeMode === 'global') {
+      set({ scopeMode: 'local' });
+    } else if (!hasCurrentRepo && scopeMode === 'local') {
+      set({ scopeMode: 'global' });
+    }
+  },
+
   setPrInfo: (sessionId: string, prInfo: PrInfo | null) => {
     set((state) => ({
       prCache: {