fix(settings): preserve debug lifecycle ownership

Author: waleedlatif1

.claude/rules/sim-react-performance.md

@@ -90,6 +90,15 @@ const [{ id }, { kbName }] = await Promise.all([params, searchParams])
 
 Only keep awaits sequential when a later call genuinely uses an earlier result, or when the ordering is deliberate (rate-limited batches, retry loops, write-then-read).
 
+## Carry exact lifecycle ownership across async boundaries
+
+When asynchronous work can outlive an execution, session, or resource instance, capture its
+opaque ownership token before the first `await` and pass that exact token through completion and
+error cleanup. Never re-adopt the current owner from delayed cleanup: a replacement may now own
+the same scope. End the lifecycle by exact-token match, and clear shared state only when that end
+succeeds. Current-owner adoption is reserved for synchronous user actions that explicitly stop
+the current lifecycle.
+
 ## Prefetch dynamic destination lists on intent
 
 For long lists of dynamic destinations, do not viewport-prefetch every row and do not assume

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/hooks/use-workflow-execution.test.tsx

@@ -8,6 +8,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
 const {
   executionStoreState,
+  idleExecution,
   mockCancel,
   mockAdoptScopedExecution,
   mockBeginScopedExecution,
@@ -89,6 +90,7 @@ const {
 
   return {
     executionStoreState,
+    idleExecution,
     mockCancel: vi.fn(),
     mockAdoptScopedExecution: vi.fn(),
     mockBeginScopedExecution: vi.fn(() => ({})),
@@ -416,9 +418,8 @@ describe('useWorkflowExecution attachment uploads', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     terminalStoreState._hasHydrated = false
-    executionStoreState.getWorkflowExecution.mockReturnValue(
-      executionStoreState.workflowExecutions.get('workflow-1')!
-    )
+    executionStoreState.workflowExecutions.set('workflow-1', idleExecution)
+    executionStoreState.getWorkflowExecution.mockReturnValue(idleExecution)
     executionStoreState.getCurrentExecutionId.mockReturnValue(null)
     mockAdoptScopedExecution.mockReturnValue(undefined)
     mockLoadExecutionPointer.mockResolvedValue(null)
@@ -679,6 +680,64 @@ describe('useWorkflowExecution attachment uploads', () => {
     unmount()
   })
 
+  it('does not let delayed debug completion reset a replacement execution', async () => {
+    const debugPersistenceExecution = {}
+    const replacementPersistenceExecution = {}
+    let currentPersistenceExecution: object | undefined = debugPersistenceExecution
+    let resolveDebugStep: ((result: unknown) => void) | undefined
+    const continueExecution = vi.fn(
+      () =>
+        new Promise((resolve) => {
+          resolveDebugStep = resolve
+        })
+    )
+    const debugExecution = {
+      ...idleExecution,
+      status: 'running',
+      isExecuting: true,
+      isDebugging: true,
+      pendingBlocks: ['start'],
+      executor: { continueExecution },
+      debugContext: { blockLogs: [] },
+    }
+    executionStoreState.workflowExecutions.set('workflow-1', debugExecution)
+    executionStoreState.getWorkflowExecution.mockReturnValue(debugExecution)
+    mockAdoptScopedExecution.mockImplementation(() => currentPersistenceExecution)
+    mockEndScopedExecution.mockImplementation((_workflowId, persistenceExecution) => {
+      if (persistenceExecution !== currentPersistenceExecution) return false
+      currentPersistenceExecution = undefined
+      return true
+    })
+
+    const { result, unmount } = renderWorkflowExecutionHook()
+    let debugStep: Promise<void>
+    act(() => {
+      debugStep = result().handleStepDebug()
+    })
+    expect(continueExecution).toHaveBeenCalledOnce()
+
+    currentPersistenceExecution = replacementPersistenceExecution
+    resolveDebugStep?.({ success: true, output: {}, logs: [] })
+    await act(async () => {
+      await debugStep
+    })
+
+    expect(mockEndScopedExecution).not.toHaveBeenCalledWith(
+      'workflow-1',
+      replacementPersistenceExecution
+    )
+    expect(mockClearExecutionPointer).not.toHaveBeenCalled()
+    expect(executionStoreState.setIsExecuting).not.toHaveBeenCalledWith('workflow-1', false)
+    expect(executionStoreState.setIsDebugging).not.toHaveBeenCalledWith('workflow-1', false)
+    expect(executionStoreState.setDebugContext).not.toHaveBeenCalledWith('workflow-1', null)
+    expect(executionStoreState.setExecutor).not.toHaveBeenCalledWith('workflow-1', null)
+    expect(executionStoreState.setPendingBlocks).not.toHaveBeenCalledWith('workflow-1', [])
+    expect(executionStoreState.setActiveBlocks).not.toHaveBeenCalled()
+    expect(mockRequestJson).not.toHaveBeenCalled()
+
+    unmount()
+  })
+
   it('uses only projected live thinking without changing normal settle behavior', async () => {
     mockExecute.mockImplementationOnce(async (options) => {
       options.onExecutionId?.('execution-1')