Restore desktop parity and preserve interrupted chat progress

Author: Sg312

apps/desktop/e2e/browser-tools.spec.ts

@@ -30,7 +30,7 @@ const FORM = `<!doctype html><html><head><title>Form fixture</title></head><body
 test.describe('browser tools', () => {
   const calls = new Map<
     string,
-    { chatId: string; toolName: BrowserToolName; args: Record<string, unknown> }
+    { chatId: string; toolName: BrowserToolName | 'terminal'; args: Record<string, unknown> }
   >()
   let server: Server
   let origin: string
@@ -50,6 +50,7 @@ test.describe('browser tools', () => {
         let body = ''
         for await (const chunk of request) body += chunk.toString()
         const authorization = calls.get(JSON.parse(body).toolCallId)
+        calls.delete(JSON.parse(body).toolCallId)
         response.writeHead(authorization ? 200 : 403, { 'Content-Type': 'application/json' })
         response.end(JSON.stringify(authorization ?? {}))
         return
@@ -269,4 +270,37 @@ test.describe('browser tools', () => {
     expect(fill.result).toMatchObject({ completed: false, completedCount: 0 })
     expect(await formState()).toMatchObject({ name: '', password: '' })
   })
+  test('local terminal executes through its native PTY and refuses repeated authorization', async () => {
+    await window.evaluate(async (scope) => {
+      const api = (globalThis as typeof globalThis & { simDesktop: SimDesktopApi }).simDesktop
+      await api.terminal.activateScope(scope)
+      await api.terminal.start({ cols: 100, rows: 30 }, scope)
+    }, SCOPE)
+    calls.set('local-cwd', {
+      chatId: SCOPE,
+      toolName: 'terminal',
+      args: { operation: 'cwd', args: {} },
+    })
+    const cwd = await window.evaluate(async (scope) => {
+      const api = (globalThis as typeof globalThis & { simDesktop: SimDesktopApi }).simDesktop
+      return api.terminal.executeTool('local-cwd', 'cwd', {}, scope)
+    }, SCOPE)
+    expect(cwd.ok).toBe(true)
+    calls.set('local-run', {
+      chatId: SCOPE,
+      toolName: 'terminal',
+      args: { operation: 'run', args: { command: "printf 'SIM_NATIVE_TERMINAL_VERIFIED\\n'" } },
+    })
+    const result = await window.evaluate(async (scope) => {
+      const api = (globalThis as typeof globalThis & { simDesktop: SimDesktopApi }).simDesktop
+      return api.terminal.executeTool('local-run', 'run', {}, scope)
+    }, SCOPE)
+    expect(result.ok).toBe(true)
+    expect(JSON.stringify(result)).toContain('SIM_NATIVE_TERMINAL_VERIFIED')
+    const replay = await window.evaluate(async (scope) => {
+      const api = (globalThis as typeof globalThis & { simDesktop: SimDesktopApi }).simDesktop
+      return api.terminal.executeTool('local-run', 'run', {}, scope)
+    }, SCOPE)
+    expect(replay.ok).toBe(false)
+  })
 })

apps/desktop/src/main/browser-agent/session.test.ts

@@ -2358,6 +2358,26 @@ describe('browser-agent session', () => {
     expect(session.listTabs()).toHaveLength(13)
   })
 
+  it('gives background automation a viewport without taking panel ownership', () => {
+    const tab = session.withBrowserScope('background-chat', () => session.ensureTab())
+
+    expect(tab.view.setBounds).toHaveBeenCalledWith({
+      x: 0,
+      y: 0,
+      width: 1180,
+      height: 850,
+    })
+    expect(win.contentView.addChildView).not.toHaveBeenCalledWith(tab.view)
+    expect(session.getActiveBrowserScopeId()).toBe('chat-test')
+  })
+
+  it('initializes a detached viewport when no application window exists', () => {
+    const headlessSession = freshSession(null)
+    const tab = headlessSession.ensureTab()
+
+    expect(tab.view.setBounds).toHaveBeenCalledWith({ x: 0, y: 0, width: 1280, height: 720 })
+  })
+
   it('embeds the active view in the MAIN window only while panel bounds are reported', () => {
     const tab = session.ensureTab()
     const view = tab.view as unknown as MockView

apps/desktop/src/main/browser-agent/session.ts

@@ -1953,6 +1953,9 @@ function createTabView(): WebContentsView {
     },
   })
   try {
+    /** Detached tabs must lay out before a foreground panel owns their native view. */
+    const [width, height] = getMainWindow()?.getContentSize() ?? [1280, 720]
+    view.setBounds({ x: 0, y: 0, width: Math.max(1, width), height: Math.max(1, height) })
     return initializeTabView(view, scopeId)
   } catch (error) {
     if (!view.webContents.isDestroyed()) view.webContents.close()

apps/sim/app/api/copilot/chat/stop/route.test.ts

@@ -5,16 +5,22 @@ import { authMockFns, dbChainMockFns, resetDbChainMock } from '@sim/testing'
 import { NextRequest } from 'next/server'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-const { mockAppendCopilotChatMessages, mockPublishStatusChanged, mockGetAccessibleChat } =
-  vi.hoisted(() => ({
-    mockGetAccessibleChat: vi.fn(),
-    mockAppendCopilotChatMessages: vi.fn(),
-    mockPublishStatusChanged: vi.fn(),
-  }))
+const {
+  mockAppendCopilotChatMessages,
+  mockPublishStatusChanged,
+  mockGetAccessibleChat,
+  mockReadEvents,
+} = vi.hoisted(() => ({
+  mockGetAccessibleChat: vi.fn(),
+  mockAppendCopilotChatMessages: vi.fn(),
+  mockPublishStatusChanged: vi.fn(),
+  mockReadEvents: vi.fn(),
+}))
 
 vi.mock('@/lib/mothership/chat/lifecycle', () => ({
   getAccessibleCopilotChatAuth: mockGetAccessibleChat,
 }))
+vi.mock('@/lib/mothership/request/session/buffer', () => ({ readEvents: mockReadEvents }))
 
 vi.mock('@/lib/mothership/chat/messages-store', () => ({
   appendCopilotChatMessages: mockAppendCopilotChatMessages,
@@ -60,6 +66,7 @@ describe('copilot chat stop route', () => {
       session: { id: 'session-1' },
     })
     mockGetAccessibleChat.mockResolvedValue({ id: 'chat-1', workspaceId: 'ws-1', userId: 'user-1' })
+    mockReadEvents.mockResolvedValue([])
   })
 
   it('does not persist stopped content after organization access is removed', async () => {
@@ -151,6 +158,7 @@ describe('copilot chat stop route', () => {
       createRequest({ chatId: 'chat-1', streamId: 'stream-1', content: '' })
     )
 
+    expect(mockReadEvents).toHaveBeenCalledWith('stream-1', '0')
     expect(response.status).toBe(200)
     expect(await response.json()).toEqual({ success: true })
 

apps/sim/app/api/copilot/chat/stop/route.ts

@@ -77,6 +77,7 @@ export const POST = withRouteHandler((req: NextRequest) =>
         userMessageId: streamId,
         assistantMessage,
         streamMarkerPolicy: 'active-or-cleared',
+        preferServerReplay: true,
       })
       span.setAttribute(TraceAttr.CopilotStopAppendedAssistant, result.appendedAssistant)
       const stopOutcome = !result.found

apps/sim/app/api/mothership/execute/route.test.ts

@@ -270,6 +270,135 @@ describe('mothership private trace provenance transport', () => {
     expect(contextRegistry).toBe(lifecycleOptions.environmentContext?.resolvedSecretTraceRegistry)
   })
 
+  it('forwards closed model controls and an ordered deduplicated safe timeline', async () => {
+    mockRunHeadlessCopilotLifecycle.mockImplementation(
+      async (payload: Record<string, unknown>, options: CopilotLifecycleOptions) => {
+        expect(payload).toMatchObject({
+          modelSelection: { model: 'gpt-6-astra', fastMode: true },
+          effort: 'max',
+        })
+        const base = { v: 1 as const, ts: new Date().toISOString(), stream: { id: 'message-1' } }
+        const thinking = {
+          ...base,
+          seq: 1,
+          type: 'text' as const,
+          payload: { channel: 'thinking' as const, text: 'Considering' },
+        }
+        await options.onEvent?.({
+          ...base,
+          seq: 0,
+          type: 'text',
+          payload: { channel: 'assistant', text: 'I will check.' },
+        })
+        await options.onEvent?.(thinking)
+        await options.onEvent?.(thinking)
+        await options.onEvent?.({
+          ...base,
+          seq: 2,
+          type: 'tool',
+          payload: {
+            phase: 'call',
+            toolCallId: 'tool-1',
+            toolName: 'Lookup',
+            executor: 'go',
+            mode: 'sync',
+            partial: true,
+            arguments: { secret: 'private-args' },
+          },
+        })
+        await options.onEvent?.({
+          ...base,
+          seq: 3,
+          type: 'tool',
+          payload: {
+            phase: 'call',
+            toolCallId: 'tool-1',
+            toolName: 'Lookup',
+            executor: 'go',
+            mode: 'sync',
+          },
+        })
+        await options.onEvent?.({
+          ...base,
+          seq: 4,
+          type: 'tool',
+          payload: {
+            phase: 'result',
+            toolCallId: 'tool-1',
+            toolName: 'Lookup',
+            executor: 'go',
+            mode: 'sync',
+            success: true,
+            output: 'private-result',
+          },
+        })
+        await options.onEvent?.({
+          ...base,
+          seq: 5,
+          type: 'text',
+          payload: { channel: 'assistant', text: 'Answer' },
+        })
+        return { ...successResult(), content: 'Answer' }
+      }
+    )
+    const response = await POST(
+      createMockRequest(
+        'POST',
+        {
+          ...requestBody,
+          modelSelection: { model: 'gpt-6-astra', fastMode: true },
+          effort: 'max',
+        },
+        {
+          Authorization: 'Bearer internal',
+          'x-sim-billing-attribution': 'billing',
+          Accept: 'application/x-ndjson',
+        },
+        'http://localhost:3000/api/mothership/execute'
+      ),
+      undefined
+    )
+    const text = await response.text()
+    const events = text
+      .trim()
+      .split('\n')
+      .map((line) => JSON.parse(line))
+    expect(events.filter((event) => event.type === 'agent_event')).toEqual([
+      { type: 'agent_event', event: { type: 'thinking_delta', text: 'Considering' } },
+      { type: 'agent_event', event: { type: 'turn_end', turn: 'intermediate' } },
+      { type: 'agent_event', event: { type: 'tool_call_start', id: 'tool-1', name: 'Lookup' } },
+      {
+        type: 'agent_event',
+        event: { type: 'tool_call_end', id: 'tool-1', name: 'Lookup', status: 'success' },
+      },
+      { type: 'agent_event', event: { type: 'turn_end', turn: 'final' } },
+    ])
+    expect(events.filter((event) => event.type === 'chunk')).toEqual([
+      { type: 'chunk', content: 'I will check.', turn: 'pending' },
+      { type: 'chunk', content: 'Answer', turn: 'pending' },
+    ])
+    expect(text).not.toContain('private-args')
+    expect(text).not.toContain('private-result')
+  })
+
+  it.each([
+    { modelSelection: { model: 'arbitrary' } },
+    { modelSelection: { model: 'claude-opus-5', fastMode: true } },
+    { effort: 'ultra' },
+  ])('rejects unsupported controls before lifecycle dispatch: %j', async (selection) => {
+    const response = await POST(
+      createMockRequest(
+        'POST',
+        { ...requestBody, ...selection },
+        { Authorization: 'Bearer internal' },
+        'http://localhost:3000/api/mothership/execute'
+      ),
+      undefined
+    )
+    expect(response.status).toBe(400)
+    expect(mockRunHeadlessCopilotLifecycle).not.toHaveBeenCalled()
+  })
+
   it('keeps context routing and display inputs raw until the lifecycle boundary', async () => {
     mockGetPersonalAndWorkspaceEnv.mockResolvedValueOnce({
       personalEncrypted: { API_KEY: 'encrypted-secret' },

apps/sim/app/api/mothership/execute/route.ts

@@ -148,6 +148,8 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
     const {
       messages,
       responseFormat,
+      modelSelection,
+      effort,
       workspaceId,
       userId: bodyUserId,
       chatId,
@@ -301,6 +303,8 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
     )
     const requestPayload: Record<string, unknown> = {
       messages: wireMessages,
+      ...(modelSelection ? { modelSelection } : {}),
+      ...(effort ? { effort } : {}),
       ...(responseFormat !== undefined ? { responseFormat } : {}),
       userId,
       protocolVersion: PROTOCOL_VERSION,
@@ -377,7 +381,9 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
 
       const stream = new ReadableStream<Uint8Array>({
         start(controller) {
-          let lastForwardedTextSeq = -1
+          let lastForwardedSeq = -1
+          const startedTools = new Set<string>()
+          const endedTools = new Set<string>()
           const send = (event: unknown) => {
             if (!cancelled) {
               controller.enqueue(encodeNdjson(event))
@@ -394,20 +400,53 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
           void (async () => {
             try {
               const result = await runLifecycle(async (event) => {
-                if (
-                  event.type === MothershipStreamV1EventType.text &&
-                  event.payload.channel === MothershipStreamV1TextChannel.assistant &&
-                  event.payload.text
-                ) {
-                  /* The wire carries text DELTAS with monotone seqs; a transport-retry
-                     replay re-delivers earlier seqs. Dedupe replays by seq — the old
-                     string-prefix guess sliced characters off a genuine delta that
-                     happened to begin with the already-forwarded content. */
-                  if (typeof event.seq === 'number') {
-                    if (event.seq <= lastForwardedTextSeq) return
-                    lastForwardedTextSeq = event.seq
+                /** Reconnect replays share the same monotone sequence across event types. */
+                if (typeof event.seq === 'number') {
+                  if (event.seq <= lastForwardedSeq) return
+                  lastForwardedSeq = event.seq
+                }
+                if (event.type === MothershipStreamV1EventType.text && event.payload.text) {
+                  if (event.payload.channel === MothershipStreamV1TextChannel.assistant) {
+                    if (event.scope?.lane === 'subagent') return
+                    send({ type: 'chunk', content: event.payload.text, turn: 'pending' })
+                  } else if (event.payload.channel === MothershipStreamV1TextChannel.thinking) {
+                    send({
+                      type: 'agent_event',
+                      event: { type: 'thinking_delta', text: event.payload.text },
+                    })
+                  }
+                } else if (event.type === MothershipStreamV1EventType.tool) {
+                  const tool = event.payload
+                  if (!('phase' in tool)) return
+                  if (tool.phase === 'call' && !startedTools.has(tool.toolCallId)) {
+                    startedTools.add(tool.toolCallId)
+                    if (event.scope?.lane !== 'subagent' && !tool.replay) {
+                      send({
+                        type: 'agent_event',
+                        event: { type: 'turn_end', turn: 'intermediate' },
+                      })
+                    }
+                    send({
+                      type: 'agent_event',
+                      event: { type: 'tool_call_start', id: tool.toolCallId, name: tool.toolName },
+                    })
+                  } else if (tool.phase === 'result' && !endedTools.has(tool.toolCallId)) {
+                    endedTools.add(tool.toolCallId)
+                    send({
+                      type: 'agent_event',
+                      event: {
+                        type: 'tool_call_end',
+                        id: tool.toolCallId,
+                        name: tool.toolName,
+                        status:
+                          tool.status === 'cancelled'
+                            ? 'cancelled'
+                            : tool.success
+                              ? 'success'
+                              : 'error',
+                      },
+                    })
                   }
-                  send({ type: 'chunk', content: event.payload.text })
                 }
               })
               allowExplicitAbort = false
@@ -450,6 +489,7 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
                 return
               }
 
+              send({ type: 'agent_event', event: { type: 'turn_end', turn: 'final' } })
               send({
                 type: 'final',
                 data: withPrivateProvenance(