@@ -17,6 +17,8 @@ import {
   sendBrowserPanelAction,
   setBrowserTabPinned,
 } from '@/lib/browser-agent/transport'
+import { BROWSER_SESSION_RESOURCE_ID } from '@/lib/copilot/resources/types'
+import { useMothershipResources } from '@/app/workspace/[workspaceId]/home/components/mothership-resources-context'
 import { useBrowserPanelOcclusion } from '@/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/browser-panel-occlusion'
 import { BrowserTabStrip } from '@/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/browser-tab-strip'
 import { useBrowserSessionStore } from '@/stores/browser-session/store'
@@ -124,6 +126,25 @@ export function BrowserSession({ visible }: { visible: boolean }) {
   const hostRef = useRef<HTMLDivElement>(null)
   const urlInputRef = useRef<HTMLInputElement>(null)
   const panelOccluded = useBrowserPanelOcclusion(hostRef, visible)
+  const { removeResource } = useMothershipResources()
+
+  // The browser session ending closes the panel, the way the terminal panel
+  // goes when its last shell does. What it leaves otherwise is a tab whose
+  // only content explains that there is nothing to show and that starting
+  // again has to happen from somewhere else — the agent reopens the panel on
+  // its next browser action anyway. Guarded on having seen a live session so
+  // that opening the panel while the store still remembers a closed one does
+  // not immediately close it again.
+  const wasAlive = useRef(false)
+  useEffect(() => {
+    if (sessionAlive) {
+      wasAlive.current = true
+      return
+    }
+    if (!wasAlive.current) return
+    wasAlive.current = false
+    removeResource('browser', BROWSER_SESSION_RESOURCE_ID)
+  }, [sessionAlive, removeResource])
   const pageUrlRef = useRef(pageState?.url ?? '')
   pageUrlRef.current = pageState?.url ?? ''
   /** Non-null while the user is editing the URL bar; otherwise it mirrors the page. */
@@ -389,13 +410,11 @@ export function BrowserSession({ visible }: { visible: boolean }) {
               className='pointer-events-none absolute inset-0 size-full object-fill'
             />
           )}
