fix(mothership): preserve file intents and workflow result contracts

Author: Sg312

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

@@ -667,6 +667,41 @@ describe('Copilot Confirm API Route', () => {
     expect(publishToolConfirmation).not.toHaveBeenCalled()
   })
 
+  it.each(['run_workflow', 'run_block', 'run_from_block', 'run_workflow_until_block'])(
+    'preserves a safe busy reason for an unlaunched %s without trusting client text',
+    async (toolName) => {
+      getAsyncToolCall.mockResolvedValue({
+        ...existingRow,
+        toolName,
+        args: { workflowId: 'workflow-1' },
+        claimedBy: null,
+      })
+      const response = await POST(
+        createMockPostRequest({
+          toolCallId: 'tool-call-123',
+          status: 'error',
+          message: 'untrusted detail',
+          data: { code: 'WORKFLOW_EXECUTION_BUSY', error: 'untrusted detail' },
+        })
+      )
+      expect(response.status).toBe(200)
+      expect(completeAsyncToolCall).toHaveBeenCalledWith(
+        expect.objectContaining({
+          status: 'failed',
+          result: {
+            success: false,
+            workflowId: 'workflow-1',
+            code: 'WORKFLOW_EXECUTION_BUSY',
+            error:
+              'Workflow is already executing. Wait for the current execution to finish before running it again.',
+          },
+        })
+      )
+      expect(JSON.stringify(publishToolConfirmation.mock.calls)).not.toContain('untrusted detail')
+      expect(getTrustedWorkflowToolExecution).not.toHaveBeenCalled()
+    }
+  )
+
   it('preserves a canonical preflight failure before an execution is bound', async () => {
     getAsyncToolCall.mockResolvedValue({
       ...existingRow,

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

@@ -43,14 +43,15 @@ import {
   sealClientToolCompletion,
 } from '@/lib/mothership/request/tools/client-completion-seal.server'
 import {
-  type AsyncWorkflowDeploymentError,
   createStructuralWorkflowToolCompletionData,
-  getAsyncWorkflowDeploymentError,
   getWorkflowToolCompletionExecutionId,
   getWorkflowToolCompletionMessage,
   getWorkflowToolConfirmationStatus,
+  getWorkflowToolLaunchError,
   isWorkflowToolName,
   resolveWorkflowToolTargetId,
+  WORKFLOW_EXECUTION_BUSY,
+  type WorkflowToolLaunchError,
 } from '@/lib/mothership/tools/workflow-tools'
 import { getTrustedWorkflowToolExecution } from '@/lib/workflows/executor/execution-state'
 
@@ -313,7 +314,7 @@ export const POST = withRouteHandler((req: NextRequest) => {
 
         let effectiveStatus = status
         let executionId = submittedExecutionId
-        let deploymentError: AsyncWorkflowDeploymentError | undefined
+        let launchError: WorkflowToolLaunchError | undefined
 
         if (isWorkflowTool) {
           const claimedExecutionId = getClaimedWorkflowExecutionId(existing.claimedBy)
@@ -368,25 +369,28 @@ export const POST = withRouteHandler((req: NextRequest) => {
 
           if (
             effectiveStatus === ASYNC_TOOL_CONFIRMATION_STATUS.error &&
-            executionId === undefined &&
-            existing.toolName === 'run_workflow' &&
-            isPlainRecord(existing.args) &&
-            existing.args.async === true
+            executionId === undefined
           ) {
-            deploymentError = getAsyncWorkflowDeploymentError(data)
+            const submittedError = getWorkflowToolLaunchError(data)
+            if (
+              submittedError?.code === WORKFLOW_EXECUTION_BUSY.code ||
+              (existing.toolName === 'run_workflow' &&
+                isPlainRecord(existing.args) &&
+                existing.args.async === true)
+            )
+              launchError = submittedError
           }
         }
 
         span.setAttribute(TraceAttr.ToolConfirmationStatus, effectiveStatus)
         const projected = isWorkflowTool
           ? {
-              message:
-                deploymentError?.message ?? getWorkflowToolCompletionMessage(effectiveStatus),
+              message: launchError?.message ?? getWorkflowToolCompletionMessage(effectiveStatus),
               data: createStructuralWorkflowToolCompletionData(
                 effectiveStatus,
                 workflowId,
                 executionId,
-                deploymentError
+                launchError
               ),
             }
           : {

apps/sim/lib/mothership/request/handlers/tool.ts

@@ -852,6 +852,12 @@ async function dispatchToolExecution(
         if (isWorkflowToolName(toolName)) {
           const race = await raceWorkflowToolClientPickup({
             toolCallId,
+            select:
+              args &&
+              Array.isArray(args.select) &&
+              args.select.every((value) => typeof value === 'string')
+                ? args.select
+                : undefined,
             workflowId: resolveWorkflowToolTargetId(args, execContext.workflowId),
             timeoutMs,
             // The caller declared its executors at turn setup (ChatRequest.clientCapabilities):

apps/sim/lib/mothership/request/tools/client.test.ts

@@ -106,6 +106,67 @@ describe('workflow client tool completion', () => {
     replaceTerminalAsyncToolCallResult.mockResolvedValue({ status: 'completed' })
   })
 
+  it('keeps a safe busy reason when no execution was launched', async () => {
+    waitForToolConfirmation.mockResolvedValue({
+      status: 'error',
+      data: { code: 'WORKFLOW_EXECUTION_BUSY', error: 'untrusted text' },
+    })
+    const completion = await waitForWorkflowToolCompletion({
+      toolCallId: 'tool-1',
+      workflowId: 'workflow-1',
+      timeoutMs: 1_000,
+    })
+    expect(completion?.data).toEqual({
+      success: false,
+      workflowId: 'workflow-1',
+      code: 'WORKFLOW_EXECUTION_BUSY',
+      error:
+        'Workflow is already executing. Wait for the current execution to finish before running it again.',
+    })
+    expect(completion?.message).toBe(
+      'Workflow is already executing. Wait for the current execution to finish before running it again.'
+    )
+    expect(getTrustedWorkflowToolExecution).not.toHaveBeenCalled()
+  })
+
+  it('selects requested trusted outputs after redaction and omits full client logs', async () => {
+    waitForToolConfirmation.mockResolvedValue({
+      status: 'success',
+      data: { executionId: 'execution-1' },
+    })
+    getTrustedWorkflowToolExecution.mockResolvedValue({
+      ...trustedExecution('execution-1'),
+      blockLogs: [
+        { blockId: 'b1', blockName: 'Read Value', output: { result: 'earlier' } },
+        {
+          blockId: 'b1',
+          blockName: 'Read Value',
+          output: { result: 'parent-secret-value', count: 3 },
+        },
+      ],
+    })
+    const completion = await waitForWorkflowToolCompletion({
+      toolCallId: 'tool-1',
+      workflowId: 'workflow-1',
+      timeoutMs: 1_000,
+      registry: createParentRegistry(),
+      select: ['readvalue.result', 'b1.count', 'Missing.result'],
+    })
+    expect(completion?.data).toMatchObject({
+      selected: {
+        'readvalue.result': '{{PARENT_SECRET}}',
+        'b1.count': 3,
+        'Missing.result': { unresolved: 'no executed block named "Missing"' },
+      },
+      logsOmitted: true,
+    })
+    expect(completion?.data).not.toHaveProperty('logs')
+    expect(JSON.stringify(completion)).not.toContain('parent-secret-value')
+    expect(replaceTerminalAsyncToolCallResult).toHaveBeenCalledWith(
+      expect.objectContaining({ result: completion?.data })
+    )
+  })
+
   it('projects a parent secret laundered through a child workflow before every live sink', async () => {
     const registry = createParentRegistry()
     waitForToolConfirmation.mockResolvedValue({

apps/sim/lib/mothership/request/tools/client.ts

@@ -14,13 +14,14 @@ import {
   unsealClientToolContext,
 } from '@/lib/mothership/request/tools/client-completion-seal.server'
 import { inspectToolResultForCopilot } from '@/lib/mothership/request/tools/resolved-secret-result'
+import { presentWorkflowLogs } from '@/lib/mothership/tools/workflow-output'
 import {
-  type AsyncWorkflowDeploymentError,
   createStructuralWorkflowToolCompletionData,
-  getAsyncWorkflowDeploymentError,
   getWorkflowToolCompletionExecutionId,
   getWorkflowToolCompletionMessage,
   getWorkflowToolConfirmationStatus,
+  getWorkflowToolLaunchError,
+  type WorkflowToolLaunchError,
 } from '@/lib/mothership/tools/workflow-tools'
 import { getTrustedWorkflowToolExecution } from '@/lib/workflows/executor/execution-state'
 import type { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secret-trace-registry'
@@ -211,6 +212,7 @@ export async function waitForClientToolCompletion({
 }
 
 interface WaitForWorkflowToolCompletionOptions {
+  select?: string[]
   toolCallId: string
   workflowId?: string
   timeoutMs: number
@@ -222,17 +224,12 @@ function structuralWorkflowCompletion(
   status: AsyncTerminalCompletionSnapshot['status'],
   workflowId?: string,
   executionId?: string,
-  deploymentError?: AsyncWorkflowDeploymentError
+  launchError?: WorkflowToolLaunchError
 ): AsyncTerminalCompletionSnapshot {
   return {
     status,
-    message: deploymentError?.message ?? getWorkflowToolCompletionMessage(status),
-    data: createStructuralWorkflowToolCompletionData(
-      status,
-      workflowId,
-      executionId,
-      deploymentError
-    ),
+    message: launchError?.message ?? getWorkflowToolCompletionMessage(status),
+    data: createStructuralWorkflowToolCompletionData(status, workflowId, executionId, launchError),
   }
 }
 
@@ -241,6 +238,7 @@ function structuralWorkflowCompletion(
  * The browser confirmation is only a wakeup and structural identity carrier.
  */
 export async function waitForWorkflowToolCompletion({
+  select,
   toolCallId,
   workflowId,
   timeoutMs,
@@ -260,7 +258,7 @@ export async function waitForWorkflowToolCompletion({
     }
 
     const executionId = getWorkflowToolCompletionExecutionId(completion.data)
-    const deploymentError = getAsyncWorkflowDeploymentError(completion.data)
+    const launchError = getWorkflowToolLaunchError(completion.data)
     if (completion.status === ASYNC_TOOL_CONFIRMATION_STATUS.background) {
       toolRegistry?.markIncomplete('client-tool-completion-deferred')
       return structuralWorkflowCompletion(completion.status, workflowId, executionId)
@@ -271,12 +269,7 @@ export async function waitForWorkflowToolCompletion({
         completion.status === MothershipStreamV1ToolOutcome.success
           ? MothershipStreamV1ToolOutcome.error
           : completion.status
-      return structuralWorkflowCompletion(
-        structuralStatus,
-        workflowId,
-        executionId,
-        deploymentError
-      )
+      return structuralWorkflowCompletion(structuralStatus, workflowId, executionId, launchError)
     }
 
     try {
@@ -381,8 +374,10 @@ export async function waitForWorkflowToolCompletion({
   )
   const projected = projection.result
   const projectedData = isPlainRecord(projected.output) ? projected.output : {}
+  const { logs, ...projectedFields } = projectedData
   const data = {
-    ...projectedData,
+    ...projectedFields,
+    ...(Object.hasOwn(projectedData, 'logs') ? presentWorkflowLogs(logs, select) : {}),
     ...createStructuralWorkflowToolCompletionData(status, workflowId, executionId),
   }
   const message =

apps/sim/lib/mothership/request/tools/workflow-client-fallback.test.ts

@@ -66,6 +66,14 @@ describe('raceWorkflowToolClientPickup', () => {
     vi.useRealTimers()
   })
 
+  it('forwards requested output selectors to the client completion boundary', async () => {
+    waitForWorkflowToolCompletion.mockResolvedValue({ status: 'success', data: {} })
+    await raceWorkflowToolClientPickup({ ...baseParams(), select: ['Result.value'] })
+    expect(waitForWorkflowToolCompletion).toHaveBeenCalledWith(
+      expect.objectContaining({ select: ['Result.value'] })
+    )
+  })
+
   it('lets the client win without ever attempting a claim', async () => {
     waitForWorkflowToolCompletion.mockResolvedValue({ status: 'success', data: { ok: true } })
     const params = baseParams()

apps/sim/lib/mothership/request/tools/workflow-client-fallback.ts

@@ -28,6 +28,7 @@ export interface WorkflowToolRaceOutcome {
 }
 
 interface RaceWorkflowToolClientPickupParams {
+  select?: string[]
   toolCallId: string
   workflowId?: string
   timeoutMs: number
@@ -68,6 +69,7 @@ export async function raceWorkflowToolClientPickup(
   // Exactly one waiter for the whole race — a second one would double-consume
   // the confirmation and emit a duplicate tool result.
   const clientWait = waitForWorkflowToolCompletion({
+    select: params.select,
     toolCallId,
     workflowId,
     timeoutMs,

apps/sim/lib/mothership/tools/client/run-tool-execution.test.ts

@@ -147,6 +147,19 @@ describe('run tool execution cancellation', () => {
     vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: true }))
   })
 
+  it('reports a typed busy reason before launching into an already-running workflow', async () => {
+    getWorkflowExecution.mockReturnValueOnce({ isExecuting: true })
+    await executeRunToolOnClient('busy-tool', 'run_workflow', { workflowId: 'wf-1' })
+    expect(executeWorkflowWithFullLogging).not.toHaveBeenCalled()
+    const [url, options] = vi.mocked(fetch).mock.calls[0]!
+    expect(url).toBe('/api/copilot/confirm')
+    expect(JSON.parse(String(options?.body))).toMatchObject({
+      toolCallId: 'busy-tool',
+      status: 'error',
+      data: { code: 'WORKFLOW_EXECUTION_BUSY' },
+    })
+  })
+
   it('passes an abort signal into executeWorkflowWithFullLogging and aborts it', async () => {
     let capturedSignal: AbortSignal | undefined
     executeWorkflowWithFullLogging.mockImplementationOnce(async (options: any) => {

apps/sim/lib/mothership/tools/client/run-tool-execution.ts

@@ -24,9 +24,10 @@ import {
   reportClientToolCompletion as reportCompletion,
 } from '@/lib/mothership/tools/client/completion'
 import {
-  type AsyncWorkflowDeploymentError,
-  getAsyncWorkflowDeploymentError,
   getWorkflowToolCompletionMessage,
+  getWorkflowToolLaunchError,
+  WORKFLOW_EXECUTION_BUSY,
+  type WorkflowToolLaunchError,
 } from '@/lib/mothership/tools/workflow-tools'
 import { executeWorkflowWithFullLogging } from '@/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-execution-utils'
 import {
@@ -106,7 +107,7 @@ async function enqueueAsyncWorkflowRun(
 
   let responseExecutionId = requestedExecutionId
   let acceptanceIsAmbiguous = false
-  let deploymentError: AsyncWorkflowDeploymentError | undefined
+  let launchError: WorkflowToolLaunchError | undefined
   try {
     // boundary-raw-fetch: this execution endpoint switches to a JSON 202 response via X-Execution-Mode
     const response = await fetch(`/api/workflows/${workflowId}/execute`, {
@@ -126,7 +127,7 @@ async function enqueueAsyncWorkflowRun(
       }),
     })
     const responseBody: unknown = await response.json().catch(() => undefined)
-    deploymentError = getAsyncWorkflowDeploymentError(responseBody)
+    launchError = getWorkflowToolLaunchError(responseBody)
     responseExecutionId =
       isPlainRecord(responseBody) && typeof responseBody.executionId === 'string'
         ? responseBody.executionId
@@ -148,7 +149,7 @@ async function enqueueAsyncWorkflowRun(
 
     if (!response.ok && !acceptanceIsAmbiguous) {
       const responseError =
-        deploymentError?.message ??
+        launchError?.message ??
         (isPlainRecord(responseBody) && typeof responseBody.error === 'string'
           ? responseBody.error
           : `Async workflow queue request failed with status ${response.status}`)
@@ -164,7 +165,7 @@ async function enqueueAsyncWorkflowRun(
     await reportCompletion(toolCallId, MothershipStreamV1ToolOutcome.error, message, {
       success: false,
       workflowId,
-      ...(deploymentError ? { code: deploymentError.code } : {}),
+      ...(launchError ? { code: launchError.code } : {}),
     })
     return
   }
@@ -456,7 +457,8 @@ async function doExecuteRunTool(
     await reportCompletion(
       toolCallId,
       MothershipStreamV1ToolOutcome.error,
-      'Workflow is already being executed by another tool. Wait for it to complete.'
+      WORKFLOW_EXECUTION_BUSY.message,
+      { code: WORKFLOW_EXECUTION_BUSY.code }
     )
     return
   }
@@ -474,7 +476,8 @@ async function doExecuteRunTool(
     await reportCompletion(
       toolCallId,
       MothershipStreamV1ToolOutcome.error,
-      'Workflow is already executing. Try again later'
+      WORKFLOW_EXECUTION_BUSY.message,
+      { code: WORKFLOW_EXECUTION_BUSY.code }
     )
     return
   }