fix(desktop): keep background chat signals behind the flag and to workspace chats

- Turn-complete notifications for chats in the background follow the
  background executor flag, so a flag-off user sees exactly what they saw
  before.
- Only a workspace chat's turn binds to a desktop. Its sidebar shows the
  status and an approval notification links back to it; an organization
  chat stays with its chat view.
- A desktop's status reads as running when Sim cannot track presence at all,
  not as blocked.
- "Running on <device>" shows in the chat row's tooltip. The status dot sits
  in the row's indicator slot, which takes no pointer and gives way to the
  row's actions on hover, so a tooltip on the dot itself could never open.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx

@@ -201,23 +201,19 @@ interface DesktopActivityDotProps {
   activity: DesktopChatActivity
 }
 
-/** The status of a chat one of the user's desktops is running in the background. */
+/**
+ * The status of a chat one of the user's desktops is running in the background. The row's
+ * indicator slot is pointer-inert and gives way to the row's actions on hover, so the label is
+ * read out here and shown in the row's own tooltip.
+ */
 function DesktopActivityDot({ activity }: DesktopActivityDotProps) {
-  const label = desktopActivityLabel(activity)
   return (
-    <Tooltip.Root>
-      <Tooltip.Trigger asChild>
-        <span
-          role='img'
-          aria-label={label}
-          className='size-[6px] rounded-full'
-          style={{ backgroundColor: DESKTOP_ACTIVITY_COLOR[activity.state] }}
-        />
-      </Tooltip.Trigger>
-      <Tooltip.Content>
-        <p>{label}</p>
-      </Tooltip.Content>
-    </Tooltip.Root>
+    <span
+      role='img'
+      aria-label={desktopActivityLabel(activity)}
+      className='size-[6px] rounded-full'
+      style={{ backgroundColor: DESKTOP_ACTIVITY_COLOR[activity.state] }}
+    />
   )
 }
 
