@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from 'vitest'
+import { describe, expect, it } from 'vitest'
 import { createApprovalNotifier } from '@/main/desktop-executor/approval-notifier'
 import type { DesktopApprovalItem } from '@/main/desktop-executor/executor'
 
@@ -15,35 +15,41 @@ function approval(toolCallId: string, chatId = 'chat-b'): DesktopApprovalItem {
 }
 
 function harness(options: { enabled?: boolean; focusedChatId?: string | null } = {}) {
+  /** Each OS notification the notifier made, and what the user would see of it now. */
   const notifications: Array<{
     options: { title: string; body: string; silent: boolean }
-    show: ReturnType<typeof vi.fn>
-    close: ReturnType<typeof vi.fn>
+    state: 'created' | 'shown' | 'closed'
     click: () => void
   }> = []
-  const openRoute = vi.fn()
+  /** Routes the app was asked to open. */
+  const opened: Array<string | undefined> = []
   let focusedChatId = options.focusedChatId ?? null
   const notifier = createApprovalNotifier({
     preferences: () => ({
       notificationsEnabled: options.enabled ?? true,
       notificationSounds: true,
     }),
     focusedChatId: () => focusedChatId,
-    openRoute,
+    openRoute: (route) => {
+      opened.push(route)
+    },
     createNotification: (notificationOptions) => {
       let click = () => {}
       const notification = {
         options: notificationOptions,
-        show: vi.fn(),
-        close: vi.fn(),
+        state: 'created' as 'created' | 'shown' | 'closed',
         get click() {
           return click
         },
       }
       notifications.push(notification)
       return {
-        show: notification.show,
-        close: notification.close,
+        show: () => {
+          notification.state = 'shown'
+        },
+        close: () => {
+          notification.state = 'closed'
+        },
         on: (_event, listener) => {
           click = listener
         },
@@ -53,7 +59,7 @@ function harness(options: { enabled?: boolean; focusedChatId?: string | null } =
   return {
     notifier,
     notifications,
-    openRoute,
+    opened,
     focus: (chatId: string | null) => {
       focusedChatId = chatId
     },
@@ -62,17 +68,17 @@ function harness(options: { enabled?: boolean; focusedChatId?: string | null } =
 
 describe('approval notifications', () => {
   it('notifies once per waiting call and opens its chat, naming neither chat nor command', () => {
-    const { notifier, notifications, openRoute } = harness()
+    const { notifier, notifications, opened } = harness()
 
     notifier.update([approval('call-1')])
     notifier.update([approval('call-1')])
 
     expect(notifications).toHaveLength(1)
-    expect(notifications[0]?.show).toHaveBeenCalledOnce()
+    expect(notifications[0]?.state).toBe('shown')
     expect(notifications[0]?.options.body).not.toContain('rm -rf')
     expect(notifications[0]?.options.body).not.toContain('Fix CI')
     notifications[0]?.click()
-    expect(openRoute).toHaveBeenCalledWith('/workspace/ws-1/chat/chat-b')
+    expect(opened).toEqual(['/workspace/ws-1/chat/chat-b'])
   })
 
   it('closes the notification once the call is decided', () => {
@@ -81,7 +87,7 @@ describe('approval notifications', () => {
 
     notifier.update([])
 
-    expect(notifications[0]?.close).toHaveBeenCalledOnce()
+    expect(notifications[0]?.state).toBe('closed')
   })
 
   it('stays quiet for the chat the user is looking at, even after they leave it', () => {
 
@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest'
+import { createDesktopExecutorClient, UnsendableRequestError } from '@/main/desktop-executor/client'
+
+describe('desktop executor client', () => {
+  it('refuses a request it cannot encode without sending anything', async () => {
+    let sent = 0
+    const client = createDesktopExecutorClient({
+      origin: () => 'https://sim.test',
+      fetch: async () => {
+        sent += 1
+        return Response.json({ outcome: 'recorded', status: 'completed' })
+      },
+      deviceId: '00000000-0000-4000-8000-000000000000',
+    })
+    const cyclic: Record<string, unknown> = {}
+    cyclic.self = cyclic
+
+    await expect(
+      client.complete({
+        toolCallId: 'call-1',
+        executionToken: 'token-1',
+        completion: { status: 'success', message: 'done', data: cyclic },
+      })
+    ).rejects.toBeInstanceOf(UnsendableRequestError)
+    expect(sent).toBe(0)
+  })
+})
@@ -44,6 +44,25 @@ export class DeviceRequestError extends Error {
   }
 }
 
+/**
+ * A request this device could not even encode (a result holding a cycle or a BigInt). Nothing was
+ * sent, and sending it again cannot help.
+ */
+export class UnsendableRequestError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'UnsendableRequestError'
+  }
+}
+
+function encode(body: Record<string, unknown>): string {
+  try {
+    return JSON.stringify(body)
+  } catch (error) {
+    throw new UnsendableRequestError(getErrorMessage(error))
+  }
+}
+
 type DeviceFetch = (url: string, init: RequestInit) => Promise<Response>
 
 export interface DesktopExecutorClient {
@@ -83,6 +102,7 @@ export function createDesktopExecutorClient(
     body?: Record<string, unknown>,
     signal?: AbortSignal
   ): Promise<Response> {
+    const encoded = body ? encode(body) : undefined
     const timeout = AbortSignal.timeout(REQUEST_TIMEOUT_MS)
     let response: Response
     try {
@@ -93,7 +113,7 @@ export function createDesktopExecutorClient(
           Accept: 'application/json',
           ...(body ? { 'Content-Type': 'application/json' } : {}),
         },
-        ...(body ? { body: JSON.stringify(body) } : {}),
+        ...(encoded !== undefined ? { body: encoded } : {}),
         signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
       })
     } catch (error) {
 
@@ -27,8 +27,14 @@ function controllableStream(signal: AbortSignal) {
 function harness(options: { staleAfterMs?: number; retryBaseMs?: number } = {}) {
   const connections: ReturnType<typeof controllableStream>[] = []
   const failures: DeviceRequestError[] = []
-  const onRing = vi.fn()
-  const onUnregistered = vi.fn()
+  /** How many times the doorbell rang, and asked to register again. */
+  const counts = { rings: 0, unregistered: 0 }
+  const onRing = () => {
+    counts.rings += 1
+  }
+  const onUnregistered = () => {
+    counts.unregistered += 1
+  }
   const doorbell = new InboxDoorbell({
     client: {
       openInboxStream: async (signal) => {
@@ -44,7 +50,7 @@ function harness(options: { staleAfterMs?: number; retryBaseMs?: number } = {})
     retryBaseMs: 5,
     ...options,
   })
-  return { doorbell, connections, failures, onRing, onUnregistered }
+  return { doorbell, connections, failures, counts }
 }
 
 describe('parseServerSentEvents', () => {
@@ -59,12 +65,12 @@ describe('parseServerSentEvents', () => {
 
 describe('InboxDoorbell', () => {
   it('rings on connect and on every inbox change', async () => {
-    const { doorbell, connections, onRing } = harness()
+    const { doorbell, connections, counts } = harness()
     doorbell.start()
-    await vi.waitFor(() => expect(onRing).toHaveBeenCalledTimes(1))
+    await vi.waitFor(() => expect(counts.rings).toBe(1))
 
     connections[0]?.write('event: inbox_changed\ndata: {"reason":"call"}\n\n')
-    await vi.waitFor(() => expect(onRing).toHaveBeenCalledTimes(2))
+    await vi.waitFor(() => expect(counts.rings).toBe(2))
     doorbell.stop()
   })
 
@@ -79,14 +85,14 @@ describe('InboxDoorbell', () => {
   })
 
   it('reconnects after the server drops the stream or refuses a connection', async () => {
-    const { doorbell, connections, failures, onRing } = harness()
+    const { doorbell, connections, failures, counts } = harness()
     failures.push(new DeviceRequestError(0, 'offline'), new DeviceRequestError(502, 'deploy'))
     doorbell.start()
     await vi.waitFor(() => expect(connections).toHaveLength(1))
 
     connections[0]?.end()
     await vi.waitFor(() => expect(connections).toHaveLength(2))
-    expect(onRing).toHaveBeenCalledTimes(2)
+    expect(counts.rings).toBe(2)
     doorbell.stop()
   })
 
@@ -100,8 +106,8 @@ describe('InboxDoorbell', () => {
           return new ReadableStream<Uint8Array>({ start: (controller) => controller.close() })
         },
       },
-      onRing: vi.fn(),
-      onUnregistered: vi.fn(),
+      onRing: () => {},
+      onUnregistered: () => {},
       retryBaseMs: 5,
     })
     try {
@@ -126,23 +132,23 @@ describe('InboxDoorbell', () => {
   })
 
   it('reports a device Sim no longer recognizes', async () => {
-    const { doorbell, failures, onUnregistered } = harness()
+    const { doorbell, failures, counts } = harness()
     failures.push(new DeviceRequestError(401, 'unregistered'))
     doorbell.start()
 
-    await vi.waitFor(() => expect(onUnregistered).toHaveBeenCalled())
+    await vi.waitFor(() => expect(counts.unregistered).toBeGreaterThan(0))
     doorbell.stop()
   })
 
   it('reconnects at once on wake, without waiting out a backoff', async () => {
-    const { doorbell, connections, onRing } = harness({ retryBaseMs: 60_000 })
+    const { doorbell, connections, counts } = harness({ retryBaseMs: 60_000 })
     doorbell.start()
     await vi.waitFor(() => expect(connections).toHaveLength(1))
 
     doorbell.wake()
 
     await vi.waitFor(() => expect(connections).toHaveLength(2))
-    await vi.waitFor(() => expect(onRing).toHaveBeenCalledTimes(2))
+    await vi.waitFor(() => expect(counts.rings).toBe(2))
     doorbell.stop()
   })
 
 
@@ -1,8 +1,16 @@
 import type { DesktopToolCompletion } from '@sim/desktop-bridge/tool-results'
 import { sleep } from '@sim/utils/helpers'
 import { describe, expect, it, vi } from 'vitest'
-import { type DesktopExecutorClient, DeviceRequestError } from '@/main/desktop-executor/client'
-import { DesktopExecutor, type DesktopToolRunner } from '@/main/desktop-executor/executor'
+import {
+  type DesktopExecutorClient,
+  DeviceRequestError,
+  UnsendableRequestError,
+} from '@/main/desktop-executor/client'
+import {
+  type DesktopApprovalItem,
+  DesktopExecutor,
+  type DesktopToolRunner,
+} from '@/main/desktop-executor/executor'
 import type { ExecutorJournal, JournalEntry } from '@/main/desktop-executor/journal'
 import type {
   ClaimedDesktopCall,
@@ -148,6 +156,8 @@ class FakeRunner implements DesktopToolRunner {
 }
 
 function setup(options: { leaseRenewMs?: number; maxHeldCalls?: number } = {}) {
+  /** Approval items the executor handed to the notifier, one array per inbox read. */
+  const approvals: DesktopApprovalItem[][] = []
   const sim = new FakeSim()
   const journal = new MemoryJournal()
   const runner = new FakeRunner()
@@ -161,9 +171,10 @@ function setup(options: { leaseRenewMs?: number; maxHeldCalls?: number } = {}) {
     retryBaseMs: 5,
     onUnregistered,
     onBusyChange: (value) => busy.push(value),
+    onApprovals: (items) => approvals.push(items),
     ...(options.maxHeldCalls ? { maxHeldCalls: options.maxHeldCalls } : {}),
   })
-  return { sim, journal, runner, executor, onUnregistered, busy }
+  return { sim, journal, runner, executor, onUnregistered, busy, approvals }
 }
 
 describe('claiming', () => {
@@ -449,6 +460,34 @@ describe('delivery', () => {
     await vi.waitFor(() => expect(sim.completions).toHaveLength(1))
   })
 
+  it('reports a result it cannot encode as outcome unknown, once, instead of retrying it', async () => {
+    const { sim, journal, executor } = setup()
+    const complete = sim.client.complete
+    let attempts = 0
+    sim.client.complete = async (request) => {
+      attempts += 1
+      if (request.completion.data && 'cyclic' in request.completion.data) {
+        throw new UnsendableRequestError('Converting circular structure to JSON')
+      }
+      return complete(request)
+    }
+    await journal.put({
+      toolCallId: 'r-1',
+      state: 'result',
+      executionToken: 't-1',
+      completion: { status: 'success', message: 'done', data: { cyclic: true } },
+    })
+
+    await executor.recover()
+
+    await vi.waitFor(() => expect(sim.completions).toHaveLength(1))
+    expect(attempts).toBe(2)
+    expect(sim.completions[0]?.completion).toMatchObject({
+      status: 'error',
+      data: { outcomeUnknown: true, doNotRetry: true },
+    })
+  })
+
   it('holds a result Sim refuses as unregistered until the device registers again', async () => {
     const { sim, journal, executor, onUnregistered } = setup()
     sim.completeErrors = [new DeviceRequestError(401, 'unregistered')]
@@ -609,6 +648,34 @@ describe('registration', () => {
     expect(journal.entries.size).toBe(0)
   })
 
+  it('raises no approval from an inbox read that Sim answers after sign-out', async () => {
+    const { sim, executor, approvals } = setup()
+    const answer = deferred<void>()
+    const listInbox = sim.client.listInbox
+    sim.client.listInbox = async () => {
+      await answer.promise
+      return listInbox()
+    }
+    sim.inbox = [
+      {
+        kind: 'approval_needed',
+        toolCallId: 'gated-1',
+        toolName: 'terminal',
+        chatId: 'chat-a',
+        chatTitle: 'Fix CI',
+        workspaceId: 'ws-1',
+        summary: 'npm publish',
+      },
+    ]
+    const reading = executor.reconcile()
+
+    const signingOut = executor.dispose()
+    answer.resolve()
+    await Promise.all([reading, signingOut])
+
+    expect(approvals).toEqual([])
+  })
+
   it('does not keep a claim that Sim answers after sign-out', async () => {
     const { sim, journal, runner, executor } = setup({ leaseRenewMs: 10 })
     const answer = deferred<void>()