fix(desktop): keep queued prompts bound to their sessions

apps/desktop/src/app/chat/composer/hooks/use-composer-queue.ts

@@ -34,6 +34,7 @@ interface UseComposerQueueArgs {
   onCancel: ChatBarProps['onCancel']
   onSubmit: ChatBarProps['onSubmit']
   queueEditRef: RefObject<QueueEditState | null>
+  queueProfile?: string | null
   queueSessionKey: ChatBarProps['queueSessionKey']
   sessionId: string | null | undefined
 }
@@ -58,6 +59,7 @@ export function useComposerQueue({
   onCancel,
   onSubmit,
   queueEditRef,
+  queueProfile,
   queueSessionKey,
   sessionId
 }: UseComposerQueueArgs) {
@@ -171,7 +173,7 @@ export function useComposerQueue({
       return false
     }
 
-    if (!enqueueQueuedPrompt(activeQueueSessionKey, { text, attachments })) {
+    if (!enqueueQueuedPrompt(activeQueueSessionKey, { text, attachments, profile: queueProfile })) {
       return false
     }
 
@@ -180,7 +182,7 @@ export function useComposerQueue({
     triggerHaptic('selection')
 
     return true
-  }, [activeQueueSessionKey, attachments, clearDraft, draftRef, scope.attachments])
+  }, [activeQueueSessionKey, attachments, clearDraft, draftRef, queueProfile, scope.attachments])
 
   // All queue drain paths share one lock + send-then-remove sequence.
   // `pickEntry` lets each caller choose head, by-id, or skip-edited.
@@ -205,6 +207,7 @@ export function useComposerQueue({
           onSubmit(entry.text, {
             attachments: entry.attachments,
             fromQueue: true,
+            ...(entry.profile ? { profile: entry.profile } : {}),
             sessionId: drainRuntimeSessionId,
             storedSessionId: drainQueueSessionKey
           })

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

@@ -68,6 +68,7 @@ export function ChatBar({
   focusKey,
   gateway,
   maxRecordingSeconds = 120,
+  queueProfile,
   queueSessionKey,
   sessionId,
   state,
@@ -203,6 +204,7 @@ export function ChatBar({
     onCancel,
     onSubmit,
     queueEditRef,
+    queueProfile,
     queueSessionKey,
     sessionId
   })

apps/desktop/src/app/chat/composer/types.ts

@@ -38,6 +38,7 @@ export interface ChatBarProps {
   maxRecordingSeconds?: number
   state: ChatBarState
   gateway?: HermesGateway | null
+  queueProfile?: string | null
   queueSessionKey?: string | null
   sessionId?: string | null
   cwd?: string | null

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

@@ -276,6 +276,11 @@ export function ChatView({
   const messagesEmpty = useStore(view.$messagesEmpty)
   const lastVisibleIsUser = useStore(view.$lastVisibleIsUser)
   const selectedSessionId = useStore(view.$storedId)
+
+  const queueProfile = selectedSessionId
+    ? ($sessions.get().find(session => sessionMatchesStoredId(session, selectedSessionId))?.profile ?? null)
+    : null
+
   const resumeExhaustedSessionId = useStore($resumeExhaustedSessionId)
   // A tile IS its session — no route involved, never "mismatched".
   const routedSessionId = isPrimary ? routeSessionId(location.pathname) : selectedSessionId
@@ -524,6 +529,7 @@ export function ChatView({
               onSteer={onSteer}
               onSubmit={onSubmit}
               onTranscribeAudio={onTranscribeAudio}
+              queueProfile={queueProfile}
               queueSessionKey={selectedSessionId}
               sessionId={activeSessionId}
               state={chatBarState}

apps/desktop/src/app/chat/session-tile-actions.ts

@@ -41,7 +41,7 @@ import {
   runRewindSubmit
 } from '../session/hooks/use-prompt-actions/rewind'
 import { useSubmitPrompt } from '../session/hooks/use-prompt-actions/submit'
-import { type SubmitTextOptions } from '../session/hooks/use-prompt-actions/utils'
+import { type GatewayRequest, type SubmitTextOptions } from '../session/hooks/use-prompt-actions/utils'
 
 import type { ComposerScope } from './composer/scope'
 
@@ -54,7 +54,7 @@ interface SessionTileActionsArgs {
 export function useSessionTileActions({ runtimeId, scope, storedSessionId }: SessionTileActionsArgs) {
   const { t } = useI18n()
   const copy = t.desktop
-  const { requestGateway } = useGatewayRequest()
+  const { requestGateway, requestGatewayForProfile } = useGatewayRequest()
 
   const runtimeIdRef = useRef(runtimeId)
   runtimeIdRef.current = runtimeId
@@ -95,9 +95,15 @@ export function useSessionTileActions({ runtimeId, scope, storedSessionId }: Ses
     async (
       sessionId: string,
       attachments: ComposerAttachment[],
-      options: { updateComposerAttachments?: boolean } = {}
+      options: { profile?: string | null; requestGateway?: GatewayRequest; updateComposerAttachments?: boolean } = {}
     ): Promise<ComposerAttachment[]> => {
-      const remote = $connection.get()?.mode === 'remote'
+      const attachmentGateway = options.requestGateway ?? requestGateway
+
+      const profileConnection = options.profile
+        ? await window.hermesDesktop?.getConnection(options.profile).catch(() => null)
+        : null
+
+      const remote = (profileConnection ?? $connection.get())?.mode === 'remote'
       const synced: ComposerAttachment[] = []
 
       for (const attachment of attachments) {
@@ -108,7 +114,11 @@ export function useSessionTileActions({ runtimeId, scope, storedSessionId }: Ses
         }
 
         if (attachment.kind === 'image' || attachment.kind === 'file') {
-          const next = await uploadComposerAttachment(attachment, { remote, requestGateway, sessionId })
+          const next = await uploadComposerAttachment(attachment, {
+            remote,
+            requestGateway: attachmentGateway,
+            sessionId
+          })
 
           if (options.updateComposerAttachments ?? true) {
             scope.attachments.update(next)
@@ -140,6 +150,7 @@ export function useSessionTileActions({ runtimeId, scope, storedSessionId }: Ses
     // token is a stable constant (the guard never trips for a tile).
     getRouteToken: () => runtimeId,
     requestGateway,
+    requestGatewayForProfile,
     // Tile ids are always bound before this hook mounts, so routed recovery is
     // unreachable here; keep the shared submit contract explicit.
     resumeStoredSession: () => undefined,

apps/desktop/src/app/contrib/wiring.tsx

@@ -197,7 +197,7 @@ export function ContribWiring({ children }: { children: ReactNode }) {
     setMessages
   })
 
-  const { connectionRef, gatewayRef, requestGateway } = useGatewayRequest()
+  const { connectionRef, gatewayRef, requestGateway, requestGatewayForProfile } = useGatewayRequest()
 
   const {
     loadMoreMessagingForPlatform,
@@ -530,6 +530,7 @@ export function ContribWiring({ children }: { children: ReactNode }) {
     openMemoryGraph: openStarmap,
     refreshSessions,
     requestGateway,
+    requestGatewayForProfile,
     resumeStoredSession: resumeSession,
     selectedStoredSessionIdRef,
     startFreshSessionDraft,
@@ -539,8 +540,17 @@ export function ContribWiring({ children }: { children: ReactNode }) {
 
   // Runs outside the selected ChatBar so queues belonging to background
   // sessions continue once those sessions are idle.
+  const getProfileForStoredSession = useCallback((storedSessionId: string): null | string => {
+    const stored = [...$sessions.get(), ...$messagingSessions.get()].find(session =>
+      sessionMatchesStoredId(session, storedSessionId)
+    )
+
+    return stored?.profile ?? null
+  }, [])
+
   useBackgroundQueueDrain({
     enabled: gatewayState === 'open',
+    getProfileForStoredSession,
     runtimeIdByStoredSessionIdRef,
     selectedStoredSessionId,
     submitText

apps/desktop/src/app/gateway/hooks/use-gateway-request.ts

@@ -3,7 +3,7 @@ import { useStore } from '@nanostores/react'
 import { useCallback, useEffect, useRef } from 'react'
 
 import type { HermesGateway } from '@/hermes'
-import { $gateway, ensureActiveGatewayOpen, isActivePrimary } from '@/store/gateway'
+import { $gateway, ensureActiveGatewayOpen, ensureGatewayOpenForProfile, isActivePrimary } from '@/store/gateway'
 import { $activeGatewayProfile } from '@/store/profile'
 import { $gatewayState, setConnection } from '@/store/session'
 
@@ -134,5 +134,18 @@ export function useGatewayRequest() {
     [ensureGatewayOpen]
   )
 
-  return { connectionRef, gatewayRef, requestGateway }
+  const requestGatewayForProfile = useCallback(
+    async <T>(profile: string, method: string, params: Record<string, unknown> = {}, timeoutMs?: number) => {
+      const gateway = await ensureGatewayOpenForProfile(profile)
+
+      if (!gateway) {
+        throw new Error(`Hermes gateway unavailable for profile: ${profile}`)
+      }
+
+      return gateway.request<T>(method, params, timeoutMs)
+    },
+    []
+  )
+
+  return { connectionRef, gatewayRef, requestGateway, requestGatewayForProfile }
 }

apps/desktop/src/app/session/hooks/use-background-queue-drain.test.tsx

@@ -11,17 +11,20 @@ import type { SubmitTextOptions } from './use-prompt-actions/utils'
 
 function Harness({
   enabled = true,
+  getProfileForStoredSession,
   runtimeMap,
   selectedStoredSessionId = 'stored-session-b',
   submitText
 }: {
   enabled?: boolean
+  getProfileForStoredSession?: (storedSessionId: string) => null | string
   runtimeMap: MutableRefObject<Map<string, string>>
   selectedStoredSessionId?: string | null
   submitText: (text: string, options?: SubmitTextOptions) => Promise<boolean> | boolean
 }) {
   useBackgroundQueueDrain({
     enabled,
+    getProfileForStoredSession,
     runtimeIdByStoredSessionIdRef: runtimeMap,
     selectedStoredSessionId,
     submitText
@@ -100,14 +103,25 @@ describe('useBackgroundQueueDrain', () => {
     const runtimeMap = { current: new Map<string, string>() }
     const submitText = vi.fn(async () => true)
 
-    enqueueQueuedPrompt('stored-session-a', { text: 'resume then send', attachments: [] })
+    enqueueQueuedPrompt('stored-session-a', {
+      text: 'resume then send',
+      attachments: [],
+      profile: 'persisted-background-profile'
+    })
 
-    render(<Harness runtimeMap={runtimeMap} submitText={submitText} />)
+    render(
+      <Harness
+        getProfileForStoredSession={() => 'stale-fallback-profile'}
+        runtimeMap={runtimeMap}
+        submitText={submitText}
+      />
+    )
 
     await waitFor(() => {
       expect(submitText).toHaveBeenCalledWith('resume then send', {
         attachments: [],
         fromQueue: true,
+        profile: 'persisted-background-profile',
         sessionId: null,
         storedSessionId: 'stored-session-a'
       })

apps/desktop/src/app/session/hooks/use-background-queue-drain.ts

@@ -20,6 +20,7 @@ type SubmitQueuedPrompt = (text: string, options?: SubmitTextOptions) => Promise
 
 interface BackgroundQueueDrainOptions {
   enabled: boolean
+  getProfileForStoredSession?: (storedSessionId: string) => null | string
   runtimeIdByStoredSessionIdRef: MutableRefObject<Map<string, string>>
   selectedStoredSessionId: string | null
   submitText: SubmitQueuedPrompt
@@ -37,6 +38,7 @@ const BACKGROUND_DRAIN_RETRY_MS = 750
  */
 export function useBackgroundQueueDrain({
   enabled,
+  getProfileForStoredSession,
   runtimeIdByStoredSessionIdRef,
   selectedStoredSessionId,
   submitText
@@ -113,11 +115,13 @@ export function useBackgroundQueueDrain({
           }
 
           const runtimeSessionId = runtimeIdByStoredSessionIdRef.current.get(sessionKey) ?? null
+          const profile = liveEntry.profile?.trim() || getProfileForStoredSession?.(sessionKey)?.trim() || null
 
           const accepted = await Promise.resolve(
             submitTextRef.current(liveEntry.text, {
               attachments: liveEntry.attachments,
               fromQueue: true,
+              ...(profile ? { profile } : {}),
               sessionId: runtimeSessionId,
               storedSessionId: sessionKey
             })
@@ -143,7 +147,7 @@ export function useBackgroundQueueDrain({
           drainingSessionIdsRef.current.delete(sessionKey)
         })
     },
-    [runtimeIdByStoredSessionIdRef, scheduleRetry, t]
+    [getProfileForStoredSession, runtimeIdByStoredSessionIdRef, scheduleRetry, t]
   )
 
   useEffect(() => {

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

@@ -77,6 +77,7 @@ function Harness({
   openMemoryGraph,
   refreshSessions,
   requestGateway,
+  requestGatewayForProfile,
   resumeStoredSession,
   seedMessages,
   selectedStoredSessionIdRef: selectedStoredSessionIdRefProp,
@@ -99,6 +100,12 @@ function Harness({
   openMemoryGraph?: () => void
   refreshSessions: () => Promise<void>
   requestGateway: <T>(method: string, params?: Record<string, unknown>) => Promise<T>
+  requestGatewayForProfile?: <T>(
+    profile: string,
+    method: string,
+    params?: Record<string, unknown>,
+    timeoutMs?: number
+  ) => Promise<T>
   resumeStoredSession?: (storedSessionId: string) => Promise<void> | void
   seedMessages?: unknown[]
   selectedStoredSessionIdRef?: MutableRefObject<string | null>
@@ -138,6 +145,7 @@ function Harness({
     openMemoryGraph: openMemoryGraph ?? (() => undefined),
     refreshSessions,
     requestGateway,
+    requestGatewayForProfile: requestGatewayForProfile ?? ((_, method, params) => requestGateway(method, params)),
     resumeStoredSession: resumeStoredSession ?? (() => undefined),
     selectedStoredSessionIdRef,
     startFreshSessionDraft: () => undefined,
@@ -601,6 +609,71 @@ describe('usePromptActions submit / queue drain semantics', () => {
     expect($busy.get()).toBe(false)
   })
 
+  it('a background queue drain with no runtime id resumes its stored session instead of using the foreground runtime', async () => {
+    $busy.set(false)
+
+    const calls: { method: string; params?: Record<string, unknown>; profile: string }[] = []
+    const recoveredBackgroundRuntimeId = 'rt-background-recovered'
+    const backgroundStoredSessionId = 'stored-background'
+    const backgroundProfile = 'background-profile'
+    const foregroundStoredSessionId = 'stored-foreground'
+    const resumeStoredSession = vi.fn()
+
+    const requestGateway = vi.fn(async () => {
+      throw new Error('foreground gateway must not serve a background-profile queue')
+    })
+
+    const requestGatewayForProfile = vi.fn(
+      async (profile: string, method: string, params?: Record<string, unknown>) => {
+        calls.push({ method, params, profile })
+
+        if (method === 'session.resume') {
+          return { session_id: recoveredBackgroundRuntimeId } as never
+        }
+
+        return {} as never
+      }
+    )
+
+    let handle: HarnessHandle | null = null
+    await actRender(
+      <Harness
+        getRoutedStoredSessionId={() => foregroundStoredSessionId}
+        getRuntimeIdForStoredSession={() => null}
+        onReady={h => (handle = h)}
+        refreshSessions={async () => undefined}
+        requestGateway={requestGateway}
+        requestGatewayForProfile={requestGatewayForProfile}
+        resumeStoredSession={resumeStoredSession}
+        storedSessionId={foregroundStoredSessionId}
+      />
+    )
+
+    const accepted = await handle!.submitText('resume queued background session', {
+      fromQueue: true,
+      profile: backgroundProfile,
+      sessionId: null,
+      storedSessionId: backgroundStoredSessionId
+    })
+
+    expect(accepted).toBe(true)
+    expect(calls).toEqual([
+      {
+        method: 'session.resume',
+        params: { session_id: backgroundStoredSessionId, source: 'desktop' },
+        profile: backgroundProfile
+      },
+      {
+        method: 'prompt.submit',
+        params: { session_id: recoveredBackgroundRuntimeId, text: 'resume queued background session' },
+        profile: backgroundProfile
+      }
+    ])
+    expect(requestGateway).not.toHaveBeenCalled()
+    expect(resumeStoredSession).not.toHaveBeenCalled()
+    expect(handle!.activeSessionIdRef.current).toBe(RUNTIME_SESSION_ID)
+  })
+
   it('a rejected fromQueue drain returns false (entry stays queued) and a later retry sends it', async () => {
     // A stale-session 404 must not strand the queued entry: submitPrompt returns
     // false on failure so the composer keeps it, and the edge-independent