fix(executions): skip archive materialization on status polls that read no output (#9308)

readWorkflowExecutionStatus returns the column-only response with error/finalOutput/blockOutputs null unless the run failed, a completed run was polled with includeOutput, or selectedOutputs were requested - the only three readers of the materialized execution data. Other polls skip the archive fetch, parse, and display projection; response key order is unchanged. Skipped polls no longer emit the archive-unavailable, provenance-fault, or write-time-projected-span warnings, and a projection exception on such a poll no longer turns it into a 500. Adds regression tests for skipped polls (fail fast via a macrotask sentinel) and for selected outputs on a running run, including the truncated-row rejection.

Author: waleedlatif1

apps/sim/lib/workflows/executor/execution-status.test.ts

@@ -1,4 +1,5 @@
 import { dbChainMockFns, queueTableRows, resetDbChainMock, schemaMock } from '@sim/testing'
+import { flushMacrotask } from '@sim/testing/helpers/async'
 import { asyncJobsMock, asyncJobsMockFns } from '@sim/testing/mocks/async-jobs.mock'
 import { traceStoreMock, traceStoreMockFns } from '@sim/testing/mocks/trace-store.mock'
 import { and } from 'drizzle-orm'
@@ -12,6 +13,7 @@ vi.mock('@/lib/workflows/executor/paused-execution-metadata', () => ({
   getAutomaticResumeWaitingMetadata: vi.fn().mockReturnValue(null),
 }))
 
+import { FunctionalOutputsUnavailableError } from '@/lib/logs/execution/functional-outputs'
 import { getWorkflowExecutionStatus } from '@/lib/workflows/executor/execution-status'
 
 const mockGetJob = asyncJobsMockFns.mockJobQueue.getJob
@@ -552,3 +554,108 @@ describe('getWorkflowExecutionStatus settled resume attempts', () => {
     expect(status).toMatchObject({ status: 'cancelled', level: 'info', error: null })
   })
 })
+
+describe('getWorkflowExecutionStatus polls that read no execution data', () => {
+  const STALLED = Symbol('stalled')
+
+  function queueLog(status: string, pausedRows: unknown[] = []) {
+    queueTableRows(schemaMock.workflowExecutionLogs, [
+      {
+        executionId: 'execution-1',
+        workflowId: 'workflow-1',
+        workspaceId: 'workspace-1',
+        status,
+        level: 'info',
+        trigger: 'api',
+        startedAt: new Date('2026-08-05T12:00:00.000Z'),
+        endedAt: new Date('2026-08-05T12:00:01.000Z'),
+        totalDurationMs: 1000,
+        executionData: { finalOutput: { answer: 42 } },
+        costTotal: '0.5',
+      },
+    ])
+    queueTableRows(schemaMock.resumeQueue, [])
+    queueTableRows(schemaMock.pausedExecutions, pausedRows)
+  }
+
+  /** Stands in for an archive read that has not come back from object storage yet. */
+  function stallArchiveRead() {
+    mockMaterializeForDisplayWithBlockOutputs.mockReturnValue(new Promise(() => {}))
+  }
+
+  /** Settles with {@link STALLED} instead of hanging when the read waits on the archive. */
+  function readOrStall(read: Parameters<typeof getWorkflowExecutionStatus>[0]) {
+    return Promise.race([getWorkflowExecutionStatus(read), flushMacrotask().then(() => STALLED)])
+  }
+
+  beforeEach(() => {
+    resetDbChainMock()
+    mockGetJob.mockResolvedValue(null)
+  })
+
+  it.each([
+    ['a running run', 'running', input],
+    ['a cancelled run', 'cancelled', input],
+    ['a completed run polled without includeOutput', 'completed', input],
+    ['a running run asked for its output early', 'running', { ...input, includeOutput: true }],
+  ])('answers %s without waiting on the run archive', async (_, status, read) => {
+    queueLog(status)
+    stallArchiveRead()
+
+    await expect(readOrStall(read)).resolves.toMatchObject({
+      status,
+      cost: { total: 0.5 },
+      error: null,
+      finalOutput: null,
+      blockOutputs: null,
+    })
+  })
+
+  it('answers a paused run without waiting on the run archive', async () => {
+    queueLog('running', [
+      {
+        id: 'paused-1',
+        status: 'paused',
+        pausePoints: [{ contextId: 'context-1', blockId: 'block-1', resumeStatus: 'paused' }],
+        metadata: {},
+        resumedCount: 0,
+        pausedAt: new Date('2026-08-05T12:00:00.500Z'),
+        nextResumeAt: null,
+      },
+    ])
+    stallArchiveRead()
+
+    await expect(readOrStall({ ...input, includeOutput: true })).resolves.toMatchObject({
+      status: 'paused',
+      paused: { contextId: 'context-1' },
+      finalOutput: null,
+    })
+  })
+
+  it('still reads selected block outputs from a run that is still running', async () => {
+    queueLog('running')
+    mockMaterializeForDisplayWithBlockOutputs.mockResolvedValue({
+      executionData: {},
+      blockOutputs: new Map([['block-1', { content: 'partial' }]]),
+    })
+
+    await expect(
+      getWorkflowExecutionStatus({ ...input, selectedOutputs: ['block-1'] })
+    ).resolves.toMatchObject({
+      status: 'running',
+      finalOutput: null,
+      blockOutputs: { 'block-1': { content: 'partial' } },
+    })
+  })
+
+  it('still rejects selected outputs of a running run whose execution data was truncated', async () => {
+    queueLog('running')
+    mockMaterializeForDisplayWithBlockOutputs.mockRejectedValue(
+      new FunctionalOutputsUnavailableError()
+    )
+
+    await expect(
+      getWorkflowExecutionStatus({ ...input, selectedOutputs: ['block-1'] })
+    ).rejects.toBeInstanceOf(FunctionalOutputsUnavailableError)
+  })
+})

