fix(desktop): report a click whose tab closed mid-release as unconfirmed

The tab being destroyed proves teardown, not that Chromium processed the
release, so the rescued result no longer claims effectObserved and its note
says the outcome could not be confirmed. Adds clickAt tests for each
TabClosedOnReleaseError guard and a driver test for the rescued shape.

Author: waleedlatif1

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

@@ -22,6 +22,7 @@ import {
   releaseFileInput,
   resolveFileInput,
   setFileInputFiles,
+  TabClosedOnReleaseError,
 } from '@/main/browser-agent/cdp'
 
 function createOopifFrameFixture() {
@@ -252,6 +253,78 @@ describe('browser-agent CDP instrumentation', () => {
     ])
   })
 
+  describe('a tab that closes during a click', () => {
+    /**
+     * Rejects the mouse event matching `type` and `clickCount` with `failure`, first marking the
+     * tab destroyed when `destroy` is `'at-rejection'`. `'before-release'` instead marks it
+     * destroyed as the press resolves, so the release is sent to an already-dead tab.
+     */
+    function failMouseEvent(
+      contents: WebContents,
+      fail: { type: string; clickCount: number },
+      failure: Error,
+      destroy: 'at-rejection' | 'before-release' | 'never'
+    ) {
+      let destroyed = false
+      vi.mocked(contents.isDestroyed).mockImplementation(() => destroyed)
+      vi.mocked(contents.debugger.sendCommand).mockImplementation(async (_method, params) => {
+        const { type, clickCount } = toRecord(params)
+        if (destroy === 'before-release' && type === 'mousePressed') destroyed = true
+        if (type === fail.type && clickCount === fail.clickCount) {
+          if (destroy === 'at-rejection') destroyed = true
+          throw failure
+        }
+        return {}
+      })
+    }
+
+    it('reports a final release rejected because the tab closed as TabClosedOnReleaseError', async () => {
+      const contents = new WebContentsView().webContents
+      failMouseEvent(
+        contents,
+        { type: 'mouseReleased', clickCount: 1 },
+        new Error('Target closed'),
+        'at-rejection'
+      )
+
+      await expect(clickAt(contents, 12, 24)).rejects.toBeInstanceOf(TabClosedOnReleaseError)
+    })
+
+    it('keeps the original error when the release fails on a tab that is still alive', async () => {
+      const contents = new WebContentsView().webContents
+      const failure = new Error('release rejected')
+      failMouseEvent(contents, { type: 'mouseReleased', clickCount: 1 }, failure, 'never')
+
+      await expect(clickAt(contents, 12, 24)).rejects.toBe(failure)
+    })
+
+    it('keeps the original error when the tab was already gone before the release was sent', async () => {
+      const contents = new WebContentsView().webContents
+      const failure = new Error('Target closed')
+      failMouseEvent(contents, { type: 'mouseReleased', clickCount: 1 }, failure, 'before-release')
+
+      await expect(clickAt(contents, 12, 24)).rejects.toBe(failure)
+    })
+
+    it('keeps the original error when the press fails as the tab closes', async () => {
+      const contents = new WebContentsView().webContents
+      const failure = new Error('Target closed')
+      failMouseEvent(contents, { type: 'mousePressed', clickCount: 1 }, failure, 'at-rejection')
+
+      await expect(clickAt(contents, 12, 24)).rejects.toBe(failure)
+    })
+
+    it('keeps the original error when a non-final release of a multi-click fails as the tab closes', async () => {
+      const contents = new WebContentsView().webContents
+      const failure = new Error('Target closed')
+      failMouseEvent(contents, { type: 'mouseReleased', clickCount: 1 }, failure, 'at-rejection')
+
+      await expect(
+        clickAt(contents, 12, 24, true, { ...PRIMARY_CLICK, clickCount: 2 })
+      ).rejects.toBe(failure)
+    })
+  })
+
   it('times out a hung press and sends cleanup before the tool watchdog can release', async () => {
     vi.useFakeTimers()
     try {

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

@@ -1095,11 +1095,12 @@ export function clearAgentContextMenu(contents: WebContents): void {
 
 /**
  * The final release of a click was sent to a live tab, and the tab was gone when that release
- * was rejected. The press and release both reached the page; only the acknowledgement was lost.
+ * was rejected: the release was in flight when the tab closed. Whether it reached the page is
+ * unknown, so this proves neither delivery nor failure, only that the click must not be repeated.
  */
 export class TabClosedOnReleaseError extends Error {
   constructor() {
-    super('The tab closed as the click was released.')
+    super('The tab closed while the click release was in flight.')
     this.name = 'TabClosedOnReleaseError'
   }
 }

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

@@ -2344,6 +2344,50 @@ describe('credential protection', () => {
     })
   })
 
+  it('reports a click whose tab closed during its release as unconfirmed, not failed', async () => {
+    const contents = await openPage()
+    let destroyed = false
+    vi.mocked(contents.isDestroyed).mockImplementation(() => destroyed)
+    vi.mocked(contents.executeJavaScript).mockImplementation((expression: string) => {
+      if (isPageCall(expression, 'describePointTarget')) {
+        return Promise.resolve({ found: true, element: 'Close', cursor: 'pointer' })
+      }
+      if (isPageCall(expression, 'readActiveElementState')) return Promise.resolve({})
+      if (isPageCall(expression, 'readPageActionState')) {
+        return Promise.resolve({
+          url: 'https://example.com/popup',
+          title: 'Popup',
+          focus: 'body',
+          mutationRevision: 0,
+          dialogs: [],
+          popups: [],
+          scroll: [0],
+        })
+      }
+      return Promise.resolve(undefined)
+    })
+    vi.mocked(contents.debugger.sendCommand).mockImplementation(async (method, params) => {
+      if (method === 'Input.dispatchMouseEvent' && toRecord(params).type === 'mouseReleased') {
+        destroyed = true
+        throw new Error('Target closed')
+      }
+      return {}
+    })
+
+    const result = await driver.executeTool('chat-test', 'browser_click_at', { x: 100, y: 200 })
+
+    expect(result).toMatchObject({
+      ok: true,
+      result: {
+        dispatched: true,
+        closedDuringDispatch: true,
+        doNotRetry: true,
+        possibleEffectObserved: true,
+      },
+    })
+    expect(toRecord(result.result)).not.toHaveProperty('effectObserved')
+  })
+
   it('reports navigation obstructed by a dialog that opened with it', async () => {
     const contents = await openPage()
     let actionReads = 0

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

@@ -1803,9 +1803,10 @@ function navigationRescue(
 }
 
 /**
- * The click's final release was sent to a live tab that was destroyed before Chromium
- * acknowledged it (cdp.clickAt raises TabClosedOnReleaseError only then), so the press and
- * release reached the page. Any other dispatch failure keeps its own error.
+ * The tab closed while the click's final release was in flight (cdp.clickAt raises
+ * TabClosedOnReleaseError only then). Whether the release reached the page cannot be confirmed,
+ * so the result reports the tab change but not the click's effect, and forbids a repeat. Any other
+ * dispatch failure keeps its own error.
  */
 function closedTabRescue(
   error: unknown,
@@ -1817,7 +1818,6 @@ function closedTabRescue(
     dispatched: true,
     trusted: base.trusted,
     activation: base.activation,
-    effectObserved: true,
     possibleEffectObserved: true,
     closedDuringDispatch: true,
     doNotRetry: true,
@@ -1826,7 +1826,7 @@ function closedTabRescue(
     ...(activeTab
       ? { activeTab: { tabId: activeTab.id, url: activeTab.view.webContents.getURL() } }
       : {}),
-    note: 'The tab closed as the click was released, so no postconditions could be read. Do not repeat the click. If this page was not expected to close itself, verify the outcome with browser_snapshot before relying on it.',
+    note: "The tab closed while the click's release was in flight, so the click's outcome could not be confirmed. Do not repeat the click; verify the outcome with browser_snapshot before relying on it.",
   }
 }