nastechai-desktop 18.1.0

package/src/store/session-switcher.test.ts

@@ -0,0 +1,115 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { SessionInfo } from '@/types/nastech'
+
+import { $selectedStoredSessionId, $sessions } from './session'
+import {
+  $switcherIndex,
+  $switcherOpen,
+  $switcherSessions,
+  closeSwitcher,
+  commitOnCtrlUp,
+  onSwitcherTabDown,
+  onSwitcherTabUp,
+  openOrAdvanceSwitcher,
+  slotSessionId,
+  SWITCHER_REVEAL_MS
+} from './session-switcher'
+
+const session = (id: string): SessionInfo => ({ id }) as SessionInfo
+
+const seed = (ids: string[], selected: null | string) => {
+  $sessions.set(ids.map(session))
+  $selectedStoredSessionId.set(selected)
+}
+
+const tabTap = (direction: 1 | -1 = 1) => {
+  onSwitcherTabDown()
+  const target = openOrAdvanceSwitcher(direction)
+  onSwitcherTabUp()
+
+  return target
+}
+
+beforeEach(() => {
+  vi.useRealTimers()
+  closeSwitcher()
+  $switcherSessions.set([])
+  $switcherIndex.set(0)
+})
+
+afterEach(() => {
+  seed([], null)
+})
+
+describe('openOrAdvanceSwitcher', () => {
+  it('does nothing with fewer than two sessions', () => {
+    seed(['a'], 'a')
+    onSwitcherTabDown()
+
+    expect(openOrAdvanceSwitcher(1)).toBeNull()
+  })
+
+  it('jumps immediately on a quick Tab tap without opening the HUD', () => {
+    seed(['a', 'b', 'c'], 'a')
+
+    expect(tabTap()).toBe('b')
+    expect($switcherOpen.get()).toBe(false)
+    expect(commitOnCtrlUp()).toBeNull()
+  })
+
+  it('does not open the HUD when Ctrl stays down but Tab was released quickly', () => {
+    vi.useFakeTimers()
+    seed(['a', 'b', 'c'], 'a')
+
+    tabTap()
+    vi.advanceTimersByTime(SWITCHER_REVEAL_MS)
+
+    expect($switcherOpen.get()).toBe(false)
+  })
+
+  it('opens the HUD when Tab stays held past the reveal delay', () => {
+    vi.useFakeTimers()
+    seed(['a', 'b', 'c'], 'a')
+
+    onSwitcherTabDown()
+    openOrAdvanceSwitcher(1)
+    vi.advanceTimersByTime(SWITCHER_REVEAL_MS)
+
+    expect($switcherOpen.get()).toBe(true)
+    onSwitcherTabUp()
+  })
+
+  it('opens on a second Tab while Ctrl is still down', () => {
+    seed(['a', 'b', 'c'], 'a')
+
+    expect(tabTap()).toBe('b')
+    onSwitcherTabDown()
+    openOrAdvanceSwitcher(1)
+    onSwitcherTabUp()
+
+    expect($switcherOpen.get()).toBe(true)
+    expect($switcherIndex.get()).toBe(2)
+  })
+
+  it('commits the HUD highlight on Ctrl up', () => {
+    seed(['a', 'b', 'c'], 'a')
+
+    expect(tabTap()).toBe('b')
+    onSwitcherTabDown()
+    openOrAdvanceSwitcher(1)
+    onSwitcherTabUp()
+
+    expect(commitOnCtrlUp()).toBe('c')
+  })
+})
+
+describe('slotSessionId', () => {
+  it('reads the armed snapshot while browsing is pending', () => {
+    seed(['a', 'b', 'c'], 'a')
+    tabTap()
+    $sessions.set([session('x')])
+
+    expect(slotSessionId(2)).toBe('b')
+  })
+})

package/src/store/session-switcher.ts

