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..fdc2e135d8f
--- /dev/null
+++ b/apps/desktop/src/main/desktop-settings.test.ts
@@ -0,0 +1,91 @@
+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,
+      background: true,
+    })
+
+    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,
+      background: true,
+    })
+
+    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)
+  })
+
+  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 7f25296b99b..f14e0157fc9 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,13 @@ export function createDesktopSettingsService(
         return false
       }
       const window = deps.getMainWindow()
-      if (preferences.notificationsOnlyWhenUnfocused && window?.isFocused()) {
+      // 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() &&
+        (!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/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
new file mode 100644
index 00000000000..3aa5c0b2162
--- /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 {
+  desktopActivityRateLimit,
+  desktopExecutorErrorPolicy,
+} from '@/lib/api/server/routes/desktop-executor'
+import { listDesktopActivity } from '@/lib/desktop/application/activity'
+
+export const dynamic = 'force-dynamic'
+
+export const GET = defineInternalJsonRoute({
+  contract: listDesktopActivityContract,
+  auth: internalSessionAuth,
+  operation: listDesktopActivity.operation,
+  rateLimit: desktopActivityRateLimit,
+  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-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 2b744ca9404..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,6 +108,73 @@ 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 { started, starters } = recordingStarters()
+    const ctx = createStreamLoopContext(
+      makeStreamLoopDeps({
+        ...starters,
+        chatIdRef: ref('chat-1'),
+        options: { desktopToolsOnDevice: true },
+      })
+    )
+
+    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(started).toEqual(['workflow-1'])
+  })
+
+  it('runs a desktop call in the view when no desktop runs the chat in the background', () => {
+    const { started, starters } = recordingStarters()
+    const ctx = createStreamLoopContext(
+      makeStreamLoopDeps({ ...starters, chatIdRef: ref('chat-1') })
+    )
+
+    dispatchCall(ctx, 'click-2', 'browser_click', { ref: 'e1' })
+
+    expect(started).toEqual(['click-2'])
+  })
+
   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..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
@@ -195,9 +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 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)) &&
+    (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/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]/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..2f8353dfb03 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,37 @@ const SEARCH_MODAL_DATE_FORMAT = new Intl.DateTimeFormat(undefined, {
   minute: '2-digit',
 })
 
