@@ -38,10 +38,14 @@ vi.mock('@/lib/workspaces/utils', () => workspacesUtilsMock)
 
 vi.mock('@/lib/workflows/executor/human-in-the-loop-manager', () => humanInTheLoopManagerMock)
 
+import { executeResumeWorkflow } from '@/lib/workflows/executor/resume-execution'
 import { POST } from '@/app/api/resume/[workflowId]/[executionId]/[contextId]/route'
 import { handleResumeExecution } from '@/app/api/resume/resume-handler'
+import { attachExecutionResult, buildBlockExecutionError } from '@/executor/utils/errors'
+import type { SerializedBlock } from '@/serializer/types'
 
-const { mockEnqueueOrStartResume, mockGetPausedExecutionDetail } = humanInTheLoopManagerMockFns
+const { mockEnqueueOrStartResume, mockGetPausedExecutionDetail, mockStartResumeExecution } =
+  humanInTheLoopManagerMockFns
 const { mockGetWorkspaceBilledAccountUserId: mockGetCurrentPayer } = workspacesUtilsMockFns
 
 const { mockShouldExecuteInline } = asyncJobsMockFns
@@ -362,6 +366,102 @@ describe('POST /api/resume/[workflowId]/[executionId]/[contextId]', () => {
     )
   })
 
+  describe('a synchronous resume whose run fails', () => {
+    const STARTED_RESUME = {
+      status: 'started',
+      resumeExecutionId: 'resume-execution-1',
+      resumeEntryId: 'resume-entry-1',
+      pausedExecution: { id: 'paused-execution-1' },
+      contextId: CONTEXT_ID,
+      resumeInput: { approved: true },
+      userId: 'current-api-key-user',
+    }
+
+    /** The shape the engine throws when a block fails mid-run: block context plus the partial result. */
+    function inBandRunFailure() {
+      const conditionBlock = {
+        id: 'condition-1',
+        metadata: { id: 'condition', name: 'Route' },
+      } as SerializedBlock
+      const error = buildBlockExecutionError({
+        block: conditionBlock,
+        error: new Error('Condition evaluation failed'),
+      })
+      attachExecutionResult(error, {
+        success: false,
+        output: { partial: true },
+        error: error.message,
+        logs: [],
+        metadata: {
+          startTime: '2026-08-05T00:00:00.000Z',
+          endTime: '2026-08-05T00:00:01.000Z',
+          duration: 1000,
+        },
+      })
+      return error
+    }
+
+    function resumeOnV2Surface() {
+      return executeResumeWorkflow({
+        workflowId: WORKFLOW_ID,
+        executionId: EXECUTION_ID,
+        contextId: CONTEXT_ID,
+        workspaceId: WORKSPACE_ID,
+        userId: 'current-api-key-user',
+        resumeInput: { approved: true },
+        isApiCaller: true,
+        pollingSurface: 'v2',
+        allowStreaming: false,
+      })
+    }
+
+    beforeEach(() => {
+      mockEnqueueOrStartResume.mockResolvedValueOnce(STARTED_RESUME)
+    })
+
+    it('settles an in-band failure as a failed run with a classified error', async () => {
+      mockStartResumeExecution.mockRejectedValueOnce(inBandRunFailure())
+
+      await expect(resumeOnV2Surface()).resolves.toEqual({
+        kind: 'sync',
+        executionId: 'resume-execution-1',
+        success: false,
+        status: 'failed',
+        output: { partial: true },
+        error: 'Route: Condition evaluation failed',
+        structuredError: {
+          message: 'Condition evaluation failed',
+          code: 'BLOCK_EXECUTION_FAILED',
+          blockId: 'condition-1',
+          blockName: 'Route',
+          blockType: 'condition',
+        },
+        metadata: {
+          startTime: '2026-08-05T00:00:00.000Z',
+          endTime: '2026-08-05T00:00:01.000Z',
+          duration: 1000,
+        },
+      })
+    })
+
+    it('still throws a failure that produced no run', async () => {
+      const infrastructureFailure = new Error('Run buffer unavailable')
+      mockStartResumeExecution.mockRejectedValueOnce(infrastructureFailure)
+
+      await expect(resumeOnV2Surface()).rejects.toBe(infrastructureFailure)
+    })
+
+    it('keeps the legacy route answering an in-band failure with its 400 error body', async () => {
+      mockStartResumeExecution.mockRejectedValueOnce(inBandRunFailure())
+      const { request, context } = makeRequest()
+
+      const response = await POST(request, context)
+
+      expect(response.status).toBe(400)
+      expect(await response.json()).toEqual({ error: 'Route: Condition evaluation failed' })
+    })
+  })
+
   it.each([
     { statusCode: 402, message: 'Member usage limit reached', retryable: false },
     { statusCode: 429, message: 'Target concurrency full', retryable: true },
 
@@ -50,6 +50,13 @@ function presentResumeResult(
         },
       })
     case 'sync':
