perf: cap messages and optimize persistence (Phase 3)

packages/app/src/hooks/use-daemon-session.ts

@@ -1,8 +1,9 @@
-import { useCallback, useRef } from "react";
+import { useCallback, useMemo, useRef } from "react";
 import { Alert } from "react-native";
 import type { SessionContextValue } from "@/contexts/session-context";
 import { useDaemonConnections } from "@/contexts/daemon-connections-context";
 import { useSessionStore } from "@/stores/session-store";
+import { useSessionHeavyState } from "@/stores/session-heavy-state";
 
 export class DaemonSessionUnavailableError extends Error {
   serverId: string;
@@ -37,7 +38,21 @@ export function useDaemonSession(serverId?: string | null, options?: UseDaemonSe
     },
     [serverId]
   );
-  const session = useSessionStore(selectSession);
+  const baseSession = useSessionStore(selectSession);
+  const heavyState = useSessionHeavyState(serverId ?? null);
+  const session = useMemo(() => {
+    if (!baseSession) {
+      return null;
+    }
+    if (!serverId || !heavyState) {
+      return baseSession;
+    }
+    return {
+      ...baseSession,
+      messages: heavyState.messages,
+      agentStreamState: heavyState.agentStreamState,
+    } as SessionContextValue;
+  }, [baseSession, heavyState, serverId]);
   const { connectionStates } = useDaemonConnections();
   const alertedDaemonsRef = useRef<Set<string>>(new Set());
   const loggedDaemonsRef = useRef<Set<string>>(new Set());

packages/app/src/hooks/use-session-directory.ts

@@ -1,13 +1,28 @@
 import { useCallback, useMemo } from "react";
 import { useStoreWithEqualityFn } from "zustand/traditional";
 import { useSessionStore, type SessionData } from "@/stores/session-store";
+import { useSessionHeavyDirectory } from "@/stores/session-heavy-state";
 
 export function useSessionDirectory(): Map<string, SessionData> {
   const sessions = useSessionStore((state) => state.sessions);
+  const heavyDirectory = useSessionHeavyDirectory();
 
   return useMemo(() => {
-    return new Map<string, SessionData>(Object.entries(sessions));
-  }, [sessions]);
+    const merged = new Map<string, SessionData>();
+    for (const [serverId, session] of Object.entries(sessions)) {
+      const heavy = heavyDirectory.get(serverId);
+      if (heavy) {
+        merged.set(serverId, {
+          ...session,
+          messages: heavy.messages,
+          agentStreamState: heavy.agentStreamState,
+        });
+      } else {
+        merged.set(serverId, session);
+      }
+    }
+    return merged;
+  }, [heavyDirectory, sessions]);
 }
 
 type SessionSelector<T> = (session: SessionData | null) => T;