@@ -19,12 +19,15 @@ const {
   mockFetch,
   mockHandleExecutionCancelledConsole,
   mockHandleExecutionErrorConsole,
+  mockIsExecutionStreamHttpError,
+  mockIsRunToolActiveForWorkflow,
   mockLoadExecutionPointer,
   mockReconnect,
   mockRequestJson,
   mockResolveStartCandidates,
   mockSelectBestTrigger,
   mockUploadInternalFileSession,
+  runToolReleaseListeners,
   terminalStoreState,
   workflowBlocks,
   workflowStoreState,
@@ -101,12 +104,15 @@ const {
     mockFetch: vi.fn(),
     mockHandleExecutionCancelledConsole: vi.fn(),
     mockHandleExecutionErrorConsole: vi.fn(),
+    mockIsExecutionStreamHttpError: vi.fn(() => false),
+    mockIsRunToolActiveForWorkflow: vi.fn(() => false),
     mockLoadExecutionPointer: vi.fn(),
     mockReconnect: vi.fn(),
     mockRequestJson: vi.fn(),
     mockResolveStartCandidates: vi.fn(),
     mockSelectBestTrigger: vi.fn(),
     mockUploadInternalFileSession: vi.fn(),
+    runToolReleaseListeners: new Set<(workflowId: string) => void>(),
     terminalStoreState,
     workflowBlocks,
     workflowStoreState,
@@ -125,6 +131,16 @@ vi.mock('@/lib/api/client/request', () => ({
   requestJson: mockRequestJson,
 }))
 
+vi.mock('@/lib/copilot/tools/client/run-tool-execution', () => ({
+  isRunToolActiveForWorkflow: mockIsRunToolActiveForWorkflow,
+  subscribeToRunToolRelease: (listener: (workflowId: string) => void) => {
+    runToolReleaseListeners.add(listener)
+    return () => {
+      runToolReleaseListeners.delete(listener)
+    }
+  },
+}))
+
 vi.mock('@/lib/api/contracts/workflows', () => ({
   cancelWorkflowExecutionContract: {},
   workflowLogContract: {},
@@ -214,7 +230,7 @@ vi.mock('@/hooks/use-execution-stream', () => {
   class SSEStreamInterruptedError extends Error {}
 
   return {
-    isExecutionStreamHttpError: () => false,
+    isExecutionStreamHttpError: mockIsExecutionStreamHttpError,
     SSEEventHandlerError,
     SSEStreamInterruptedError,
     useExecutionStream: () => ({
@@ -419,6 +435,8 @@ function resetWorkflowExecutionTestState() {
   mockBeginScopedExecution.mockReset().mockReturnValue({})
   mockAdoptScopedExecution.mockReset().mockReturnValue(undefined)
   mockEndScopedExecution.mockReset().mockReturnValue(true)
+  mockIsExecutionStreamHttpError.mockReset().mockReturnValue(false)
+  mockIsRunToolActiveForWorkflow.mockReset().mockReturnValue(false)
   mockLoadExecutionPointer.mockReset().mockResolvedValue(null)
   mockReconnect.mockReset().mockResolvedValue(undefined)
   mockResolveStartCandidates.mockReset().mockReturnValue([])
@@ -430,6 +448,36 @@ function resetWorkflowExecutionTestState() {
   executionStoreState.getWorkflowExecution.mockReturnValue(idleExecution)
   executionStoreState.getCurrentExecutionId.mockReturnValue(null)
   workflowStoreState.edges.length = 0
+  runToolReleaseListeners.clear()
+}
+
+/**
+ * The store and pointer state a Sim run tool leaves behind the moment it starts
+ * a run, before the server has acknowledged it: this is what the reconnect
+ * flow reads as an orphaned run.
+ */
+function primeRunToolOwnedExecution() {
+  terminalStoreState._hasHydrated = true
+  executionStoreState.getWorkflowExecution.mockReturnValue({
+    ...executionStoreState.getWorkflowExecution(),
+    status: 'running',
+    isExecuting: true,
+    currentExecutionId: 'execution-1',
+  })
+  executionStoreState.getCurrentExecutionId.mockReturnValue('execution-1')
+  mockLoadExecutionPointer.mockResolvedValue({
+    workflowId: 'workflow-1',
+    executionId: 'execution-1',
+    lastEventId: 0,
+  })
+}
+
+/** The reconnect endpoint's answer while the run's buffer does not exist yet. */
+function rejectReconnectWithMissingRunBuffer() {
+  mockIsExecutionStreamHttpError.mockReturnValue(true)
+  mockReconnect.mockRejectedValue(
+    Object.assign(new Error('Reconnect failed (404)'), { httpStatus: 404 })
+  )
 }
 
 describe('useWorkflowExecution lifecycle ownership', () => {
@@ -594,6 +642,118 @@ describe('useWorkflowExecution lifecycle ownership', () => {
     unmount()
   })
 
+  it('logs a Run Error when a reconnect for an unowned pointer finds no run buffer', async () => {
+    primeRunToolOwnedExecution()
+    rejectReconnectWithMissingRunBuffer()
+
+    const { unmount } = renderWorkflowExecutionHook()
+    await act(async () => {
+      await Promise.resolve()
+      await Promise.resolve()
+    })
+
+    expect(mockReconnect).toHaveBeenCalledTimes(1)
+    expect(mockHandleExecutionErrorConsole.mock.calls[0]).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          executionId: 'execution-1',
+          error: 'Execution state is no longer available after reconnect',
+        }),
+      ])
+    )
+    expect(executionStoreState.setCurrentExecutionId).toHaveBeenCalledWith('workflow-1', null)
+    expect(executionStoreState.setIsExecuting).toHaveBeenCalledWith('workflow-1', false)
+    expect(mockClearExecutionPointer).toHaveBeenCalledWith('workflow-1')
+
+    unmount()
+  })
+
+  it('leaves a run owned by a client run tool to its live stream instead of reconnecting', async () => {
+    /*
+     * Same state as above, but a Sim run tool in this tab still owns the run.
+     * Its live stream is the source of truth, so reconnecting here would race
+     * the run's own start (the 404 above, logged as a Run Error mid-run), tear
+     * down the live run's store state, and clear the pointer the tool keeps
+     * for reload recovery.
+     */
+    primeRunToolOwnedExecution()
+    rejectReconnectWithMissingRunBuffer()
+    mockIsRunToolActiveForWorkflow.mockReturnValue(true)
+
+    const { unmount } = renderWorkflowExecutionHook()
+    await act(async () => {
+      await Promise.resolve()
+      await Promise.resolve()
+    })
+
+    expect(mockIsRunToolActiveForWorkflow).toHaveBeenCalledWith('workflow-1')
+    expect(mockReconnect).not.toHaveBeenCalled()
+    expect(mockHandleExecutionErrorConsole).not.toHaveBeenCalled()
+    expect(mockClearExecutionPointer).not.toHaveBeenCalled()
+    expect(executionStoreState.setCurrentExecutionId).not.toHaveBeenCalled()
+    expect(executionStoreState.setIsExecuting).not.toHaveBeenCalled()
+    expect(executionStoreState.setActiveBlocks).not.toHaveBeenCalled()
+
+    unmount()
+  })
+
+  it('reconnects once the client run tool releases a run whose stream dropped', async () => {
+    primeRunToolOwnedExecution()
+    mockIsRunToolActiveForWorkflow.mockReturnValue(true)
+
+    const { unmount } = renderWorkflowExecutionHook()
+    await act(async () => {
+      await Promise.resolve()
+      await Promise.resolve()
+    })
+    expect(mockReconnect).not.toHaveBeenCalled()
+    expect(runToolReleaseListeners.size).toBeGreaterThan(0)
+
+    /*
+     * What the run tool leaves behind when it gives the run up: no current
+     * execution, not executing, ownership released, and the pointer still
+     * carrying the last event it persisted.
+     */
+    executionStoreState.getWorkflowExecution.mockReturnValue({
+      ...executionStoreState.getWorkflowExecution(),
+      status: 'idle',
+      isExecuting: false,
+      currentExecutionId: null,
+    })
+    executionStoreState.getCurrentExecutionId.mockReturnValue(null)
+    mockLoadExecutionPointer.mockResolvedValue({
+      workflowId: 'workflow-1',
+      executionId: 'execution-1',
+      lastEventId: 5,
+    })
+    mockIsRunToolActiveForWorkflow.mockReturnValue(false)
+    await act(async () => {
+      for (const listener of runToolReleaseListeners) listener('workflow-2')
+      await Promise.resolve()
+      await Promise.resolve()
+    })
+    expect(mockReconnect).not.toHaveBeenCalled()
+
+    await act(async () => {
+      for (const listener of runToolReleaseListeners) listener('workflow-1')
+      await Promise.resolve()
+      await Promise.resolve()
+    })
+
+    expect(mockReconnect).toHaveBeenCalledTimes(1)
+    expect(mockReconnect).toHaveBeenCalledWith(
+      expect.objectContaining({
+        workflowId: 'workflow-1',
+        executionId: 'execution-1',
+        fromEventId: 5,
+      })
+    )
+    expect(mockClearExecutionPointer).not.toHaveBeenCalled()
+
+    unmount()
+    expect(runToolReleaseListeners.size).toBe(0)
+  })
+
   it('does not let delayed debug completion reset a replacement execution', async () => {
     const debugPersistenceExecution = {}
     const replacementPersistenceExecution = {}
 
@@ -21,6 +21,10 @@ import {
   workflowLogContract,
   workflowStateSchema,
 } from '@/lib/api/contracts/workflows'
+import {
+  isRunToolActiveForWorkflow,
+  subscribeToRunToolRelease,
+} from '@/lib/copilot/tools/client/run-tool-execution'
 import type { SecretSafeBlockLog } from '@/lib/logs/execution/display-types'
 import { buildTraceSpans } from '@/lib/logs/execution/trace-spans/trace-spans'
 import { processStreamingBlockLogs } from '@/lib/tokenization'
@@ -2386,6 +2390,14 @@ export function useWorkflowExecution() {
     [activeWorkflowId, setExecutionResult, tryStartExecution]
   )
 
+  useEffect(() => {
+    if (!activeWorkflowId) return
+    return subscribeToRunToolRelease((workflowId) => {
+      if (workflowId !== activeWorkflowId) return
+      setReconnectAttemptNonce((nonce) => nonce + 1)
+    })
+  }, [activeWorkflowId])
+
   useEffect(() => {
     if (!activeWorkflowId || !hasHydrated) return
     if (activeReconnections.has(activeWorkflowId)) return
@@ -2404,6 +2416,13 @@ export function useWorkflowExecution() {
     }
 
     const runReconnect = async () => {
+      if (isRunToolActiveForWorkflow(reconnectWorkflowId)) {
+        logger.info('Reconnection skipped; a client run tool owns this workflow run', {
+          workflowId: reconnectWorkflowId,
+        })
+        return
+      }
+
       let executionId: string | undefined
       let fromEventId = 0
 
 
@@ -115,7 +115,9 @@ import {
   cancelRunToolExecution,
   executeRunToolOnClient,
   isRunToolActiveForId,
+  isRunToolActiveForWorkflow,
   reportManualRunToolStop,
+  subscribeToRunToolRelease,
 } from './run-tool-execution'
 
 describe('run tool execution cancellation', () => {
@@ -150,6 +152,83 @@ describe('run tool execution cancellation', () => {
     expect(capturedSignal?.aborted).toBe(true)
   })
 
+  it('owns the workflow for exactly as long as the client run is in flight', async () => {
+    executeWorkflowWithFullLogging.mockImplementationOnce(async (options: any) => {
+      await new Promise((_, reject) => {
+        options.abortSignal.addEventListener(
+          'abort',
+          () => reject(new DOMException('Aborted', 'AbortError')),
+          { once: true }
+        )
+      })
+    })
+    let ownedWhenPointerSaved: boolean | undefined
+    saveExecutionPointer.mockImplementationOnce(() => {
+      ownedWhenPointerSaved = isRunToolActiveForWorkflow('wf-1')
+    })
+    expect(isRunToolActiveForWorkflow('wf-1')).toBe(false)
+
+    executeRunToolOnClient('tool-1', 'run_workflow', { workflowId: 'wf-1' })
+    await Promise.resolve()
+    const ownedWhileInFlight = isRunToolActiveForWorkflow('wf-1')
+    const otherWorkflowOwnedWhileInFlight = isRunToolActiveForWorkflow('wf-2')
+
+    cancelRunToolExecution('wf-1')
+    await vi.waitFor(() => expect(clearExecutionPointer).toHaveBeenCalledWith('wf-1'))
+
+    expect(ownedWhenPointerSaved).toBe(true)
+    expect(ownedWhileInFlight).toBe(true)
+    expect(otherWorkflowOwnedWhileInFlight).toBe(false)
+    expect(saveExecutionPointer).toHaveBeenCalledWith(
+      expect.objectContaining({ workflowId: 'wf-1', lastEventId: 0 })
+    )
+    expect(isRunToolActiveForWorkflow('wf-1')).toBe(false)
+  })
+
+  it('releases an interrupted run to reconnect subscribers only after giving up ownership', async () => {
+    const ownedAtRelease: boolean[] = []
+    const listener = vi.fn((workflowId: string) => {
+      ownedAtRelease.push(isRunToolActiveForWorkflow(workflowId))
+    })
+    const unsubscribe = subscribeToRunToolRelease(listener)
+    executeWorkflowWithFullLogging.mockRejectedValueOnce(
+      new MockSSEEventHandlerError('Block handler failed on event 7', 'exec-1')
+    )
+
+    try {
+      executeRunToolOnClient('tool-1', 'run_workflow', { workflowId: 'wf-1' })
+      await vi.waitFor(() => expect(listener).toHaveBeenCalledWith('wf-1'))
+
+      expect(listener).toHaveBeenCalledTimes(1)
+      expect(ownedAtRelease).toEqual([false])
+      expect(setIsExecuting).toHaveBeenCalledWith('wf-1', false)
+      expect(setCurrentExecutionId).toHaveBeenCalledWith('wf-1', null)
+      expect(setIsExecuting.mock.invocationCallOrder.at(-1)).toBeLessThan(
+        listener.mock.invocationCallOrder[0]
+      )
+      expect(clearExecutionPointer).not.toHaveBeenCalled()
+    } finally {
+      unsubscribe()
+    }
+  })
+
+  it('does not release a run it observed to completion, even when the report fails', async () => {
+    const listener = vi.fn()
+    const unsubscribe = subscribeToRunToolRelease(listener)
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: false, status: 500 }))
+    executeWorkflowWithFullLogging.mockResolvedValueOnce({ success: true })
+
+    try {
+      executeRunToolOnClient('tool-1', 'run_workflow', { workflowId: 'wf-1' })
+      await vi.waitFor(() => expect(isRunToolActiveForWorkflow('wf-1')).toBe(false))
+
+      expect(listener).not.toHaveBeenCalled()
+      expect(clearExecutionPointer).not.toHaveBeenCalled()
+    } finally {
+      unsubscribe()
+    }
+  })
+
   it('can report a manual stop using the explicit toolCallId override', async () => {
     const fetchMock = vi.fn().mockResolvedValue({ ok: true })
     vi.stubGlobal('fetch', fetchMock)