+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 {
+  if (state === 'needs_input') return 'Needs input'
+  if (state === 'blocked') return `Waiting for ${deviceName} to come back online`
+  return `Running on ${deviceName}`
+}
+
+interface DesktopActivityDotProps {
+  activity: DesktopChatActivity
+}
+
+/**
+ * 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) {
+  return (
+    <span
+      role='img'
+      aria-label={desktopActivityLabel(activity)}
+      className={cn('size-[6px] rounded-full', DESKTOP_ACTIVITY_COLOR_CLASS[activity.state])}
+    />
+  )
+}
+
 const SidebarChatItem = memo(function SidebarChatItem({
   chat,
   isCurrentRoute,
@@ -190,6 +223,7 @@ const SidebarChatItem = memo(function SidebarChatItem({
   isActive,
   isUnread,
   isPinned,
+  desktopActivity,
   isMenuOpen,
   showCollapsedTooltips,
   onMultiSelectClick,
@@ -203,6 +237,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 +253,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'
@@ -239,7 +275,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}
@@ -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'
@@ -842,7 +885,20 @@ 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
+  )
+  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 +1593,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..b5b4db97db1
--- /dev/null
+++ b/apps/sim/hooks/queries/utils/desktop-activity-keys.ts
@@ -0,0 +1,5 @@
+export const desktopActivityKeys = {
+  all: ['desktop-activity'] as const,
+  lists: () => [...desktopActivityKeys.all, 'list'] as const,
+  list: (workspaceId?: string) => [...desktopActivityKeys.lists(), workspaceId ?? ''] as const,
+}
diff --git a/apps/sim/hooks/use-mothership-chat-events.test.ts b/apps/sim/hooks/use-mothership-chat-events.test.ts
index c451810d378..f8e58df7b90 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'
@@ -11,8 +12,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 +297,136 @@ describe('resyncMothershipChatCaches', () => {
     )
   })
 })
+
+describe('reflectBackgroundChatStatus', () => {
+  /** 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: async (payload: DesktopNotificationPayload) => {
+                  shown.push(payload)
+                  return true
+                },
+              },
+            },
+          }
+        : {}),
+    })
+    queryClient = new QueryClient()
+    queryClient.setQueryData(mothershipChatKeys.ownerList('ws-1'), [
+      { id: 'chat-b', name: 'Fix CI' },
+    ])
+    queryClient.setQueryData(desktopActivityKeys.list('ws-1'), [
+      { chatId: 'chat-b', streamId: 's-1', state: 'running', deviceName: 'Studio Mac' },
+    ])
+  }
+
+  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', () => {
+    showing('/workspace/ws-1/chat/chat-c')
+
+    reflectBackgroundChatStatus(queryClient, 'ws-1', completed, true)
+
+    expect(shown).toEqual([
+      {
+        title: 'Fix CI',
+        body: 'Sim finished responding.',
+        route: '/workspace/ws-1/chat/chat-b',
+        background: true,
+      },
+    ])
+  })
+
+  it('announces nothing while the background executor is off', () => {
+    showing('/workspace/ws-1/chat/chat-c')
+
+    reflectBackgroundChatStatus(queryClient, 'ws-1', completed, false)
+
+    expect(shown).toEqual([])
+  })
+
+  it('leaves the chat on screen to announce itself', () => {
+    showing('/workspace/ws-1/chat/chat-b')
+
+    reflectBackgroundChatStatus(queryClient, 'ws-1', completed, true)
+
+    expect(shown).toEqual([])
+  })
+
+  it('stays silent for a turn that only started', () => {
+    showing('/workspace/ws-1/chat/chat-c')
+
+    reflectBackgroundChatStatus(
+      queryClient,
+      'ws-1',
+      JSON.stringify({ chatId: 'chat-b', type: 'started', streamId: 's-2' }),
+      true
+    )
+
+    expect(shown).toEqual([])
+  })
+
+  it('refreshes which chats run on a desktop when a turn starts', () => {
+    showing('/workspace/ws-1/home', false)
+
+    reflectBackgroundChatStatus(
+      queryClient,
+      'ws-1',
+      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',
+      JSON.stringify({ chatId: 'chat-b', type: 'renamed' }),
+      true
+    )
+
+    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([])
+  })
+
+  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 887eae2d3d5..bd7850174dd 100644
--- a/apps/sim/hooks/use-mothership-chat-events.ts
+++ b/apps/sim/hooks/use-mothership-chat-events.ts
@@ -1,15 +1,20 @@
-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'
 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'
 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 +186,66 @@ 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, 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.
+ */
+export function reflectBackgroundChatStatus(
+  queryClient: Pick<QueryClient, 'getQueryData' | 'invalidateQueries'>,
+  owner: MothershipChatOwner,
+  data: unknown,
+  announceCompletions: boolean
+): 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 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 && activity.streamId === payload.streamId
+        )
+    )
+  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)
+  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,
+      background: true,
+    })
+    .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.
@@ -191,9 +256,13 @@ export function resyncMothershipChatCaches(
  */
 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
 
@@ -210,11 +279,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, announceRef.current)
         },
       },
       onOpen: (reason) => {
diff --git a/apps/sim/lib/api/contracts/desktop-executor.ts b/apps/sim/lib/api/contracts/desktop-executor.ts
index 5d03116954e..626bf2486b2 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,31 @@ 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),
+  /** 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(),
+})
+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/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.integration.ts b/apps/sim/lib/desktop/application/activity.integration.ts
new file mode 100644
index 00000000000..b587caf094c
--- /dev/null
+++ b/apps/sim/lib/desktop/application/activity.integration.ts
@@ -0,0 +1,266 @@
+/**
+ * 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 } 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'
+
+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', 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')
+
+    expect(
+      (
+        await listDesktopActivity.execute({
+          principal: desktop.principal,
+          input: { workspaceId: desktop.workspaceId },
+        })
+      ).chats
+    ).toEqual(
+      expect.arrayContaining([
+        {
+          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',
+        },
+      ])
+    )
+
+    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,
+            streamId: expect.any(String),
+            state: 'running',
+            deviceName: 'Studio Mac',
+          },
+          {
+            chatId: waiting.chatId,
+            streamId: expect.any(String),
+            state: 'needs_input',
+            deviceName: 'Studio Mac',
+          },
+        ])
+      )
+    } finally {
+      close()
+    }
+  })
+
+  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()
+    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/application/activity.test.ts b/apps/sim/lib/desktop/application/activity.test.ts
new file mode 100644
index 00000000000..15eb8fec70f
--- /dev/null
+++ b/apps/sim/lib/desktop/application/activity.test.ts
@@ -0,0 +1,59 @@
+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',
+        streamId: 's-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', streamId: 's-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', 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
new file mode 100644
index 00000000000..06e6b5dd674
--- /dev/null
+++ b/apps/sim/lib/desktop/application/activity.ts
@@ -0,0 +1,78 @@
+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 { isDesktopPresenceAvailable, 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; its desktop calls fail as not run until it
+ *   returns, while the rest of the turn carries on.
+ */
+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
+}
+
+/** 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) {
+    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.
+ * 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.
+  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,
+        streamId: run.streamId,
+        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 d5e478b67b3..324e55f2de2 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,
@@ -442,3 +443,64 @@ 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, 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
+    .select({
+      runId: copilotRuns.id,
+      chatId: copilotRuns.chatId,
+      streamId: copilotRuns.streamId,
+      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 waitingOnUser = await db
+    .selectDistinct({ runId: copilotAsyncToolCalls.runId })
+    .from(copilotAsyncToolCalls)
+    .where(
+      and(
+        inArray(
+          copilotAsyncToolCalls.runId,
+          runs.map((run) => run.runId)
+        ),
+        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'`
+              )
+            )
+          )
+        )
+      )
+    )
+  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/application/admit-turn.test.ts b/apps/sim/lib/mothership/chat/application/admit-turn.test.ts
index f2f8a45c923..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,10 +22,11 @@ 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(),
+  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,14 @@ 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')
+    const offered = '33333333-3333-4333-8333-333333333333'
+
+    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',
     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..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,9 +100,7 @@ export const admitChatTurn = defineAuthorizedChatUseCase({
       else await requireOrganizationSearchAvailable(organizationId)
     }
     await assertChatStreamLease(input.lease)
-    const desktopDeviceId = input.desktopDeviceId
-      ? 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/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'
 
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. */