From 433051f0bdb1115977b76cf29b12ba8f0c4c530c Mon Sep 17 00:00:00 2001
From: Waleed Latif <walif6@gmail.com>
Date: Mon, 5 Oct 2026 17:16:59 -0700
Subject: [PATCH 1/7] feat(desktop): show which chats a desktop runs in the
 background

Behind mothership-desktop-background-executor (resolved server-side and
passed through the workspace feature flags):

- GET /api/desktop/activity lists the caller's chats in a workspace whose
  turn runs on one of their desktops, as running, needs input (a call waits
  for approval) or blocked (that desktop is offline), with the device name.
- The sidebar marks those chats with a status dot whose tooltip reads
  "Running on <device>", "Needs input" or "Blocked: <device> is offline";
  unread replies keep the existing Ready dot.
- A chat view showing a turn a desktop runs in the background only displays
  its desktop calls and never executes them.
---
 apps/sim/app/api/desktop/activity/route.ts    |  20 ++
 .../components/composer/composer.test.tsx     |   3 +
 apps/sim/app/o/[organizationId]/layout.tsx    |   1 +
 .../hooks/stream/handle-tool-event.test.ts    |  54 +++++
 .../home/hooks/stream/handle-tool-event.ts    |  10 +
 .../home/hooks/stream/stream-test-helpers.ts  |   1 +
 .../app/workspace/[workspaceId]/layout.tsx    |   4 +
 .../providers/feature-flags-provider.tsx      |   1 +
 .../w/components/sidebar/sidebar.tsx          |  57 ++++-
 apps/sim/hooks/queries/desktop-activity.ts    |  41 ++++
 .../queries/utils/desktop-activity-keys.ts    |  24 +++
 .../sim/lib/api/contracts/desktop-executor.ts |  27 +++
 .../application/activity.integration.ts       | 200 ++++++++++++++++++
 apps/sim/lib/desktop/executor/repository.ts   |  51 +++++
 14 files changed, 492 insertions(+), 2 deletions(-)
 create mode 100644 apps/sim/app/api/desktop/activity/route.ts
 create mode 100644 apps/sim/hooks/queries/desktop-activity.ts
 create mode 100644 apps/sim/hooks/queries/utils/desktop-activity-keys.ts
 create mode 100644 apps/sim/lib/desktop/application/activity.integration.ts

diff --git a/apps/sim/app/api/desktop/activity/route.ts b/apps/sim/app/api/desktop/activity/route.ts
new file mode 100644
index 00000000000..176881de51e
--- /dev/null
+++ b/apps/sim/app/api/desktop/activity/route.ts
@@ -0,0 +1,20 @@
+import { listDesktopActivityContract } from '@/lib/api/contracts/desktop-executor'
+import { defineInternalJsonRoute, internalSessionAuth } from '@/lib/api/server/routes'
+import {
+  desktopExecutorErrorPolicy,
+  desktopExecutorRateLimit,
+} from '@/lib/api/server/routes/desktop-executor'
+import { listDesktopActivity } from '@/lib/desktop/application/executor'
+
+export const dynamic = 'force-dynamic'
+
+export const GET = defineInternalJsonRoute({
+  contract: listDesktopActivityContract,
+  auth: internalSessionAuth,
+  operation: listDesktopActivity.operation,
+  rateLimit: desktopExecutorRateLimit,
+  errorPolicy: desktopExecutorErrorPolicy,
+  mapInput: ({ query }) => ({ workspaceId: query.workspaceId }),
+  useCase: listDesktopActivity,
+  staticResponseHeaders: { 'Cache-Control': 'no-store' },
+})
diff --git a/apps/sim/app/o/[organizationId]/home/components/composer/composer.test.tsx b/apps/sim/app/o/[organizationId]/home/components/composer/composer.test.tsx
index aa1466b9499..e78a1c35fbe 100644
--- a/apps/sim/app/o/[organizationId]/home/components/composer/composer.test.tsx
+++ b/apps/sim/app/o/[organizationId]/home/components/composer/composer.test.tsx
@@ -235,6 +235,7 @@ async function render(
             'table-row-ttl': false,
             'mothership-model-selector': mocks.advanced,
             'mothership-plan-mode': mocks.plan,
+            'mothership-desktop-background-executor': false,
           }}
         >
           <Harness />
@@ -313,6 +314,7 @@ it.each([
               'table-row-ttl': false,
               'mothership-model-selector': false,
               'mothership-plan-mode': planEnabled,
+              'mothership-desktop-background-executor': false,
             }}
           >
             <Harness />
@@ -408,6 +410,7 @@ it('keeps restored queued skills scoped when replacing a draft', async () => {
             'table-row-ttl': false,
             'mothership-model-selector': mocks.advanced,
             'mothership-plan-mode': mocks.plan,
+            'mothership-desktop-background-executor': false,
           }}
         >
           <Harness />
diff --git a/apps/sim/app/o/[organizationId]/layout.tsx b/apps/sim/app/o/[organizationId]/layout.tsx
index 3ad21c07b64..14ea8b747ca 100644
--- a/apps/sim/app/o/[organizationId]/layout.tsx
+++ b/apps/sim/app/o/[organizationId]/layout.tsx
@@ -79,6 +79,7 @@ export default async function OrganizationLayout({
           'table-row-ttl': tableRowTtlEnabled,
           'mothership-model-selector': modelSelectorEnabled,
           'mothership-plan-mode': planModeEnabled,
+          'mothership-desktop-background-executor': false,
         }}
       >
         <OrganizationProvider context={context}>
diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.test.ts b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.test.ts
index 2b744ca9404..e6cdb6c72b5 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.test.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.test.ts
@@ -108,6 +108,60 @@ describe('tool events (dispatch → model + side effects)', () => {
     )
   })
 
