fix(mothership): end refused replay turns cleanly and bound oversized stream events

apps/sim/app/api/copilot/confirm/route.ts

@@ -42,13 +42,13 @@ import {
   retainSealedClientToolContext,
   sealClientToolCompletion,
 } from '@/lib/mothership/request/tools/client-completion-seal.server'
+import { isWorkflowToolName } from '@/lib/mothership/tools/client-executed-tools'
 import {
   createStructuralWorkflowToolCompletionData,
   getWorkflowToolCompletionExecutionId,
   getWorkflowToolCompletionMessage,
   getWorkflowToolConfirmationStatus,
   getWorkflowToolLaunchError,
-  isWorkflowToolName,
   resolveWorkflowToolTargetId,
   WORKFLOW_EXECUTION_BUSY,
   type WorkflowToolLaunchError,

apps/sim/app/workspace/[workspaceId]/home/hooks/message-reconcile.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from 'vitest'
+import type { PersistedMessage } from '@/lib/mothership/chat/persisted-message'
+import { markMessageStopped } from '@/app/workspace/[workspaceId]/home/hooks/message-reconcile'
+
+describe('markMessageStopped', () => {
+  it.each(['executing', 'pending', 'awaiting_approval'] as const)(
+    'settles a %s tool row as stopped',
+    (state) => {
+      const message: PersistedMessage = {
+        id: 'assistant-1',
+        role: 'assistant',
+        content: '',
+        timestamp: '2026-09-29T00:00:00.000Z',
+        contentBlocks: [
+          {
+            type: 'tool',
+            endedAt: 1,
+            toolCall: { id: 'call-1', name: 'gmail_read_v2', state },
+          },
+        ],
+      }
+
+      const stopped = markMessageStopped(message)
+
+      expect(stopped.contentBlocks?.[0].toolCall?.state).toBe('cancelled')
+    }
+  )
+})

apps/sim/app/workspace/[workspaceId]/home/hooks/message-reconcile.ts

@@ -8,7 +8,11 @@
 import { isBrowserToolName } from '@sim/browser-protocol'
 import type { PersistedContentBlock } from '@/lib/api/contracts/copilot-messages'
 import type { PersistedMessage } from '@/lib/mothership/chat/persisted-message'
-import { normalizeMessage, withBlockTiming } from '@/lib/mothership/chat/persisted-message'
+import {
+  isUnsettledToolState,
+  normalizeMessage,
+  withBlockTiming,
+} from '@/lib/mothership/chat/persisted-message'
 import {
   MothershipStreamV1CompletionStatus,
   MothershipStreamV1EventType,
@@ -18,7 +22,7 @@ import {
   MothershipStreamV1ToolPhase,
 } from '@/lib/mothership/generated/mothership-stream-v1'
 import type { StreamBatchEvent } from '@/lib/mothership/request/session/types'
-import { isWorkflowToolName } from '@/lib/mothership/tools/workflow-tools'
+import { isWorkflowToolName } from '@/lib/mothership/tools/client-executed-tools'
 import type { ContentBlock } from '@/app/workspace/[workspaceId]/home/types'
 import type { MothershipChatHistory } from '@/hooks/queries/mothership-chats'
 import { isZeroStreamCursor } from './stream-protocol'
@@ -142,18 +146,18 @@ export function buildAssistantSnapshotMessage(params: {
 }
 
 export function markMessageStopped(message: PersistedMessage): PersistedMessage {
-  const hasExecutingTool = message.contentBlocks?.some(
-    (block) => block.toolCall?.state === 'executing'
+  const hasUnsettledTool = message.contentBlocks?.some((block) =>
+    isUnsettledToolState(block.toolCall?.state)
   )
   const hasOpenBlock = message.contentBlocks?.some((block) => block.endedAt === undefined)
-  if (!hasExecutingTool && !hasOpenBlock) {
+  if (!hasUnsettledTool && !hasOpenBlock) {
     return message
   }
 
   const stopTs = Date.now()
   const nextBlocks = (message.contentBlocks ?? []).map((block) => {
     const stamped = block.endedAt === undefined ? { ...block, endedAt: stopTs } : block
-    if (stamped.toolCall?.state !== 'executing') {
+    if (!stamped.toolCall || !isUnsettledToolState(stamped.toolCall.state)) {
       return stamped
     }
     return {

apps/sim/app/workspace/[workspaceId]/home/hooks/preview/apply-file-preview-phase.test.ts

@@ -1,6 +1,9 @@
 import { describe, expect, it } from 'vitest'
 import type { FilePreviewSession } from '@/lib/mothership/request/session'
-import { deriveFilePreviewSession } from './apply-file-preview-phase'
+import {
+  deriveFilePreviewSession,
+  previewHoldsFinalContent,
+} from '@/app/workspace/[workspaceId]/home/hooks/preview/apply-file-preview-phase'
 
 const NOW = '2026-06-08T00:00:00.000Z'
 
@@ -94,3 +97,40 @@ describe('deriveFilePreviewSession', () => {
     expect(third?.previewText).toBe('ABC')
   })
 })
+
+describe('previewHoldsFinalContent', () => {
+  const complete = (previewVersion?: number) => ({
+    previewPhase: 'file_preview_complete' as const,
+    toolCallId: 'tool-1',
+    toolName: 'prepare_file_edit' as const,
+    ...(previewVersion !== undefined ? { previewVersion } : {}),
+  })
+
+  it('holds the final content when the last content received is the completed version', () => {
+    const prev = session({ previewText: 'final text', previewVersion: 7 })
+
+    expect(previewHoldsFinalContent(prev, complete(7))).toBe(true)
+  })
+
+  it('does not hold it when later versions were never received, so the stored file must load', () => {
+    const prev = session({ previewText: 'an earlier draft', previewVersion: 5 })
+
+    expect(previewHoldsFinalContent(prev, complete(7))).toBe(false)
+  })
+
+  it('does not hold it when no content was received at all', () => {
+    expect(previewHoldsFinalContent(undefined, complete(7))).toBe(false)
+  })
+
+  it('does not hold it when the session exists but received no text', () => {
+    const prev = session({ previewText: '', previewVersion: 7 })
+
+    expect(previewHoldsFinalContent(prev, complete(7))).toBe(false)
+  })
+
+  it('holds the received text when the completion carries no version to compare', () => {
+    const prev = session({ previewText: 'final text', previewVersion: 3 })
+
+    expect(previewHoldsFinalContent(prev, complete())).toBe(true)
+  })
+})

apps/sim/app/workspace/[workspaceId]/home/hooks/preview/apply-file-preview-phase.ts

@@ -99,3 +99,17 @@ export function deriveFilePreviewSession(
       }
   }
 }
+
+/**
+ * Whether the preview text the client holds is the edit's final content. The
+ * server skips a content frame too large for the stream, so a completion whose
+ * version is newer than the last content received means the text is an earlier
+ * draft, and only the stored file is the saved result.
+ */
+export function previewHoldsFinalContent(
+  prev: FilePreviewSession | undefined,
+  completion: Extract<SyntheticFilePreviewPayload, { previewPhase: 'file_preview_complete' }>
+): boolean {
+  if (!prev || prev.previewText.length === 0) return false
+  return completion.previewVersion === undefined || prev.previewVersion >= completion.previewVersion
+}

apps/sim/app/workspace/[workspaceId]/home/hooks/preview/use-file-preview-controller.ts

@@ -12,7 +12,10 @@ import { useQueryClient } from '@tanstack/react-query'
 import type { SyntheticFilePreviewPayload } from '@/lib/mothership/request/session'
 import type { FilePreviewSession } from '@/lib/mothership/request/session/file-preview-session-contract'
 import { invalidateResourceQueries } from '@/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-registry'
-import { deriveFilePreviewSession } from '@/app/workspace/[workspaceId]/home/hooks/preview/apply-file-preview-phase'
+import {
+  deriveFilePreviewSession,
+  previewHoldsFinalContent,
+} from '@/app/workspace/[workspaceId]/home/hooks/preview/apply-file-preview-phase'
 import {
   buildCompletedPreviewSessions,
   type FilePreviewSessionsState,
@@ -381,7 +384,7 @@ export function useFilePreviewController({
           sessionId: nextSession.id,
           suppressActivation: !shouldActivateOnComplete,
         })
-        if (hasRenderableFilePreviewContent(nextSession)) {
+        if (previewHoldsFinalContent(prevSession, payload)) {
           seedCompletedPreviewContentCache(fileId, nextSession.previewText)
         }
         if (workspaceId) invalidateResourceQueries(queryClient, workspaceId, 'file', fileId)

apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.test.ts

@@ -4,9 +4,6 @@ vi.mock('@/lib/mothership/resources/extraction', () => ({
   isResourceToolName: vi.fn(() => false),
   extractResourcesFromToolResult: vi.fn(() => []),
 }))
-vi.mock('@/lib/mothership/tools/workflow-tools', () => ({
-  isWorkflowToolName: vi.fn(() => false),
-}))
 vi.mock(
   '@/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-registry',
   () => ({ invalidateResourceQueries: vi.fn() })

apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.ts

@@ -14,8 +14,10 @@ import {
   extractResourcesFromToolResult,
   isResourceToolName,
 } from '@/lib/mothership/resources/extraction'
-import { isNativeFileTool, isUserLocalVfsToolCall } from '@/lib/mothership/tools/local-filesystem'
-import { isWorkflowToolName } from '@/lib/mothership/tools/workflow-tools'
+import {
+  isClientExecutedToolCall,
+  isWorkflowToolName,
+} from '@/lib/mothership/tools/client-executed-tools'
 import { invalidateResourceQueries } from '@/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-registry'
 import type { StreamLoopContext } from '@/app/workspace/[workspaceId]/home/hooks/stream/stream-context'
 import {
@@ -188,56 +190,23 @@ export function handleToolEvent(ctx: StreamLoopContext, parsed: ToolEvent): void
   const name = payload.toolName
   const isPartial =
     payload.partial === true || payload.status === MothershipStreamV1ToolStatus.generating
-  if (isWorkflowToolName(name) && !isPartial) {
-    const shouldStartWorkflowTool =
-      !deps.options.suppressedWorkflowToolStartIds?.has(rawId) &&
-      node?.kind === 'tool' &&
-      node.status === 'running' &&
-      !node.result
-    if (shouldStartWorkflowTool) {
-      const args = payload.arguments as Record<string, unknown> | undefined
+  const args = payload.arguments as Record<string, unknown> | undefined
+  const shouldStartClientTool =
+    isClientExecutedToolCall(name, args) &&
+    !isPartial &&
+    !deps.options.suppressedWorkflowToolStartIds?.has(rawId) &&
+    node?.kind === 'tool' &&
+    node.status === 'running' &&
+    !node.result
+  if (shouldStartClientTool) {
+    if (isWorkflowToolName(name)) {
       deps.startClientWorkflowTool(rawId, name, args ?? {})
-    }
-  }
-  const localFilesystemArgs = payload.arguments as Record<string, unknown> | undefined
-  if ((isNativeFileTool(name) || isUserLocalVfsToolCall(name, localFilesystemArgs)) && !isPartial) {
-    const shouldStartLocalFilesystemTool =
-      !deps.options.suppressedWorkflowToolStartIds?.has(rawId) &&
-      node?.kind === 'tool' &&
-      node.status === 'running' &&
-      !node.result
-    if (shouldStartLocalFilesystemTool) {
-      deps.startClientLocalFilesystemTool(rawId, name, localFilesystemArgs ?? {})
-    }
-  }
-  if (isCurrentBrowserToolName(name) && !isPartial) {
-    const shouldStartBrowserTool =
-      !deps.options.suppressedWorkflowToolStartIds?.has(rawId) &&
-      node?.kind === 'tool' &&
-      node.status === 'running' &&
-      !node.result
-    if (shouldStartBrowserTool) {
-      deps.startClientBrowserTool(
-        rawId,
-        name,
-        (payload.arguments as Record<string, unknown> | undefined) ?? {},
-        parsed.ts
-      )
-    }
-  }
-  if (isTerminalToolName(name) && !isPartial) {
-    const shouldStartTerminalTool =
-      !deps.options.suppressedWorkflowToolStartIds?.has(rawId) &&
-      node?.kind === 'tool' &&
-      node.status === 'running' &&
-      !node.result
-    if (shouldStartTerminalTool) {
-      deps.startClientTerminalTool(
-        rawId,
-        name,
-        (payload.arguments as Record<string, unknown> | undefined) ?? {},
-        parsed.ts
-      )
+    } else if (isCurrentBrowserToolName(name)) {
+      deps.startClientBrowserTool(rawId, name, args ?? {}, parsed.ts)
+    } else if (isTerminalToolName(name)) {
+      deps.startClientTerminalTool(rawId, name, args ?? {}, parsed.ts)
+    } else {
+      deps.startClientLocalFilesystemTool(rawId, name, args ?? {})
     }
   }
   ops.flush()

apps/sim/app/workspace/[workspaceId]/home/hooks/stream/stream-helpers.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest'
+import { finalizeResidualToolCalls } from '@/app/workspace/[workspaceId]/home/hooks/stream/stream-helpers'
+import type { ContentBlock } from '@/app/workspace/[workspaceId]/home/types'
+
+describe('finalizeResidualToolCalls', () => {
+  it.each(['executing', 'awaiting_approval'] as const)(
+    'settles a %s tool row with the turn outcome on Stop',
+    (status) => {
+      const blocks: ContentBlock[] = [
+        { type: 'tool_call', toolCall: { id: 'call-1', name: 'gmail_read_v2', status } },
+      ]
+
+      finalizeResidualToolCalls(blocks, 'cancelled')
+
+      expect(blocks[0].toolCall?.status).toBe('cancelled')
+    }
+  )
+
+  it('reports whether any tool row was left to settle', () => {
+    const open: ContentBlock[] = [
+      { type: 'tool_call', toolCall: { id: 'call-1', name: 'read', status: 'awaiting_approval' } },
+    ]
+    const settled: ContentBlock[] = [
+      { type: 'tool_call', toolCall: { id: 'call-2', name: 'read', status: 'success' } },
+    ]
+
+    expect(finalizeResidualToolCalls(open, 'error')).toBe(true)
+    expect(finalizeResidualToolCalls(settled, 'error')).toBe(false)
+  })
+
+  it('reports closing an open subagent lane as a change to persist', () => {
+    const blocks: ContentBlock[] = [{ type: 'subagent', content: 'research' }]
+
+    expect(finalizeResidualToolCalls(blocks, 'error')).toBe(true)
+    expect(blocks[0].endedAt).toEqual(expect.any(Number))
+  })
+})

apps/sim/app/workspace/[workspaceId]/home/hooks/stream/stream-helpers.ts

@@ -1,5 +1,6 @@
 import { createLogger } from '@sim/logger'
 import { isRecordLike } from '@sim/utils/object'
+import { isUnsettledToolState } from '@/lib/mothership/chat/persisted-message'
 import {
   CallIntegrationTool,
   CreateEmptyFile,
@@ -68,17 +69,17 @@ export function asPayloadRecord(value: unknown): StreamPayload | undefined {
 }
 
 /**
- * Settles any tool row still `executing` at a turn terminal by propagating the
- * turn's outcome — the deterministic replacement for the old `interrupted`
- * invention. A clean `complete` means the turn succeeded, so a straggler is
- * settled `success` (with explicit tool/span terminals from the backend there
- * are normally none); a stop settles `cancelled`; an error settles `error`.
+ * Settles every unfinished tool row (running, pending, or awaiting approval) at
+ * a turn terminal by propagating the turn's outcome: a clean `complete` settles
+ * a straggler `success`, a stop `cancelled`, an error `error`. Also closes any
+ * open subagent lane. Returns whether it settled a row or closed a lane.
  */
 export function finalizeResidualToolCalls(
   blocks: ContentBlock[],
   turnTerminal: 'complete' | 'cancelled' | 'error'
-): void {
+): boolean {
   const endedAt = Date.now()
+  let settled = false
   const propagated =
     turnTerminal === 'cancelled'
       ? ToolCallStatus.cancelled
@@ -93,10 +94,12 @@ export function finalizeResidualToolCalls(
     // transport-based gating.
     if (block.type === 'subagent' && block.endedAt === undefined) {
       block.endedAt = endedAt
+      settled = true
       continue
     }
     const tc = block.toolCall
-    if (!tc || tc.status !== ToolCallStatus.executing) continue
+    if (!tc || !isUnsettledToolState(tc.status)) continue
+    settled = true
     tc.status = propagated
     if (propagated === ToolCallStatus.cancelled) {
       tc.displayTitle = 'Stopped by user'
@@ -105,6 +108,7 @@ export function finalizeResidualToolCalls(
       block.endedAt = endedAt
     }
   }
+  return settled
 }
 
 function stringParam(value: unknown): string | undefined {