fix(gateway): scope sidebar messaging sessions to the active profile

apps/desktop/electron/main.ts

@@ -9988,7 +9988,8 @@ async function interceptSessionRequestForRemote(request) {
 
     const cronSp = sliceParams('cron_limit', '50', { profile: 'all', source: 'cron' })
 
-    const messagingSp = sliceParams('messaging_limit', '100', { profile: 'all' })
+    const messagingProfile = (searchParams.get('messaging_profile') || 'all').trim() || 'all'
+    const messagingSp = sliceParams('messaging_limit', '100', { profile: messagingProfile })
     const messagingExclude = searchParams.get('messaging_exclude')
 
     if (messagingExclude) {

apps/desktop/src/app/chat/sidebar/index.tsx

@@ -63,7 +63,15 @@ import {
   toggleSidebarMessagingOpen,
   unpinSession
 } from '@/store/layout'
-import { $newChatProfile, $profiles, $profileScope, ALL_PROFILES, normalizeProfileKey } from '@/store/profile'
+import {
+  $newChatProfile,
+  $profiles,
+  $profileScope,
+  ALL_PROFILES,
+  messagingProfileFor,
+  messagingTotalsKey,
+  normalizeProfileKey
+} from '@/store/profile'
 import {
   $activeProjectId,
   $projects,
@@ -884,20 +892,33 @@ export function ChatSidebar({
 
   // Each messaging platform is its own self-managed section: split the
   // separately-fetched messaging slice by source, newest platform first, rows
-  // within a platform by recency. Per-platform totals (when a "load more" has
-  // resolved them) drive the count + whether more remain on disk.
+  // within a platform by recency. Per-platform totals for the active profile
+  // (when a "load more" has resolved them) drive the count + whether more
+  // remain on disk.
   const messagingGroups = useMemo<MessagingSection[]>(() => {
     if (!messagingSessions.length) {
       return []
     }
 
+    // The fetch is already profile-scoped, but a profile switch doesn't wipe
+    // $messagingSessions (only a gateway-mode switch does), so the previous
+    // profile's rows would linger until the next refresh lands. Filtering here
+    // makes the switch instant; it's a no-op once the scoped rows arrive.
+    const visibleMessaging = showAllProfiles
+      ? messagingSessions
+      : messagingSessions.filter(s => normalizeProfileKey(s.profile) === profileScope)
+
+    // Totals are cached per (profile, source), so read the slot belonging to the
+    // scope this render is showing rather than whichever profile resolved it last.
+    const messagingProfile = messagingProfileFor(profileScope)
+
     const bySource = new Map<string, SessionInfo[]>()
     // Rows this platform owns that the Pinned section is showing instead. The
     // backend's per-platform total counts them, so discount it or "load more"
     // promises rows that will never appear.
     const pinnedBySource = new Map<string, number>()
 
-    for (const session of messagingSessions) {
+    for (const session of visibleMessaging) {
       const sourceId = normalizeSessionSource(session.source)
 
       if (!sourceId) {
@@ -918,7 +939,7 @@ export function ChatSidebar({
     return [...bySource.entries()]
       .map(([sourceId, list]) => {
         const ordered = [...list].sort((a, b) => sessionTime(b) - sessionTime(a))
-        const known = messagingPlatformTotals[sourceId]
+        const known = messagingPlatformTotals[messagingTotalsKey(messagingProfile, sourceId)]
         const unpinnedKnown = known == null ? null : Math.max(0, known - (pinnedBySource.get(sourceId) ?? 0))
         const total = Math.max(ordered.length, unpinnedKnown ?? 0)
 
@@ -934,7 +955,7 @@ export function ChatSidebar({
         }
       })
       .sort((a, b) => sessionTime(b.sessions[0]) - sessionTime(a.sessions[0]))
-  }, [messagingSessions, messagingPlatformTotals, messagingTruncated, isPinnedSession])
+  }, [messagingSessions, messagingPlatformTotals, messagingTruncated, isPinnedSession, profileScope, showAllProfiles])
 
   // ALL-profiles view: one collapsible group per profile, color on the header
   // (not on every row). Default profile floats to the top, the rest alpha.

apps/desktop/src/app/session/hooks/use-session-list-actions.test.tsx

@@ -4,11 +4,14 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type { SessionInfo, SidebarSessionsResponse } from '@/hermes'
 import {
   $cronSessions,
+  $messagingPlatformTotals,
   $messagingSessions,
   $sessions,
   $sessionsLoading,
   setCronSessions,
+  setMessagingPlatformTotals,
   setMessagingSessions,
+  setMessagingTruncated,
   setSessions,
   setSessionsLoading
 } from '@/store/session'
@@ -70,21 +73,27 @@ vi.mock('@/store/projects', () => ({
   $removedSessionIds: { get: () => removed.ids }
 }))
 
-beforeEach(() => {
-  listSidebarSessions.mockReset()
-  listAllProfileSessions.mockReset()
-  removed.ids = new Set()
+// $messagingPlatformTotals / $messagingTruncated are module-level atoms that
+// nothing in the app clears on a profile switch, so leaving them dirty between
+// tests makes the profile-scope assertions below order-dependent.
+const resetSessionStores = () => {
   setSessions([])
   setCronSessions([])
   setMessagingSessions([])
+  setMessagingPlatformTotals({})
+  setMessagingTruncated(false)
   setSessionsLoading(false)
+}
+
+beforeEach(() => {
+  listSidebarSessions.mockReset()
+  listAllProfileSessions.mockReset()
+  removed.ids = new Set()
+  resetSessionStores()
 })
 
 afterEach(() => {
-  setSessions([])
-  setCronSessions([])
-  setMessagingSessions([])
-  setSessionsLoading(false)
+  resetSessionStores()
 })
 
 describe('refreshSessions identity + loading hygiene', () => {
@@ -223,7 +232,8 @@ describe('refreshSessions batches slices into one request', () => {
       expect.objectContaining({
         recentsProfile: 'work',
         recentsExclude: expect.arrayContaining(['cron']),
-        messagingExclude: expect.arrayContaining(['cron'])
+        messagingExclude: expect.arrayContaining(['cron']),
+        messagingProfile: 'work'
       })
     )
   })
@@ -248,4 +258,87 @@ describe('refreshSessions batches slices into one request', () => {
 
     expect(getCronJobs).toHaveBeenLastCalledWith('all')
   })
+
+  // Messaging conversations live in the owning profile's state.db and every
+  // messaging read windows a shared row budget, so an unscoped fetch let a busy
+  // profile crowd the quieter ones out of the window — the sidebar's WeChat /
+  // Telegram sections showed a truncated union no matter which profile was
+  // selected.
+  it('scopes the messaging slices to the active profile (all → unified view)', async () => {
+    listSidebarSessions.mockResolvedValue(sidebar({ sessions: [] }))
+    listAllProfileSessions.mockResolvedValue({ sessions: [], total: 0 })
+
+    const scoped = renderHook(() => useSessionListActions({ profileScope: 'work' }))
+
+    await act(async () => {
+      await scoped.result.current.refreshMessagingSessions()
+    })
+
+    // 5th positional arg of listAllProfileSessions is the profile.
+    expect(listAllProfileSessions.mock.calls.at(-1)?.[4]).toBe('work')
+
+    await act(async () => {
+      await scoped.result.current.loadMoreMessagingForPlatform('weixin')
+    })
+
+    expect(listAllProfileSessions.mock.calls.at(-1)?.[4]).toBe('work')
+
+    const unified = renderHook(() => useSessionListActions({ profileScope: '__all__' }))
+
+    await act(async () => {
+      await unified.result.current.refreshMessagingSessions()
+    })
+
+    expect(listAllProfileSessions.mock.calls.at(-1)?.[4]).toBe('all')
+
+    await act(async () => {
+      await unified.result.current.refreshSessions()
+    })
+
+    expect(listSidebarSessions).toHaveBeenLastCalledWith(expect.objectContaining({ messagingProfile: 'all' }))
+  })
+
+  // Regression: per-platform totals are what drive a section's count and its
+  // "load more" affordance, and scoping the fetch made each total profile-
+  // specific. Keyed by source alone they leaked across a profile switch — too
+  // high showed a phantom "load more", too low SUPPRESSED a real one (a known
+  // total overrides the coarse truncation flag, and nothing re-fetches to
+  // correct it). Nothing clears these on a profile switch, so the key has to
+  // carry the profile.
+  it('keeps per-platform totals separate across a profile switch', async () => {
+    listSidebarSessions.mockResolvedValue(sidebar({ sessions: [] }))
+    listAllProfileSessions.mockResolvedValue({
+      sessions: [row('wx-1', { profile: 'work', source: 'weixin' })],
+      total: 42
+    })
+
+    const { rerender, result } = renderHook(({ profileScope }) => useSessionListActions({ profileScope }), {
+      initialProps: { profileScope: 'work' }
+    })
+
+    await act(async () => {
+      await result.current.loadMoreMessagingForPlatform('weixin')
+    })
+
+    expect($messagingPlatformTotals.get()['work:weixin']).toBe(42)
+
+    // Switch profiles: the quieter profile must not inherit work's count, and
+    // work's resolved total must survive so switching back doesn't re-fetch.
+    rerender({ profileScope: 'other' })
+
+    expect($messagingPlatformTotals.get()['other:weixin']).toBeUndefined()
+    expect($messagingPlatformTotals.get()['work:weixin']).toBe(42)
+
+    // The next profile resolves its own slot, side by side with work's.
+    listAllProfileSessions.mockResolvedValue({
+      sessions: [row('wx-2', { profile: 'other', source: 'weixin' })],
+      total: 3
+    })
+
+    await act(async () => {
+      await result.current.loadMoreMessagingForPlatform('weixin')
+    })
+
+    expect($messagingPlatformTotals.get()).toMatchObject({ 'other:weixin': 3, 'work:weixin': 42 })
+  })
 })

apps/desktop/src/app/session/hooks/use-session-list-actions.ts

@@ -10,7 +10,7 @@ import {
 } from '@/lib/session-source'
 import { setCronJobs } from '@/store/cron'
 import { $pinnedSessionIds, $sessionsLimit, bumpSessionsLimit, SIDEBAR_SESSIONS_PAGE_SIZE } from '@/store/layout'
-import { ALL_PROFILES, normalizeProfileKey } from '@/store/profile'
+import { ALL_PROFILES, messagingProfileFor, messagingTotalsKey, normalizeProfileKey } from '@/store/profile'
 import { $removedSessionIds } from '@/store/projects'
 import {
   $messagingSessions,
@@ -75,13 +75,20 @@ interface UseSessionListActionsArgs {
 export function useSessionListActions({ profileScope }: UseSessionListActionsArgs) {
   const refreshSessionsRequestRef = useRef(0)
 
+  // Messaging conversations are stored in the owning profile's state.db, and
+  // every messaging read windows a shared row budget — so an unscoped fetch
+  // lets a busy profile crowd the others out of the window. Scope them like
+  // recents/cron: a concrete profile sees only its own platform conversations,
+  // ALL_PROFILES keeps the unified view.
+  const messagingProfile = messagingProfileFor(profileScope)
+
   // Messaging-platform sessions as their own slice, fetched separately from
   // local recents so each platform renders a self-managed section and never
   // competes with local chats for the recents page budget. One combined fetch
   // seeds every platform; the sidebar splits the rows per source.
   const refreshMessagingSessions = useCallback(async () => {
     try {
-      const result = await listAllProfileSessions(MESSAGING_SECTION_LIMIT, 1, 'exclude', 'recent', 'all', {
+      const result = await listAllProfileSessions(MESSAGING_SECTION_LIMIT, 1, 'exclude', 'recent', messagingProfile, {
         excludeSources: MESSAGING_EXCLUDED_SOURCES
       })
 
@@ -96,29 +103,42 @@ export function useSessionListActions({ profileScope }: UseSessionListActionsArg
     } catch {
       // Non-fatal: the messaging sections just stay empty/stale.
     }
-  }, [])
+  }, [messagingProfile])
 
   // Page a single platform's section independently (mirrors the per-profile
   // pager): fetch that source's next window and merge it back in place, leaving
   // every other platform's rows untouched. Resolves the platform's exact total.
-  const loadMoreMessagingForPlatform = useCallback(async (platform: string) => {
-    const inPlatform = (s: SessionInfo) => normalizeSessionSource(s.source) === platform
-    const loaded = $messagingSessions.get().filter(inPlatform).length
-
-    const result = await listAllProfileSessions(loaded + SIDEBAR_SESSIONS_PAGE_SIZE, 1, 'exclude', 'recent', 'all', {
-      source: platform
-    })
-
-    const incoming = result.sessions.filter(s => normalizeSessionSource(s.source) === platform)
-
-    setMessagingSessions(prev => [
-      ...prev.filter(s => !inPlatform(s)),
-      ...mergeSessionPage(prev.filter(inPlatform), incoming, sessionsToKeep())
-    ])
-
-    const total = result.total ?? incoming.length
-    setMessagingPlatformTotals(prev => ({ ...prev, [platform]: Math.max(total, incoming.length) }))
-  }, [])
+  const loadMoreMessagingForPlatform = useCallback(
+    async (platform: string) => {
+      const inPlatform = (s: SessionInfo) => normalizeSessionSource(s.source) === platform
+      const loaded = $messagingSessions.get().filter(inPlatform).length
+
+      const result = await listAllProfileSessions(
+        loaded + SIDEBAR_SESSIONS_PAGE_SIZE,
+        1,
+        'exclude',
+        'recent',
+        messagingProfile,
+        { source: platform }
+      )
+
+      const incoming = result.sessions.filter(s => normalizeSessionSource(s.source) === platform)
+
+      setMessagingSessions(prev => [
+        ...prev.filter(s => !inPlatform(s)),
+        ...mergeSessionPage(prev.filter(inPlatform), incoming, sessionsToKeep())
+      ])
+
+      const total = result.total ?? incoming.length
+      // Stamp the total against the profile it was counted in — the same platform
+      // has a different count per profile, and switching profiles must not inherit
+      // this one.
+      const totalsKey = messagingTotalsKey(messagingProfile, platform)
+
+      setMessagingPlatformTotals(prev => ({ ...prev, [totalsKey]: Math.max(total, incoming.length) }))
+    },
+    [messagingProfile]
+  )
 
   // Cron *jobs* drive the sidebar "Cron jobs" section. Jobs are created
   // synchronously (agent tool call or the cron UI), so refreshing here right
@@ -161,8 +181,9 @@ export function useSessionListActions({ profileScope }: UseSessionListActionsArg
       // the same rows tagged profile="default".
       // Scope recents to the active profile (not always 'all') so a profile
       // with few recent sessions isn't windowed out of the cross-profile
-      // recency page — the empty-history-on-profile-switch bug. Cron + messaging
-      // stay cross-profile.
+      // recency page — the empty-history-on-profile-switch bug. Messaging is
+      // scoped the same way (see messagingProfile); only cron stays
+      // cross-profile.
       const sessionProfile = profileScope === ALL_PROFILES ? 'all' : profileScope
 
       // Batched: one request opens each profile DB once and returns all three
@@ -174,7 +195,8 @@ export function useSessionListActions({ profileScope }: UseSessionListActionsArg
         recentsExclude: SIDEBAR_EXCLUDED_SOURCES,
         cronLimit: CRON_SECTION_LIMIT,
         messagingLimit: MESSAGING_SECTION_LIMIT,
-        messagingExclude: MESSAGING_EXCLUDED_SOURCES
+        messagingExclude: MESSAGING_EXCLUDED_SOURCES,
+        messagingProfile
       })
 
       if (refreshSessionsRequestRef.current === requestId) {
@@ -236,7 +258,7 @@ export function useSessionListActions({ profileScope }: UseSessionListActionsArg
 
     // Cron *jobs* are a distinct API (getCronJobs), not a session slice.
     void refreshCronJobs()
-  }, [profileScope, refreshCronJobs])
+  }, [messagingProfile, profileScope, refreshCronJobs])
 
   const loadMoreSessions = useCallback(async () => {
     bumpSessionsLimit()

apps/desktop/src/hermes.test.ts

@@ -81,19 +81,39 @@ describe('Hermes REST helpers', () => {
       recentsExclude: ['cron', 'tool'],
       cronLimit: 50,
       messagingLimit: 100,
-      messagingExclude: ['cron', 'desktop']
+      messagingExclude: ['cron', 'desktop'],
+      messagingProfile: 'work'
     })
 
     expect(api).toHaveBeenCalledWith(
       expect.objectContaining({
         path:
           '/api/profiles/sessions/sidebar?recents_profile=work&recents_limit=30&cron_limit=50' +
-          '&messaging_limit=100&recents_exclude=cron%2Ctool&messaging_exclude=cron%2Cdesktop',
+          '&messaging_limit=100&messaging_profile=work&recents_exclude=cron%2Ctool' +
+          '&messaging_exclude=cron%2Cdesktop',
         timeoutMs: 60_000
       })
     )
   })
 
+  // messagingProfile is optional so existing callers keep the cross-profile
+  // default; omitting it must still send an explicit messaging_profile=all
+  // rather than dropping the param.
+  it('defaults the messaging slice to all profiles when no messagingProfile is given', async () => {
+    api.mockResolvedValue({ recents: { sessions: [] }, cron: { sessions: [] }, messaging: { sessions: [] } })
+
+    await listSidebarSessions({
+      recentsProfile: 'work',
+      recentsLimit: 30,
+      recentsExclude: [],
+      cronLimit: 50,
+      messagingLimit: 100,
+      messagingExclude: []
+    })
+
+    expect(api.mock.calls.at(-1)?.[0].path).toContain('messaging_profile=all')
+  })
+
   it('defaults missing sidebar slices to empty session arrays', async () => {
     api.mockResolvedValue({})