fix(logs): persist execution diagnostics markers

Store last-started and last-completed block markers with finalization metadata so later read surfaces can explain how a run ended without reconstructing executor state.

Author: test

apps/sim/lib/logs/execution/diagnostics.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest'
+import { buildExecutionDiagnostics } from '@/lib/logs/execution/diagnostics'
+
+describe('buildExecutionDiagnostics', () => {
+  it('derives trace span counts and preserves finalization details', () => {
+    const diagnostics = buildExecutionDiagnostics({
+      status: 'failed',
+      level: 'error',
+      startedAt: '2025-01-01T00:00:00.000Z',
+      endedAt: '2025-01-01T00:00:05.000Z',
+      executionData: {
+        traceSpans: [
+          {
+            id: 'span-1',
+            children: [{ id: 'span-1-child' }],
+          },
+          { id: 'span-2' },
+        ],
+        lastStartedBlock: { blockId: 'block-1' },
+        lastCompletedBlock: { blockId: 'block-2' },
+        finalizationPath: 'force_failed',
+        completionFailure: 'fallback store failed',
+        executionState: { blockStates: {} },
+      },
+    })
+
+    expect(diagnostics.traceSpanCount).toBe(3)
+    expect(diagnostics.hasTraceSpans).toBe(true)
+    expect(diagnostics.lastStartedBlock).toEqual({ blockId: 'block-1' })
+    expect(diagnostics.lastCompletedBlock).toEqual({ blockId: 'block-2' })
+    expect(diagnostics.finalizationPath).toBe('force_failed')
+    expect(diagnostics.completionFailure).toBe('fallback store failed')
+    expect(diagnostics.errorMessage).toBe('fallback store failed')
+    expect(diagnostics.hasExecutionState).toBe(true)
+  })
+
+  it('uses explicit trace flags and falls back to final output errors', () => {
+    const diagnostics = buildExecutionDiagnostics({
+      status: 'completed',
+      startedAt: '2025-01-01T00:00:00.000Z',
+      executionData: {
+        hasTraceSpans: false,
+        traceSpanCount: 7,
+        finalOutput: { error: 'stored error' },
+        finalizationPath: 'not-valid',
+      },
+    })
+
+    expect(diagnostics.hasTraceSpans).toBe(false)
+    expect(diagnostics.traceSpanCount).toBe(7)
+    expect(diagnostics.errorMessage).toBe('stored error')
+    expect(diagnostics.finalizationPath).toBeUndefined()
+    expect(diagnostics.hasExecutionState).toBe(false)
+  })
+})

apps/sim/lib/logs/execution/diagnostics.ts

@@ -0,0 +1,90 @@
+import type { ExecutionFinalizationPath } from '@/lib/logs/types'
+import { isExecutionFinalizationPath } from '@/lib/logs/types'
+
+type ExecutionData = {
+  error?: string
+  traceSpans?: unknown[]
+  executionState?: unknown
+  finalOutput?: { error?: unknown }
+  lastStartedBlock?: unknown
+  lastCompletedBlock?: unknown
+  hasTraceSpans?: boolean
+  traceSpanCount?: number
+  completionFailure?: string
+  finalizationPath?: unknown
+}
+
+function countTraceSpans(traceSpans: unknown[] | undefined): number {
+  if (!Array.isArray(traceSpans) || traceSpans.length === 0) {
+    return 0
+  }
+
+  return traceSpans.reduce<number>((count, span) => {
+    const children =
+      span && typeof span === 'object' && 'children' in span && Array.isArray(span.children)
+        ? (span.children as unknown[])
+        : undefined
+
+    return count + 1 + countTraceSpans(children)
+  }, 0)
+}
+
+export function buildExecutionDiagnostics(params: {
+  status: string
+  level?: string | null
+  startedAt: string
+  endedAt?: string | null
+  executionData?: ExecutionData | null
+}): {
+  status: string
+  level?: string
+  startedAt: string
+  endedAt?: string
+  lastStartedBlock?: unknown
+  lastCompletedBlock?: unknown
+  hasTraceSpans: boolean
+  traceSpanCount: number
+  hasExecutionState: boolean
+  finalizationPath?: ExecutionFinalizationPath
+  completionFailure?: string
+  errorMessage?: string
+} {
+  const executionData = params.executionData ?? {}
+  const derivedTraceSpanCount = countTraceSpans(executionData.traceSpans)
+  const traceSpanCount =
+    typeof executionData.traceSpanCount === 'number'
+      ? executionData.traceSpanCount
+      : derivedTraceSpanCount
+  const hasTraceSpans =
+    typeof executionData.hasTraceSpans === 'boolean'
+      ? executionData.hasTraceSpans
+      : traceSpanCount > 0
+  const completionFailure =
+    typeof executionData.completionFailure === 'string'
+      ? executionData.completionFailure
+      : undefined
+  const errorMessage =
+    completionFailure ||
+    (typeof executionData.error === 'string' ? executionData.error : undefined) ||
+    (typeof executionData.finalOutput?.error === 'string'
+      ? executionData.finalOutput.error
+      : undefined)
+  const finalizationPath = isExecutionFinalizationPath(executionData.finalizationPath)
+    ? executionData.finalizationPath
+    : undefined
+
+  return {
+    status: params.status,
+    level: params.level ?? undefined,
+    startedAt: params.startedAt,
+    endedAt: params.endedAt ?? undefined,
+    lastStartedBlock: executionData.lastStartedBlock,
+    lastCompletedBlock: executionData.lastCompletedBlock,
+    hasTraceSpans,
+    traceSpanCount,
+    hasExecutionState: executionData.executionState !== undefined,
+    ...(finalizationPath ? { finalizationPath } : {}),
+    ...(completionFailure ? { completionFailure } : {}),
+    ...(errorMessage ? { errorMessage } : {}),
+  }
+}

