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

Author: waleedlatif1

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

@@ -249,19 +249,21 @@ describe('useBrowserTabResources', () => {
     expect(restoreResource).toHaveBeenCalledExactlyOnceWith('1')
   })
 
-  it('leaves a stored resource the history pinned alone once hydrated', () => {
-    const rerender = render({ hydrated: false })
-    pushTabs(SCOPE, [tab('1', true), tab('2')], '1')
-    rerender({
-      resources: [
-        { type: 'browser', id: '1', title: 'Page 1' },
-        { type: 'browser', id: '2', title: 'Page 2' },
-        { type: 'file', id: 'f', title: 'notes.md' },
-      ],
-      activeResourceId: 'f',
-      selectedResourceId: 'f',
-      hydrated: true,
+  it('leaves an explicitly selected page alone when the history is applied', () => {
+    const resources: MothershipResource[] = [
+      { type: 'browser', id: '1', title: 'Page 1' },
+      { type: 'browser', id: '2', title: 'Page 2' },
+    ]
+    // The user is on page 2 by choice while the desktop app shows page 1.
+    const rerender = render({
+      resources,
+      activeResourceId: '2',
+      selectedResourceId: '2',
+      hydrated: false,
     })
+    pushTabs(SCOPE, [tab('1', true), tab('2')], '1')
+
+    rerender({ resources, activeResourceId: '2', selectedResourceId: '2', hydrated: true })
     expect(restoreResource).not.toHaveBeenCalled()
   })
 
@@ -309,6 +311,29 @@ describe('useBrowserTabResources', () => {
     expect(sendBrowserPanelAction).not.toHaveBeenCalled()
   })
 
+  it('does not let a first report override a selection made before the pages landed', () => {
+    const resources: MothershipResource[] = [
+      { type: 'browser', id: '1', title: 'Page 1' },
+      { type: 'browser', id: '2', title: 'Page 2' },
+    ]
+    // The pages land first, with the desktop app not yet reporting which it shows.
+    const rerender = render({ selectedResourceId: '2', activeResourceId: '2' })
+    pushTabs(SCOPE, [tab('1'), tab('2')], null)
+    rerender({ resources, selectedResourceId: '2', activeResourceId: '2' })
+    // The selection is honoured by switching the native page to it.
+    expect(sendBrowserPanelAction).toHaveBeenCalledWith(
+      'switch-tab',
+      { tabId: '2', claim: false },
+      SCOPE
+    )
+
+    // The desktop app then reports the page it was already on. The strip must
+    // not move onto it, or the selection the user made would be lost.
+    pushTabs(SCOPE, [tab('1', true), tab('2')], '1')
+    expect(restoreResource).not.toHaveBeenCalled()
+    expect(selectResource).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' },

apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts

@@ -2490,6 +2490,9 @@ export function useChat(
       // Replacing the array with an identical one still re-renders the tab
       // strip and panel — skip the no-op so open panels don't flash.
       if (!resourcesUnchanged) {
+        // The ref keeps an eager fallback so a request sent in this commit
+        // still attaches a resource; the selection itself stays empty so the
+        // desktop app's remembered tab can win.
         activeResourceIdRef.current =
           hydratedActiveResourceId ?? mergedResources[mergedResources.length - 1].id
         setResources(mergedResources)

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

@@ -8,24 +8,8 @@ export interface DesktopTab {
   title: string
 }
 
-export interface DesktopTabResourceCallbacks {
-  /** Adds a tab without activating it; activation goes through {@link onResourceEvent}. */
-  addResource: (resource: MothershipResource) => void
-  removeResource: (resourceType: MothershipResourceType, resourceId: string) => void
-  /** Explicit user selection, which claims the strip's selection for the user. */
-  selectResource: (resourceId: string) => void
-  /**
-   * Adopts the desktop app's remembered tab as the shown resource without
-   * claiming the selection for the user, so agent activity can still take the
-   * view the way it does on any chat open.
-   */
-  restoreResource: (resourceId: string) => void
-  /** Agent activity on a tab, subject to the panel's user-ownership policy. */
-  onResourceEvent: ResourceEventHandler
-}
-
 /** What the strip shares with every kind of desktop-backed resource tab. */
-export interface DesktopTabStripOptions extends DesktopTabResourceCallbacks {
+export interface DesktopTabStripOptions {
   /** Desktop scope whose live tabs back this chat's resource tabs. */
   scopeId: string
   resources: readonly MothershipResource[]
@@ -35,15 +19,24 @@ export interface DesktopTabStripOptions extends DesktopTabResourceCallbacks {
   selectedResourceId: string | null
   /**
    * Whether the chat's stored resources have been applied to the strip.
-   *
-   * Adopting a tab writes it to `activeResourceId`, which is the one place the
-   * rest of the surface reads as the shown resource, so adopting on top of a
+   * Adopting a tab writes it to `activeResourceId`, so adopting on top of a
    * provisional fallback would let the arrival order of the tab list and the
-   * chat history decide what the chat opens on. Waiting makes the outcome the
-   * same either way: the history pins a stored resource, or it pins nothing
-   * and the desktop app's remembered tab stands.
+   * chat history decide what the chat opens on.
    */
   hydrated: boolean
+  /** Adds a tab without activating it; activation goes through {@link onResourceEvent}. */
+  addResource: (resource: MothershipResource) => void
+  removeResource: (resourceType: MothershipResourceType, resourceId: string) => void
+  /** Explicit user selection, which claims the strip's selection for the user. */
+  selectResource: (resourceId: string) => void
+  /**
+   * Adopts the desktop app's remembered tab as the shown resource without
+   * claiming the selection for the user, so agent activity can still take the
+   * view the way it does on any chat open.
+   */
+  restoreResource: (resourceId: string) => void
+  /** Agent activity on a tab, subject to the panel's user-ownership policy. */
+  onResourceEvent: ResourceEventHandler
 }
 
 interface UseDesktopTabResourcesOptions extends DesktopTabStripOptions {
@@ -65,21 +58,40 @@ interface UseDesktopTabResourcesOptions extends DesktopTabStripOptions {
 }
 
 /**
- * The desktop app's active tab to adopt in place of the strip's fallback: one
- * the strip does not show yet, of the same kind as the fallback, and still in
- * the strip — a tab just closed there stays the desktop app's active tab until
- * the close lands.
+ * The desktop app's active tab when it is not the tab the strip shows, and the
+ * strip is on one of this kind. Null when the two already agree or the strip
+ * is showing something else entirely.
  */
-function nativeTabToAdopt(
+function nativeTabOffStrip(
   resources: readonly MothershipResource[],
   activeResourceId: string | null,
   activeTabId: string | null,
   type: MothershipResourceType
 ): string | null {
   if (!activeTabId || activeTabId === activeResourceId) return null
-  if (resources.find((resource) => resource.id === activeResourceId)?.type !== type) return null
-  const live = resources.some((resource) => resource.type === type && resource.id === activeTabId)
-  return live ? activeTabId : null
+  return resources.find((resource) => resource.id === activeResourceId)?.type === type
+    ? activeTabId
+    : null
+}
+
+/**
+ * The same tab, narrowed to one the strip still holds as a resource: a tab
+ * just closed there stays the desktop app's active tab until the close lands,
+ * and adopting it would show a tab that is gone. Following a switch the user
+ * made needs no such check — a brand-new tab is followed before the strip has
+ * projected it.
+ */
+function nativeTabToAdopt(
+  resources: readonly MothershipResource[],
+  activeResourceId: string | null,
+  activeTabId: string | null,
+  type: MothershipResourceType
+): string | null {
+  const tabId = nativeTabOffStrip(resources, activeResourceId, activeTabId, type)
+  if (!tabId) return null
+  return resources.some((resource) => resource.type === type && resource.id === tabId)
+    ? tabId
+    : null
 }
 
 /**
@@ -131,8 +143,6 @@ export function useDesktopTabResources({
   const requestedTabIdRef = useRef<string | null>(null)
   const scopeIdRef = useRef(scopeId)
   scopeIdRef.current = scopeId
-  const tabsRef = useRef(tabs)
-  tabsRef.current = tabs
   const activeTabIdRef = useRef(activeTabId)
   activeTabIdRef.current = activeTabId
   const resourcesRef = useRef(resources)
@@ -141,6 +151,8 @@ export function useDesktopTabResources({
   activeResourceIdRef.current = activeResourceId
   /** Whether the strip shows an explicit selection rather than its fallback. */
   const explicitSelection = selectedResourceId !== null && selectedResourceId === activeResourceId
+  const explicitSelectionRef = useRef(explicitSelection)
+  explicitSelectionRef.current = explicitSelection
   const hydratedRef = useRef(hydrated)
   hydratedRef.current = hydrated
   /**
@@ -187,7 +199,6 @@ export function useDesktopTabResources({
     }
   }, [addResource, hasSession, removeResource, resources, scopeId, tabs, type])
 
-  /** Whether the selected resource is one of this kind's live tabs. */
   const selectedTabIsLive =
     selectedResourceId !== null && tabs.some((tab) => tab.id === selectedResourceId)
 
@@ -232,15 +243,13 @@ export function useDesktopTabResources({
     }
     const activeResourceId = activeResourceIdRef.current
     if (previousActiveTabId !== null) {
-      const activeResource = resourcesRef.current.find(
-        (resource) => resource.id === activeResourceId
-      )
-      if (activeTabId && activeResource?.type === type && activeResource.id !== activeTabId) {
-        selectResourceRef.current(activeTabId)
-      }
+      const tabId = nativeTabOffStrip(resourcesRef.current, activeResourceId, activeTabId, type)
+      if (tabId) selectResourceRef.current(tabId)
       return
     }
-    if (!hydratedRef.current) return
+    // Same guards as the adopt effect above: a first report must not override
+    // a selection the user made before the tab list arrived.
+    if (!hydratedRef.current || explicitSelectionRef.current) return
     const tabId = nativeTabToAdopt(resourcesRef.current, activeResourceId, activeTabId, type)
     if (tabId) restoreResourceRef.current(tabId)
   }, [activeTabId, type])