fix(workflows): stop deriving outputs from traces

Author: TheodoreSpeaks

apps/sim/lib/logs/execution/trace-store.test.ts

@@ -136,7 +136,7 @@ describe('projectExecutionDataForDisplay', () => {
     expect(JSON.stringify([...materialized.blockOutputs])).not.toContain('12345678')
   })
 
-  it('falls back to projected trace output for a requested block missing from partial state', async () => {
+  it('does not use trace output for a requested block missing from partial state', async () => {
     const emptyProvenance = {
       version: 1 as const,
       complete: true,
@@ -172,12 +172,59 @@ describe('projectExecutionDataForDisplay', () => {
       ['state-only', 'trace-only']
     )
 
-    expect(materialized.blockOutputs).toEqual(
-      new Map([
-        ['trace-only', { result: 'trace-output' }],
-        ['state-only', { result: 'state-output' }],
-      ])
+    expect(materialized.blockOutputs).toEqual(new Map([['state-only', { result: 'state-output' }]]))
+  })
+
+  it('does not derive block outputs from legacy trace spans', async () => {
+    const materialized = await materializeExecutionDataForDisplayWithBlockOutputs(
+      {
+        traceSpans: [
+          {
+            id: 'span-1',
+            blockId: 'function-1',
+            name: 'Function 1',
+            type: 'function',
+            duration: 1,
+            startTime: '2026-08-11T00:00:00.000Z',
+            endTime: '2026-08-11T00:00:00.001Z',
+            output: { token: 'raw-legacy-secret' },
+          },
+        ],
+      },
+      CONTEXT,
+      ['function-1']
+    )
+
+    expect(materialized.blockOutputs).toEqual(new Map())
+  })
+
+  it('does not mix legacy trace output into partial execution state', async () => {
+    const materialized = await materializeExecutionDataForDisplayWithBlockOutputs(
+      {
+        traceSpans: [
+          {
+            id: 'span-1',
+            blockId: 'trace-only',
+            name: 'Trace-only block',
+            type: 'function',
+            duration: 1,
+            startTime: '2026-08-11T00:00:00.000Z',
+            endTime: '2026-08-11T00:00:00.001Z',
+            output: { token: 'raw-legacy-secret' },
+          },
+        ],
+        executionState: {
+          blockStates: {
+            'state-only': { output: { result: 'unproven-state-output' } },
+          },
+        },
+      },
+      CONTEXT,
+      ['state-only', 'trace-only']
     )
+
+    expect(materialized.blockOutputs).toEqual(new Map())
+    expect(JSON.stringify([...materialized.blockOutputs])).not.toContain('raw-legacy-secret')
   })
 
   it('omits state-only block outputs that lack usable secret provenance', async () => {

apps/sim/lib/logs/execution/trace-store.ts

@@ -3,10 +3,7 @@ import { toError } from '@sim/utils/errors'
 import { omit } from '@sim/utils/object'
 import { isLargeValueRef } from '@/lib/execution/payloads/large-value-ref'
 import { materializeLargeValueRef, storeLargeValue } from '@/lib/execution/payloads/store'
-import {
-  collectFunctionalBlockOutputs,
-  type FunctionalExecutionDataSource,
-} from '@/lib/logs/execution/functional-outputs'
+import { FunctionalOutputsUnavailableError } from '@/lib/logs/execution/functional-outputs'
 import { projectTraceSpansForSecrets } from '@/lib/logs/execution/trace-secret-projection'
 import type { TraceSpan } from '@/lib/logs/types'
 import {
@@ -280,8 +277,8 @@ export async function materializeExecutionDataForDisplay(
 
 /**
  * Materializes one trusted row into its display envelope plus secret-safe functional outputs.
- * Execution-state output remains authoritative when present, but only requested blocks are
- * projected and returned; the raw execution state never crosses the display boundary.
+ * Only requested execution-state outputs are projected and returned; trace spans remain display
+ * data and the raw execution state never crosses the display boundary.
  */
 export async function materializeExecutionDataForDisplayWithBlockOutputs(
   executionData: Record<string, unknown> | null | undefined,
@@ -296,27 +293,25 @@ export async function materializeExecutionDataForDisplayWithBlockOutputs(
 
   const executionState = readRecord(materialized.executionState)
   const blockStates = readRecord(executionState?.blockStates)
-  const displaySource = displayData as FunctionalExecutionDataSource
   if (!blockStates) {
-    return {
-      executionData: displayData,
-      blockOutputs: collectFunctionalBlockOutputs(displaySource),
+    if (materialized.executionDataTruncated === true) {
+      throw new FunctionalOutputsUnavailableError()
     }
+    return { executionData: displayData, blockOutputs: new Map() }
   }
 
   const runRegistry = await importResolvedSecretTraceRegistry(
     materialized[RESOLVED_SECRET_PROVENANCE_KEY] ??
       executionState?.[RESOLVED_SECRET_PROVENANCE_KEY],
     'traceStore.blockOutputRunProvenance'
   )
-  const blockOutputs = collectFunctionalBlockOutputs({ traceSpans: displaySource.traceSpans })
+  const blockOutputs = new Map<string, unknown>()
   const projectionStore = createReadOnlyProjectionStore(context)
 
   for (const blockId of new Set(blockIds)) {
     const blockState = readRecord(blockStates[blockId])
     if (!blockState || blockState.output === undefined) continue
 
-    blockOutputs.delete(blockId)
     const hasExactProvenance = Object.hasOwn(blockState, RESOLVED_SECRET_PROVENANCE_KEY)
     const registry = hasExactProvenance
       ? await importResolvedSecretTraceRegistry(