apps/sim/lib/workflows/executor/execution-status.ts

@@ -430,6 +430,27 @@ async function readWorkflowExecutionStatus(
 
   const cost = logRow.costTotal != null ? { total: Number(logRow.costTotal) } : null
 
+  const resource = {
+    executionId: logRow.executionId,
+    // Column is `set null` on workflow delete; the caller's param is the fallback.
+    workflowId: logRow.workflowId ?? workflowId,
+    status,
+    trigger: logRow.trigger,
+    level: logRow.level,
+    startedAt: logRow.startedAt.toISOString(),
+    endedAt: logRow.endedAt?.toISOString() ?? null,
+    totalDurationMs: logRow.totalDurationMs ?? null,
+    paused,
+    cost,
+  }
+
+  // Mirrors the three output conditions below; a poll needing none skips the archive read.
+  const readsExecutionData =
+    status === 'failed' || (includeOutput && status === 'completed') || selectedOutputs.length > 0
+  if (!readsExecutionData) {
+    return { ...resource, error: null, finalOutput: null, blockOutputs: null }
+  }
+
   const requestedBlockIds = [
     ...new Set(selectedOutputs.map((selector) => selector.split('.')[0]).filter(Boolean)),
   ]
@@ -456,20 +477,5 @@ async function readWorkflowExecutionStatus(
       ? pickSelectedOutputs(selectedOutputs, materialized.blockOutputs)
       : null
 
-  return {
-    executionId: logRow.executionId,
-    // Column is `set null` on workflow delete; the caller's param is the fallback.
-    workflowId: logRow.workflowId ?? workflowId,
-    status,
-    trigger: logRow.trigger,
-    level: logRow.level,
-    startedAt: logRow.startedAt.toISOString(),
-    endedAt: logRow.endedAt?.toISOString() ?? null,
-    totalDurationMs: logRow.totalDurationMs ?? null,
-    paused,
-    cost,
-    error,
-    finalOutput,
-    blockOutputs,
-  }
+  return { ...resource, error, finalOutput, blockOutputs }
 }