@@ -0,0 +1,128 @@
+import { atom } from 'nanostores'
+
+import type { SessionInfo } from '@/types/nastech'
+
+import { $selectedStoredSessionId, $sessions } from './session'
+
+// Mac-style session switcher (^Tab). Quick tap jumps on keydown; the HUD opens
+// only when Tab is held past REVEAL_MS or tapped again while Ctrl is down.
+
+export const SWITCHER_REVEAL_MS = 220
+
+export const $switcherOpen = atom(false)
+export const $switcherSessions = atom<SessionInfo[]>([])
+export const $switcherIndex = atom(0)
+
+const wrap = (index: number, length: number): number => ((index % length) + length) % length
+
+let pendingBrowse = false
+let revealTimer: ReturnType<typeof setTimeout> | null = null
+let tabHeld = false
+let closedAt = 0
+
+function clearRevealTimer(): void {
+  if (revealTimer) {
+    clearTimeout(revealTimer)
+    revealTimer = null
+  }
+}
+
+function revealOverlay(): void {
+  pendingBrowse = false
+  $switcherOpen.set(true)
+}
+
+function scheduleReveal(): void {
+  clearRevealTimer()
+  revealTimer = setTimeout(() => {
+    revealTimer = null
+
+    if (pendingBrowse && tabHeld) {
+      revealOverlay()
+    }
+  }, SWITCHER_REVEAL_MS)
+}
+
+export function onSwitcherTabDown(): void {
+  tabHeld = true
+}
+
+export function onSwitcherTabUp(): void {
+  tabHeld = false
+
+  if (!$switcherOpen.get()) {
+    clearRevealTimer()
+  }
+}
+
+// First Tab returns a session id to jump to immediately; later Tabs move the
+// highlight (Ctrl↑ commits when the HUD is open).
+export function openOrAdvanceSwitcher(direction: 1 | -1): string | null {
+  const sessions = $sessions.get()
+
+  if (sessions.length < 2) {
+    return null
+  }
+
+  if ($switcherOpen.get()) {
+    const { length } = $switcherSessions.get()
+
+    if (length) {
+      $switcherIndex.set(wrap($switcherIndex.get() + direction, length))
+    }
+
+    return null
+  }
+
+  const current = sessions.findIndex(session => session.id === $selectedStoredSessionId.get())
+  const start = current === -1 ? (direction === 1 ? -1 : 0) : current
+  const nextIndex = wrap(start + direction, sessions.length)
+
+  $switcherSessions.set(sessions)
+  $switcherIndex.set(nextIndex)
+
+  if (pendingBrowse) {
+    clearRevealTimer()
+    $switcherIndex.set(wrap($switcherIndex.get() + direction, sessions.length))
+    revealOverlay()
+
+    return null
+  }
+
+  pendingBrowse = true
+  scheduleReveal()
+
+  return sessions[nextIndex]?.id ?? null
+}
+
+export const highlightedSessionId = (): string | null =>
+  $switcherSessions.get()[$switcherIndex.get()]?.id ?? null
+
+export const slotSessionId = (slot: number): string | null =>
+  ($switcherOpen.get() || pendingBrowse ? $switcherSessions.get() : $sessions.get())[slot - 1]?.id ?? null
+
+export function closeSwitcher(): void {
+  closedAt = Date.now()
+  clearRevealTimer()
+  pendingBrowse = false
+  tabHeld = false
+  $switcherOpen.set(false)
+}
+
+export function commitOnCtrlUp(): string | null {
+  clearRevealTimer()
+  pendingBrowse = false
+
+  if (!$switcherOpen.get()) {
+    return null
+  }
+
+  const target = highlightedSessionId()
+  closeSwitcher()
+
+  return target
+}
+
+export const switcherJustClosed = (): boolean => Date.now() - closedAt < 400
+
+export const switcherActive = (): boolean => $switcherOpen.get() || pendingBrowse

package/src/store/session-sync.ts