+  it("only shows a desktop call when the chat's turn runs on a desktop in the background", () => {
+    const startClientBrowserTool = vi.fn()
+    const deps = makeStreamLoopDeps({ startClientBrowserTool, chatIdRef: ref('chat-1') })
+    vi.mocked(deps.queryClient.getQueryData).mockImplementation((key) =>
+      JSON.stringify(key) === JSON.stringify(['desktop-activity', 'list', 'ws-1'])
+        ? [{ chatId: 'chat-1', state: 'running', deviceName: 'MacBook' }]
+        : undefined
+    )
+    const ctx = createStreamLoopContext(deps)
+
+    dispatchStreamEvent(
+      ctx,
+      toolEnv({
+        phase: 'call',
+        executor: 'client',
+        mode: 'async',
+        toolCallId: 'click-1',
+        toolName: 'browser_click',
+        arguments: { ref: 'e1' },
+        status: 'executing',
+      })
+    )
+
+    expect(toolNode(ctx, 'click-1').status).toBe('running')
+    expect(startClientBrowserTool).not.toHaveBeenCalled()
+  })
+
+  it('runs a desktop call in the view when no desktop runs the chat in the background', () => {
+    const startClientBrowserTool = vi.fn()
+    const ctx = createStreamLoopContext(
+      makeStreamLoopDeps({ startClientBrowserTool, chatIdRef: ref('chat-1') })
+    )
+
+    dispatchStreamEvent(
+      ctx,
+      toolEnv({
+        phase: 'call',
+        executor: 'client',
+        mode: 'async',
+        toolCallId: 'click-2',
+        toolName: 'browser_click',
+        arguments: { ref: 'e1' },
+        status: 'executing',
+      })
+    )
+
+    expect(startClientBrowserTool).toHaveBeenCalledWith(
+      'click-2',
+      'browser_click',
+      { ref: 'e1' },
+      expect.anything()
+    )
+  })
+
   it('never starts a skipped terminal command', () => {
     const startClientTerminalTool = vi.fn()
     const ctx = createStreamLoopContext(makeStreamLoopDeps({ startClientTerminalTool }))
diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.ts b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.ts
index 154aac0dce4..61604f4d18e 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.ts
@@ -37,6 +37,7 @@ import { resolveFileResourceSelectionId } from '@/app/workspace/[workspaceId]/ho
 import { deploymentKeys } from '@/hooks/queries/deployments'
 import { oauthCredentialKeys } from '@/hooks/queries/oauth/oauth-credentials'
 import { workspaceCredentialKeys } from '@/hooks/queries/utils/credential-keys'
+import { isChatRunOnDesktop } from '@/hooks/queries/utils/desktop-activity-keys'
 import { folderKeys } from '@/hooks/queries/utils/folder-keys'
 import { invalidateWorkflowLists } from '@/hooks/queries/utils/invalidate-workflow-lists'
 import { invalidateSelectorQueries } from '@/hooks/queries/utils/selector-keys'
@@ -195,9 +196,18 @@ export function handleToolEvent(ctx: StreamLoopContext, parsed: ToolEvent): void
   const args = payload.arguments as Record<string, unknown> | undefined
   // Every client tailing the chat sees the call. A client without the desktop app leaves desktop
   // tools to it: its answer could only be an error, and that error would beat the real result.
+  // A turn running on a desktop's background executor belongs to that desktop: this view only shows it.
+  const runsInBackground =
+    isDesktopToolCall(name, args) &&
+    isChatRunOnDesktop(
+      deps.queryClient,
+      deps.workspaceId,
+      deps.options.targetChatId ?? deps.chatIdRef.current
+    )
   const shouldStartClientTool =
     isClientExecutedToolCall(name, args) &&
     (isDesktopApp() || !isDesktopToolCall(name, args)) &&
+    !runsInBackground &&
     !isPartial &&
     !deps.options.suppressedWorkflowToolStartIds?.has(rawId) &&
     node?.kind === 'tool' &&
diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/stream-test-helpers.ts b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/stream-test-helpers.ts
index 1f406a501e9..34e8c2a26dc 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/stream-test-helpers.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/stream-test-helpers.ts
@@ -25,6 +25,7 @@ export function makeStreamLoopDeps(overrides: Partial<StreamLoopDeps> = {}): Str
     queryClient: {
       invalidateQueries: vi.fn(),
       cancelQueries: vi.fn(),
+      getQueryData: vi.fn(),
       setQueryData: vi.fn(),
       // double-cast-allowed: minimal QueryClient stub for stream-loop unit fixtures
     } as unknown as QueryClient,
diff --git a/apps/sim/app/workspace/[workspaceId]/layout.tsx b/apps/sim/app/workspace/[workspaceId]/layout.tsx
index d9fcd6f9a9e..006daa63cfd 100644
--- a/apps/sim/app/workspace/[workspaceId]/layout.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/layout.tsx
@@ -5,6 +5,7 @@ import { SettingsNavigationProvider } from '@/components/settings/settings-navig
 import { getSession } from '@/lib/auth'
 import { getActiveOrganizationId } from '@/lib/auth/session-response'
 import { isDashboardsEnabled } from '@/lib/dashboards/feature-flag'
+import { isDesktopBackgroundExecutorEnabled } from '@/lib/desktop/executor/flag'
 import { isMothershipModelSelectorEnabled, isPlanModeEnabled } from '@/lib/mothership/feature-flags'
 import { resolveOrganizationEntryPath } from '@/lib/navigation/resolve-app-entry'
 import { isTableRowTtlEnabled } from '@/lib/table/ttl-availability'
@@ -67,6 +68,7 @@ export default async function WorkspaceLayout({
     planModeEnabled,
     organizationHref,
     dashboardsEnabled,
+    desktopBackgroundExecutorEnabled,
   ] = await Promise.all([
     cookies(),
     hostContext.hostOrganizationId
@@ -84,6 +86,7 @@ export default async function WorkspaceLayout({
     isPlanModeEnabled(),
     resolveOrganizationEntryPath(session),
     isDashboardsEnabled(hostContext.hostOrganizationId),
+    isDesktopBackgroundExecutorEnabled(session.user.id),
     prefetchWorkspaceAccess(queryClient, workspaceId, principal),
     prefetchWorkspaceForkAvailability(queryClient, workspaceId, principal, hostContext),
   ])
@@ -97,6 +100,7 @@ export default async function WorkspaceLayout({
           'table-row-ttl': tableRowTtlEnabled,
           'mothership-model-selector': modelSelectorEnabled,
           'mothership-plan-mode': planModeEnabled,
+          'mothership-desktop-background-executor': desktopBackgroundExecutorEnabled,
         }}
       >
         <WorkspaceHostProvider workspaceId={workspaceId} initialContext={hostContext}>
diff --git a/apps/sim/app/workspace/[workspaceId]/providers/feature-flags-provider.tsx b/apps/sim/app/workspace/[workspaceId]/providers/feature-flags-provider.tsx
index d27ba042643..ac6eb96fcae 100644
--- a/apps/sim/app/workspace/[workspaceId]/providers/feature-flags-provider.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/providers/feature-flags-provider.tsx
@@ -7,6 +7,7 @@ export interface WorkspaceFeatureFlags {
   'table-row-ttl': boolean
   'mothership-model-selector': boolean
   'mothership-plan-mode': boolean
+  'mothership-desktop-background-executor': boolean
 }
 
 const FeatureFlagsContext = createContext<WorkspaceFeatureFlags | null>(null)
diff --git a/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx b/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx
index 683439f271b..f2b3e927899 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx
@@ -41,6 +41,7 @@ import {
 import { createLogger } from '@sim/logger'
 import { useParams, usePathname, useRouter } from 'next/navigation'
 import { usePostHog } from 'posthog-js/react'
+import type { DesktopChatActivity } from '@/lib/api/contracts/desktop-executor'
 import { useSession } from '@/lib/auth/auth-client'
 import { canViewWorkspaceBillingSettings } from '@/lib/billing/workspace-permissions'
 import { focusVisibleBrowserOmnibox } from '@/lib/browser-agent/renderer-shortcuts'
@@ -123,6 +124,7 @@ import { useImportWorkflow } from '@/app/workspace/[workspaceId]/w/hooks'
 import { useCustomBlockOverlayVersion } from '@/blocks/custom/client-overlay'
 import { useWorkspaceAccessRequestFeatures } from '@/ee/access-requests/components/permission-access-boundary'
 import { useWorkspaceCredentials } from '@/hooks/queries/credentials'
+import { useDesktopActivity } from '@/hooks/queries/desktop-activity'
 import { useFolderMap, useFolders } from '@/hooks/queries/folders'
 import { type LogFilters, useLogsList } from '@/hooks/queries/logs'
 import type { MothershipChatMetadata } from '@/hooks/queries/mothership-chats'
@@ -183,6 +185,42 @@ const SEARCH_MODAL_DATE_FORMAT = new Intl.DateTimeFormat(undefined, {
   minute: '2-digit',
 })
 
+const DESKTOP_ACTIVITY_COLOR: Record<DesktopChatActivity['state'], string> = {
+  running: '#EAB308',
+  needs_input: '#F97316',
+  blocked: 'var(--text-error)',
+}
+
+function desktopActivityLabel({ state, deviceName }: DesktopChatActivity): string {
+  if (state === 'needs_input') return 'Needs input'
+  if (state === 'blocked') return `Blocked: ${deviceName} is offline`
+  return `Running on ${deviceName}`
+}
+
+interface DesktopActivityDotProps {
+  activity: DesktopChatActivity
+}
+
+/** The status of a chat one of the user's desktops is running in the background. */
+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>
+  )
+}
+
 const SidebarChatItem = memo(function SidebarChatItem({
   chat,
   isCurrentRoute,
@@ -190,6 +228,7 @@ const SidebarChatItem = memo(function SidebarChatItem({
   isActive,
   isUnread,
   isPinned,
+  desktopActivity,
   isMenuOpen,
   showCollapsedTooltips,
   onMultiSelectClick,
@@ -203,6 +242,8 @@ const SidebarChatItem = memo(function SidebarChatItem({
   isActive: boolean
   isUnread: boolean
   isPinned: boolean
+  /** Set while one of the user's desktops runs this chat's turn in the background. */
+  desktopActivity?: DesktopChatActivity
   isMenuOpen: boolean
   showCollapsedTooltips: boolean
   onMultiSelectClick: (chatId: string, shiftKey: boolean) => void
@@ -217,7 +258,7 @@ const SidebarChatItem = memo(function SidebarChatItem({
    * transient state (a run in progress, or an unread reply elsewhere), while pinning
    * is persistent and already conveyed by the row sorting to the top of the list.
    */
-  const showStatusDot = isActive || (!isCurrentRoute && isUnread)
+  const showStatusDot = Boolean(desktopActivity) || isActive || (!isCurrentRoute && isUnread)
 
   function handleDragStart(e: React.DragEvent) {
     e.dataTransfer.effectAllowed = 'copyMove'
@@ -262,7 +303,9 @@ const SidebarChatItem = memo(function SidebarChatItem({
           <RowActions
             open={isMenuOpen}
             indicator={
-              showStatusDot ? (
+              desktopActivity ? (
+                <DesktopActivityDot activity={desktopActivity} />
+              ) : showStatusDot ? (
                 <span
                   aria-hidden='true'
                   className='size-[6px] rounded-full'
@@ -843,6 +886,15 @@ export const Sidebar = memo(function Sidebar({ organizationHref }: SidebarProps)
   )
 
   useMothershipChatEvents(workspaceId, chatEnabled && !permissionConfig.hideCopilot)
+  const desktopExecutorEnabled = useFeatureFlag('mothership-desktop-background-executor')
+  const { data: desktopActivity } = useDesktopActivity(
+    workspaceId,
+    desktopExecutorEnabled && chatEnabled && !permissionConfig.hideCopilot
+  )
+  const desktopActivityByChat = useMemo(
+    () => new Map((desktopActivity ?? []).map((activity) => [activity.chatId, activity])),
+    [desktopActivity]
+  )
 
   /**
    * Stays empty when Chat is disabled, which also drops the command palette's
@@ -1537,6 +1589,7 @@ export const Sidebar = memo(function Sidebar({ organizationHref }: SidebarProps)
                                       isActive={!!chat.isActive}
                                       isUnread={!!chat.isUnread}
                                       isPinned={!!chat.isPinned}
+                                      desktopActivity={desktopActivityByChat.get(chat.id)}
                                       isMenuOpen={menuOpenChatId === chat.id}
                                       showCollapsedTooltips={showCollapsedTooltips}
                                       onMultiSelectClick={handleChatClick}
diff --git a/apps/sim/hooks/queries/desktop-activity.ts b/apps/sim/hooks/queries/desktop-activity.ts
new file mode 100644
index 00000000000..a583838ab88
--- /dev/null
+++ b/apps/sim/hooks/queries/desktop-activity.ts
@@ -0,0 +1,41 @@
+'use client'
+
+import { keepPreviousData, useQuery } from '@tanstack/react-query'
+import { requestJson } from '@/lib/api/client/request'
+import {
+  type DesktopChatActivity,
+  listDesktopActivityContract,
+} from '@/lib/api/contracts/desktop-executor'
+import { desktopActivityKeys } from '@/hooks/queries/utils/desktop-activity-keys'
+
+const DESKTOP_ACTIVITY_STALE_TIME = 10 * 1000
+/**
+ * Presence, approvals and new background turns change without a chat event this query hears, so
+ * it is re-read on a timer: often while a desktop runs a chat, rarely otherwise. Only users in the
+ * executor's rollout ever run it.
+ */
+const DESKTOP_ACTIVITY_ACTIVE_REFETCH_MS = 15 * 1000
+const DESKTOP_ACTIVITY_IDLE_REFETCH_MS = 30 * 1000
+
+async function fetchDesktopActivity(
+  workspaceId: string,
+  signal?: AbortSignal
+): Promise<DesktopChatActivity[]> {
+  const data = await requestJson(listDesktopActivityContract, { query: { workspaceId }, signal })
+  return data.chats
+}
+
+/** The user's chats in this workspace whose turn runs on one of their desktops. */
+export function useDesktopActivity(workspaceId: string | undefined, enabled: boolean) {
+  return useQuery({
+    queryKey: desktopActivityKeys.list(workspaceId),
+    queryFn: ({ signal }) => fetchDesktopActivity(workspaceId as string, signal),
+    enabled: Boolean(workspaceId) && enabled,
+    staleTime: DESKTOP_ACTIVITY_STALE_TIME,
+    refetchInterval: (query) =>
+      query.state.data?.length
+        ? DESKTOP_ACTIVITY_ACTIVE_REFETCH_MS
+        : DESKTOP_ACTIVITY_IDLE_REFETCH_MS,
+    placeholderData: keepPreviousData,
+  })
+}
diff --git a/apps/sim/hooks/queries/utils/desktop-activity-keys.ts b/apps/sim/hooks/queries/utils/desktop-activity-keys.ts
new file mode 100644
index 00000000000..9b7de7fddc7
--- /dev/null
+++ b/apps/sim/hooks/queries/utils/desktop-activity-keys.ts
@@ -0,0 +1,24 @@
+import type { QueryClient } from '@tanstack/react-query'
+import type { DesktopChatActivity } from '@/lib/api/contracts/desktop-executor'
+
+export const desktopActivityKeys = {
+  all: ['desktop-activity'] as const,
+  lists: () => [...desktopActivityKeys.all, 'list'] as const,
+  list: (workspaceId?: string) => [...desktopActivityKeys.lists(), workspaceId ?? ''] as const,
+}
+
+/**
+ * Whether one of the user's desktops is running this chat's turn in the background, read from
+ * the cached activity list. Its calls then belong to that desktop; the chat view only shows them.
+ */
+export function isChatRunOnDesktop(
+  queryClient: QueryClient,
+  workspaceId: string | undefined,
+  chatId: string | undefined
+): boolean {
+  if (!workspaceId || !chatId) return false
+  const chats = queryClient.getQueryData<DesktopChatActivity[]>(
+    desktopActivityKeys.list(workspaceId)
+  )
+  return chats?.some((chat) => chat.chatId === chatId) ?? false
+}
diff --git a/apps/sim/lib/api/contracts/desktop-executor.ts b/apps/sim/lib/api/contracts/desktop-executor.ts
index 5d03116954e..07c8c2d865d 100644
--- a/apps/sim/lib/api/contracts/desktop-executor.ts
+++ b/apps/sim/lib/api/contracts/desktop-executor.ts
@@ -1,5 +1,6 @@
 import { z } from 'zod'
 import { desktopToolCallIdSchema } from '@/lib/api/contracts/desktop-tool-authorization'
+import { workspaceIdSchema } from '@/lib/api/contracts/primitives'
 import { defineRouteContract } from '@/lib/api/contracts/types'
 
 /**
@@ -182,3 +183,29 @@ export const completeDesktopToolContract = defineRouteContract({
   response: { mode: 'json', schema: completeDesktopToolResponseSchema },
   error: z.object({ error: z.string() }),
 })
+
+const desktopActivityQuerySchema = z.object({ workspaceId: workspaceIdSchema })
+
+/**
+ * `running`: the desktop is working on the chat. `needs_input`: a call waits for the user's
+ * approval in the chat. `blocked`: the desktop the chat runs on is offline.
+ */
+const desktopChatActivitySchema = z.object({
+  chatId: z.string().min(1),
+  state: z.enum(['running', 'needs_input', 'blocked']),
+  deviceName: z.string(),
+})
+export type DesktopChatActivity = z.output<typeof desktopChatActivitySchema>
+
+const desktopActivityResponseSchema = z.object({
+  chats: z.array(desktopChatActivitySchema),
+})
+
+/** The caller's chats in a workspace whose turn is running on one of their desktops. */
+export const listDesktopActivityContract = defineRouteContract({
+  method: 'GET',
+  path: '/api/desktop/activity',
+  query: desktopActivityQuerySchema,
+  response: { mode: 'json', schema: desktopActivityResponseSchema },
+  error: z.object({ error: z.string() }),
+})
diff --git a/apps/sim/lib/desktop/application/activity.integration.ts b/apps/sim/lib/desktop/application/activity.integration.ts
new file mode 100644
index 00000000000..2048405cba2
--- /dev/null
+++ b/apps/sim/lib/desktop/application/activity.integration.ts
@@ -0,0 +1,200 @@
+/**
+ * Background desktop activity against real PostgreSQL and Redis: which of a user's chats a desktop
+ * runs, and whether each is running, waiting on the user's approval, or blocked by an offline desktop.
+ */
+import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { redisUrl } = await vi.hoisted(async () => {
+  const { readTestRedisUrl } = await import('@sim/db/testing/test-infrastructure')
+  const url = readTestRedisUrl()
+  /** The real Redis module and the tool-permission switch read these at import. */
+  if (url) process.env.REDIS_URL = url
+  process.env.COPILOT_TOOL_PERMISSIONS_ENABLED = 'true'
+  return { redisUrl: url }
+})
+
+vi.mock('@/lib/core/config/feature-flags', () => featureFlagsMock)
+
+import type { SessionPrincipal } from '@sim/auth/principal'
+import { db } from '@sim/db'
+import {
+  copilotAsyncToolCalls,
+  copilotChats,
+  desktopDevices,
+  session,
+  user,
+  workspace,
+} from '@sim/db/schema'
+import { featureFlagsMock, featureFlagsMockFns } from '@sim/testing/mocks/feature-flags.mock'
+import { generateId } from '@sim/utils/id'
+import { inArray } from 'drizzle-orm'
+import { closeRedisConnection } from '@/lib/core/config/redis'
+import {
+  listDesktopActivity,
+  openDesktopInboxStream,
+  registerDesktopDevice,
+} from '@/lib/desktop/application/executor'
+import { isDesktopPresent } from '@/lib/desktop/executor/presence'
+import { createRunSegment } from '@/lib/mothership/async-runs/repository'
+
+afterAll(async () => {
+  await closeRedisConnection()
+})
+
+describe.runIf(Boolean(redisUrl))('background desktop activity', () => {
+  const userIds: string[] = []
+  const workspaceIds: string[] = []
+  const deviceIds: string[] = []
+
+  beforeEach(() => {
+    featureFlagsMockFns.mockIsFeatureEnabled.mockResolvedValue(true)
+  })
+
+  afterAll(async () => {
+    if (workspaceIds.length) await db.delete(workspace).where(inArray(workspace.id, workspaceIds))
+    if (deviceIds.length)
+      await db.delete(desktopDevices).where(inArray(desktopDevices.id, deviceIds))
+    if (userIds.length) await db.delete(user).where(inArray(user.id, userIds))
+  })
+
+  async function signedInDesktop() {
+    const userId = generateId()
+    const workspaceId = generateId()
+    const sessionId = generateId()
+    const deviceId = generateId()
+    const now = new Date()
+    userIds.push(userId)
+    workspaceIds.push(workspaceId)
+    deviceIds.push(deviceId)
+    await db.insert(user).values({
+      id: userId,
+      name: 'Desktop activity fixture',
+      email: `${userId}@desktop-activity.test`,
+      emailVerified: true,
+      createdAt: now,
+      updatedAt: now,
+    })
+    await db.insert(workspace).values({
+      id: workspaceId,
+      name: 'Desktop activity fixture',
+      ownerId: userId,
+      billedAccountUserId: userId,
+    })
+    await db.insert(session).values({
+      id: sessionId,
+      userId,
+      token: generateId(),
+      expiresAt: new Date(now.getTime() + 3_600_000),
+      createdAt: now,
+      updatedAt: now,
+    })
+    const principal: SessionPrincipal = { kind: 'session', userId, sessionId }
+    await registerDesktopDevice.execute({
+      principal,
+      input: {
+        deviceId,
+        name: 'Studio Mac',
+        appVersion: '0.9.0',
+        platform: 'darwin-arm64',
+        capabilities: { executor: 1, browser: true, terminal: true, localFiles: true },
+      },
+    })
+    return { userId, workspaceId, principal, deviceId }
+  }
+
+  async function chatWithRun(
+    owner: { userId: string; workspaceId: string },
+    deviceId: string | null,
+    status: 'active' | 'complete' = 'active'
+  ) {
+    const chatId = generateId()
+    await db.insert(copilotChats).values({
+      id: chatId,
+      userId: owner.userId,
+      workspaceId: owner.workspaceId,
+      type: 'mothership',
+    })
+    const run = await createRunSegment({
+      executionId: generateId(),
+      chatId,
+      userId: owner.userId,
+      workspaceId: owner.workspaceId,
+      streamId: generateId(),
+      status,
+      desktopDeviceId: deviceId,
+    })
+    return { chatId, runId: run.id }
+  }
+
+  it('reports running, needs input and blocked for the chats a desktop runs', async () => {
+    const desktop = await signedInDesktop()
+    const running = await chatWithRun(desktop, desktop.deviceId)
+    const waiting = await chatWithRun(desktop, desktop.deviceId)
+    await db.insert(copilotAsyncToolCalls).values({
+      runId: waiting.runId,
+      toolCallId: generateId(),
+      toolName: 'terminal',
+      args: { operation: 'run', command: 'npm publish' },
+    })
+    await chatWithRun(desktop, null)
+    await chatWithRun(desktop, desktop.deviceId, 'complete')
+
+    expect(
+      (
+        await listDesktopActivity.execute({
+          principal: desktop.principal,
+          input: { workspaceId: desktop.workspaceId },
+        })
+      ).chats
+    ).toEqual(
+      expect.arrayContaining([
+        { chatId: running.chatId, state: 'blocked', deviceName: 'Studio Mac' },
+        { chatId: waiting.chatId, state: 'needs_input', deviceName: 'Studio Mac' },
+      ])
+    )
+
+    const stream = await openDesktopInboxStream.execute({
+      principal: desktop.principal,
+      input: { deviceId: desktop.deviceId },
+    })
+    const close = stream.subscribe(() => {})
+    try {
+      await expect.poll(() => isDesktopPresent(desktop.deviceId)).toBe(true)
+      const { chats } = await listDesktopActivity.execute({
+        principal: desktop.principal,
+        input: { workspaceId: desktop.workspaceId },
+      })
+      expect(chats).toHaveLength(2)
+      expect(chats).toEqual(
+        expect.arrayContaining([
+          { chatId: running.chatId, state: 'running', deviceName: 'Studio Mac' },
+          { chatId: waiting.chatId, state: 'needs_input', deviceName: 'Studio Mac' },
+        ])
+      )
+    } finally {
+      close()
+    }
+  })
+
+  it("never reports another user's chats, or chats in another workspace", async () => {
+    const desktop = await signedInDesktop()
+    const other = await signedInDesktop()
+    await chatWithRun(other, other.deviceId)
+    const elsewhere = await signedInDesktop()
+    await chatWithRun(
+      { userId: desktop.userId, workspaceId: elsewhere.workspaceId },
+      desktop.deviceId
+    )
+
+    const { chats } = await listDesktopActivity.execute({
+      principal: desktop.principal,
+      input: { workspaceId: desktop.workspaceId },
+    })
+    expect(chats).toEqual([])
+    const { chats: otherWorkspace } = await listDesktopActivity.execute({
+      principal: other.principal,
+      input: { workspaceId: elsewhere.workspaceId },
+    })
+    expect(otherWorkspace).toEqual([])
+  })
+})
diff --git a/apps/sim/lib/desktop/executor/repository.ts b/apps/sim/lib/desktop/executor/repository.ts
index d5e478b67b3..d19f54799c4 100644
--- a/apps/sim/lib/desktop/executor/repository.ts
+++ b/apps/sim/lib/desktop/executor/repository.ts
@@ -442,3 +442,54 @@ export async function listOverdueDesktopToolCalls(input: { slackMs: number; limi
     .limit(input.limit)
   return rows.map((row) => row.toolCallId)
 }
+
+/**
+ * The caller's live device-bound runs in a workspace, newest first, with each run's calls that
+ * are still waiting to be offered (the ones that may be held for approval).
+ */
+export async function listDesktopActivityRows(input: { userId: string; workspaceId: string }) {
+  const runs = await db
+    .select({
+      runId: copilotRuns.id,
+      chatId: copilotRuns.chatId,
+      deviceId: desktopDevices.id,
+      deviceName: desktopDevices.name,
+    })
+    .from(copilotRuns)
+    .innerJoin(desktopDevices, eq(desktopDevices.id, copilotRuns.desktopDeviceId))
+    .where(
+      and(
+        eq(copilotRuns.userId, input.userId),
+        eq(copilotRuns.workspaceId, input.workspaceId),
+        isNotNull(copilotRuns.desktopDeviceId),
+        sql`${copilotRuns.startedAt} > now() - make_interval(hours => ${DESKTOP_INBOX_HORIZON_HOURS})`,
+        inArray(copilotRuns.status, LIVE_RUN_STATUSES),
+        isNull(copilotRuns.toolAdmissionClosedAt)
+      )
+    )
+    .orderBy(sql`${copilotRuns.startedAt} DESC`)
+    .limit(INBOX_ROW_LIMIT)
+  if (runs.length === 0) return []
+  const waiting = await db
+    .select({
+      runId: copilotAsyncToolCalls.runId,
+      toolName: copilotAsyncToolCalls.toolName,
+      args: copilotAsyncToolCalls.args,
+    })
+    .from(copilotAsyncToolCalls)
+    .where(
+      and(
+        inArray(
+          copilotAsyncToolCalls.runId,
+          runs.map((run) => run.runId)
+        ),
+        eq(copilotAsyncToolCalls.status, ASYNC_TOOL_STATUS.pending),
+        isNull(copilotAsyncToolCalls.permissionDecision),
+        isNull(copilotAsyncToolCalls.executionLeaseExpiresAt)
+      )
+    )
+  return runs.map((run) => ({
+    ...run,
+    waitingCalls: waiting.filter((call) => call.runId === run.runId),
+  }))
+}

From 69c4dfb3de7b6001861f2034cc85e984bb166905 Mon Sep 17 00:00:00 2001
From: Waleed Latif <walif6@gmail.com>
Date: Mon, 5 Oct 2026 23:37:10 -0700
Subject: [PATCH 2/7] fix(desktop): learn a turn's executor from its stream and
 announce background chats

Builds on the background activity commit, against the final binding contract.

- Display only, deterministically. Sim marks a turn its desktop's executor runs
  on the stream that serves it: a response header on the send and on every
  reconnect, and a flag on the replay batch a reload attaches with. The chat
  view only shows that turn's desktop calls and never starts or reports them.
  This replaces reading the cached activity list, which a new turn's first call
  could beat.
- Needs input comes from the durable record: a call Sim asked the user about and
  they have not answered, or a running terminal handoff or browser takeover.
  An auto-allowed command no longer reads as needing input. Presence Sim cannot
  read is not reported as offline.
- Turn-complete notifications for chats in the background: a chat that finishes
  while the user is elsewhere is announced and opens on click; the chat on
  screen announces itself as before. "Notify only for chats in the background"
  (the existing default) now means exactly that, so a background chat is
  announced even while Sim is focused.
- The activity list refreshes when a turn starts or ends.
---
 .../desktop/src/main/desktop-settings.test.ts |  77 ++++++++++
 apps/desktop/src/main/desktop-settings.ts     |  21 ++-
 .../stream/desktop-executor.integration.ts    | 134 ++++++++++++++++++
 apps/sim/app/api/copilot/chat/stream/route.ts |  14 +-
 apps/sim/app/api/desktop/activity/route.ts    |   2 +-
 .../home/hooks/stream-protocol.ts             |   3 +
 .../hooks/stream/handle-tool-event.test.ts    |  54 ++++---
 .../home/hooks/stream/handle-tool-event.ts    |  15 +-
 .../home/hooks/stream/stream-context.ts       |   5 +
 .../home/hooks/stream/stream-test-helpers.ts  |   1 -
 .../[workspaceId]/home/hooks/use-chat.ts      |   9 ++
 .../settings/components/desktop/desktop.tsx   |   2 +-
 .../w/components/sidebar/sidebar.tsx          |   2 +-
 .../queries/utils/desktop-activity-keys.ts    |  19 ---
 .../hooks/use-mothership-chat-events.test.ts  |  73 ++++++++++
 apps/sim/hooks/use-mothership-chat-events.ts  |  51 ++++++-
 .../application/activity.integration.ts       |  58 +++++++-
 apps/sim/lib/desktop/application/activity.ts  |  72 ++++++++++
 apps/sim/lib/desktop/executor/repository.ts   |  40 ++++--
 apps/sim/lib/mothership/chat/post.ts          |   9 +-
 apps/sim/lib/mothership/constants.ts          |   6 +
 21 files changed, 582 insertions(+), 85 deletions(-)
 create mode 100644 apps/desktop/src/main/desktop-settings.test.ts
 create mode 100644 apps/sim/app/api/copilot/chat/stream/desktop-executor.integration.ts
 create mode 100644 apps/sim/lib/desktop/application/activity.ts

diff --git a/apps/desktop/src/main/desktop-settings.test.ts b/apps/desktop/src/main/desktop-settings.test.ts
new file mode 100644
index 00000000000..8fa53111c66
--- /dev/null
+++ b/apps/desktop/src/main/desktop-settings.test.ts
@@ -0,0 +1,77 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('electron', () => import('@/test/electron-mock'))
+
+import type { BrowserWindow } from 'electron'
+import { createDesktopSettingsService } from '@/main/desktop-settings'
+import { Notification } from '@/test/electron-mock'
+
+function service(window: { url: string; focused: boolean } | null) {
+  const config = new Map<string, unknown>()
+  return createDesktopSettingsService({
+    config: {
+      get: (key: string) => config.get(key),
+      set: (key: string, value: unknown) => config.set(key, value),
+      flush: () => true,
+    } as never,
+    getMainWindow: () =>
+      window
+        ? ({
+            isFocused: () => window.focused,
+            webContents: { getURL: () => window.url },
+          } as unknown as BrowserWindow)
+        : null,
+    openMainWindowAt: vi.fn(),
+    setAutoDownloadUpdates: vi.fn(),
+    setTrayEnabled: vi.fn(),
+    setBrowserEnabled: vi.fn(),
+    setTerminalEnabled: vi.fn(),
+    setBrowserTheme: vi.fn(),
+    setBrowserDefaultZoom: vi.fn(),
+    setTerminalDefaultZoom: vi.fn(),
+    getDefaultBrowserDownloadDirectory: () => '/tmp',
+    chooseBrowserDownloadDirectory: async () => null,
+  })
+}
+
+const BACKGROUND_CHAT = '/workspace/ws-1/chat/chat-b'
+
+describe('desktop notifications in the default "background only" mode', () => {
+  beforeEach(() => {
+    Notification.instances.length = 0
+  })
+
+  it('announces a chat in the background while the user works in another one', () => {
+    const shown = service({
+      url: 'https://sim.ai/workspace/ws-1/chat/chat-c',
+      focused: true,
+    }).notify({
+      title: 'Fix CI',
+      body: 'Sim finished responding.',
+      route: BACKGROUND_CHAT,
+    })
+
+    expect(shown).toBe(true)
+    expect(Notification.instances).toHaveLength(1)
+  })
+
+  it('stays quiet about the chat the focused window shows', () => {
+    const shown = service({ url: `https://sim.ai${BACKGROUND_CHAT}`, focused: true }).notify({
+      title: 'Fix CI',
+      body: 'Sim finished responding.',
+      route: BACKGROUND_CHAT,
+    })
+
+    expect(shown).toBe(false)
+    expect(Notification.instances).toHaveLength(0)
+  })
+
+  it('stays quiet about the app as a whole while it is focused', () => {
+    const shown = service({ url: 'https://sim.ai/workspace/ws-1/home', focused: true }).notify({
+      title: 'Update ready',
+      body: 'Restart to update.',
+    })
+
+    expect(shown).toBe(false)
+  })
+})
diff --git a/apps/desktop/src/main/desktop-settings.ts b/apps/desktop/src/main/desktop-settings.ts
index 7f25296b99b..4367109eb08 100644
--- a/apps/desktop/src/main/desktop-settings.ts
+++ b/apps/desktop/src/main/desktop-settings.ts
@@ -105,6 +105,21 @@ function readPreferences(
   }
 }
 
+/**
+ * Whether a focused window already shows what a notification is about. One without a route is
+ * about the app as a whole, which a focused window always shows; one about a chat is news only
+ * while that chat is in the background.
+ */
+function showsRoute(window: BrowserWindow, route: string | undefined): boolean {
+  if (!route) return true
+  try {
+    const shown = new URL(window.webContents.getURL()).pathname
+    return shown === new URL(route, 'https://sim.invalid').pathname
+  } catch {
+    return false
+  }
+}
+
 /**
  * Owns device preferences and their native side effects. Renderer code can
  * request a change, but only this main-process service touches login items,
@@ -203,7 +218,11 @@ export function createDesktopSettingsService(
         return false
       }
       const window = deps.getMainWindow()
-      if (preferences.notificationsOnlyWhenUnfocused && window?.isFocused()) {
+      if (
+        preferences.notificationsOnlyWhenUnfocused &&
+        window?.isFocused() &&
+        showsRoute(window, payload.route)
+      ) {
         return false
       }
 
diff --git a/apps/sim/app/api/copilot/chat/stream/desktop-executor.integration.ts b/apps/sim/app/api/copilot/chat/stream/desktop-executor.integration.ts
new file mode 100644
index 00000000000..2a0bb1c84bd
--- /dev/null
+++ b/apps/sim/app/api/copilot/chat/stream/desktop-executor.integration.ts
@@ -0,0 +1,134 @@
+/**
+ * A chat view learns from the stream it reads whether the desktop app's background executor runs
+ * the turn's desktop tools, so it only shows those calls. Exercised against real PostgreSQL and
+ * Redis through the production reconnect route, for the live tail and the replay batch a view
+ * attaches with after a reload.
+ */
+import { authMock, authMockFns } from '@sim/testing/mocks/auth.mock'
+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
+
+const { redisUrl } = await vi.hoisted(async () => {
+  const { readTestRedisUrl } = await import('@sim/db/testing/test-infrastructure')
+  const url = readTestRedisUrl()
+  if (url) process.env.REDIS_URL = url
+  return { redisUrl: url }
+})
+
+vi.mock('@/lib/auth', () => authMock)
+
+import { db } from '@sim/db'
+import {
+  copilotChats,
+  copilotRuns,
+  desktopDevices,
+  permissions,
+  user,
+  workspace,
+} from '@sim/db/schema'
+import { generateId } from '@sim/utils/id'
+import { eq } from 'drizzle-orm'
+import { NextRequest } from 'next/server'
+import { closeRedisConnection } from '@/lib/core/config/redis'
+import { MOTHERSHIP_DESKTOP_EXECUTOR_HEADER } from '@/lib/mothership/constants'
+import { GET as streamGET } from '@/app/api/copilot/chat/stream/route'
+
+const userId = generateId()
+const workspaceId = generateId()
+const chatId = generateId()
+const deviceId = generateId()
+
+async function finishedRun(desktopDeviceId: string | null): Promise<string> {
+  const streamId = generateId()
+  await db.insert(copilotRuns).values({
+    id: generateId(),
+    executionId: generateId(),
+    chatId,
+    userId,
+    workspaceId,
+    streamId,
+    status: 'complete',
+    desktopDeviceId,
+  })
+  return streamId
+}
+
+function reconnect(streamId: string, batch: boolean) {
+  return streamGET(
+    new NextRequest(
+      `http://localhost:3000/api/copilot/chat/stream?streamId=${streamId}&after=0${batch ? '&batch=true' : ''}`
+    ),
+    { params: Promise.resolve({}) }
+  )
+}
+
+describe.runIf(Boolean(redisUrl))('desktop executor binding on a chat stream', () => {
+  beforeAll(async () => {
+    const now = new Date()
+    await db.insert(user).values({
+      id: userId,
+      name: 'Desktop stream fixture',
+      email: `${userId}@desktop-stream.test`,
+      emailVerified: true,
+      createdAt: now,
+      updatedAt: now,
+    })
+    await db.insert(workspace).values({
+      id: workspaceId,
+      name: 'Desktop stream fixture',
+      ownerId: userId,
+      billedAccountUserId: userId,
+    })
+    await db.insert(permissions).values({
+      id: generateId(),
+      userId,
+      entityType: 'workspace',
+      entityId: workspaceId,
+      permissionType: 'admin',
+    })
+    await db.insert(copilotChats).values({ id: chatId, userId, workspaceId, type: 'mothership' })
+    await db.insert(desktopDevices).values({
+      id: deviceId,
+      userId,
+      name: 'Studio Mac',
+      appVersion: '0.9.0',
+      platform: 'darwin-arm64',
+      capabilities: { executor: 1, browser: true, terminal: true, localFiles: true },
+    })
+    authMockFns.mockGetSession.mockResolvedValue({
+      user: { id: userId },
+      session: { id: generateId() },
+    })
+  })
+
+  afterAll(async () => {
+    await db.delete(copilotRuns).where(eq(copilotRuns.chatId, chatId))
+    await db.delete(copilotChats).where(eq(copilotChats.id, chatId))
+    await db.delete(desktopDevices).where(eq(desktopDevices.id, deviceId))
+    await db.delete(permissions).where(eq(permissions.userId, userId))
+    await db.delete(workspace).where(eq(workspace.id, workspaceId))
+    await db.delete(user).where(eq(user.id, userId))
+    await closeRedisConnection()
+  })
+
+  it('marks the live tail and the replay batch of a turn a desktop runs', async () => {
+    const streamId = await finishedRun(deviceId)
+
+    const tail = await reconnect(streamId, false)
+    await tail.text()
+    const batch = await (await reconnect(streamId, true)).json()
+
+    expect(tail.headers.get(MOTHERSHIP_DESKTOP_EXECUTOR_HEADER)).toBe('device')
+    expect(batch.desktopToolsOnDevice).toBe(true)
+  })
+
+  it('leaves a turn the chat view runs unmarked', async () => {
+    const streamId = await finishedRun(null)
+
+    const tail = await reconnect(streamId, false)
+    await tail.text()
+    const batch = await (await reconnect(streamId, true)).json()
+
+    expect(tail.headers.get(MOTHERSHIP_DESKTOP_EXECUTOR_HEADER)).toBeNull()
+    expect(batch.desktopToolsOnDevice).toBeUndefined()
+  })
+})
diff --git a/apps/sim/app/api/copilot/chat/stream/route.ts b/apps/sim/app/api/copilot/chat/stream/route.ts
index 3bdaeecf49d..b557b0a0145 100644
--- a/apps/sim/app/api/copilot/chat/stream/route.ts
+++ b/apps/sim/app/api/copilot/chat/stream/route.ts
@@ -13,7 +13,10 @@ import {
 } from '@/lib/api/server/routes'
 import { encodeSSEComment } from '@/lib/core/utils/sse'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
-import { MOTHERSHIP_STREAM_REPLAY_HEADER } from '@/lib/mothership/constants'
+import {
+  MOTHERSHIP_DESKTOP_EXECUTOR_HEADER,
+  MOTHERSHIP_STREAM_REPLAY_HEADER,
+} from '@/lib/mothership/constants'
 import {
   MothershipStreamV1CompletionStatus,
   MothershipStreamV1EventType,
@@ -285,6 +288,7 @@ async function handleResumeRequestBody({
       previewSessions,
       status: run.status,
       ...(run.chatId ? { chatId: run.chatId } : {}),
+      ...(run.desktopDeviceId ? { desktopToolsOnDevice: true } : {}),
     })
   }
 
@@ -606,8 +610,10 @@ async function handleResumeRequestBody({
   }
 
   return new Response(stream, {
-    headers: replayBody
-      ? { ...SSE_RESPONSE_HEADERS, [MOTHERSHIP_STREAM_REPLAY_HEADER]: 'log' }
-      : SSE_RESPONSE_HEADERS,
+    headers: {
+      ...SSE_RESPONSE_HEADERS,
+      ...(replayBody ? { [MOTHERSHIP_STREAM_REPLAY_HEADER]: 'log' } : {}),
+      ...(run.desktopDeviceId ? { [MOTHERSHIP_DESKTOP_EXECUTOR_HEADER]: 'device' } : {}),
+    },
   })
 }
diff --git a/apps/sim/app/api/desktop/activity/route.ts b/apps/sim/app/api/desktop/activity/route.ts
index 176881de51e..d603d7309a7 100644
--- a/apps/sim/app/api/desktop/activity/route.ts
+++ b/apps/sim/app/api/desktop/activity/route.ts
@@ -4,7 +4,7 @@ import {
   desktopExecutorErrorPolicy,
   desktopExecutorRateLimit,
 } from '@/lib/api/server/routes/desktop-executor'
-import { listDesktopActivity } from '@/lib/desktop/application/executor'
+import { listDesktopActivity } from '@/lib/desktop/application/activity'
 
 export const dynamic = 'force-dynamic'
 
diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream-protocol.ts b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream-protocol.ts
index c27b6a28930..0b142054ff3 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream-protocol.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream-protocol.ts
@@ -25,6 +25,8 @@ export type StreamBatchResponse = {
   previewSessions?: FilePreviewSession[]
   status: string
   chatId?: string
+  /** The desktop app's background executor runs this turn's desktop tools. */
+  desktopToolsOnDevice?: true
 }
 
 const STREAM_SCHEMA_ENFORCEMENT_PREFIX = 'Client stream schema enforcement failed.'
@@ -108,6 +110,7 @@ export function parseStreamBatchResponse(value: unknown): StreamBatchResponse {
     ...(previewSessions ? { previewSessions } : {}),
     status: typeof value.status === 'string' ? value.status : 'unknown',
     ...(typeof value.chatId === 'string' && value.chatId ? { chatId: value.chatId } : {}),
+    ...(value.desktopToolsOnDevice === true ? { desktopToolsOnDevice: true as const } : {}),
   }
 }
 
diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.test.ts b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.test.ts
index e6cdb6c72b5..8befdcf0cfe 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.test.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.test.ts
@@ -108,31 +108,47 @@ describe('tool events (dispatch → model + side effects)', () => {
     )
   })
 
-  it("only shows a desktop call when the chat's turn runs on a desktop in the background", () => {
+  it("only shows desktop calls when the desktop's background executor runs the turn", () => {
     const startClientBrowserTool = vi.fn()
-    const deps = makeStreamLoopDeps({ startClientBrowserTool, chatIdRef: ref('chat-1') })
-    vi.mocked(deps.queryClient.getQueryData).mockImplementation((key) =>
-      JSON.stringify(key) === JSON.stringify(['desktop-activity', 'list', 'ws-1'])
-        ? [{ chatId: 'chat-1', state: 'running', deviceName: 'MacBook' }]
-        : undefined
-    )
-    const ctx = createStreamLoopContext(deps)
-
-    dispatchStreamEvent(
-      ctx,
-      toolEnv({
-        phase: 'call',
-        executor: 'client',
-        mode: 'async',
-        toolCallId: 'click-1',
-        toolName: 'browser_click',
-        arguments: { ref: 'e1' },
-        status: 'executing',
+    const startClientTerminalTool = vi.fn()
+    const startClientLocalFilesystemTool = vi.fn()
+    const startClientWorkflowTool = vi.fn()
+    const ctx = createStreamLoopContext(
+      makeStreamLoopDeps({
+        startClientBrowserTool,
+        startClientTerminalTool,
+        startClientLocalFilesystemTool,
+        startClientWorkflowTool,
+        chatIdRef: ref('chat-1'),
+        options: { desktopToolsOnDevice: true },
       })
     )
+    const call = (toolCallId: string, toolName: string, args: Record<string, unknown>) =>
+      dispatchStreamEvent(
+        ctx,
+        toolEnv({
+          phase: 'call',
+          executor: 'client',
+          mode: 'async',
+          toolCallId,
+          toolName,
+          arguments: args,
+          status: 'executing',
+        })
+      )
+
+    call('click-1', 'browser_click', { ref: 'e1' })
+    call('run-1', 'terminal', { operation: 'run', args: { command: 'ls' } })
+    call('read-1', 'read_local_file', { path: '~/notes.txt' })
+    call('workflow-1', 'run_workflow', { workflowId: 'wf-1' })
 
     expect(toolNode(ctx, 'click-1').status).toBe('running')
     expect(startClientBrowserTool).not.toHaveBeenCalled()
+    expect(startClientTerminalTool).not.toHaveBeenCalled()
+    expect(startClientLocalFilesystemTool).not.toHaveBeenCalled()
+    expect(startClientWorkflowTool).toHaveBeenCalledWith('workflow-1', 'run_workflow', {
+      workflowId: 'wf-1',
+    })
   })
 
   it('runs a desktop call in the view when no desktop runs the chat in the background', () => {
diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.ts b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.ts
index 61604f4d18e..9e8e50663b0 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.ts
@@ -37,7 +37,6 @@ import { resolveFileResourceSelectionId } from '@/app/workspace/[workspaceId]/ho
 import { deploymentKeys } from '@/hooks/queries/deployments'
 import { oauthCredentialKeys } from '@/hooks/queries/oauth/oauth-credentials'
 import { workspaceCredentialKeys } from '@/hooks/queries/utils/credential-keys'
-import { isChatRunOnDesktop } from '@/hooks/queries/utils/desktop-activity-keys'
 import { folderKeys } from '@/hooks/queries/utils/folder-keys'
 import { invalidateWorkflowLists } from '@/hooks/queries/utils/invalidate-workflow-lists'
 import { invalidateSelectorQueries } from '@/hooks/queries/utils/selector-keys'
@@ -196,18 +195,12 @@ export function handleToolEvent(ctx: StreamLoopContext, parsed: ToolEvent): void
   const args = payload.arguments as Record<string, unknown> | undefined
   // Every client tailing the chat sees the call. A client without the desktop app leaves desktop
   // tools to it: its answer could only be an error, and that error would beat the real result.
-  // A turn running on a desktop's background executor belongs to that desktop: this view only shows it.
-  const runsInBackground =
-    isDesktopToolCall(name, args) &&
-    isChatRunOnDesktop(
-      deps.queryClient,
-      deps.workspaceId,
-      deps.options.targetChatId ?? deps.chatIdRef.current
-    )
+  // A turn a desktop's background executor runs belongs to that desktop: this view only shows it.
+  const isDesktopCall = isDesktopToolCall(name, args)
   const shouldStartClientTool =
     isClientExecutedToolCall(name, args) &&
-    (isDesktopApp() || !isDesktopToolCall(name, args)) &&
-    !runsInBackground &&
+    (isDesktopApp() || !isDesktopCall) &&
+    !(isDesktopCall && deps.options.desktopToolsOnDevice) &&
     !isPartial &&
     !deps.options.suppressedWorkflowToolStartIds?.has(rawId) &&
     node?.kind === 'tool' &&
diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/stream-context.ts b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/stream-context.ts
index 0ad8a63c1b2..de83519b5c7 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/stream-context.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/stream-context.ts
@@ -56,6 +56,11 @@ export interface StreamLoopOptions {
    */
   deferFlushes?: boolean
   suppressedWorkflowToolStartIds?: ReadonlySet<string>
+  /**
+   * The desktop app's background executor runs this turn's desktop tools, as Sim says when it
+   * serves the stream. The view then only shows those calls: it never starts or reports them.
+   */
+  desktopToolsOnDevice?: boolean
   targetChatId?: string
   shouldContinue?: () => boolean
 }
diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/stream-test-helpers.ts b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/stream-test-helpers.ts
index 34e8c2a26dc..1f406a501e9 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/stream-test-helpers.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/stream-test-helpers.ts
@@ -25,7 +25,6 @@ export function makeStreamLoopDeps(overrides: Partial<StreamLoopDeps> = {}): Str
     queryClient: {
       invalidateQueries: vi.fn(),
       cancelQueries: vi.fn(),
-      getQueryData: vi.fn(),
       setQueryData: vi.fn(),
       // double-cast-allowed: minimal QueryClient stub for stream-loop unit fixtures
     } as unknown as QueryClient,
diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts b/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts
index ff5db89ef70..123cef77ad5 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts
@@ -56,6 +56,7 @@ import {
 import {
   MOTHERSHIP_CHAT_API_PATH,
   MOTHERSHIP_CHAT_ID_HEADER,
+  MOTHERSHIP_DESKTOP_EXECUTOR_HEADER,
   MOTHERSHIP_STREAM_REPLAY_HEADER,
 } from '@/lib/mothership/constants'
 import { sendMothershipMessage } from '@/lib/mothership/events'
@@ -2683,6 +2684,7 @@ export function useChat(
                 resumeCursor: latestCursor,
                 deferFlushes: true,
                 suppressedWorkflowToolStartIds: suppressedSeedWorkflowToolStartIds,
+                ...(opts.initialBatch?.desktopToolsOnDevice ? { desktopToolsOnDevice: true } : {}),
                 ...(targetChatId ? { targetChatId } : {}),
                 ...(shouldContinue ? { shouldContinue } : {}),
               }
@@ -2753,6 +2755,9 @@ export function useChat(
             {
               preserveExistingState: preserveNextReplayState,
               resumeCursor: latestCursor,
+              ...(sseRes.headers.get(MOTHERSHIP_DESKTOP_EXECUTOR_HEADER) === 'device'
+                ? { desktopToolsOnDevice: true }
+                : {}),
               ...(targetChatId ? { targetChatId } : {}),
               ...(shouldContinue ? { shouldContinue } : {}),
             }
@@ -2860,6 +2865,7 @@ export function useChat(
               resumeCursor: replaySelection.afterCursor,
               deferFlushes: true,
               suppressedWorkflowToolStartIds: getReplayCompletedWorkflowToolCallIds(batch.events),
+              ...(batch.desktopToolsOnDevice ? { desktopToolsOnDevice: true } : {}),
               ...(targetChatId ? { targetChatId } : {}),
               ...(shouldContinue ? { shouldContinue } : {}),
             }
@@ -4092,6 +4098,9 @@ export function useChat(
         if (!response.body) throw new Error('No response body')
 
         const streamResult = await processSSEStream(response.body.getReader(), assistantId, gen, {
+          ...(response.headers.get(MOTHERSHIP_DESKTOP_EXECUTOR_HEADER) === 'device'
+            ? { desktopToolsOnDevice: true }
+            : {}),
           ...(streamTargetChatId ? { targetChatId: streamTargetChatId } : {}),
         })
         if (streamGenRef.current === gen) {
diff --git a/apps/sim/app/workspace/[workspaceId]/settings/components/desktop/desktop.tsx b/apps/sim/app/workspace/[workspaceId]/settings/components/desktop/desktop.tsx
index 20d72828869..1b96613d97d 100644
--- a/apps/sim/app/workspace/[workspaceId]/settings/components/desktop/desktop.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/settings/components/desktop/desktop.tsx
@@ -125,7 +125,7 @@ export function Desktop() {
           />
           <PreferenceRow
             id='desktop-notifications-unfocused'
-            label="Notify only when Sim isn't focused"
+            label='Notify only for chats in the background'
             checked={preferences.notificationsOnlyWhenUnfocused}
             disabled={notificationsDisabled || pendingPreference !== null}
             onCheckedChange={(checked) =>
diff --git a/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx b/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx
index f2b3e927899..896c181647d 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx
@@ -187,7 +187,7 @@ const SEARCH_MODAL_DATE_FORMAT = new Intl.DateTimeFormat(undefined, {
 
 const DESKTOP_ACTIVITY_COLOR: Record<DesktopChatActivity['state'], string> = {
   running: '#EAB308',
-  needs_input: '#F97316',
+  needs_input: 'var(--warning)',
   blocked: 'var(--text-error)',
 }
 
diff --git a/apps/sim/hooks/queries/utils/desktop-activity-keys.ts b/apps/sim/hooks/queries/utils/desktop-activity-keys.ts
index 9b7de7fddc7..b5b4db97db1 100644
--- a/apps/sim/hooks/queries/utils/desktop-activity-keys.ts
+++ b/apps/sim/hooks/queries/utils/desktop-activity-keys.ts
@@ -1,24 +1,5 @@
-import type { QueryClient } from '@tanstack/react-query'
-import type { DesktopChatActivity } from '@/lib/api/contracts/desktop-executor'
-
 export const desktopActivityKeys = {
   all: ['desktop-activity'] as const,
   lists: () => [...desktopActivityKeys.all, 'list'] as const,
   list: (workspaceId?: string) => [...desktopActivityKeys.lists(), workspaceId ?? ''] as const,
 }
-
-/**
- * Whether one of the user's desktops is running this chat's turn in the background, read from
- * the cached activity list. Its calls then belong to that desktop; the chat view only shows them.
- */
-export function isChatRunOnDesktop(
-  queryClient: QueryClient,
-  workspaceId: string | undefined,
-  chatId: string | undefined
-): boolean {
-  if (!workspaceId || !chatId) return false
-  const chats = queryClient.getQueryData<DesktopChatActivity[]>(
-    desktopActivityKeys.list(workspaceId)
-  )
-  return chats?.some((chat) => chat.chatId === chatId) ?? false
-}
diff --git a/apps/sim/hooks/use-mothership-chat-events.test.ts b/apps/sim/hooks/use-mothership-chat-events.test.ts
index c451810d378..44c8f760733 100644
--- a/apps/sim/hooks/use-mothership-chat-events.test.ts
+++ b/apps/sim/hooks/use-mothership-chat-events.test.ts
@@ -11,8 +11,10 @@ vi.mock('@/lib/browser-agent/transport', () => ({ suspendBrowserScope }))
 vi.mock('@/lib/terminal/transport', () => ({ suspendTerminalScope }))
 
 import { type MothershipChatHistory, mothershipChatKeys } from '@/hooks/queries/mothership-chats'
+import { desktopActivityKeys } from '@/hooks/queries/utils/desktop-activity-keys'
 import {
   handleMothershipChatStatusEvent,
+  reflectBackgroundChatStatus,
   resyncMothershipChatCaches,
 } from '@/hooks/use-mothership-chat-events'
 import { useMothershipQueueStore } from '@/stores/mothership-queue/store'
@@ -294,3 +296,74 @@ describe('resyncMothershipChatCaches', () => {
     )
   })
 })
+
+describe('reflectBackgroundChatStatus', () => {
+  const notify = vi.fn(async () => true)
+  const queryClient = {
+    getQueryData: vi.fn(),
+    invalidateQueries: vi.fn().mockResolvedValue(undefined),
+  } satisfies Pick<QueryClient, 'getQueryData' | 'invalidateQueries'>
+
+  function showing(pathname: string, desktop = true) {
+    vi.stubGlobal('window', {
+      location: { pathname },
+      ...(desktop ? { simDesktop: { settings: { notify } } } : {}),
+    })
+    queryClient.getQueryData.mockReturnValue([{ id: 'chat-b', name: 'Fix CI' }])
+  }
+
+  const completed = JSON.stringify({ chatId: 'chat-b', type: 'completed', streamId: 's-1' })
+
+  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)
+
+    expect(notify).toHaveBeenCalledWith({
+      title: 'Fix CI',
+      body: 'Sim finished responding.',
+      route: '/workspace/ws-1/chat/chat-b',
+    })
+  })
+
+  it('leaves the chat on screen to announce itself', () => {
+    showing('/workspace/ws-1/chat/chat-b')
+
+    reflectBackgroundChatStatus(queryClient, 'ws-1', completed)
+
+    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)
+    showing('/workspace/ws-1/chat/chat-c')
+    reflectBackgroundChatStatus(
+      queryClient,
+      'ws-1',
+      JSON.stringify({ chatId: 'chat-b', type: 'started', streamId: 's-2' })
+    )
+
+    expect(notify).not.toHaveBeenCalled()
+  })
+
+  it('refreshes which chats run on a desktop whenever a turn starts or ends', () => {
+    showing('/workspace/ws-1/home', false)
+
+    reflectBackgroundChatStatus(
+      queryClient,
+      'ws-1',
+      JSON.stringify({ chatId: 'chat-b', type: 'started', streamId: 's-3' })
+    )
+    reflectBackgroundChatStatus(
+      queryClient,
+      'ws-1',
+      JSON.stringify({ chatId: 'chat-b', type: 'renamed' })
+    )
+
+    expect(queryClient.invalidateQueries).toHaveBeenCalledTimes(1)
+    expect(queryClient.invalidateQueries).toHaveBeenCalledWith({
+      queryKey: desktopActivityKeys.lists(),
+    })
+  })
+})
diff --git a/apps/sim/hooks/use-mothership-chat-events.ts b/apps/sim/hooks/use-mothership-chat-events.ts
index 887eae2d3d5..a6b11343bfc 100644
--- a/apps/sim/hooks/use-mothership-chat-events.ts
+++ b/apps/sim/hooks/use-mothership-chat-events.ts
@@ -1,15 +1,19 @@
 import { useEffect } from 'react'
 import { createLogger } from '@sim/logger'
+import { getErrorMessage } from '@sim/utils/errors'
 import type { QueryClient } from '@tanstack/react-query'
 import { useQueryClient } from '@tanstack/react-query'
+import { getDesktopBridge } from '@/lib/desktop'
 import { suspendDesktopChatScopes } from '@/lib/desktop/chat-scope'
 import { createRotatingEventSource } from '@/lib/events/rotating-event-source'
 import { getLiveAssistantMessageId } from '@/lib/mothership/chat/live-message-id'
 import {
   type MothershipChatHistory,
+  type MothershipChatMetadata,
   type MothershipChatOwner,
   mothershipChatKeys,
 } from '@/hooks/queries/mothership-chats'
+import { desktopActivityKeys } from '@/hooks/queries/utils/desktop-activity-keys'
 import { useMothershipQueueStore } from '@/stores/mothership-queue/store'
 
 const logger = createLogger('MothershipChatEvents')
@@ -181,6 +185,45 @@ export function resyncMothershipChatCaches(
   queryClient.invalidateQueries({ queryKey: mothershipChatKeys.ownerLists(owner) })
 }
 
+/** The chat route a page shows, so a notification never repeats what is on screen. */
+function chatRoute(owner: MothershipChatOwner, chatId: string): string {
+  return typeof owner === 'string'
+    ? `/workspace/${owner}/chat/${chatId}`
+    : `/o/${owner.organizationId}/chat/${chatId}`
+}
+
+/**
+ * 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.
+ */
+export function reflectBackgroundChatStatus(
+  queryClient: Pick<QueryClient, 'getQueryData' | 'invalidateQueries'>,
+  owner: MothershipChatOwner,
+  data: unknown
+): 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
+  const settings = getDesktopBridge()?.settings
+  if (!settings) return
+  const route = chatRoute(owner, payload.chatId)
+  if (typeof window !== 'undefined' && window.location.pathname === route) return
+  const chats = queryClient.getQueryData<MothershipChatMetadata[]>(
+    mothershipChatKeys.ownerList(owner)
+  )
+  const name = chats?.find((chat) => chat.id === payload.chatId)?.name
+  void settings
+    .notify({ title: name ?? 'Task complete', body: 'Sim finished responding.', route })
+    .catch((error) =>
+      logger.warn('Could not show a chat completion notification', {
+        error: getErrorMessage(error),
+      })
+    )
+}
+
 /**
  * Subscribes to chat status SSE events and invalidates chat caches on changes.
  * The SSE event name remains `task_status` for wire compatibility.
@@ -210,11 +253,9 @@ export function useMothershipChatEvents(
       url: `/api/mothership/events?${ownerParam}`,
       events: {
         task_status: (event) => {
-          handleMothershipChatStatusEvent(
-            queryClient,
-            eventOwner,
-            event instanceof MessageEvent ? event.data : undefined
-          )
+          const data = event instanceof MessageEvent ? event.data : undefined
+          handleMothershipChatStatusEvent(queryClient, eventOwner, data)
+          reflectBackgroundChatStatus(queryClient, eventOwner, data)
         },
       },
       onOpen: (reason) => {
diff --git a/apps/sim/lib/desktop/application/activity.integration.ts b/apps/sim/lib/desktop/application/activity.integration.ts
index 2048405cba2..8b5c1765cb6 100644
--- a/apps/sim/lib/desktop/application/activity.integration.ts
+++ b/apps/sim/lib/desktop/application/activity.integration.ts
@@ -29,11 +29,8 @@ import { featureFlagsMock, featureFlagsMockFns } from '@sim/testing/mocks/featur
 import { generateId } from '@sim/utils/id'
 import { inArray } from 'drizzle-orm'
 import { closeRedisConnection } from '@/lib/core/config/redis'
-import {
-  listDesktopActivity,
-  openDesktopInboxStream,
-  registerDesktopDevice,
-} from '@/lib/desktop/application/executor'
+import { listDesktopActivity } from '@/lib/desktop/application/activity'
+import { openDesktopInboxStream, registerDesktopDevice } from '@/lib/desktop/application/executor'
 import { isDesktopPresent } from '@/lib/desktop/executor/presence'
 import { createRunSegment } from '@/lib/mothership/async-runs/repository'
 
@@ -134,7 +131,15 @@ describe.runIf(Boolean(redisUrl))('background desktop activity', () => {
       runId: waiting.runId,
       toolCallId: generateId(),
       toolName: 'terminal',
-      args: { operation: 'run', command: 'npm publish' },
+      args: { operation: 'run', args: { command: 'npm publish' } },
+      permissionRequestedAt: new Date(),
+    })
+    // An allowed command waits for nobody: the desktop simply runs it.
+    await db.insert(copilotAsyncToolCalls).values({
+      runId: running.runId,
+      toolCallId: generateId(),
+      toolName: 'terminal',
+      args: { operation: 'run', args: { command: 'npm test' } },
     })
     await chatWithRun(desktop, null)
     await chatWithRun(desktop, desktop.deviceId, 'complete')
@@ -176,6 +181,47 @@ describe.runIf(Boolean(redisUrl))('background desktop activity', () => {
     }
   })
 
+  it('reports a chat whose running call handed control to the user as needing input', async () => {
+    const desktop = await signedInDesktop()
+    const handoff = await chatWithRun(desktop, desktop.deviceId)
+    const takeover = await chatWithRun(desktop, desktop.deviceId)
+    const decided = await chatWithRun(desktop, desktop.deviceId)
+    await db.insert(copilotAsyncToolCalls).values([
+      {
+        runId: handoff.runId,
+        toolCallId: generateId(),
+        toolName: 'terminal',
+        args: { operation: 'handoff', args: { reason: 'Enter your password' } },
+        status: 'running',
+      },
+      {
+        runId: takeover.runId,
+        toolCallId: generateId(),
+        toolName: 'browser_request_takeover',
+        args: { reason: 'Solve the captcha' },
+        status: 'running',
+      },
+      {
+        runId: decided.runId,
+        toolCallId: generateId(),
+        toolName: 'terminal',
+        args: { operation: 'run', args: { command: 'npm publish' } },
+        permissionRequestedAt: new Date(),
+        permissionDecision: 'skip',
+        status: 'pending',
+      },
+    ])
+
+    const { chats } = await listDesktopActivity.execute({
+      principal: desktop.principal,
+      input: { workspaceId: desktop.workspaceId },
+    })
+    const stateOf = (chatId: string) => chats.find((chat) => chat.chatId === chatId)?.state
+    expect(stateOf(handoff.chatId)).toBe('needs_input')
+    expect(stateOf(takeover.chatId)).toBe('needs_input')
+    expect(stateOf(decided.chatId)).toBe('blocked')
+  })
+
   it("never reports another user's chats, or chats in another workspace", async () => {
     const desktop = await signedInDesktop()
     const other = await signedInDesktop()
diff --git a/apps/sim/lib/desktop/application/activity.ts b/apps/sim/lib/desktop/application/activity.ts
new file mode 100644
index 00000000000..6b7b5eb8490
--- /dev/null
+++ b/apps/sim/lib/desktop/application/activity.ts
@@ -0,0 +1,72 @@
+import type { SessionPrincipal } from '@sim/auth/principal'
+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 { listDesktopActivityRows } from '@/lib/desktop/executor/repository'
+
+const logger = createLogger('DesktopActivity')
+
+/**
+ * - `running`: the desktop is working on the chat's turn.
+ * - `needs_input`: the turn waits on the user: an approval, a terminal handoff, a browser takeover.
+ * - `blocked`: the desktop the turn runs on is offline, so its desktop calls cannot start.
+ */
+type DesktopChatActivityState = 'running' | 'needs_input' | 'blocked'
+
+export interface DesktopChatActivityEntry {
+  chatId: string
+  state: DesktopChatActivityState
+  deviceName: string
+}
+
+/** Presence Sim cannot read is not evidence of an offline desktop. */
+async function readPresence(deviceId: string): Promise<boolean> {
+  try {
+    return await isDesktopPresent(deviceId)
+  } catch (error) {
+    logger.warn('Could not read desktop presence for activity', { error: getErrorMessage(error) })
+    return true
+  }
+}
+
+/**
+ * Which of the caller's chats in a workspace are running on one of their desktops, and in what
+ * state. Lists only the caller's own runs, never their content, so it needs no workspace role.
+ * Runs already bound keep showing after the executor is turned off, until they end.
+ */
+export const listDesktopActivity = defineAuthorizedCredentialUserUseCase({
+  // permission-group-exempt: reports only the caller's own runs, with no content.
+  operation: defineOperation({
+    id: 'desktop.executor.activity.list',
+    principalKinds: ['session'],
+    capability: 'none',
+  }),
+  async execute({
+    principal,
+    input,
+  }: {
+    principal: SessionPrincipal
+    input: { workspaceId: string }
+  }): Promise<{ chats: DesktopChatActivityEntry[] }> {
+    const runs = await listDesktopActivityRows({
+      userId: principal.userId,
+      workspaceId: input.workspaceId,
+    })
+    const devices = [...new Set(runs.map((run) => run.deviceId))]
+    const online = new Map(
+      await Promise.all(devices.map(async (id) => [id, await readPresence(id)] as const))
+    )
+    const chats = new Map<string, DesktopChatActivityEntry>()
+    for (const run of runs) {
+      if (chats.has(run.chatId)) continue
+      chats.set(run.chatId, {
+        chatId: run.chatId,
+        deviceName: run.deviceName,
+        state: run.needsInput ? 'needs_input' : online.get(run.deviceId) ? 'running' : 'blocked',
+      })
+    }
+    return { chats: [...chats.values()] }
+  },
+})
diff --git a/apps/sim/lib/desktop/executor/repository.ts b/apps/sim/lib/desktop/executor/repository.ts
index d19f54799c4..5760986b0fb 100644
--- a/apps/sim/lib/desktop/executor/repository.ts
+++ b/apps/sim/lib/desktop/executor/repository.ts
@@ -6,6 +6,7 @@ import {
   copilotRuns,
   desktopDevices,
 } from '@sim/db/schema'
+import { TERMINAL_TOOL_NAME } from '@sim/terminal-protocol'
 import {
   and,
   asc,
@@ -444,8 +445,9 @@ export async function listOverdueDesktopToolCalls(input: { slackMs: number; limi
 }
 
 /**
- * The caller's live device-bound runs in a workspace, newest first, with each run's calls that
- * are still waiting to be offered (the ones that may be held for approval).
+ * The caller's live device-bound runs in a workspace, newest first, each with whether one of its
+ * calls waits on the user: a call held for their approval (Sim asked, and they have not answered),
+ * or a running call that handed control to them (a terminal handoff, a browser takeover).
  */
 export async function listDesktopActivityRows(input: { userId: string; workspaceId: string }) {
   const runs = await db
@@ -470,12 +472,8 @@ export async function listDesktopActivityRows(input: { userId: string; workspace
     .orderBy(sql`${copilotRuns.startedAt} DESC`)
     .limit(INBOX_ROW_LIMIT)
   if (runs.length === 0) return []
-  const waiting = await db
-    .select({
-      runId: copilotAsyncToolCalls.runId,
-      toolName: copilotAsyncToolCalls.toolName,
-      args: copilotAsyncToolCalls.args,
-    })
+  const waitingOnUser = await db
+    .selectDistinct({ runId: copilotAsyncToolCalls.runId })
     .from(copilotAsyncToolCalls)
     .where(
       and(
@@ -483,13 +481,25 @@ export async function listDesktopActivityRows(input: { userId: string; workspace
           copilotAsyncToolCalls.runId,
           runs.map((run) => run.runId)
         ),
-        eq(copilotAsyncToolCalls.status, ASYNC_TOOL_STATUS.pending),
-        isNull(copilotAsyncToolCalls.permissionDecision),
-        isNull(copilotAsyncToolCalls.executionLeaseExpiresAt)
+        or(
+          and(
+            eq(copilotAsyncToolCalls.status, ASYNC_TOOL_STATUS.pending),
+            isNotNull(copilotAsyncToolCalls.permissionRequestedAt),
+            isNull(copilotAsyncToolCalls.permissionDecision)
+          ),
+          and(
+            eq(copilotAsyncToolCalls.status, ASYNC_TOOL_STATUS.running),
+            or(
+              eq(copilotAsyncToolCalls.toolName, 'browser_request_takeover'),
+              and(
+                eq(copilotAsyncToolCalls.toolName, TERMINAL_TOOL_NAME),
+                sql`${copilotAsyncToolCalls.args} ->> 'operation' = 'handoff'`
+              )
+            )
+          )
+        )
       )
     )
-  return runs.map((run) => ({
-    ...run,
-    waitingCalls: waiting.filter((call) => call.runId === run.runId),
-  }))
+  const needsInput = new Set(waitingOnUser.map((row) => row.runId))
+  return runs.map((run) => ({ ...run, needsInput: needsInput.has(run.runId) }))
 }
diff --git a/apps/sim/lib/mothership/chat/post.ts b/apps/sim/lib/mothership/chat/post.ts
index 4850f93f479..b80730c90a5 100644
--- a/apps/sim/lib/mothership/chat/post.ts
+++ b/apps/sim/lib/mothership/chat/post.ts
@@ -63,7 +63,11 @@ import {
   MAX_TABLE_SELECTION_ROWS,
   safeBrowserSelectionUrl,
 } from '@/lib/mothership/chat/selection-context'
-import { COPILOT_REQUEST_MODES, MOTHERSHIP_CHAT_ID_HEADER } from '@/lib/mothership/constants'
+import {
+  COPILOT_REQUEST_MODES,
+  MOTHERSHIP_CHAT_ID_HEADER,
+  MOTHERSHIP_DESKTOP_EXECUTOR_HEADER,
+} from '@/lib/mothership/constants'
 import { prepareCopilotEnvironmentContext } from '@/lib/mothership/environment-context'
 import { isMothershipModelSelectorEnabled, isPlanModeEnabled } from '@/lib/mothership/feature-flags'
 import { AssistantSearchLevel } from '@/lib/mothership/generated/assistant'
@@ -1598,6 +1602,9 @@ export async function handleUnifiedChatPost(req: NextRequest) {
           ...SSE_RESPONSE_HEADERS,
           traceparent: rootTraceparent,
           ...(actualChatId ? { [MOTHERSHIP_CHAT_ID_HEADER]: actualChatId } : {}),
+          ...(admittedRun?.desktopDeviceId
+            ? { [MOTHERSHIP_DESKTOP_EXECUTOR_HEADER]: 'device' }
+            : {}),
         },
       })
     }) // end otelContextApi.with
diff --git a/apps/sim/lib/mothership/constants.ts b/apps/sim/lib/mothership/constants.ts
index a8f0ba510a8..63180031d15 100644
--- a/apps/sim/lib/mothership/constants.ts
+++ b/apps/sim/lib/mothership/constants.ts
@@ -94,6 +94,12 @@ export const MOTHERSHIP_STREAM_REPLAY_HEADER = 'x-mothership-stream-replay'
 /** Durable chat identity returned after the send transaction commits, before SSE delivery. */
 export const MOTHERSHIP_CHAT_ID_HEADER = 'x-mothership-chat-id'
 
+/**
+ * Set to `device` on a turn's stream when a desktop app's background executor runs its desktop
+ * tools. A chat view reading that stream only shows those calls; it never starts or reports them.
+ */
+export const MOTHERSHIP_DESKTOP_EXECUTOR_HEADER = 'x-mothership-desktop-executor'
+
 /** POST — confirm or reject a tool call. */
 export const COPILOT_CONFIRM_API_PATH = '/api/copilot/confirm'
 

From c278450395151c447f3c7d82634bdd161642dd74 Mon Sep 17 00:00:00 2001
From: Waleed Latif <walif6@gmail.com>
Date: Tue, 6 Oct 2026 08:32:46 -0700
Subject: [PATCH 3/7] 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.
---
 .../w/components/sidebar/sidebar.tsx          | 39 ++++++++-------
 .../hooks/use-mothership-chat-events.test.ts  | 23 ++++++---
 apps/sim/hooks/use-mothership-chat-events.ts  | 22 ++++++---
 .../lib/desktop/application/activity.test.ts  | 49 +++++++++++++++++++
 apps/sim/lib/desktop/application/activity.ts  |  5 +-
 .../chat/application/admit-turn.test.ts       | 23 +++++++++
 .../mothership/chat/application/admit-turn.ts |  9 ++--
 7 files changed, 134 insertions(+), 36 deletions(-)
 create mode 100644 apps/sim/lib/desktop/application/activity.test.ts

diff --git a/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx b/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx
index 896c181647d..8073cbed0a8 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx
+++ b/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
diff --git a/apps/sim/hooks/use-mothership-chat-events.test.ts b/apps/sim/hooks/use-mothership-chat-events.test.ts
index 44c8f760733..ac0dcd625f1 100644
--- a/apps/sim/hooks/use-mothership-chat-events.test.ts
+++ b/apps/sim/hooks/use-mothership-chat-events.test.ts
@@ -317,7 +317,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',
@@ -326,22 +326,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()
@@ -353,12 +362,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)
diff --git a/apps/sim/hooks/use-mothership-chat-events.ts b/apps/sim/hooks/use-mothership-chat-events.ts
index a6b11343bfc..e86a8e58e09 100644
--- a/apps/sim/hooks/use-mothership-chat-events.ts
+++ b/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'
@@ -194,19 +194,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)
@@ -234,9 +236,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
 
@@ -255,7 +261,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) => {
diff --git a/apps/sim/lib/desktop/application/activity.test.ts b/apps/sim/lib/desktop/application/activity.test.ts
new file mode 100644
index 00000000000..6ff4d2f2e7b
--- /dev/null
+++ b/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' }])
+  })
+})
diff --git a/apps/sim/lib/desktop/application/activity.ts b/apps/sim/lib/desktop/application/activity.ts
index 6b7b5eb8490..9edb55adad7 100644
--- a/apps/sim/lib/desktop/application/activity.ts
+++ b/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) {
diff --git a/apps/sim/lib/mothership/chat/application/admit-turn.test.ts b/apps/sim/lib/mothership/chat/application/admit-turn.test.ts
index f2f8a45c923..7ee17fdbe67 100644
--- a/apps/sim/lib/mothership/chat/application/admit-turn.test.ts
+++ b/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) => {
diff --git a/apps/sim/lib/mothership/chat/application/admit-turn.ts b/apps/sim/lib/mothership/chat/application/admit-turn.ts
index dbd0a35f3e5..487d19a93f4 100644
--- a/apps/sim/lib/mothership/chat/application/admit-turn.ts
+++ b/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

From b34c8cf68749759d157254dbb1571befee5b461c Mon Sep 17 00:00:00 2001
From: Waleed Latif <walif6@gmail.com>
Date: Tue, 6 Oct 2026 10:28:33 -0700
Subject: [PATCH 4/7] test(desktop): observe what the chat view starts and
 announces instead of asserting mock calls

The background-chat tests now record the calls a view starts and the
notifications it asks the desktop app to show, and read whether the
desktop activity query went stale from a real query client, instead of
asserting that mocks were called.
---
 .../hooks/stream/handle-tool-event.test.ts    | 99 +++++++++----------
 .../hooks/use-mothership-chat-events.test.ts  | 65 +++++++-----
 .../chat/application/admit-turn.test.ts       |  1 -
 3 files changed, 90 insertions(+), 75 deletions(-)

diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.test.ts b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.test.ts
index 8befdcf0cfe..9a4e60ee1cc 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.test.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.test.ts
@@ -108,74 +108,71 @@ describe('tool events (dispatch → model + side effects)', () => {
     )
   })
 
+  /** Starters that record which calls this view started, by tool call id. */
+  function recordingStarters() {
+    const started: string[] = []
+    const record = (toolCallId: string) => {
+      started.push(toolCallId)
+    }
+    return {
+      started,
+      starters: {
+        startClientBrowserTool: record,
+        startClientTerminalTool: record,
+        startClientLocalFilesystemTool: record,
+        startClientWorkflowTool: record,
+      },
+    }
+  }
+
+  function dispatchCall(
+    ctx: StreamLoopContext,
+    toolCallId: string,
+    toolName: string,
+    args: Record<string, unknown>
+  ) {
+    dispatchStreamEvent(
+      ctx,
+      toolEnv({
+        phase: 'call',
+        executor: 'client',
+        mode: 'async',
+        toolCallId,
+        toolName,
+        arguments: args,
+        status: 'executing',
+      })
+    )
+  }
+
   it("only shows desktop calls when the desktop's background executor runs the turn", () => {
-    const startClientBrowserTool = vi.fn()
-    const startClientTerminalTool = vi.fn()
-    const startClientLocalFilesystemTool = vi.fn()
-    const startClientWorkflowTool = vi.fn()
+    const { started, starters } = recordingStarters()
     const ctx = createStreamLoopContext(
       makeStreamLoopDeps({
-        startClientBrowserTool,
-        startClientTerminalTool,
-        startClientLocalFilesystemTool,
-        startClientWorkflowTool,
+        ...starters,
         chatIdRef: ref('chat-1'),
         options: { desktopToolsOnDevice: true },
       })
     )
-    const call = (toolCallId: string, toolName: string, args: Record<string, unknown>) =>
-      dispatchStreamEvent(
-        ctx,
-        toolEnv({
-          phase: 'call',
-          executor: 'client',
-          mode: 'async',
-          toolCallId,
-          toolName,
-          arguments: args,
-          status: 'executing',
-        })
-      )
 
-    call('click-1', 'browser_click', { ref: 'e1' })
-    call('run-1', 'terminal', { operation: 'run', args: { command: 'ls' } })
-    call('read-1', 'read_local_file', { path: '~/notes.txt' })
-    call('workflow-1', 'run_workflow', { workflowId: 'wf-1' })
+    dispatchCall(ctx, 'click-1', 'browser_click', { ref: 'e1' })
+    dispatchCall(ctx, 'run-1', 'terminal', { operation: 'run', args: { command: 'ls' } })
+    dispatchCall(ctx, 'read-1', 'read_local_file', { path: '~/notes.txt' })
+    dispatchCall(ctx, 'workflow-1', 'run_workflow', { workflowId: 'wf-1' })
 
     expect(toolNode(ctx, 'click-1').status).toBe('running')
-    expect(startClientBrowserTool).not.toHaveBeenCalled()
-    expect(startClientTerminalTool).not.toHaveBeenCalled()
-    expect(startClientLocalFilesystemTool).not.toHaveBeenCalled()
-    expect(startClientWorkflowTool).toHaveBeenCalledWith('workflow-1', 'run_workflow', {
-      workflowId: 'wf-1',
-    })
+    expect(started).toEqual(['workflow-1'])
   })
 
   it('runs a desktop call in the view when no desktop runs the chat in the background', () => {
-    const startClientBrowserTool = vi.fn()
+    const { started, starters } = recordingStarters()
     const ctx = createStreamLoopContext(
-      makeStreamLoopDeps({ startClientBrowserTool, chatIdRef: ref('chat-1') })
+      makeStreamLoopDeps({ ...starters, chatIdRef: ref('chat-1') })
     )
 
-    dispatchStreamEvent(
-      ctx,
-      toolEnv({
-        phase: 'call',
-        executor: 'client',
-        mode: 'async',
-        toolCallId: 'click-2',
-        toolName: 'browser_click',
-        arguments: { ref: 'e1' },
-        status: 'executing',
-      })
-    )
+    dispatchCall(ctx, 'click-2', 'browser_click', { ref: 'e1' })
 
-    expect(startClientBrowserTool).toHaveBeenCalledWith(
-      'click-2',
-      'browser_click',
-      { ref: 'e1' },
-      expect.anything()
-    )
+    expect(started).toEqual(['click-2'])
   })
 
   it('never starts a skipped terminal command', () => {
diff --git a/apps/sim/hooks/use-mothership-chat-events.test.ts b/apps/sim/hooks/use-mothership-chat-events.test.ts
index ac0dcd625f1..a54b717bee6 100644
--- a/apps/sim/hooks/use-mothership-chat-events.test.ts
+++ b/apps/sim/hooks/use-mothership-chat-events.test.ts
@@ -1,3 +1,4 @@
+import type { DesktopNotificationPayload } from '@sim/desktop-bridge'
 import { sleep } from '@sim/utils/helpers'
 import { QueryClient, QueryObserver } from '@tanstack/react-query'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
@@ -298,20 +299,37 @@ describe('resyncMothershipChatCaches', () => {
 })
 
 describe('reflectBackgroundChatStatus', () => {
-  const notify = vi.fn(async () => true)
-  const queryClient = {
-    getQueryData: vi.fn(),
-    invalidateQueries: vi.fn().mockResolvedValue(undefined),
-  } satisfies Pick<QueryClient, 'getQueryData' | 'invalidateQueries'>
+  /** What the desktop app was asked to show. */
+  let shown: DesktopNotificationPayload[] = []
+  let queryClient: QueryClient
 
   function showing(pathname: string, desktop = true) {
+    shown = []
     vi.stubGlobal('window', {
       location: { pathname },
-      ...(desktop ? { simDesktop: { settings: { notify } } } : {}),
+      ...(desktop
+        ? {
+            simDesktop: {
+              settings: {
+                notify: async (payload: DesktopNotificationPayload) => {
+                  shown.push(payload)
+                  return true
+                },
+              },
+            },
+          }
+        : {}),
     })
-    queryClient.getQueryData.mockReturnValue([{ id: 'chat-b', name: 'Fix CI' }])
+    queryClient = new QueryClient()
+    queryClient.setQueryData(mothershipChatKeys.ownerList('ws-1'), [
+      { id: 'chat-b', name: 'Fix CI' },
+    ])
+    queryClient.setQueryData(desktopActivityKeys.list('ws-1'), [])
   }
 
+  const activityStale = () =>
+    queryClient.getQueryState(desktopActivityKeys.list('ws-1'))?.isInvalidated ?? false
+
   const completed = JSON.stringify({ chatId: 'chat-b', type: 'completed', streamId: 's-1' })
 
   it('announces a chat that finished in the background, and opens it from the notification', () => {
@@ -319,11 +337,9 @@ describe('reflectBackgroundChatStatus', () => {
 
     reflectBackgroundChatStatus(queryClient, 'ws-1', completed, true)
 
-    expect(notify).toHaveBeenCalledWith({
-      title: 'Fix CI',
-      body: 'Sim finished responding.',
-      route: '/workspace/ws-1/chat/chat-b',
-    })
+    expect(shown).toEqual([
+      { title: 'Fix CI', body: 'Sim finished responding.', route: '/workspace/ws-1/chat/chat-b' },
+    ])
   })
 
   it('announces nothing while the background executor is off', () => {
@@ -331,7 +347,7 @@ describe('reflectBackgroundChatStatus', () => {
 
     reflectBackgroundChatStatus(queryClient, 'ws-1', completed, false)
 
-    expect(notify).not.toHaveBeenCalled()
+    expect(shown).toEqual([])
   })
 
   it('leaves the chat on screen to announce itself', () => {
@@ -339,13 +355,12 @@ describe('reflectBackgroundChatStatus', () => {
 
     reflectBackgroundChatStatus(queryClient, 'ws-1', completed, true)
 
-    expect(notify).not.toHaveBeenCalled()
+    expect(shown).toEqual([])
   })
 
-  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, true)
+  it('stays silent for a turn that only started', () => {
     showing('/workspace/ws-1/chat/chat-c')
+
     reflectBackgroundChatStatus(
       queryClient,
       'ws-1',
@@ -353,10 +368,10 @@ describe('reflectBackgroundChatStatus', () => {
       true
     )
 
-    expect(notify).not.toHaveBeenCalled()
+    expect(shown).toEqual([])
   })
 
-  it('refreshes which chats run on a desktop whenever a turn starts or ends', () => {
+  it('refreshes which chats run on a desktop when a turn starts', () => {
     showing('/workspace/ws-1/home', false)
 
     reflectBackgroundChatStatus(
@@ -365,6 +380,13 @@ describe('reflectBackgroundChatStatus', () => {
       JSON.stringify({ chatId: 'chat-b', type: 'started', streamId: 's-3' }),
       true
     )
+
+    expect(activityStale()).toBe(true)
+  })
+
+  it('leaves the desktop activity alone for a rename', () => {
+    showing('/workspace/ws-1/home', false)
+
     reflectBackgroundChatStatus(
       queryClient,
       'ws-1',
@@ -372,9 +394,6 @@ describe('reflectBackgroundChatStatus', () => {
       true
     )
 
-    expect(queryClient.invalidateQueries).toHaveBeenCalledTimes(1)
-    expect(queryClient.invalidateQueries).toHaveBeenCalledWith({
-      queryKey: desktopActivityKeys.lists(),
-    })
+    expect(activityStale()).toBe(false)
   })
 })
diff --git a/apps/sim/lib/mothership/chat/application/admit-turn.test.ts b/apps/sim/lib/mothership/chat/application/admit-turn.test.ts
index 7ee17fdbe67..df6acee6eb4 100644
--- a/apps/sim/lib/mothership/chat/application/admit-turn.test.ts
+++ b/apps/sim/lib/mothership/chat/application/admit-turn.test.ts
@@ -137,7 +137,6 @@ describe('organization turn admission through current private-chat authorization
       input: { ...input(), desktopDeviceId: '33333333-3333-4333-8333-333333333333' },
     })
 
-    expect(hoisted.resolveDesktop).not.toHaveBeenCalled()
     expect(dbChainMockFns.values).toHaveBeenCalledWith(
       expect.objectContaining({ organizationId: 'org-1', desktopDeviceId: null })
     )

From 50bb444aab5313099f105fef93f4c9c72e90ba9f Mon Sep 17 00:00:00 2001
From: Waleed Latif <walif6@gmail.com>
Date: Tue, 6 Oct 2026 13:53:34 -0700
Subject: [PATCH 5/7] fix(desktop): keep the old notification rule with the
 flag off, and announce only the user's own chats

- Every existing notification is held back whenever the window is focused,
  as before. Only a background chat's completion, now marked as such, is
  shown when the focused window is somewhere else. With the flag off, a
  flag-off user watching the workflow panel is no longer told about the
  chat they are looking at. The settings label is back to its original
  wording.
- Workspace chat events carry every member's chats. A completion is now
  announced only for a chat this user's own desktop was running, so a
  teammate's finished chat raises nothing.
- The sidebar's activity reads get their own rate-limit bucket, so polling
  tabs can never spend the tokens a device needs to renew its leases.
- An offline desktop's chat now says it is waiting for the device to come
  back, not that it is blocked.
- The rule for which turns bind to a desktop is a named function, tested on
  its outcome.
---
 .../desktop/src/main/desktop-settings.test.ts | 14 +++++++++++
 apps/desktop/src/main/desktop-settings.ts     |  4 +++-
 apps/desktop/src/main/ipc.ts                  | 10 ++++++--
 apps/sim/app/api/desktop/activity/route.ts    |  4 ++--
 .../settings/components/desktop/desktop.tsx   |  2 +-
 .../w/components/sidebar/sidebar.tsx          |  2 +-
 .../hooks/use-mothership-chat-events.test.ts  | 24 +++++++++++++++++--
 apps/sim/hooks/use-mothership-chat-events.ts  | 22 ++++++++++++++---
 .../lib/api/server/routes/desktop-executor.ts |  9 +++++++
 apps/sim/lib/desktop/application/activity.ts  |  6 +++--
 .../chat/application/admit-turn.test.ts       | 20 ++++------------
 .../mothership/chat/application/admit-turn.ts | 21 +++++++++++-----
 packages/desktop-bridge/src/index.ts          |  6 +++++
 13 files changed, 109 insertions(+), 35 deletions(-)

diff --git a/apps/desktop/src/main/desktop-settings.test.ts b/apps/desktop/src/main/desktop-settings.test.ts
index 8fa53111c66..fdc2e135d8f 100644
--- a/apps/desktop/src/main/desktop-settings.test.ts
+++ b/apps/desktop/src/main/desktop-settings.test.ts
@@ -49,6 +49,7 @@ describe('desktop notifications in the default "background only" mode', () => {
       title: 'Fix CI',
       body: 'Sim finished responding.',
       route: BACKGROUND_CHAT,
+      background: true,
     })
 
     expect(shown).toBe(true)
@@ -60,6 +61,7 @@ describe('desktop notifications in the default "background only" mode', () => {
       title: 'Fix CI',
       body: 'Sim finished responding.',
       route: BACKGROUND_CHAT,
+      background: true,
     })
 
     expect(shown).toBe(false)
@@ -74,4 +76,16 @@ describe('desktop notifications in the default "background only" mode', () => {
 
     expect(shown).toBe(false)
   })
+
+  it('holds back an ordinary notification whenever the window is focused, wherever it is', () => {
+    // The workflow panel's chat completes while the user watches it on the workflow page.
+    const shown = service({ url: 'https://sim.ai/workspace/ws-1/w/wf-1', focused: true }).notify({
+      title: 'Task complete',
+      body: 'Sim finished responding.',
+      route: BACKGROUND_CHAT,
+    })
+
+    expect(shown).toBe(false)
+    expect(Notification.instances).toHaveLength(0)
+  })
 })
diff --git a/apps/desktop/src/main/desktop-settings.ts b/apps/desktop/src/main/desktop-settings.ts
index 4367109eb08..f14e0157fc9 100644
--- a/apps/desktop/src/main/desktop-settings.ts
+++ b/apps/desktop/src/main/desktop-settings.ts
@@ -218,10 +218,12 @@ export function createDesktopSettingsService(
         return false
       }
       const window = deps.getMainWindow()
+      // A focused window holds back every notification, as it always has. Only a background
+      // chat's completion is shown anyway when the focused window is somewhere else.
       if (
         preferences.notificationsOnlyWhenUnfocused &&
         window?.isFocused() &&
-        showsRoute(window, payload.route)
+        (!payload.background || showsRoute(window, payload.route))
       ) {
         return false
       }
diff --git a/apps/desktop/src/main/ipc.ts b/apps/desktop/src/main/ipc.ts
index 1ca3b569f59..cd5b81d8400 100644
--- a/apps/desktop/src/main/ipc.ts
+++ b/apps/desktop/src/main/ipc.ts
@@ -305,10 +305,11 @@ export function parseDesktopNotificationPayload(raw: unknown): DesktopNotificati
   if (typeof raw !== 'object' || raw === null) {
     return null
   }
-  const { title, body, route } = raw as {
+  const { title, body, route, background } = raw as {
     title?: unknown
     body?: unknown
     route?: unknown
+    background?: unknown
   }
   if (
     typeof title !== 'string' ||
@@ -323,7 +324,12 @@ export function parseDesktopNotificationPayload(raw: unknown): DesktopNotificati
   if (route !== undefined && (typeof route !== 'string' || !isSafeInternalPath(route))) {
     return null
   }
-  return { title, body, ...(route !== undefined ? { route } : {}) }
+  return {
+    title,
+    body,
+    ...(route !== undefined ? { route } : {}),
+    ...(background === true ? { background: true } : {}),
+  }
 }
 
 export interface IpcDeps {
diff --git a/apps/sim/app/api/desktop/activity/route.ts b/apps/sim/app/api/desktop/activity/route.ts
index d603d7309a7..3aa5c0b2162 100644
--- a/apps/sim/app/api/desktop/activity/route.ts
+++ b/apps/sim/app/api/desktop/activity/route.ts
@@ -1,8 +1,8 @@
 import { listDesktopActivityContract } from '@/lib/api/contracts/desktop-executor'
 import { defineInternalJsonRoute, internalSessionAuth } from '@/lib/api/server/routes'
 import {
+  desktopActivityRateLimit,
   desktopExecutorErrorPolicy,
-  desktopExecutorRateLimit,
 } from '@/lib/api/server/routes/desktop-executor'
 import { listDesktopActivity } from '@/lib/desktop/application/activity'
 
@@ -12,7 +12,7 @@ export const GET = defineInternalJsonRoute({
   contract: listDesktopActivityContract,
   auth: internalSessionAuth,
   operation: listDesktopActivity.operation,
-  rateLimit: desktopExecutorRateLimit,
+  rateLimit: desktopActivityRateLimit,
   errorPolicy: desktopExecutorErrorPolicy,
   mapInput: ({ query }) => ({ workspaceId: query.workspaceId }),
   useCase: listDesktopActivity,
diff --git a/apps/sim/app/workspace/[workspaceId]/settings/components/desktop/desktop.tsx b/apps/sim/app/workspace/[workspaceId]/settings/components/desktop/desktop.tsx
index 1b96613d97d..20d72828869 100644
--- a/apps/sim/app/workspace/[workspaceId]/settings/components/desktop/desktop.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/settings/components/desktop/desktop.tsx
@@ -125,7 +125,7 @@ export function Desktop() {
           />
           <PreferenceRow
             id='desktop-notifications-unfocused'
-            label='Notify only for chats in the background'
+            label="Notify only when Sim isn't focused"
             checked={preferences.notificationsOnlyWhenUnfocused}
             disabled={notificationsDisabled || pendingPreference !== null}
             onCheckedChange={(checked) =>
diff --git a/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx b/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx
index 8073cbed0a8..5f3f99e7530 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx
@@ -193,7 +193,7 @@ const DESKTOP_ACTIVITY_COLOR: Record<DesktopChatActivity['state'], string> = {
 
 function desktopActivityLabel({ state, deviceName }: DesktopChatActivity): string {
   if (state === 'needs_input') return 'Needs input'
-  if (state === 'blocked') return `Blocked: ${deviceName} is offline`
+  if (state === 'blocked') return `Waiting for ${deviceName} to come back online`
   return `Running on ${deviceName}`
 }
 
diff --git a/apps/sim/hooks/use-mothership-chat-events.test.ts b/apps/sim/hooks/use-mothership-chat-events.test.ts
index a54b717bee6..2f7062f7309 100644
--- a/apps/sim/hooks/use-mothership-chat-events.test.ts
+++ b/apps/sim/hooks/use-mothership-chat-events.test.ts
@@ -324,7 +324,9 @@ describe('reflectBackgroundChatStatus', () => {
     queryClient.setQueryData(mothershipChatKeys.ownerList('ws-1'), [
       { id: 'chat-b', name: 'Fix CI' },
     ])
-    queryClient.setQueryData(desktopActivityKeys.list('ws-1'), [])
+    queryClient.setQueryData(desktopActivityKeys.list('ws-1'), [
+      { chatId: 'chat-b', state: 'running', deviceName: 'Studio Mac' },
+    ])
   }
 
   const activityStale = () =>
@@ -338,7 +340,12 @@ describe('reflectBackgroundChatStatus', () => {
     reflectBackgroundChatStatus(queryClient, 'ws-1', completed, true)
 
     expect(shown).toEqual([
-      { title: 'Fix CI', body: 'Sim finished responding.', route: '/workspace/ws-1/chat/chat-b' },
+      {
+        title: 'Fix CI',
+        body: 'Sim finished responding.',
+        route: '/workspace/ws-1/chat/chat-b',
+        background: true,
+      },
     ])
   })
 
@@ -396,4 +403,17 @@ describe('reflectBackgroundChatStatus', () => {
 
     expect(activityStale()).toBe(false)
   })
+
+  it("never announces a teammate's chat that finished in the same workspace", () => {
+    showing('/workspace/ws-1/chat/chat-c')
+
+    reflectBackgroundChatStatus(
+      queryClient,
+      'ws-1',
+      JSON.stringify({ chatId: 'teammate-chat', type: 'completed', streamId: 's-9' }),
+      true
+    )
+
+    expect(shown).toEqual([])
+  })
 })
diff --git a/apps/sim/hooks/use-mothership-chat-events.ts b/apps/sim/hooks/use-mothership-chat-events.ts
index e86a8e58e09..419bc201f2a 100644
--- a/apps/sim/hooks/use-mothership-chat-events.ts
+++ b/apps/sim/hooks/use-mothership-chat-events.ts
@@ -3,6 +3,7 @@ import { createLogger } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
 import type { QueryClient } from '@tanstack/react-query'
 import { useQueryClient } from '@tanstack/react-query'
+import type { DesktopChatActivity } from '@/lib/api/contracts/desktop-executor'
 import { getDesktopBridge } from '@/lib/desktop'
 import { suspendDesktopChatScopes } from '@/lib/desktop/chat-scope'
 import { createRotatingEventSource } from '@/lib/events/rotating-event-source'
@@ -194,8 +195,8 @@ 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, 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
+ * activity list changes and, with `announceCompletions`, a chat of the user's own that their
+ * desktop was running and that they are not looking at is announced when its turn finishes. 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.
  */
@@ -207,8 +208,18 @@ export function reflectBackgroundChatStatus(
 ): void {
   const payload = parseChatStatusEventPayload(data)
   if (payload?.type !== 'started' && payload?.type !== 'completed') return
+  // Read before the refresh below drops it. The events carry every member's chats in the
+  // workspace; only one this user's own desktop was running is theirs to be told about.
+  const ranOnDesktop =
+    typeof owner === 'string' &&
+    Boolean(
+      queryClient
+        .getQueryData<DesktopChatActivity[]>(desktopActivityKeys.list(owner))
+        ?.some((activity) => activity.chatId === payload.chatId)
+    )
   queryClient.invalidateQueries({ queryKey: desktopActivityKeys.lists() })
   if (!announceCompletions || payload.type !== 'completed' || !payload.chatId) return
+  if (!ranOnDesktop) return
   const settings = getDesktopBridge()?.settings
   if (!settings) return
   const route = chatRoute(owner, payload.chatId)
@@ -218,7 +229,12 @@ export function reflectBackgroundChatStatus(
   )
   const name = chats?.find((chat) => chat.id === payload.chatId)?.name
   void settings
-    .notify({ title: name ?? 'Task complete', body: 'Sim finished responding.', route })
+    .notify({
+      title: name ?? 'Task complete',
+      body: 'Sim finished responding.',
+      route,
+      background: true,
+    })
     .catch((error) =>
       logger.warn('Could not show a chat completion notification', {
         error: getErrorMessage(error),
diff --git a/apps/sim/lib/api/server/routes/desktop-executor.ts b/apps/sim/lib/api/server/routes/desktop-executor.ts
index c78b6b7dbc6..7b504dbb03e 100644
--- a/apps/sim/lib/api/server/routes/desktop-executor.ts
+++ b/apps/sim/lib/api/server/routes/desktop-executor.ts
@@ -34,3 +34,12 @@ export const desktopExecutorRateLimit = internalRateLimits.user({
   bucketName: 'desktop-executor',
   config: { maxTokens: 600, refillRate: 10, refillIntervalMs: 1_000 },
 })
+
+/**
+ * The sidebar's desktop activity reads, in a bucket of their own: however many tabs poll it, they
+ * can never spend the tokens a device needs to renew its leases.
+ */
+export const desktopActivityRateLimit = internalRateLimits.user({
+  bucketName: 'desktop-activity',
+  config: { maxTokens: 120, refillRate: 2, refillIntervalMs: 1_000 },
+})
diff --git a/apps/sim/lib/desktop/application/activity.ts b/apps/sim/lib/desktop/application/activity.ts
index 9edb55adad7..245697b8621 100644
--- a/apps/sim/lib/desktop/application/activity.ts
+++ b/apps/sim/lib/desktop/application/activity.ts
@@ -11,7 +11,8 @@ const logger = createLogger('DesktopActivity')
 /**
  * - `running`: the desktop is working on the chat's turn.
  * - `needs_input`: the turn waits on the user: an approval, a terminal handoff, a browser takeover.
- * - `blocked`: the desktop the turn runs on is offline, so its desktop calls cannot start.
+ * - `blocked`: the desktop the turn runs on is offline; its desktop calls fail as not run until it
+ *   returns, while the rest of the turn carries on.
  */
 type DesktopChatActivityState = 'running' | 'needs_input' | 'blocked'
 
@@ -35,7 +36,8 @@ async function readPresence(deviceId: string): Promise<boolean> {
 /**
  * Which of the caller's chats in a workspace are running on one of their desktops, and in what
  * state. Lists only the caller's own runs, never their content, so it needs no workspace role.
- * Runs already bound keep showing after the executor is turned off, until they end.
+ * The endpoint is not flag-gated (runs already bound are listed until they end); the sidebar asks
+ * only while the background executor is on for the user.
  */
 export const listDesktopActivity = defineAuthorizedCredentialUserUseCase({
   // permission-group-exempt: reports only the caller's own runs, with no content.
diff --git a/apps/sim/lib/mothership/chat/application/admit-turn.test.ts b/apps/sim/lib/mothership/chat/application/admit-turn.test.ts
index df6acee6eb4..dd43615f58f 100644
--- a/apps/sim/lib/mothership/chat/application/admit-turn.test.ts
+++ b/apps/sim/lib/mothership/chat/application/admit-turn.test.ts
@@ -22,7 +22,7 @@ import {
   permissionGroupsResolveMockFns,
 } from '@sim/testing/mocks/permission-groups-resolve.mock'
 import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest'
-import { admitChatTurn } from '@/lib/mothership/chat/application/admit-turn'
+import { admitChatTurn, turnDesktopDevice } from '@/lib/mothership/chat/application/admit-turn'
 
 const hoisted = vi.hoisted(() => ({
   lease: vi.fn(),
@@ -125,21 +125,11 @@ describe('organization turn admission through current private-chat authorization
   })
   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' },
-    })
+    const offered = '33333333-3333-4333-8333-333333333333'
 
-    expect(dbChainMockFns.values).toHaveBeenCalledWith(
-      expect.objectContaining({ organizationId: 'org-1', desktopDeviceId: null })
-    )
+    await expect(turnDesktopDevice(principal, null, offered)).resolves.toBeNull()
+    await expect(turnDesktopDevice(principal, 'ws-1', offered)).resolves.toBe('device-1')
+    await expect(turnDesktopDevice(principal, 'ws-1', undefined)).resolves.toBeNull()
   })
   it.each(['agent', 'assistant', 'plan'] as const)(
     'switches the same chat to %s atomically with turn admission',
diff --git a/apps/sim/lib/mothership/chat/application/admit-turn.ts b/apps/sim/lib/mothership/chat/application/admit-turn.ts
index 487d19a93f4..b35ea6d5a58 100644
--- a/apps/sim/lib/mothership/chat/application/admit-turn.ts
+++ b/apps/sim/lib/mothership/chat/application/admit-turn.ts
@@ -43,6 +43,20 @@ interface AdmitTurnInput {
   desktopDeviceId?: string
 }
 
+/**
+ * The desktop a turn runs on, if any. 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.
+ */
+export async function turnDesktopDevice(
+  principal: SessionPrincipal,
+  workspaceId: string | null | undefined,
+  offeredDeviceId: string | undefined
+): Promise<string | null> {
+  if (!offeredDeviceId || !workspaceId) return null
+  return resolveTurnDesktopDevice(principal, offeredDeviceId)
+}
+
 /** The accepted message, its start intent and retry destination commit together. */
 export const admitChatTurn = defineAuthorizedChatUseCase({
   operation: defineWorkspaceOperation({
@@ -86,12 +100,7 @@ export const admitChatTurn = defineAuthorizedChatUseCase({
       else await requireOrganizationSearchAvailable(organizationId)
     }
     await assertChatStreamLease(input.lease)
-    // 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 desktopDeviceId = await turnDesktopDevice(principal, workspaceId, input.desktopDeviceId)
     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
diff --git a/packages/desktop-bridge/src/index.ts b/packages/desktop-bridge/src/index.ts
index 89c89f28e2b..1ffed49b294 100644
--- a/packages/desktop-bridge/src/index.ts
+++ b/packages/desktop-bridge/src/index.ts
@@ -954,6 +954,12 @@ export interface DesktopNotificationPayload {
   body: string
   /** Optional in-app route opened when the notification is clicked. */
   route?: string
+  /**
+   * A chat that finished in the background. In "only when unfocused" mode such a notification is
+   * held back only while the focused window shows its `route`; every other notification is held
+   * back whenever the window is focused.
+   */
+  background?: boolean
 }
 
 /** Device-level settings owned by the desktop shell. */

From 9518d434f02c2900930e1c03d52701ae25f1738f Mon Sep 17 00:00:00 2001
From: Waleed Latif <walif6@gmail.com>
Date: Tue, 6 Oct 2026 14:30:10 -0700
Subject: [PATCH 6/7] fix(desktop): announce a background completion only for
 the very turn the desktop ran

Desktop activity now names each bound turn's stream, and a completion is
announced only when that turn was seen running on the user's own desktop.
An earlier desktop turn no longer makes a later chat-view turn in the same
chat look eligible.
---
 .../hooks/use-mothership-chat-events.test.ts  | 15 +++++++++-
 apps/sim/hooks/use-mothership-chat-events.ts  |  8 ++++--
 .../sim/lib/api/contracts/desktop-executor.ts |  2 ++
 .../application/activity.integration.ts       | 28 ++++++++++++++++---
 .../lib/desktop/application/activity.test.ts  | 16 +++++++++--
 apps/sim/lib/desktop/application/activity.ts  |  3 ++
 apps/sim/lib/desktop/executor/repository.ts   |  1 +
 7 files changed, 63 insertions(+), 10 deletions(-)

diff --git a/apps/sim/hooks/use-mothership-chat-events.test.ts b/apps/sim/hooks/use-mothership-chat-events.test.ts
index 2f7062f7309..f8e58df7b90 100644
--- a/apps/sim/hooks/use-mothership-chat-events.test.ts
+++ b/apps/sim/hooks/use-mothership-chat-events.test.ts
@@ -325,7 +325,7 @@ describe('reflectBackgroundChatStatus', () => {
       { id: 'chat-b', name: 'Fix CI' },
     ])
     queryClient.setQueryData(desktopActivityKeys.list('ws-1'), [
-      { chatId: 'chat-b', state: 'running', deviceName: 'Studio Mac' },
+      { chatId: 'chat-b', streamId: 's-1', state: 'running', deviceName: 'Studio Mac' },
     ])
   }
 
@@ -416,4 +416,17 @@ describe('reflectBackgroundChatStatus', () => {
 
     expect(shown).toEqual([])
   })
+
+  it('stays silent for a later turn the chat view ran in a chat a desktop ran before', () => {
+    showing('/workspace/ws-1/chat/chat-c')
+
+    reflectBackgroundChatStatus(
+      queryClient,
+      'ws-1',
+      JSON.stringify({ chatId: 'chat-b', type: 'completed', streamId: 's-later' }),
+      true
+    )
+
+    expect(shown).toEqual([])
+  })
 })
diff --git a/apps/sim/hooks/use-mothership-chat-events.ts b/apps/sim/hooks/use-mothership-chat-events.ts
index 419bc201f2a..bd7850174dd 100644
--- a/apps/sim/hooks/use-mothership-chat-events.ts
+++ b/apps/sim/hooks/use-mothership-chat-events.ts
@@ -209,13 +209,17 @@ export function reflectBackgroundChatStatus(
   const payload = parseChatStatusEventPayload(data)
   if (payload?.type !== 'started' && payload?.type !== 'completed') return
   // Read before the refresh below drops it. The events carry every member's chats in the
-  // workspace; only one this user's own desktop was running is theirs to be told about.
+  // workspace; only this very turn, seen running on this user's own desktop, is theirs to be told
+  // about. Matching the turn, not just the chat, keeps an earlier desktop turn from vouching for a
+  // later one the chat view ran.
   const ranOnDesktop =
     typeof owner === 'string' &&
     Boolean(
       queryClient
         .getQueryData<DesktopChatActivity[]>(desktopActivityKeys.list(owner))
-        ?.some((activity) => activity.chatId === payload.chatId)
+        ?.some(
+          (activity) => activity.chatId === payload.chatId && activity.streamId === payload.streamId
+        )
     )
   queryClient.invalidateQueries({ queryKey: desktopActivityKeys.lists() })
   if (!announceCompletions || payload.type !== 'completed' || !payload.chatId) return
diff --git a/apps/sim/lib/api/contracts/desktop-executor.ts b/apps/sim/lib/api/contracts/desktop-executor.ts
index 07c8c2d865d..626bf2486b2 100644
--- a/apps/sim/lib/api/contracts/desktop-executor.ts
+++ b/apps/sim/lib/api/contracts/desktop-executor.ts
@@ -192,6 +192,8 @@ const desktopActivityQuerySchema = z.object({ workspaceId: workspaceIdSchema })
  */
 const desktopChatActivitySchema = z.object({
   chatId: z.string().min(1),
+  /** The turn the desktop runs, as chat status events name it. */
+  streamId: z.string().min(1),
   state: z.enum(['running', 'needs_input', 'blocked']),
   deviceName: z.string(),
 })
diff --git a/apps/sim/lib/desktop/application/activity.integration.ts b/apps/sim/lib/desktop/application/activity.integration.ts
index 8b5c1765cb6..b587caf094c 100644
--- a/apps/sim/lib/desktop/application/activity.integration.ts
+++ b/apps/sim/lib/desktop/application/activity.integration.ts
@@ -153,8 +153,18 @@ describe.runIf(Boolean(redisUrl))('background desktop activity', () => {
       ).chats
     ).toEqual(
       expect.arrayContaining([
-        { chatId: running.chatId, state: 'blocked', deviceName: 'Studio Mac' },
-        { chatId: waiting.chatId, state: 'needs_input', deviceName: 'Studio Mac' },
+        {
+          chatId: running.chatId,
+          streamId: expect.any(String),
+          state: 'blocked',
+          deviceName: 'Studio Mac',
+        },
+        {
+          chatId: waiting.chatId,
+          streamId: expect.any(String),
+          state: 'needs_input',
+          deviceName: 'Studio Mac',
+        },
       ])
     )
 
@@ -172,8 +182,18 @@ describe.runIf(Boolean(redisUrl))('background desktop activity', () => {
       expect(chats).toHaveLength(2)
       expect(chats).toEqual(
         expect.arrayContaining([
-          { chatId: running.chatId, state: 'running', deviceName: 'Studio Mac' },
-          { chatId: waiting.chatId, state: 'needs_input', deviceName: 'Studio Mac' },
+          {
+            chatId: running.chatId,
+            streamId: expect.any(String),
+            state: 'running',
+            deviceName: 'Studio Mac',
+          },
+          {
+            chatId: waiting.chatId,
+            streamId: expect.any(String),
+            state: 'needs_input',
+            deviceName: 'Studio Mac',
+          },
         ])
       )
     } finally {
diff --git a/apps/sim/lib/desktop/application/activity.test.ts b/apps/sim/lib/desktop/application/activity.test.ts
index 6ff4d2f2e7b..15eb8fec70f 100644
--- a/apps/sim/lib/desktop/application/activity.test.ts
+++ b/apps/sim/lib/desktop/application/activity.test.ts
@@ -19,7 +19,13 @@ const principal = createSessionPrincipal({ userId: 'user-1', sessionId: 'session
 describe('desktop activity presence', () => {
   beforeEach(() => {
     rows.mockResolvedValue([
-      { chatId: 'chat-1', deviceId: 'device-1', deviceName: 'Studio Mac', needsInput: false },
+      {
+        chatId: 'chat-1',
+        streamId: 's-1',
+        deviceId: 'device-1',
+        deviceName: 'Studio Mac',
+        needsInput: false,
+      },
     ])
   })
 
@@ -32,7 +38,9 @@ describe('desktop activity presence', () => {
       input: { workspaceId: 'ws-1' },
     })
 
-    expect(chats).toEqual([{ chatId: 'chat-1', state: 'running', deviceName: 'Studio Mac' }])
+    expect(chats).toEqual([
+      { chatId: 'chat-1', streamId: 's-1', state: 'running', deviceName: 'Studio Mac' },
+    ])
   })
 
   it('calls a desktop blocked when presence is tracked and it is gone', async () => {
@@ -44,6 +52,8 @@ describe('desktop activity presence', () => {
       input: { workspaceId: 'ws-1' },
     })
 
-    expect(chats).toEqual([{ chatId: 'chat-1', state: 'blocked', deviceName: 'Studio Mac' }])
+    expect(chats).toEqual([
+      { chatId: 'chat-1', streamId: 's-1', state: 'blocked', deviceName: 'Studio Mac' },
+    ])
   })
 })
diff --git a/apps/sim/lib/desktop/application/activity.ts b/apps/sim/lib/desktop/application/activity.ts
index 245697b8621..06e6b5dd674 100644
--- a/apps/sim/lib/desktop/application/activity.ts
+++ b/apps/sim/lib/desktop/application/activity.ts
@@ -18,6 +18,8 @@ type DesktopChatActivityState = 'running' | 'needs_input' | 'blocked'
 
 export interface DesktopChatActivityEntry {
   chatId: string
+  /** The turn the desktop runs, as chat status events name it. */
+  streamId: string
   state: DesktopChatActivityState
   deviceName: string
 }
@@ -66,6 +68,7 @@ export const listDesktopActivity = defineAuthorizedCredentialUserUseCase({
       if (chats.has(run.chatId)) continue
       chats.set(run.chatId, {
         chatId: run.chatId,
+        streamId: run.streamId,
         deviceName: run.deviceName,
         state: run.needsInput ? 'needs_input' : online.get(run.deviceId) ? 'running' : 'blocked',
       })
diff --git a/apps/sim/lib/desktop/executor/repository.ts b/apps/sim/lib/desktop/executor/repository.ts
index 5760986b0fb..324e55f2de2 100644
--- a/apps/sim/lib/desktop/executor/repository.ts
+++ b/apps/sim/lib/desktop/executor/repository.ts
@@ -454,6 +454,7 @@ export async function listDesktopActivityRows(input: { userId: string; workspace
     .select({
       runId: copilotRuns.id,
       chatId: copilotRuns.chatId,
+      streamId: copilotRuns.streamId,
       deviceId: desktopDevices.id,
       deviceName: desktopDevices.name,
     })

From 684261b1fdf65160aafa59c7c404ac79c09945a6 Mon Sep 17 00:00:00 2001
From: Waleed Latif <walif6@gmail.com>
Date: Tue, 6 Oct 2026 17:26:05 -0700
Subject: [PATCH 7/7] style(desktop): color the background activity dot with
 Tailwind classes

---
 .../[workspaceId]/w/components/sidebar/sidebar.tsx    | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx b/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx
index 5f3f99e7530..2f8353dfb03 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx
@@ -185,10 +185,10 @@ const SEARCH_MODAL_DATE_FORMAT = new Intl.DateTimeFormat(undefined, {
   minute: '2-digit',
 })
 
-const DESKTOP_ACTIVITY_COLOR: Record<DesktopChatActivity['state'], string> = {
-  running: '#EAB308',
-  needs_input: 'var(--warning)',
-  blocked: 'var(--text-error)',
+const DESKTOP_ACTIVITY_COLOR_CLASS: Record<DesktopChatActivity['state'], string> = {
+  running: 'bg-[#EAB308]',
+  needs_input: 'bg-[var(--warning)]',
+  blocked: 'bg-[var(--text-error)]',
 }
 
 function desktopActivityLabel({ state, deviceName }: DesktopChatActivity): string {
@@ -211,8 +211,7 @@ function DesktopActivityDot({ activity }: DesktopActivityDotProps) {
     <span
       role='img'
       aria-label={desktopActivityLabel(activity)}
-      className='size-[6px] rounded-full'
-      style={{ backgroundColor: DESKTOP_ACTIVITY_COLOR[activity.state] }}
+      className={cn('size-[6px] rounded-full', DESKTOP_ACTIVITY_COLOR_CLASS[activity.state])}
     />
   )
 }