🐛 Improve swallowed hook error handling

Improves Stellar network error propagation so init, batch refresh, and auto-solve failures update hook state, and keeps malformed localStorage cache handling non-fatal with a logged fallback.\n\nFixes #19300

Author: clubanderson

web/src/hooks/__tests__/useStackDiscovery.test.ts

@@ -541,13 +541,19 @@ describe('useStackDiscovery', () => {
   })
 
   it('handles malformed localStorage data without crashing', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
     localStorage.setItem(CACHE_KEY, 'not-valid-json{{')
 
     const { result, unmount } = renderHook(() => useStackDiscovery([]))
 
     expect(result.current.stacks).toEqual([])
     expect(result.current.isLoading).toBe(true)
+    expect(warnSpy).toHaveBeenCalledWith(
+      '[useStackDiscovery] Ignoring malformed JSON for stack cache:',
+      expect.any(SyntaxError),
+    )
     unmount()
+    warnSpy.mockRestore()
   })
 
   it('persists discovered stacks to localStorage', async () => {

web/src/hooks/__tests__/useStellarSource.test.tsx

@@ -324,6 +324,16 @@ describe('useStellarSource — Initial state and SSE messages', () => {
     expect(result.current.solves).toEqual([])
   })
 
+  it('stores an error message when the initial refresh fails', async () => {
+    mockStellarApi.getState.mockRejectedValueOnce(new Error('Initial refresh failed'))
+
+    const { result } = renderHook(() => useStellarSource())
+
+    await waitFor(() => {
+      expect(result.current.connectionError).toBe('Initial refresh failed')
+    })
+  })
+
   it('parses incoming SSE notification event and appends to state', async () => {
     const { result } = renderHook(() => useStellarSource())
 
@@ -706,6 +716,22 @@ describe('useStellarSource — Batch refresh', () => {
     expect(spyClearTimeout).toHaveBeenCalled()
     spyClearTimeout.mockRestore()
   })
+
+  it('stores an error message when a batch refresh request fails', async () => {
+    const { result } = renderHook(() => useStellarSource())
+
+    await waitFor(() => {
+      expect(eventSourceInstances).toHaveLength(1)
+    })
+
+    mockStellarApi.getNotifications.mockRejectedValueOnce(new Error('Batch refresh failed'))
+
+    await act(async () => {
+      await result.current.runBatchNow()
+    })
+
+    expect(result.current.connectionError).toBe('Batch refresh failed')
+  })
 })
 
 describe('useStellarSource — Auto-solve trigger', () => {
@@ -788,4 +814,32 @@ describe('useStellarSource — Auto-solve trigger', () => {
     expect(mockStellarApi.startSolve).not.toHaveBeenCalled()
     expect(result.current.solveProgress['n-warning']).toBeUndefined()
   })
+
+  it('stores an error message when auto-solve fails for a critical notification', async () => {
+    const { result } = renderHook(() => useStellarSource())
+
+    await waitFor(() => {
+      expect(eventSourceInstances).toHaveLength(1)
+    })
+
+    mockStellarApi.startSolve.mockRejectedValueOnce(new Error('Auto-solve failed'))
+
+    await act(async () => {
+      eventSourceInstances[0]._triggerEvent('notification', {
+        id: 'n-critical-fail',
+        type: 'event',
+        severity: 'critical',
+        title: 'Critical Alert',
+        body: 'Emergency!',
+        read: false,
+        createdAt: new Date().toISOString(),
+      })
+      await Promise.resolve()
+    })
+
+    await waitFor(() => {
+      expect(result.current.connectionError).toBe('Auto-solve failed')
+    })
+    expect(result.current.solveProgress['n-critical-fail']).toBeUndefined()
+  })
 })

web/src/hooks/useStackDiscovery.ts

@@ -326,12 +326,12 @@ function loadCachedStacks(): { stacks: LLMdStack[]; timestamp: number } | null {
   try {
     const cached = localStorage.getItem(CACHE_KEY)
     if (!cached) return null
-    const parsed = JSON.parse(cached)
-    if (parsed.timestamp && parsed.stacks) {
-      return parsed
+    const parsed = safeJsonParse<{ stacks?: LLMdStack[]; timestamp?: number } | null>(cached, null, 'stack cache')
+    if (parsed?.timestamp && parsed.stacks) {
+      return { stacks: parsed.stacks, timestamp: parsed.timestamp }
     }
   } catch {
-    // Ignore parse errors
+    // Ignore storage errors
   }
   return null
 }

web/src/hooks/useStellarSource.ts

@@ -12,6 +12,7 @@ export const STELLAR_RECONNECT_MAX_MS = 30000
 export const STELLAR_TOKEN_POLL_INTERVAL_MS = 100
 export const STELLAR_TOKEN_POLL_MAX_ATTEMPTS = 30
 export const STELLAR_MISSION_TRIGGER_EVENT = 'stellar:mission_trigger'
+const STELLAR_REFRESH_REQUEST_COUNT = 7
 
 export interface StellarMissionTriggerPayload {
   solveId: string
@@ -53,6 +54,12 @@ function getStoredStellarBatchIntervalMs(): number {
   return resolveStellarBatchIntervalMs(safeGetItem(STORAGE_KEY_STELLAR_BATCH_INTERVAL_MS))
 }
 
+function getErrorMessage(error: unknown, fallback: string): string {
+  if (error instanceof Error && error.message.trim()) return error.message
+  if (typeof error === 'string' && error.trim()) return error
+  return fallback
+}
+
 export function useStellarSource() {
   const [isConnected, setIsConnected] = useState(false)
   const [connectionError, setConnectionError] = useState<string | null>(null)
@@ -92,6 +99,9 @@ export function useStellarSource() {
   const [nextBatchAtMs, setNextBatchAtMs] = useState(() => getNextBatchTime(batchIntervalMs))
   const [isBatchRefreshing, setIsBatchRefreshing] = useState(false)
   const batchRefreshInFlightRef = useRef(false)
+  const setOperationalError = useCallback((error: unknown, fallback: string) => {
+    setConnectionError(getErrorMessage(error, fallback))
+  }, [])
 
   useEffect(() => {
     const handleStorage = (event: StorageEvent) => {
@@ -131,8 +141,19 @@ export function useStellarSource() {
     if (results[5].status === 'fulfilled') setSolves(results[5].value || [])
     if (results[6].status === 'fulfilled') setActivity(results[6].value || [])
     const failures = results.filter(result => result.status === 'rejected')
-    if (failures.length > 0) console.warn('stellar: refreshState partial failure —', failures.length, 'of 7 calls failed')
-  }, [setNotifications])
+    if (failures.length === 0) {
+      setConnectionError(null)
+      return
+    }
+    console.warn('stellar: refreshState partial failure —', failures.length, 'of', STELLAR_REFRESH_REQUEST_COUNT, 'calls failed')
+    const firstFailure = failures[0]
+    setOperationalError(
+      firstFailure.status === 'rejected' ? firstFailure.reason : null,
+      failures.length === 1
+        ? 'Failed to refresh Stellar state'
+        : `Failed to refresh Stellar state (${failures.length}/${STELLAR_REFRESH_REQUEST_COUNT} requests failed)`,
+    )
+  }, [setNotifications, setOperationalError])
   const scheduleNextBatch = useCallback((intervalMs = batchIntervalMsRef.current) => {
     setNextBatchAtMs(getNextBatchTime(intervalMs))
   }, [])
@@ -144,12 +165,13 @@ export function useStellarSource() {
       await refreshState()
     } catch (err) {
       console.warn('stellar: batch refresh failed:', err)
+      setOperationalError(err, 'Failed to refresh Stellar state')
     } finally {
       batchRefreshInFlightRef.current = false
       setIsBatchRefreshing(false)
       scheduleNextBatch()
     }
-  }, [refreshState, scheduleNextBatch])
+  }, [refreshState, scheduleNextBatch, setOperationalError])
   const setBatchIntervalMs = useCallback((intervalMs: number) => {
     const nextIntervalMs = resolveStellarBatchIntervalMs(intervalMs)
     batchIntervalMsRef.current = nextIntervalMs
@@ -193,6 +215,7 @@ export function useStellarSource() {
       })
       stellarApi.startSolve(notif.id).catch(err => {
         console.warn('stellar: auto-solve for critical event failed:', notif.id, err)
+        setOperationalError(err, 'Failed to auto-solve critical event')
         setSolveProgress(prev => {
           const copy = { ...prev }
           delete copy[notif.id]
@@ -267,7 +290,7 @@ export function useStellarSource() {
     on<StellarMissionTriggerPayload>('mission_trigger', payload => {
       window.dispatchEvent(new CustomEvent(STELLAR_MISSION_TRIGGER_EVENT, { detail: payload }))
     })
-  }, [setNotifications])
+  }, [setNotifications, setOperationalError])
 
   useEffect(() => {
     reconnectRef.current = connectSSE
@@ -308,6 +331,7 @@ export function useStellarSource() {
         await refreshState()
       } catch (err) {
         console.warn('stellar: init failed:', err)
+        setOperationalError(err, 'Failed to initialize Stellar state')
       }
       scheduleNextBatch()
       connectSSE()
@@ -328,7 +352,7 @@ export function useStellarSource() {
       }
       esRef.current?.close()
     }
-  }, [connectSSE, refreshState, scheduleNextBatch])
+  }, [connectSSE, refreshState, scheduleNextBatch, setOperationalError])
 
   const unreadCount = notifications.filter(item => !item.read).length
   const acknowledgeNotification = useCallback(async (id: string) => {