-        {(!pageState || !sessionAlive) && (
+        {!pageState && (
           <div className='absolute inset-0 flex flex-col items-center justify-center gap-2'>
             <Cursor className='size-[18px] text-[var(--text-tertiary)]' />
             <p className='text-[var(--text-muted)] text-small'>
-              {sessionAlive
-                ? 'Waiting for the browser session to start…'
-                : 'The browser session was closed — ask Sim to navigate again to start a new one.'}
+              Waiting for the browser session to start…
             </p>
           </div>
         )}
 
@@ -10,7 +10,7 @@ import {
 import type { StreamBatchEvent } from '@/lib/copilot/request/session/types'
 import {
   getReplayCompletedWorkflowToolCallIds,
-  hasExecutingBrowserToolCall,
+  panelForExecutingClientTool,
   reconcileLiveAssistantTurn,
   selectReconnectReplayState,
 } from '@/app/workspace/[workspaceId]/home/hooks/use-chat'
@@ -220,7 +220,7 @@ describe('getReplayCompletedWorkflowToolCallIds', () => {
   })
 })
 
-describe('hasExecutingBrowserToolCall', () => {
+describe('panelForExecutingClientTool', () => {
   function toolCallMessage(id: string, name: string, status: ToolCallStatus): ChatMessage {
     return {
       id,
@@ -236,16 +236,42 @@ describe('hasExecutingBrowserToolCall', () => {
       toolCallMessage('m2', 'browser_navigate', 'executing'),
     ]
 
-    expect(hasExecutingBrowserToolCall(messages)).toBe(true)
+    expect(panelForExecutingClientTool(messages)).toBe('browser')
   })
 
-  it('ignores completed browser tool calls and executing non-browser tools', () => {
+  it('detects a terminal tool call that is still executing', () => {
+    const messages = [
+      toolCallMessage('m1', 'terminal', 'success'),
+      toolCallMessage('m2', 'terminal', 'executing'),
+    ]
+
+    expect(panelForExecutingClientTool(messages)).toBe('terminal')
+  })
+
+  it('ignores completed calls and executing tools that own no panel', () => {
     const messages = [
       toolCallMessage('m1', 'browser_click', 'success'),
-      toolCallMessage('m2', 'run_workflow', 'executing'),
-      { id: 'm3', role: 'assistant' as const, content: 'no blocks' },
+      toolCallMessage('m2', 'terminal', 'success'),
+      toolCallMessage('m3', 'run_workflow', 'executing'),
+      { id: 'm4', role: 'assistant' as const, content: 'no blocks' },
+    ]
+
+    expect(panelForExecutingClientTool(messages)).toBe(null)
+  })
+
+  // Both panels can be in flight at once; the later call is the one the user
+  // was watching when they navigated away.
+  it('picks the later panel when both are mid-action', () => {
+    const browserFirst = [
+      toolCallMessage('m1', 'browser_navigate', 'executing'),
+      toolCallMessage('m2', 'terminal', 'executing'),
+    ]
+    const terminalFirst = [
+      toolCallMessage('m1', 'terminal', 'executing'),
+      toolCallMessage('m2', 'browser_navigate', 'executing'),
     ]
 
-    expect(hasExecutingBrowserToolCall(messages)).toBe(false)
+    expect(panelForExecutingClientTool(browserFirst)).toBe('terminal')
+    expect(panelForExecutingClientTool(terminalFirst)).toBe('browser')
   })
 })
@@ -956,21 +956,28 @@ export function getReplayCompletedWorkflowToolCallIds(events: StreamBatchEvent[]
 }
 
 /**
- * True when the transcript holds a browser tool call that is still executing —
- * i.e. the live turn is mid browser-action. Used on reconnect to restore the
- * Browser resource panel the way workflow-run recovery restores workflows:
- * completed browser calls are suppressed on replay (exactly-once) and so never
- * re-surface the panel themselves.
+ * Which live panel the transcript is mid-action on, or null for neither.
+ *
+ * Used on reconnect to restore that panel, the way workflow-run recovery
+ * restores workflows. A completed browser or terminal call is suppressed on
+ * replay, so it never re-opens its own panel — without this, returning to a
+ * chat mid-turn lands on whichever resource happened to be persisted last
+ * while the agent is driving a different one. When calls against both are in
+ * flight the later one wins, being the one the user was watching.
  */
-export function hasExecutingBrowserToolCall(messages: ChatMessage[]): boolean {
-  return messages.some((message) =>
-    (message.contentBlocks ?? []).some(
-      (block) =>
-        block.toolCall !== undefined &&
-        isBrowserToolName(block.toolCall.name) &&
-        block.toolCall.status === 'executing'
-    )
-  )
+export function panelForExecutingClientTool(
+  messages: ChatMessage[]
+): 'browser' | 'terminal' | null {
+  let panel: 'browser' | 'terminal' | null = null
+  for (const message of messages) {
+    for (const block of message.contentBlocks ?? []) {
+      const call = block.toolCall
+      if (call === undefined || call.status !== 'executing') continue
+      if (isBrowserToolName(call.name)) panel = 'browser'
+      else if (isTerminalToolName(call.name)) panel = 'terminal'
+    }
+  }
+  return panel
 }
 
 function buildRecoverySubjectKey(
@@ -1952,15 +1959,14 @@ export function useChat(
       setActiveResourceId(null)
     }
 
-    // Browser counterpart of the workflow-run recovery above: returning to a
-    // chat whose live turn is mid browser-action re-focuses the Browser tab
-    // and re-expands a collapsed panel. Runs after the resource hydration so
-    // it wins over the "last resource" active fallback. Completed browser
-    // calls are suppressed on replay (exactly-once) and never re-fire
-    // `startClientBrowserTool`, so without this the panel restores to
-    // whichever resource happened to be persisted last.
-    if (shouldReconnectActiveStream && hasExecutingBrowserToolCall(mappedMessages)) {
-      openBrowserResource()
+    // Live-panel counterpart of the workflow-run recovery above: returning to
+    // a chat whose turn is mid browser-action or mid-command re-focuses that
+    // tab and re-expands a collapsed panel. Runs after the resource hydration
+    // so it wins over the "last resource" active fallback.
+    if (shouldReconnectActiveStream) {
+      const panel = panelForExecutingClientTool(mappedMessages)
+      if (panel === 'browser') openBrowserResource()
+      else if (panel === 'terminal') openTerminalResource()
     }
 
     const snapshotPreviewSessions = Array.isArray(chatHistory.streamSnapshot?.previewSessions)
@@ -2029,6 +2035,7 @@ export function useChat(
     cancelActiveStreamRecovery,
     flushPendingResources,
     openBrowserResource,
+    openTerminalResource,
     recoverPendingClientWorkflowTools,
     seedPreviewSessions,
     setTransportIdle,