@@ -0,0 +1,25 @@
+// Cross-window session-list sync. Each desktop window is its own renderer
+// process with its own gateway socket and session store, so a mutation in one
+// (e.g. a new chat started in the compact pop-out) never reaches another
+// window. This bus pings every window to re-pull the shared session list; the
+// data already lives in the backend, the other window just doesn't know to look.
+const CHANNEL = 'nastech:sessions'
+
+const channel = typeof BroadcastChannel === 'undefined' ? null : new BroadcastChannel(CHANNEL)
+
+// A window that mutated the session list (created / titled a chat) tells the
+// others to refresh. A BroadcastChannel never delivers to its own poster, so the
+// caller refreshes locally as it already does.
+export function broadcastSessionsChanged(): void {
+  channel?.postMessage(1)
+}
+
+export function onSessionsChanged(handler: () => void): () => void {
+  if (!channel) {
+    return () => {}
+  }
+
+  channel.addEventListener('message', handler)
+
+  return () => channel.removeEventListener('message', handler)
+}

package/src/store/session.test.ts

@@ -0,0 +1,131 @@
+import { describe, expect, it } from 'vitest'
+
+import type { SessionInfo } from '@/types/nastech'
+
+import { $attentionSessionIds, mergeSessionPage, sessionPinId, setSessionAttention } from './session'
+
+const session = (over: Partial<SessionInfo>): SessionInfo => ({
+  archived: false,
+  cwd: null,
+  ended_at: null,
+  id: 'live',
+  input_tokens: 0,
+  is_active: false,
+  last_active: 0,
+  message_count: 0,
+  model: null,
+  output_tokens: 0,
+  preview: null,
+  source: null,
+  started_at: 0,
+  title: null,
+  tool_call_count: 0,
+  ...over
+})
+
+describe('setSessionAttention', () => {
+  it('adds and removes a session id without duplicating it', () => {
+    $attentionSessionIds.set([])
+
+    setSessionAttention('s1', true)
+    setSessionAttention('s1', true)
+    expect($attentionSessionIds.get()).toEqual(['s1'])
+
+    setSessionAttention('s2', true)
+    expect($attentionSessionIds.get()).toEqual(['s1', 's2'])
+
+    setSessionAttention('s1', false)
+    expect($attentionSessionIds.get()).toEqual(['s2'])
+
+    $attentionSessionIds.set([])
+  })
+
+  it('ignores empty ids and no-op clears', () => {
+    $attentionSessionIds.set([])
+
+    setSessionAttention(null, true)
+    setSessionAttention(undefined, true)
+    setSessionAttention('', true)
+    setSessionAttention('missing', false)
+    expect($attentionSessionIds.get()).toEqual([])
+  })
+})
+
+describe('sessionPinId', () => {
+  it('uses the live id when there is no compression lineage', () => {
+    expect(sessionPinId(session({ id: 'abc' }))).toBe('abc')
+  })
+
+  it('uses the lineage root so a pin survives compression', () => {
+    // After auto-compression the entry surfaces under a fresh tip id but keeps
+    // the original root — pinning on the root keeps the pin stable.
+    expect(sessionPinId(session({ id: 'tip', _lineage_root_id: 'root' }))).toBe('root')
+  })
+})
+
+describe('mergeSessionPage', () => {
+  it('returns the server page untouched when there is nothing to keep', () => {
+    const previous = [session({ id: 'a' }), session({ id: 'b' })]
+    const incoming = [session({ id: 'a' })]
+
+    expect(mergeSessionPage(previous, incoming, [])).toBe(incoming)
+  })
+
+  it('keeps a still-working session the server omitted', () => {
+    // Repro of the disappearing-sessions bug: A finished and is returned by the
+    // server, but B and C are mid-first-response (message_count 0 in the DB) so
+    // listSessions(min_messages=1) skips them. They must survive the refresh.
+    const previous = [session({ id: 'c' }), session({ id: 'b' }), session({ id: 'a' })]
+    const incoming = [session({ id: 'a', message_count: 2 })]
+
+    const merged = mergeSessionPage(previous, incoming, ['b', 'c'])
+
+    expect(merged.map(s => s.id)).toEqual(['c', 'b', 'a'])
+    // The finished session comes from the fresh server payload, not the stale
+    // optimistic copy.
+    expect(merged.find(s => s.id === 'a')?.message_count).toBe(2)
+  })
+
+  it('does not duplicate a working session the server already returned', () => {
+    const previous = [session({ id: 'b' }), session({ id: 'a' })]
+    const incoming = [session({ id: 'b', message_count: 4 }), session({ id: 'a' })]
+
+    const merged = mergeSessionPage(previous, incoming, ['b'])
+
+    expect(merged.map(s => s.id)).toEqual(['b', 'a'])
+    expect(merged.find(s => s.id === 'b')?.message_count).toBe(4)
+  })
+
+  it('never resurrects a session the server dropped that is not in the keep set', () => {
+    // A deleted/archived session is removed from `previous` optimistically and
+    // is not in the keep set, so it must stay gone after a refresh.
+    const previous = [session({ id: 'b' }), session({ id: 'gone' })]
+    const incoming = [session({ id: 'b' })]
+
+    expect(mergeSessionPage(previous, incoming, ['b']).map(s => s.id)).toEqual(['b'])
+  })
+
+  it('keeps a pinned session that has aged off the recent page', () => {
+    // Repro of "loses pins until you refresh": a pinned chat falls off the
+    // most-recent page, so the server stops returning it. A hard replace would
+    // evict it and the Pinned section would go empty. The keep set (which
+    // carries pinned ids) must hold it in memory.
+    const previous = [session({ id: 'recent' }), session({ id: 'pinned' })]
+    const incoming = [session({ id: 'recent' })]
+
+    const merged = mergeSessionPage(previous, incoming, ['pinned'])
+
+    expect(merged.map(s => s.id)).toEqual(['pinned', 'recent'])
+  })
+
+  it('keeps a pinned session matched by its lineage root after compression', () => {
+    // The pin is stored on the lineage-root id, but the loaded row surfaces
+    // under its live compression tip. Matching on _lineage_root_id keeps it.
+    const previous = [session({ id: 'tip', _lineage_root_id: 'root' })]
+    const incoming = [session({ id: 'other' })]
+
+    const merged = mergeSessionPage(previous, incoming, ['root'])
+
+    expect(merged.map(s => s.id)).toEqual(['tip', 'other'])
+  })
+})