@@ -280,7 +276,12 @@ const SidebarChatItem = memo(function SidebarChatItem({
   }
 
   return (
-    <SidebarTooltip label={chat.name} enabled={showCollapsedTooltips}>
+    <SidebarTooltip
+      label={
+        desktopActivity ? `${chat.name} · ${desktopActivityLabel(desktopActivity)}` : chat.name
+      }
+      enabled={showCollapsedTooltips || Boolean(desktopActivity)}
+    >
       <ChatNavigationLink
         chatId={chat.id}
         href={chat.href}
@@ -885,8 +886,12 @@ export const Sidebar = memo(function Sidebar({ organizationHref }: SidebarProps)
     { enabled: chatEnabled && !permissionConfig.hideCopilot }
   )
 
-  useMothershipChatEvents(workspaceId, chatEnabled && !permissionConfig.hideCopilot)
   const desktopExecutorEnabled = useFeatureFlag('mothership-desktop-background-executor')
+  useMothershipChatEvents(
+    workspaceId,
+    chatEnabled && !permissionConfig.hideCopilot,
+    desktopExecutorEnabled
+  )
   const { data: desktopActivity } = useDesktopActivity(
     workspaceId,
     desktopExecutorEnabled && chatEnabled && !permissionConfig.hideCopilot

apps/sim/hooks/use-mothership-chat-events.test.ts

@@ -295,7 +295,7 @@ describe('reflectBackgroundChatStatus', () => {
   it('announces a chat that finished in the background, and opens it from the notification', () => {
     showing('/workspace/ws-1/chat/chat-c')
 
-    reflectBackgroundChatStatus(queryClient, 'ws-1', completed)
+    reflectBackgroundChatStatus(queryClient, 'ws-1', completed, true)
 
     expect(notify).toHaveBeenCalledWith({
       title: 'Fix CI',
@@ -304,22 +304,31 @@ describe('reflectBackgroundChatStatus', () => {
     })
   })
 
+  it('announces nothing while the background executor is off', () => {
+    showing('/workspace/ws-1/chat/chat-c')
+
+    reflectBackgroundChatStatus(queryClient, 'ws-1', completed, false)
+
+    expect(notify).not.toHaveBeenCalled()
+  })
+
   it('leaves the chat on screen to announce itself', () => {
     showing('/workspace/ws-1/chat/chat-b')
 
-    reflectBackgroundChatStatus(queryClient, 'ws-1', completed)
+    reflectBackgroundChatStatus(queryClient, 'ws-1', completed, true)
 
     expect(notify).not.toHaveBeenCalled()
   })
 
   it('stays silent outside the desktop app and for a turn that only started', () => {
     showing('/workspace/ws-1/chat/chat-c', false)
-    reflectBackgroundChatStatus(queryClient, 'ws-1', completed)
+    reflectBackgroundChatStatus(queryClient, 'ws-1', completed, true)
     showing('/workspace/ws-1/chat/chat-c')
     reflectBackgroundChatStatus(
       queryClient,
       'ws-1',
-      JSON.stringify({ chatId: 'chat-b', type: 'started', streamId: 's-2' })
+      JSON.stringify({ chatId: 'chat-b', type: 'started', streamId: 's-2' }),
+      true
     )
 
     expect(notify).not.toHaveBeenCalled()
@@ -331,12 +340,14 @@ describe('reflectBackgroundChatStatus', () => {
     reflectBackgroundChatStatus(
       queryClient,
       'ws-1',
-      JSON.stringify({ chatId: 'chat-b', type: 'started', streamId: 's-3' })
+      JSON.stringify({ chatId: 'chat-b', type: 'started', streamId: 's-3' }),
+      true
     )
     reflectBackgroundChatStatus(
       queryClient,
       'ws-1',
-      JSON.stringify({ chatId: 'chat-b', type: 'renamed' })
+      JSON.stringify({ chatId: 'chat-b', type: 'renamed' }),
+      true
     )
 
     expect(queryClient.invalidateQueries).toHaveBeenCalledTimes(1)

apps/sim/hooks/use-mothership-chat-events.ts

@@ -1,4 +1,4 @@
-import { useEffect } from 'react'
+import { useEffect, useRef } from 'react'
 import { createLogger } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
 import type { QueryClient } from '@tanstack/react-query'
@@ -189,19 +189,21 @@ function chatRoute(owner: MothershipChatOwner, chatId: string): string {
 
 /**
  * Reflects a turn starting or ending in the chats that run in the background: the desktop
- * activity list changes, and a chat the user is not looking at that finished its turn is
- * announced. The desktop app decides whether to show that notification (notifications on, the
- * chat not on screen in the focused window); the chat on screen announces its own completion.
+ * activity list changes and, with `announceCompletions`, a chat the user is not looking at that
+ * finished its turn is announced. The desktop app decides whether to show that notification
+ * (notifications on, the chat not on screen in the focused window); the chat on screen announces
+ * its own completion.
  */
 export function reflectBackgroundChatStatus(
   queryClient: Pick<QueryClient, 'getQueryData' | 'invalidateQueries'>,
   owner: MothershipChatOwner,
-  data: unknown
+  data: unknown,
+  announceCompletions: boolean
 ): void {
   const payload = parseChatStatusEventPayload(data)
   if (payload?.type !== 'started' && payload?.type !== 'completed') return
   queryClient.invalidateQueries({ queryKey: desktopActivityKeys.lists() })
-  if (payload.type !== 'completed' || !payload.chatId) return
+  if (!announceCompletions || payload.type !== 'completed' || !payload.chatId) return
   const settings = getDesktopBridge()?.settings
   if (!settings) return
   const route = chatRoute(owner, payload.chatId)
@@ -229,9 +231,13 @@ export function reflectBackgroundChatStatus(
  */
 export function useMothershipChatEvents(
   owner: MothershipChatOwner | undefined,
-  chatEnabled: boolean
+  chatEnabled: boolean,
+  /** Announce chats that finish in the background; only with the background executor on. */
+  announceBackgroundCompletions = false
 ) {
   const queryClient = useQueryClient()
+  const announceRef = useRef(announceBackgroundCompletions)
+  announceRef.current = announceBackgroundCompletions
   const workspaceId = typeof owner === 'string' ? owner : undefined
   const organizationId = typeof owner === 'object' ? owner.organizationId : undefined
 
@@ -250,7 +256,7 @@ export function useMothershipChatEvents(
         task_status: (event) => {
           const data = event instanceof MessageEvent ? event.data : undefined
           handleMothershipChatStatusEvent(queryClient, eventOwner, data)
-          reflectBackgroundChatStatus(queryClient, eventOwner, data)
+          reflectBackgroundChatStatus(queryClient, eventOwner, data, announceRef.current)
         },
       },
       onOpen: (reason) => {

apps/sim/lib/desktop/application/activity.test.ts

@@ -0,0 +1,49 @@
+import { createSessionPrincipal } from '@sim/testing/factories/principal.factory'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { presence, rows } = vi.hoisted(() => ({
+  presence: { available: vi.fn(), present: vi.fn() },
+  rows: vi.fn(),
+}))
+
+vi.mock('@/lib/desktop/executor/presence', () => ({
+  isDesktopPresenceAvailable: presence.available,
+  isDesktopPresent: presence.present,
+}))
+vi.mock('@/lib/desktop/executor/repository', () => ({ listDesktopActivityRows: rows }))
+
+import { listDesktopActivity } from '@/lib/desktop/application/activity'
+
+const principal = createSessionPrincipal({ userId: 'user-1', sessionId: 'session-1' })
+
+describe('desktop activity presence', () => {
+  beforeEach(() => {
+    rows.mockResolvedValue([
+      { chatId: 'chat-1', deviceId: 'device-1', deviceName: 'Studio Mac', needsInput: false },
+    ])
+  })
+
+  it('does not call a desktop blocked when Sim cannot track presence at all', async () => {
+    presence.available.mockReturnValue(false)
+    presence.present.mockResolvedValue(false)
+
+    const { chats } = await listDesktopActivity.execute({
+      principal,
+      input: { workspaceId: 'ws-1' },
+    })
+
+    expect(chats).toEqual([{ chatId: 'chat-1', state: 'running', deviceName: 'Studio Mac' }])
+  })
+
+  it('calls a desktop blocked when presence is tracked and it is gone', async () => {
+    presence.available.mockReturnValue(true)
+    presence.present.mockResolvedValue(false)
+
+    const { chats } = await listDesktopActivity.execute({
+      principal,
+      input: { workspaceId: 'ws-1' },
+    })
+
+    expect(chats).toEqual([{ chatId: 'chat-1', state: 'blocked', deviceName: 'Studio Mac' }])
+  })
+})

apps/sim/lib/desktop/application/activity.ts

@@ -3,7 +3,7 @@ import { createLogger } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
 import { defineOperation } from '@/lib/core/application'
 import { defineAuthorizedCredentialUserUseCase } from '@/lib/credentials/application/authorized-user-use-case'
-import { isDesktopPresent } from '@/lib/desktop/executor/presence'
+import { isDesktopPresenceAvailable, isDesktopPresent } from '@/lib/desktop/executor/presence'
 import { listDesktopActivityRows } from '@/lib/desktop/executor/repository'
 
 const logger = createLogger('DesktopActivity')
@@ -21,8 +21,9 @@ export interface DesktopChatActivityEntry {
   deviceName: string
 }
 
-/** Presence Sim cannot read is not evidence of an offline desktop. */
+/** Presence Sim cannot read, or cannot track at all, is not evidence of an offline desktop. */
 async function readPresence(deviceId: string): Promise<boolean> {
+  if (!isDesktopPresenceAvailable()) return true
   try {
     return await isDesktopPresent(deviceId)
   } catch (error) {

apps/sim/lib/mothership/chat/application/admit-turn.test.ts

@@ -26,6 +26,7 @@ import { admitChatTurn } from '@/lib/mothership/chat/application/admit-turn'
 
 const hoisted = vi.hoisted(() => ({
   lease: vi.fn(),
+  resolveDesktop: vi.fn(),
 }))
 const mocks = {
   ...hoisted,
@@ -43,6 +44,9 @@ vi.mock('@/lib/mothership/request/session/controller-lease', () => ({
 vi.mock('@/lib/auth/ban', () => authBanMock)
 vi.mock('@/lib/permission-groups/resolve.server', () => permissionGroupsResolveMock)
 vi.mock('@/lib/mothership/chat-status', () => mothershipChatStatusMock)
+vi.mock('@/lib/desktop/application/executor', () => ({
+  resolveTurnDesktopDevice: hoisted.resolveDesktop,
+}))
 
 const principal = createSessionPrincipal({ userId: 'actor', sessionId: 'session' })
 const chatId = '11111111-1111-4111-8111-111111111111'
@@ -119,6 +123,25 @@ describe('organization turn admission through current private-chat authorization
       expect.anything()
     )
   })
+  it("keeps an organization chat's turn with its chat view, never on a desktop", async () => {
+    hoisted.resolveDesktop.mockResolvedValue('device-1')
+    queueTableRows(copilotChats, [chat])
+    queueTableRows(member, [{ role: 'member' }])
+    dbChainMockFns.returning
+      .mockResolvedValueOnce([{ model: null }])
+      .mockResolvedValueOnce([{ id: 'run-1', organizationId: 'org-1', workspaceId: null }])
+      .mockResolvedValueOnce([{ key: 'claim' }])
+
+    await admitChatTurn.execute({
+      principal,
+      input: { ...input(), desktopDeviceId: '33333333-3333-4333-8333-333333333333' },
+    })
+
+    expect(hoisted.resolveDesktop).not.toHaveBeenCalled()
+    expect(dbChainMockFns.values).toHaveBeenCalledWith(
+      expect.objectContaining({ organizationId: 'org-1', desktopDeviceId: null })
+    )
+  })
   it.each(['agent', 'assistant', 'plan'] as const)(
     'switches the same chat to %s atomically with turn admission',
     async (mode) => {

apps/sim/lib/mothership/chat/application/admit-turn.ts

@@ -86,9 +86,12 @@ export const admitChatTurn = defineAuthorizedChatUseCase({
       else await requireOrganizationSearchAvailable(organizationId)
     }
     await assertChatStreamLease(input.lease)
-    const desktopDeviceId = input.desktopDeviceId
-      ? await resolveTurnDesktopDevice(principal, input.desktopDeviceId)
-      : null
+    // Only a workspace chat runs on a desktop in the background: its sidebar shows the status and
+    // an approval notification links back to it. An organization chat stays with its chat view.
+    const desktopDeviceId =
+      input.desktopDeviceId && workspaceId
+        ? await resolveTurnDesktopDevice(principal, input.desktopDeviceId)
+        : null
     const turnConfig = sql`COALESCE(${copilotChats.config}, '{}'::jsonb) || jsonb_build_object('conversationMode', ${request.mode ?? 'agent'}::text)`
     return withRunAdmissionLock(userId, request.messageId, async (tx) => {
       const [chat] = await tx