fix(desktop): reopen a chat on the browser tab the user left it on (#7793)

* fix(desktop): reopen a chat on the browser tab the user left it on

The resource strip pushed its own last-tab fallback onto the desktop app
whenever a chat opened without an explicit selection, overriding the tab
the desktop remembers the user was on. The shared desktop-tab hook now
switches the native tab only for an explicit selection, adopts the
desktop's active tab when the strip is on its fallback, and defers a
selected tab that has not landed yet until it does. Chat hydration no
longer writes a browser or terminal tab into the URL as a fallback.

* fix(desktop): adopt the remembered tab without claiming the user's selection

Review round on the reopen fix.

A late first report of the desktop app's active tab carries the tab it
remembers, not a switch the user made, so it is adopted rather than
claimed and agent activity can still take the view on chat open. A move
away from a tab the desktop was already showing stays the user's own.

Adoption now waits for the chat history to be applied, so the arrival
order of the tab list and the history no longer decides which resource a
chat opens on, and it skips a tab the strip has already dropped, so
closing the shown tab cannot write the closed id back. Closing the shown
tab selects its neighbour the way the desktop app picks the next native
tab, instead of flashing through the strip's last tab.

The two wrapper hooks now share one options type with the strip, and the
adopt rule lives in a single helper.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0139YonWmiZUnPMTHoH4PtAJ

* fix(desktop): show a selected tab that arrives after the tab list

The effect that shows an explicitly selected tab was keyed on the
selection alone, so a selection made before the desktop app published
its tab list was dropped rather than applied when the tab arrived. It is
now keyed on that tab being live as well, which covers the late arrival
without a retry ref to arm and disarm.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0139YonWmiZUnPMTHoH4PtAJ

* refactor(desktop): align the two tab-adoption paths and drop dead plumbing

Quality pass on the reopen fix.

The late-arrival adoption now carries the same guards as the hydrated
one, so a first report of the desktop app's active tab can no longer
override a selection the user made before the tab list arrived. Both
guards are pinned by tests that fail when either is removed.

The predicate the adopt and claim paths share moved into one helper, so
the single difference between them — adoption needs the tab to still be
in the strip, following the user does not — is stated once. Removes a
ref nothing read and an options interface with no second consumer.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0139YonWmiZUnPMTHoH4PtAJ

* test(desktop): give the tab-resource hosts the shared options interface

The test hosts took their props through a type alias derived from the
hook signature. The repo asks for an interface, and the hook already
exports one that is exactly this shape, so the hosts use it directly
instead of restating it.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0139YonWmiZUnPMTHoH4PtAJ

* fix(desktop): resolve the shown tab instead of writing it back

Reopening a chat could show the wrong page for as long as the chat
history took to load. The strip wrote the desktop app's remembered tab
into the selection from an effect, and that write had to wait for the
history or the arrival order would decide what the chat opened on. With
the history held back 2.5s, an instrumented run showed the wrong page
for 2164ms before it corrected.

The rule is now a pure function: an explicit selection wins, otherwise
the last resource, except that a desktop-backed last resource defers to
the tab the desktop app is showing. Nothing is written back, so the
gate, the passive setter and the effect behind them are gone, and the
same run now shows the remembered page immediately.

A native switch is claimed as the user's against the tab the desktop app
was showing rather than the one the strip shows, since with no explicit
selection those are now the same tab. Closing the shown tab prefers a
neighbour of its own kind, so the strip and the desktop app agree on
what comes next.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0139YonWmiZUnPMTHoH4PtAJ

---------

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-tabs/resource-tabs.tsx

@@ -408,11 +408,21 @@ export function ResourceTabs({
 
   const handleClose = useCallback(
     (id: string) => {
-      const resource = resources.find((r) => r.id === id)
+      const index = resources.findIndex((r) => r.id === id)
+      const resource = resources[index]
       if (!resource) return
       const isMulti = selectedIds.has(resource.id) && selectedIds.size > 1
       const targets = isMulti ? resources.filter((r) => selectedIds.has(r.id)) : [resource]
       if (!confirmClosingRunningTerminals(targets, terminalTabs)) return
+      // Closing the shown tab moves to its neighbour, right then left, so the
+      // strip does not fall back to its last tab and jump. For a desktop tab
+      // this is also the neighbour the desktop app itself picks.
+      if (!isMulti && activeId === resource.id) {
+        const sameKind = new Set(resources.filter((r) => r.type === resource.type).map((r) => r.id))
+        const nextId =
+          findNearestId(resources, index, sameKind) ?? findNearestId(resources, index, null)
+        if (nextId) selectResource(nextId)
+      }
       // A browser tab's page is closed natively and its resource dropped at
       // once; the tab list then confirms the removal. A shell's close answers
       // with the tab list, so its resource follows that list instead — a
@@ -451,7 +461,16 @@ export function ResourceTabs({
       }
     },
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [chatId, desktopScopeId, onRemoveResource, resources, selectedIds, terminalTabs]
+    [
+      activeId,
+      chatId,
+      desktopScopeId,
+      onRemoveResource,
+      resources,
+      selectResource,
+      selectedIds,
+      terminalTabs,
+    ]
   )
 
   /**

apps/sim/app/workspace/[workspaceId]/home/home.tsx

@@ -224,7 +224,7 @@ export function Home({ chatId, userName, userId }: HomeProps) {
   const resourceSelectionOwnedByUserRef = useRef(false)
 
   function handleResourceEvent(resourceId: string, options?: ResourceEventOptions) {
-    const activeResourceId = activeResourceParamRef.current
+    const activeResourceId = effectiveActiveResourceIdRef.current
     const presentation = resolveResourceEventPresentation({
       activeResourceId,
       activationRequested: shouldActivateResourceEvent(activeResourceId, resourceId, options),
@@ -317,7 +317,7 @@ export function Home({ chatId, userName, userId }: HomeProps) {
   const expandResource = () => {
     resourceCollapseOwnedByUserRef.current = false
     resourceSelectionOwnedByUserRef.current = true
-    const activeResourceId = activeResourceParamRef.current
+    const activeResourceId = effectiveActiveResourceIdRef.current
     if (activeResourceId) clearResourceActivity(activeResourceId)
     setResourceCollapsed(false)
   }
@@ -334,24 +334,18 @@ export function Home({ chatId, userName, userId }: HomeProps) {
     [setActiveResourceId, clearResourceActivity]
   )
 
-  const desktopTabResourceCallbacks = {
+  const desktopTabResourceOptions = {
+    scopeId: desktopScopeId,
+    resources,
+    activeResourceId,
+    selectedResourceId: activeResourceParam,
     addResource,
     removeResource,
     selectResource: selectResourceFromUser,
     onResourceEvent: handleResourceEvent,
   }
-  useBrowserTabResources({
-    scopeId: desktopScopeId,
-    resources,
-    activeResourceId,
-    ...desktopTabResourceCallbacks,
-  })
-  useTerminalTabResources({
-    scopeId: desktopScopeId,
-    resources,
-    activeResourceId,
-    ...desktopTabResourceCallbacks,
-  })
+  useBrowserTabResources(desktopTabResourceOptions)
+  useTerminalTabResources(desktopTabResourceOptions)
 
   const addResourceFromUser = useCallback(
     (resource: MothershipResource) => {

apps/sim/app/workspace/[workspaceId]/home/hooks/use-browser-tab-resources.test.tsx

@@ -6,6 +6,7 @@ import { createRoot, type Root } from 'react-dom/client'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type { MothershipResource } from '@/lib/copilot/resources/types'
 import { useBrowserTabResources } from '@/app/workspace/[workspaceId]/home/hooks/use-browser-tab-resources'
+import type { DesktopTabResourceOptions } from '@/app/workspace/[workspaceId]/home/hooks/use-desktop-tab-resources'
 import { useBrowserSessionStore } from '@/stores/browser-session/store'
 
 const { sendBrowserPanelAction, openUrlInNewBrowserTab, openInPanelListeners } = vi.hoisted(() => ({
@@ -37,17 +38,7 @@ function pushTabs(scopeId: string, tabs: ReturnType<typeof tab>[], activeTabId:
   })
 }
 
-interface HostProps {
-  scopeId: string
-  resources: MothershipResource[]
-  activeResourceId: string | null
-  addResource: (resource: MothershipResource) => void
-  removeResource: (type: MothershipResource['type'], id: string) => void
-  selectResource: (id: string) => void
-  onResourceEvent: (id: string, options?: { activate?: boolean }) => void
-}
-
-function Host(props: HostProps) {
+function Host(props: DesktopTabResourceOptions) {
   useBrowserTabResources(props)
   return null
 }
@@ -60,19 +51,25 @@ describe('useBrowserTabResources', () => {
   const selectResource = vi.fn()
   const onResourceEvent = vi.fn()
 
-  function render(overrides: Partial<HostProps> = {}) {
-    const props: HostProps = {
+  function render(overrides: Partial<DesktopTabResourceOptions> = {}) {
+    const props: DesktopTabResourceOptions = {
       scopeId: SCOPE,
       resources: [],
       activeResourceId: null,
+      selectedResourceId: null,
       addResource,
       removeResource,
       selectResource,
       onResourceEvent,
       ...overrides,
     }
     act(() => root.render(<Host {...props} />))
-    return (next: Partial<HostProps>) => act(() => root.render(<Host {...props} {...next} />))
+    /** `alsoInThisCommit` lands a store push and the new props together. */
+    return (next: Partial<DesktopTabResourceOptions>, alsoInThisCommit?: () => void) =>
+      act(() => {
+        alsoInThisCommit?.()
+        root.render(<Host {...props} {...next} />)
+      })
   }
 
   beforeEach(() => {
@@ -153,11 +150,11 @@ describe('useBrowserTabResources', () => {
       { type: 'browser', id: '1', title: 'Page 1' },
       { type: 'browser', id: '2', title: 'Page 2' },
     ]
-    const rerender = render({ resources, activeResourceId: '1' })
+    const rerender = render({ resources, activeResourceId: '1', selectedResourceId: '1' })
     pushTabs(SCOPE, [tab('1', true), tab('2')], '1')
     expect(sendBrowserPanelAction).not.toHaveBeenCalled()
 
-    rerender({ activeResourceId: '2' })
+    rerender({ activeResourceId: '2', selectedResourceId: '2' })
     expect(sendBrowserPanelAction).toHaveBeenCalledExactlyOnceWith(
       'switch-tab',
       { tabId: '2', claim: false },
@@ -169,21 +166,70 @@ describe('useBrowserTabResources', () => {
     expect(selectResource).not.toHaveBeenCalled()
   })
 
+  it('shows a page selected before the pages landed, once it arrives', () => {
+    render({ selectedResourceId: '2', activeResourceId: '2' })
+    expect(sendBrowserPanelAction).not.toHaveBeenCalled()
+
+    pushTabs(SCOPE, [tab('1', true), tab('2')], '1')
+    expect(sendBrowserPanelAction).toHaveBeenCalledExactlyOnceWith(
+      'switch-tab',
+      { tabId: '2', claim: false },
+      SCOPE
+    )
+  })
+
+  it('does not claim the scope first report as a user switch', () => {
+    const resources: MothershipResource[] = [
+      { type: 'browser', id: '1', title: 'Page 1' },
+      { type: 'browser', id: '2', title: 'Page 2' },
+    ]
+    const rerender = render()
+    pushTabs(SCOPE, [tab('1'), tab('2')], null)
+    rerender({ resources, activeResourceId: '2', selectedResourceId: null })
+
+    // The desktop app reports the page it restored. The strip resolves to that
+    // page on its own, so there is nothing here to claim for the user.
+    pushTabs(SCOPE, [tab('1', true), tab('2')], '1')
+    expect(selectResource).not.toHaveBeenCalled()
+    expect(sendBrowserPanelAction).not.toHaveBeenCalled()
+  })
+
+  it('claims a native switch away from a page it was already showing', () => {
+    const resources: MothershipResource[] = [
+      { type: 'browser', id: '1', title: 'Page 1' },
+      { type: 'browser', id: '2', title: 'Page 2' },
+    ]
+    const rerender = render()
+    pushTabs(SCOPE, [tab('1', true), tab('2')], '1')
+    rerender({ resources, activeResourceId: '1', selectedResourceId: null })
+    expect(selectResource).not.toHaveBeenCalled()
+
+    // A keyboard shortcut in the page moves the desktop app to page 2. With no
+    // explicit selection the strip resolves to that page in the same commit,
+    // so the switch is only visible against the page the desktop app left.
+    rerender({ resources, activeResourceId: '2' }, () => {
+      useBrowserSessionStore
+        .getState()
+        .setTabsState({ scopeId: SCOPE, tabs: [tab('1'), tab('2', true)], activeTabId: '2' })
+    })
+    expect(selectResource).toHaveBeenCalledExactlyOnceWith('2')
+  })
+
   it('follows a native switch into the strip only while the user is on the browser', () => {
     const resources: MothershipResource[] = [
       { type: 'browser', id: '1', title: 'Page 1' },
       { type: 'browser', id: '2', title: 'Page 2' },
       { type: 'file', id: 'f', title: 'notes.md' },
     ]
-    const rerender = render({ resources, activeResourceId: '1' })
+    const rerender = render({ resources, activeResourceId: '1', selectedResourceId: '1' })
     pushTabs(SCOPE, [tab('1', true), tab('2')], '1')
 
     pushTabs(SCOPE, [tab('1'), tab('2', true)], '2')
     expect(selectResource).toHaveBeenCalledExactlyOnceWith('2')
     expect(sendBrowserPanelAction).not.toHaveBeenCalled()
 
     selectResource.mockClear()
-    rerender({ activeResourceId: 'f' })
+    rerender({ activeResourceId: 'f', selectedResourceId: 'f' })
     pushTabs(SCOPE, [tab('1', true), tab('2')], '1')
     expect(selectResource).not.toHaveBeenCalled()
   })
@@ -192,6 +238,7 @@ describe('useBrowserTabResources', () => {
     render({
       resources: [{ type: 'browser', id: '1', title: 'Page 1' }],
       activeResourceId: '1',
+      selectedResourceId: '1',
     })
     pushTabs(SCOPE, [tab('1', true)], '1')
     act(() => {

apps/sim/app/workspace/[workspaceId]/home/hooks/use-browser-tab-resources.ts

@@ -5,9 +5,8 @@ import { getErrorMessage } from '@sim/utils/errors'
 import { onOpenInBrowserPanel } from '@/lib/browser-agent/open-in-panel'
 import { browserTabTitle } from '@/lib/browser-agent/tab-label'
 import { openUrlInNewBrowserTab, sendBrowserPanelAction } from '@/lib/browser-agent/transport'
-import type { MothershipResource } from '@/lib/copilot/resources/types'
 import {
-  type DesktopTabResourceCallbacks,
+  type DesktopTabResourceOptions,
   useDesktopTabResources,
 } from '@/app/workspace/[workspaceId]/home/hooks/use-desktop-tab-resources'
 import { useBrowserSessionStore } from '@/stores/browser-session/store'
@@ -16,13 +15,6 @@ const logger = createLogger('BrowserTabResources')
 
 const EMPTY_BROWSER_TABS: BrowserTabState[] = []
 
-interface UseBrowserTabResourcesOptions extends DesktopTabResourceCallbacks {
-  /** Desktop browser scope whose pages back this chat's browser tabs. */
-  scopeId: string
-  resources: readonly MothershipResource[]
-  activeResourceId: string | null
-}
-
 function switchBrowserTab(tabId: string, scopeId: string): void {
   sendBrowserPanelAction('switch-tab', { tabId, claim: false }, scopeId)
 }
@@ -31,15 +23,8 @@ function switchBrowserTab(tabId: string, scopeId: string): void {
  * Projects the desktop app's live browser pages into `browser` resource tabs,
  * one per page. See {@link useDesktopTabResources} for the shared model.
  */
-export function useBrowserTabResources({
-  scopeId,
-  resources,
-  activeResourceId,
-  addResource,
-  removeResource,
-  selectResource,
-  onResourceEvent,
-}: UseBrowserTabResourcesOptions): void {
+export function useBrowserTabResources(options: DesktopTabResourceOptions): void {
+  const { scopeId, selectResource } = options
   const hasSession = useBrowserSessionStore((state) => state.sessions[scopeId] !== undefined)
   const browserTabs = useBrowserSessionStore(
     (state) => state.sessions[scopeId]?.tabs ?? EMPTY_BROWSER_TABS
@@ -64,19 +49,13 @@ export function useBrowserTabResources({
   selectResourceRef.current = selectResource
 
   useDesktopTabResources({
+    ...options,
     type: 'browser',
-    scopeId,
     tabs,
     hasSession,
     activeTabId,
     agentTabId,
     switchTab: switchBrowserTab,
-    resources,
-    activeResourceId,
-    addResource,
-    removeResource,
-    selectResource,
-    onResourceEvent,
   })
 
   // Chat links clicked in the desktop app open in a new browser tab. The user