+      /** This surface has always answered a failed run with a 400 error body, never a run payload. */
+      if (result.status === 'failed') {
+        return NextResponse.json(
+          { error: typeof result.error === 'string' ? result.error : 'Resume execution failed' },
+          { status: 400 }
+        )
+      }
       return NextResponse.json({
         success: result.success,
         status: result.status,
 
@@ -144,6 +144,7 @@ describe('POST /api/v2/workflows/[workflowId]/runs/[runId]/resume', () => {
       executionId: 'resume-execution-3',
       output: { approved: true },
       error: undefined,
+      structuredError: null,
       metadata: {
         startTime: '2026-08-05T00:00:00.000Z',
         endTime: '2026-08-05T00:00:01.000Z',
@@ -172,6 +173,55 @@ describe('POST /api/v2/workflows/[workflowId]/runs/[runId]/resume', () => {
     expect(v2ResumeWorkflowContract.response.schema.parse(body)).toEqual(body)
   })
 
+  it('answers a resume whose run failed in-band with the failed run resource', async () => {
+    mocks.resume.mockResolvedValueOnce({
+      kind: 'sync',
+      success: false,
+      status: 'failed',
+      executionId: 'resume-execution-4',
+      output: { partial: true },
+      error: 'Route: Condition evaluation failed',
+      structuredError: {
+        message: 'Condition evaluation failed',
+        code: 'BLOCK_EXECUTION_FAILED',
+        blockId: 'condition-1',
+        blockName: 'Route',
+        blockType: 'condition',
+      },
+      metadata: {
+        startTime: '2026-08-05T00:00:00.000Z',
+        endTime: '2026-08-05T00:00:01.000Z',
+        duration: 1000,
+      },
+    })
+    const { request, context } = makeRequest(JSON.stringify({ contextId: 'context-4' }))
+
+    const response = await POST(request, context)
+    const body = await response.json()
+
+    expect(response.status).toBe(200)
+    expect(body).toEqual({
+      data: {
+        runId: 'resume-execution-4',
+        workflowId: WORKFLOW_ID,
+        status: 'failed',
+        output: { partial: true },
+        blockOutputs: null,
+        error: {
+          message: 'Condition evaluation failed',
+          code: 'BLOCK_EXECUTION_FAILED',
+          blockId: 'condition-1',
+          blockName: 'Route',
+          blockType: 'condition',
+        },
+        startedAt: '2026-08-05T00:00:00.000Z',
+        endedAt: '2026-08-05T00:00:01.000Z',
+        durationMs: 1000,
+      },
+    })
+    expect(v2ResumeWorkflowContract.response.schema.parse(body)).toEqual(body)
+  })
+
   it('returns a safe error when the resume manager fails', async () => {
     mocks.resume.mockRejectedValueOnce(new Error('resume database connection details'))
     const { request, context } = makeRequest(JSON.stringify({ contextId: 'context-6' }))
 
@@ -23,7 +23,6 @@ import { workflowOperations } from '@/lib/workflows/application/operations'
 import { resumeWorkflowRun } from '@/lib/workflows/application/resume-run'
 import { ResumeWorkflowExecutionError } from '@/lib/workflows/executor/resume-execution'
 import { v2Data, v2Error } from '@/app/api/v2/lib/response'
-import { classifyExecutionError } from '@/executor/utils/errors'
 
 const logger = createLogger('V2WorkflowResumeAPI')
 
@@ -114,10 +113,7 @@ export const POST = withRouteHandler(
           output: result.output ?? null,
           // Resume has no request body to name selectors in, so selection never applies here.
           blockOutputs: null,
-          error:
-            typeof result.error === 'string'
-              ? classifyExecutionError(new Error(result.error))
-              : null,
+          error: result.structuredError,
           startedAt: result.metadata?.startTime,
           endedAt: result.metadata?.endTime,
           durationMs: result.metadata?.duration,
 
@@ -16,6 +16,12 @@ import { PauseResumeManager } from '@/lib/workflows/executor/human-in-the-loop-m
 import { createStreamingResponse } from '@/lib/workflows/streaming/streaming'
 import { executeResumeJob, type ResumeExecutionPayload } from '@/background/resume-execution'
 import { ExecutionSnapshot } from '@/executor/execution/snapshot'
+import type { ExecutionResult } from '@/executor/types'
+import {
+  classifyExecutionError,
+  hasExecutionResult,
+  type StructuredExecutionError,
+} from '@/executor/utils/errors'
 import { projectResolvedSecretDiagnosticError } from '@/executor/utils/resolved-secret-content-projection'
 
 const logger = createLogger('WorkflowResumeExecution')
@@ -71,6 +77,8 @@ export type ResumeWorkflowExecutionResult =
       status: string
       output: unknown
       error: unknown
+      /** The run's failure classified the way a sync execute classifies it; null when it did not fail. */
+      structuredError: StructuredExecutionError | null
       metadata?: {
         duration?: number
         startTime?: string
@@ -298,14 +306,37 @@ export async function executeResumeWorkflow({
     }
 
     if (isApiCaller && executionMode === 'sync') {
-      const result = await PauseResumeManager.startResumeExecution(resumeArgs)
+      let result: ExecutionResult
+      let runFailure: unknown
+      try {
+        result = await PauseResumeManager.startResumeExecution(resumeArgs)
+      } catch (error) {
+        /**
+         * A run that started and then failed carries its partial result: that is the run's
+         * answer, not a failed request. Anything else produced no run and stays an exception.
+         */
+        if (!hasExecutionResult(error)) throw error
+        result = error.executionResult
+        runFailure = error
+      }
+      const status =
+        runFailure !== undefined
+          ? 'failed'
+          : (result.status ?? (result.success ? 'completed' : 'failed'))
       return {
         kind: 'sync',
         executionId: enqueueResult.resumeExecutionId,
-        success: result.success,
-        status: result.status ?? (result.success ? 'completed' : 'failed'),
+        success: runFailure === undefined && result.success,
+        status,
         output: result.output,
         error: result.error,
+        structuredError:
+          status === 'failed' || (status === 'cancelled' && result.error)
+            ? classifyExecutionError(
+                runFailure ?? (result.error ? new Error(result.error) : undefined),
+                result
+              )
+            : null,
         metadata: result.metadata
           ? {
               duration: result.metadata.duration,