package/src/store/session.ts

@@ -0,0 +1,255 @@
+import { atom } from 'nanostores'
+
+import type { ContextSuggestion } from '@/app/types'
+import type { NasTechConnection } from '@/global'
+import type { ChatMessage } from '@/lib/chat-messages'
+import { persistString, storedString } from '@/lib/storage'
+import type { SessionInfo, UsageStats } from '@/types/nastech'
+
+type Updater<T> = T | ((current: T) => T)
+
+const WORKSPACE_CWD_KEY = 'NASTECH.desktop.workspace-cwd'
+
+export const getRememberedWorkspaceCwd = (): string => storedString(WORKSPACE_CWD_KEY)?.trim() || ''
+
+interface AppAtom<T> {
+  get: () => T
+  set: (value: T) => void
+}
+
+function updateAtom<T>(store: AppAtom<T>, next: Updater<T>) {
+  store.set(typeof next === 'function' ? (next as (current: T) => T)(store.get()) : next)
+}
+
+/** Durable id for pinning. Auto-compression rotates a conversation's session
+ *  id (root -> continuation tip), so pins keyed on the live id evaporate. The
+ *  lineage root is stable across every compression, so we pin on that. */
+export const sessionPinId = (session: Pick<SessionInfo, '_lineage_root_id' | 'id'>): string =>
+  session._lineage_root_id ?? session.id
+
+/** Merge a fresh server session page into the in-memory list, keeping any
+ *  row the server omitted that we still want visible — both still-"working"
+ *  sessions and pinned sessions.
+ *
+ *  Two reasons the server drops a row we must keep:
+ *
+ *  1. A brand-new session's first user message isn't flushed to the SessionDB
+ *     until its turn is persisted, so `listSessions(min_messages=1)` skips
+ *     sessions that are mid-first-response. Because every `message.complete`
+ *     triggers a full refresh, a hard replace makes concurrent new chats vanish
+ *     the instant any one of them finishes.
+ *  2. The sidebar lists only the most-recent page (`SIDEBAR_SESSIONS_PAGE_SIZE`)
+ *     ordered by activity. A pinned conversation that hasn't been touched in a
+ *     while falls off that page, so a hard replace silently evicts it from the
+ *     in-memory list — and because the Pinned section resolves pins against
+ *     that list, the pin "disappears until you refresh".
+ *
+ *  `keepIds` carries both the working set and the pinned set. Pins are stored
+ *  on the durable lineage-root id (see {@link sessionPinId}), while the loaded
+ *  row surfaces under its live compression tip, so we match a survivor by
+ *  either its live `id` or its `_lineage_root_id`. Optimistic deletes/archives
+ *  drop the row from `previous` (and unpin it), so a removed session can't be
+ *  resurrected here. */
+export function mergeSessionPage(
+  previous: SessionInfo[],
+  incoming: SessionInfo[],
+  keepIds: Iterable<string>
+): SessionInfo[] {
+  const keep = keepIds instanceof Set ? keepIds : new Set(keepIds)
+
+  if (keep.size === 0) {
+    return incoming
+  }
+
+  const incomingIds = new Set(incoming.map(session => session.id))
+
+  const survivors = previous.filter(
+    session =>
+      !incomingIds.has(session.id) &&
+      (keep.has(session.id) || (session._lineage_root_id != null && keep.has(session._lineage_root_id)))
+  )
+
+  return survivors.length ? [...survivors, ...incoming] : incoming
+}
+
+export const $connection = atom<NasTechConnection | null>(null)
+export const $gatewayState = atom('idle')
+export const $sessions = atom<SessionInfo[]>([])
+export const $sessionsTotal = atom<number>(0)
+// Cron-job sessions (source === 'cron') are fetched as their own list so the
+// scheduler's always-newest sessions never crowd recents out of the page
+// budget. Powers the collapsed "Cron jobs" sidebar section.
+export const $cronSessions = atom<SessionInfo[]>([])
+// Max cron sessions fetched for the sidebar section (single bounded page). When
+// the fetch returns exactly this many rows we know more exist, so the section
+// badge renders "N+". Lives here so the controller (fetch) and sidebar (badge)
+// share one source of truth without a circular import.
+export const CRON_SECTION_LIMIT = 50
+// Listable conversation count per profile (children excluded), keyed by profile
+// name. Lets the sidebar scope its "Load more" footer to the active profile so a
+// huge default profile doesn't keep "Load more" visible while browsing a small
+// one. Empty for single-profile users (fall back to $sessionsTotal).
+export const $sessionProfileTotals = atom<Record<string, number>>({})
+export const $sessionsLoading = atom(true)
+export const $workingSessionIds = atom<string[]>([])
+export const $activeSessionId = atom<string | null>(null)
+export const $selectedStoredSessionId = atom<string | null>(null)
+export const $messages = atom<ChatMessage[]>([])
+export const $freshDraftReady = atom(false)
+export const $busy = atom(false)
+export const $awaitingResponse = atom(false)
+export const $currentModel = atom('')
+export const $currentProvider = atom('')
+export const $currentReasoningEffort = atom('')
+export const $currentServiceTier = atom('')
+export const $currentFastMode = atom(false)
+// Effective approval-bypass state mirrored from the gateway (session.info).
+// Persistence lives in the backend config (approvals.mode), so this is a plain
+// reflection of the truth the gateway reports rather than its own store.
+export const $yoloActive = atom(false)
+export const $currentCwd = atom(getRememberedWorkspaceCwd())
+export const $currentBranch = atom('')
+export const $currentUsage = atom<UsageStats>({
+  calls: 0,
+  input: 0,
+  output: 0,
+  total: 0
+})
+export const $sessionStartedAt = atom<number | null>(null)
+export const $turnStartedAt = atom<number | null>(null)
+export const $introPersonality = atom('')
+export const $currentPersonality = atom('')
+export const $availablePersonalities = atom<string[]>([])
+export const $introSeed = atom(0)
+export const $contextSuggestions = atom<ContextSuggestion[]>([])
+export const $modelPickerOpen = atom(false)
+
+export const setConnection = (next: Updater<NasTechConnection | null>) => updateAtom($connection, next)
+export const setGatewayState = (next: Updater<string>) => updateAtom($gatewayState, next)
+export const setSessions = (next: Updater<SessionInfo[]>) => updateAtom($sessions, next)
+export const setSessionsTotal = (next: Updater<number>) => updateAtom($sessionsTotal, next)
+export const setCronSessions = (next: Updater<SessionInfo[]>) => updateAtom($cronSessions, next)
+export const setSessionProfileTotals = (next: Updater<Record<string, number>>) =>
+  updateAtom($sessionProfileTotals, next)
+export const setSessionsLoading = (next: Updater<boolean>) => updateAtom($sessionsLoading, next)
+export const setWorkingSessionIds = (next: Updater<string[]>) => updateAtom($workingSessionIds, next)
+export const setActiveSessionId = (next: Updater<string | null>) => updateAtom($activeSessionId, next)
+export const setSelectedStoredSessionId = (next: Updater<string | null>) => updateAtom($selectedStoredSessionId, next)
+export const setMessages = (next: Updater<ChatMessage[]>) => updateAtom($messages, next)
+export const setFreshDraftReady = (next: Updater<boolean>) => updateAtom($freshDraftReady, next)
+export const setBusy = (next: Updater<boolean>) => updateAtom($busy, next)
+export const setAwaitingResponse = (next: Updater<boolean>) => updateAtom($awaitingResponse, next)
+export const setCurrentModel = (next: Updater<string>) => updateAtom($currentModel, next)
+export const setCurrentProvider = (next: Updater<string>) => updateAtom($currentProvider, next)
+export const setCurrentReasoningEffort = (next: Updater<string>) => updateAtom($currentReasoningEffort, next)
+export const setCurrentServiceTier = (next: Updater<string>) => updateAtom($currentServiceTier, next)
+export const setCurrentFastMode = (next: Updater<boolean>) => updateAtom($currentFastMode, next)
+export const setYoloActive = (next: Updater<boolean>) => updateAtom($yoloActive, next)
+
+export const setCurrentCwd = (next: Updater<string>) => {
+  updateAtom($currentCwd, next)
+  // Keep localStorage in sync with the atom: a real folder is remembered, an
+  // empty cwd clears the key (|| null → removeItem).
+  persistString(WORKSPACE_CWD_KEY, $currentCwd.get().trim() || null)
+}
+
+export const setCurrentBranch = (next: Updater<string>) => updateAtom($currentBranch, next)
+export const setCurrentUsage = (next: Updater<UsageStats>) => updateAtom($currentUsage, next)
+export const setSessionStartedAt = (next: Updater<number | null>) => updateAtom($sessionStartedAt, next)
+export const setTurnStartedAt = (next: Updater<number | null>) => updateAtom($turnStartedAt, next)
+export const setIntroPersonality = (next: Updater<string>) => updateAtom($introPersonality, next)
+export const setCurrentPersonality = (next: Updater<string>) => updateAtom($currentPersonality, next)
+export const setAvailablePersonalities = (next: Updater<string[]>) => updateAtom($availablePersonalities, next)
+export const setIntroSeed = (next: Updater<number>) => updateAtom($introSeed, next)
+export const setContextSuggestions = (next: Updater<ContextSuggestion[]>) => updateAtom($contextSuggestions, next)
+export const setModelPickerOpen = (next: Updater<boolean>) => updateAtom($modelPickerOpen, next)
+
+// Watchdog tracking — when does a "working" session count as stuck?
+// Long-running tool calls (LLM inference, long shell commands, web fetches)
+// can take a few minutes legitimately. We allow 8 minutes of complete
+// silence on the stream before clearing the working flag; in practice this
+// catches gateway hangs and dropped streams without false-positive-clearing
+// real long turns.
+const SESSION_WATCHDOG_TIMEOUT_MS = 8 * 60 * 1000
+const sessionWatchdogTimers = new Map<string, ReturnType<typeof setTimeout>>()
+
+function armSessionWatchdog(sessionId: string) {
+  const existing = sessionWatchdogTimers.get(sessionId)
+
+  if (existing) {
+    clearTimeout(existing)
+  }
+
+  const timer = setTimeout(() => {
+    sessionWatchdogTimers.delete(sessionId)
+
+    // Re-check the latest state at fire-time. If the user already navigated
+    // away or the session genuinely finished, the timer is a no-op.
+    if ($workingSessionIds.get().includes(sessionId)) {
+      setWorkingSessionIds(current => current.filter(id => id !== sessionId))
+    }
+  }, SESSION_WATCHDOG_TIMEOUT_MS)
+
+  sessionWatchdogTimers.set(sessionId, timer)
+}
+
+function clearSessionWatchdog(sessionId: string) {
+  const existing = sessionWatchdogTimers.get(sessionId)
+
+  if (existing) {
+    clearTimeout(existing)
+    sessionWatchdogTimers.delete(sessionId)
+  }
+}
+
+/** Call when a streaming event for a session lands. Refreshes the watchdog
+ *  so the session keeps its "working" status as long as data keeps coming. */
+export function noteSessionActivity(sessionId: string | null | undefined) {
+  if (!sessionId || !$workingSessionIds.get().includes(sessionId)) {
+    return
+  }
+
+  armSessionWatchdog(sessionId)
+}
+
+// Toggle an id's membership in a string-set atom, no-op when unchanged (keeps
+// the same array reference so subscribers don't churn).
+const toggleMembership = (set: (next: Updater<string[]>) => void, id: string, on: boolean) =>
+  set(current => {
+    const present = current.includes(id)
+
+    if (on) {
+      return present ? current : [...current, id]
+    }
+
+    return present ? current.filter(x => x !== id) : current
+  })
+
+// Stored session ids with a blocking prompt (clarify) waiting on the user.
+// Separate from $workingSessionIds: a session can be "working" (turn running)
+// AND need input. The sidebar row reads this for a persistent indicator that,
+// unlike a toast, survives window blur / alt-tab.
+export const $attentionSessionIds = atom<string[]>([])
+export const setAttentionSessionIds = (next: Updater<string[]>) => updateAtom($attentionSessionIds, next)
+
+export function setSessionAttention(sessionId: string | null | undefined, needsInput: boolean) {
+  if (sessionId) {
+    toggleMembership(setAttentionSessionIds, sessionId, needsInput)
+  }
+}
+
+export function setSessionWorking(sessionId: string | null | undefined, working: boolean) {
+  if (!sessionId) {
+    return
+  }
+
+  toggleMembership(setWorkingSessionIds, sessionId, working)
+
+  // Bookend the watchdog: arm on enter, disarm on leave. A later
+  // noteSessionActivity() from a streaming event refreshes the timer.
+  if (working) {
+    armSessionWatchdog(sessionId)
+  } else {
+    clearSessionWatchdog(sessionId)
+  }
+}