fix(mothership): resolve a browser run's select before the secret projection

The browser-run restoration projected the full raw block logs and only then
applied `select`, so a large run was still withheld whenever a selector was
given. The server handler selects first. Both paths now build their log fields
through one shared `presentWorkflowLogsForModel`, from raw logs and before
projection: a `select` resolves against the full logs and replaces them;
otherwise the echoed logs are bounded. Selected values are still projected, so
a selected secret is redacted.

Author: waleedlatif1

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

@@ -247,6 +247,46 @@ describe('workflow client tool completion', () => {
     expect(JSON.stringify(completion)).not.toContain('parent-secret-value')
   })
 
+  /** Parity with the server path: a `select` is resolved from raw logs before projection. */
+  it('projects selected values from a large browser run instead of withholding it', async () => {
+    const rows = (count: number) =>
+      Array.from({ length: count }, (_, index) => ({
+        id: `row_${index}`,
+        data: { a: 'x', b: 'y', c: 'z', d: 'w' },
+      }))
+    getTrustedWorkflowToolExecution.mockResolvedValue({
+      ...trustedExecution('execution-1'),
+      blockLogs: [
+        { blockId: 'reader', blockName: 'Reader', output: { token: 'parent-secret-value', n: 2 } },
+        ...Array.from({ length: 4 }, (_, index) => ({
+          blockId: `query-${index}`,
+          blockName: `Query ${index}`,
+          output: { rows: rows(5_000) },
+        })),
+      ],
+    })
+    waitForToolConfirmation.mockResolvedValue({
+      status: 'success',
+      data: { workflowId: 'workflow-1', executionId: 'execution-1' },
+    })
+
+    const completion = await waitForWorkflowToolCompletion({
+      toolCallId: 'tool-1',
+      workflowId: 'workflow-1',
+      timeoutMs: 1_000,
+      registry: createParentRegistry(),
+      select: ['Reader.token', 'Reader.n'],
+    })
+
+    expect(completion?.data).toMatchObject({
+      output: { value: 'child read {{PARENT_SECRET}} from execution-1' },
+      selected: { 'Reader.token': '{{PARENT_SECRET}}', 'Reader.n': 2 },
+      logsOmitted: true,
+    })
+    expect(completion?.data).not.toHaveProperty('logs')
+    expect(JSON.stringify(completion)).not.toContain('parent-secret-value')
+  })
+
   it('preserves the server-confirmed status while omitting unavailable execution content', async () => {
     const registry = createParentRegistry()
     waitForToolConfirmation.mockResolvedValue({

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

@@ -15,7 +15,7 @@ import {
   unsealClientToolContext,
 } from '@/lib/mothership/request/tools/client-completion-seal.server'
 import { inspectToolResultForCopilot } from '@/lib/mothership/request/tools/resolved-secret-result'
-import { compactBlockLogOutputs, presentWorkflowLogs } from '@/lib/mothership/tools/workflow-output'
+import { presentWorkflowLogsForModel } from '@/lib/mothership/tools/workflow-output'
 import {
   createStructuralWorkflowToolCompletionData,
   getWorkflowToolCompletionExecutionId,
@@ -376,10 +376,8 @@ export async function waitForWorkflowToolCompletion({
     ...(Object.hasOwn(trustedExecution, 'finalOutput')
       ? { output: trustedExecution.finalOutput }
       : {}),
-    // `select` reads full values from these logs; only logs echoed whole are bounded.
-    logs: select?.length
-      ? trustedExecution.blockLogs
-      : compactBlockLogOutputs(trustedExecution.blockLogs, executionId),
+    // Built from raw logs before projection, matching the server handler's presentation.
+    ...presentWorkflowLogsForModel(trustedExecution.blockLogs, executionId, select),
     ...(trustedExecution.error !== undefined ? { error: trustedExecution.error } : {}),
     ...(status === MothershipStreamV1ToolOutcome.cancelled
       ? { reason: 'user_cancelled', cancelledByUser: true }
@@ -397,10 +395,8 @@ export async function waitForWorkflowToolCompletion({
   )
   const projected = projection.result
   const projectedData = isPlainRecord(projected.output) ? projected.output : {}
-  const { logs, ...projectedFields } = projectedData
   const data = {
-    ...projectedFields,
-    ...(Object.hasOwn(projectedData, 'logs') ? presentWorkflowLogs(logs, select) : {}),
+    ...projectedData,
     ...createStructuralWorkflowToolCompletionData(status, workflowId, executionId),
   }
   const message =

apps/sim/lib/mothership/tools/handlers/workflow/mutations.ts

@@ -31,8 +31,7 @@ import type {
 import { requireCopilotWorkspace } from '@/lib/mothership/tools/server/workspace-scope'
 import {
   compactBlockLogInputs,
-  compactBlockLogOutputs,
-  presentWorkflowLogs,
+  presentWorkflowLogsForModel,
 } from '@/lib/mothership/tools/workflow-output'
 import { decodeVfsPathSegments, encodeVfsPathSegments } from '@/lib/mothership/vfs/path-utils'
 import { cancelWorkflowRun } from '@/lib/workflows/application/cancel-run'
@@ -157,11 +156,7 @@ function buildExecutionOutput(
       ...extra,
       output: lifted ? lifted.output : output,
       ...(lifted ? { outputFrom: lifted.outputFrom } : {}),
-      // `select` reads full values from the run's own logs, so only the echoed logs are bounded.
-      ...presentWorkflowLogs(
-        select?.length ? logs : compactBlockLogOutputs(logs, executionId),
-        select
-      ),
+      ...presentWorkflowLogsForModel(logs, executionId, select),
     },
     error: result.success
       ? undefined

apps/sim/lib/mothership/tools/workflow-output.ts

@@ -6,12 +6,29 @@ import {
 } from '@/executor/utils/resolved-secret-content-projection'
 
 /** Shared presentation for server execution and trusted client execution restoration. */
-export function presentWorkflowLogs(logs: unknown, select?: string[]): Record<string, unknown> {
+function presentWorkflowLogs(logs: unknown, select?: string[]): Record<string, unknown> {
   return select?.length
     ? { selected: selectFromLogs(select, Array.isArray(logs) ? logs : []), logsOmitted: true }
     : { logs }
 }
 
+/**
+ * The model-facing log fields for one run, built from raw logs before secret projection so both the
+ * server handler and browser-run restoration present the same bounded shape: a `select` resolves
+ * against the full logs and replaces them, otherwise the echoed logs are bounded by
+ * {@link compactBlockLogOutputs}.
+ */
+export function presentWorkflowLogsForModel(
+  logs: unknown,
+  executionId: string | undefined,
+  select?: string[]
+): Record<string, unknown> {
+  return presentWorkflowLogs(
+    select?.length ? logs : compactBlockLogOutputs(logs, executionId),
+    select
+  )
+}
+
 /** The executor's block-name rule: lowercase, whitespace and dots removed. */
 function normalizeSelectorHead(value: string): string {
   return value.toLowerCase().replace(/[\s.]+/g, '')
@@ -107,7 +124,7 @@ interface MeasuredLogOutput {
  * would disclose a secret's length. It says "inspect" rather than promising the full value, since
  * the stored trace can itself be summarized.
  */
-export function compactBlockLogOutputs(logs: unknown, executionId: string | undefined): unknown {
+function compactBlockLogOutputs(logs: unknown, executionId: string | undefined): unknown {
   if (!Array.isArray(logs)) return logs
   const reference = executionId ?? '<executionId>'
   const measured: MeasuredLogOutput[] = []