apps/sim/lib/logs/execution/logger.test.ts

@@ -1,6 +1,6 @@
 import { databaseMock, loggerMock } from '@sim/testing'
 import { beforeEach, describe, expect, test, vi } from 'vitest'
-import { ExecutionLogger } from '@/lib/logs/execution/logger'
+import { ExecutionLogger } from './logger'
 
 vi.mock('@sim/db', () => databaseMock)
 
@@ -111,6 +111,43 @@ describe('ExecutionLogger', () => {
     test('should have getWorkflowExecution method', () => {
       expect(typeof logger.getWorkflowExecution).toBe('function')
     })
+
+    test('preserves progress markers and finalization summaries when execution completes', () => {
+      const loggerInstance = new ExecutionLogger() as any
+
+      const completedData = loggerInstance.buildCompletedExecutionData({
+        existingExecutionData: {
+          lastStartedBlock: {
+            blockId: 'block-start',
+            blockName: 'Start',
+            blockType: 'agent',
+            startedAt: '2025-01-01T00:00:00.000Z',
+          },
+          lastCompletedBlock: {
+            blockId: 'block-end',
+            blockName: 'Finish',
+            blockType: 'api',
+            endedAt: '2025-01-01T00:00:05.000Z',
+            success: true,
+          },
+        },
+        traceSpans: [],
+        finalOutput: { ok: true },
+        finalizationPath: 'completed',
+        completionFailure: 'fallback failure',
+        executionCost: {
+          tokens: { input: 0, output: 0, total: 0 },
+          models: {},
+        },
+      })
+
+      expect(completedData.lastStartedBlock?.blockId).toBe('block-start')
+      expect(completedData.lastCompletedBlock?.blockId).toBe('block-end')
+      expect(completedData.finalizationPath).toBe('completed')
+      expect(completedData.completionFailure).toBe('fallback failure')
+      expect(completedData.hasTraceSpans).toBe(false)
+      expect(completedData.traceSpanCount).toBe(0)
+    })
   })
 
   describe('file extraction', () => {

apps/sim/lib/logs/execution/logger.ts

@@ -26,6 +26,7 @@ import { snapshotService } from '@/lib/logs/execution/snapshot/service'
 import type {
   BlockOutputData,
   ExecutionEnvironment,
+  ExecutionFinalizationPath,
   ExecutionTrigger,
   ExecutionLoggerService as IExecutionLoggerService,
   TraceSpan,
@@ -48,7 +49,70 @@ export interface ToolCall {
 
 const logger = createLogger('ExecutionLogger')
 
+function countTraceSpans(traceSpans?: TraceSpan[]): number {
+  if (!Array.isArray(traceSpans) || traceSpans.length === 0) {
+    return 0
+  }
+
+  return traceSpans.reduce((count, span) => count + 1 + countTraceSpans(span.children), 0)
+}
+
 export class ExecutionLogger implements IExecutionLoggerService {
+  private buildCompletedExecutionData(params: {
+    existingExecutionData?: WorkflowExecutionLog['executionData']
+    traceSpans?: TraceSpan[]
+    finalOutput: BlockOutputData
+    finalizationPath?: ExecutionFinalizationPath
+    completionFailure?: string
+    executionCost: {
+      tokens: {
+        input: number
+        output: number
+        total: number
+      }
+      models: NonNullable<WorkflowExecutionLog['executionData']['models']>
+    }
+    executionState?: SerializableExecutionState
+  }): WorkflowExecutionLog['executionData'] {
+    const {
+      existingExecutionData,
+      traceSpans,
+      finalOutput,
+      finalizationPath,
+      completionFailure,
+      executionCost,
+      executionState,
+    } = params
+    const traceSpanCount = countTraceSpans(traceSpans)
+
+    return {
+      ...(existingExecutionData?.environment
+        ? { environment: existingExecutionData.environment }
+        : {}),
+      ...(existingExecutionData?.trigger ? { trigger: existingExecutionData.trigger } : {}),
+      ...(existingExecutionData?.error ? { error: existingExecutionData.error } : {}),
+      ...(existingExecutionData?.lastStartedBlock
+        ? { lastStartedBlock: existingExecutionData.lastStartedBlock }
+        : {}),
+      ...(existingExecutionData?.lastCompletedBlock
+        ? { lastCompletedBlock: existingExecutionData.lastCompletedBlock }
+        : {}),
+      ...(completionFailure ? { completionFailure } : {}),
+      ...(finalizationPath ? { finalizationPath } : {}),
+      hasTraceSpans: traceSpanCount > 0,
+      traceSpanCount,
+      traceSpans,
+      finalOutput,
+      tokens: {
+        input: executionCost.tokens.input,
+        output: executionCost.tokens.output,
+        total: executionCost.tokens.total,
+      },
+      models: executionCost.models,
+      ...(executionState ? { executionState } : {}),
+    }
+  }
+
   async startWorkflowExecution(params: {
     workflowId: string
     workspaceId: string
@@ -131,6 +195,8 @@ export class ExecutionLogger implements IExecutionLoggerService {
         executionData: {
           environment,
           trigger,
+          hasTraceSpans: false,
+          traceSpanCount: 0,
         },
         cost: {
           total: BASE_EXECUTION_CHARGE,
@@ -189,6 +255,8 @@ export class ExecutionLogger implements IExecutionLoggerService {
     traceSpans?: TraceSpan[]
     workflowInput?: any
     executionState?: SerializableExecutionState
+    finalizationPath?: ExecutionFinalizationPath
+    completionFailure?: string
     isResume?: boolean
     level?: 'info' | 'error'
     status?: 'completed' | 'failed' | 'cancelled' | 'pending'
@@ -202,6 +270,8 @@ export class ExecutionLogger implements IExecutionLoggerService {
       traceSpans,
       workflowInput,
       executionState,
+      finalizationPath,
+      completionFailure,
       isResume,
       level: levelOverride,
       status: statusOverride,
@@ -216,7 +286,7 @@ export class ExecutionLogger implements IExecutionLoggerService {
       .limit(1)
     const billingUserId = this.extractBillingUserId(existingLog?.executionData)
     const existingExecutionData = existingLog?.executionData as
-      | { traceSpans?: TraceSpan[] }
+      | WorkflowExecutionLog['executionData']
       | undefined
 
     // Determine if workflow failed by checking trace spans for unhandled errors
@@ -272,6 +342,16 @@ export class ExecutionLogger implements IExecutionLoggerService {
         ? Math.max(0, Math.round(rawDurationMs))
         : 0
 
+    const completedExecutionData = this.buildCompletedExecutionData({
+      existingExecutionData,
+      traceSpans: redactedTraceSpans,
+      finalOutput: redactedFinalOutput,
+      finalizationPath,
+      completionFailure,
+      executionCost,
+      executionState,
+    })
+
     const [updatedLog] = await db
       .update(workflowExecutionLogs)
       .set({
@@ -280,17 +360,7 @@ export class ExecutionLogger implements IExecutionLoggerService {
         endedAt: new Date(endedAt),
         totalDurationMs: totalDuration,
         files: executionFiles.length > 0 ? executionFiles : null,
-        executionData: {
-          traceSpans: redactedTraceSpans,
-          finalOutput: redactedFinalOutput,
-          tokens: {
-            input: executionCost.tokens.input,
-            output: executionCost.tokens.output,
-            total: executionCost.tokens.total,
-          },
-          models: executionCost.models,
-          ...(executionState ? { executionState } : {}),
-        },
+        executionData: completedExecutionData,
         cost: executionCost,
       })
       .where(eq(workflowExecutionLogs.executionId, executionId))