@@ -13,6 +13,7 @@ import {
   permissionGroupMember,
   permissionGroupWorkspace,
   permissions,
+  resumeQueue,
   user,
   workflow,
   workflowDeploymentVersion,
@@ -29,6 +30,7 @@ import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
 import { encryptSecret } from '@/lib/core/security/encryption'
 import { executeWorkflowOperation } from '@/lib/workflows/application/execute-workflow'
 import { readWorkflowRun } from '@/lib/workflows/application/read-workflow-run'
+import { PauseResumeManager } from '@/lib/workflows/executor/human-in-the-loop-manager'
 import type { PausePoint } from '@/executor/types'
 
 const organizationId = generateId()
@@ -285,4 +287,30 @@ describe('a deployed run paused at a human-in-the-loop block', () => {
     const run = await readRun(restricted, runId, { includeOutput: true })
     expect(run.pausePoints).toEqual([expect.objectContaining({ display: null, inputFields: null })])
   })
+
+  it('lists the paused parent run points when read by a settled resume attempt id', async () => {
+    const runId = await pausedRun()
+    const attempt = await PauseResumeManager.enqueueOrStartResume({
+      executionId: runId,
+      workflowId,
+      contextId: 'approval',
+      resumeInput: {},
+      userId: ownerId,
+    })
+    /** The attempt settled without finishing the run, which still waits at its pause. */
+    await db
+      .update(resumeQueue)
+      .set({ status: 'completed', completedAt: new Date() })
+      .where(eq(resumeQueue.newExecutionId, attempt.resumeExecutionId))
+
+    const run = await readRun(owner, attempt.resumeExecutionId, { includeOutput: true })
+    expect(run).toMatchObject({ status: 'paused' })
+    expect(run.pausePoints).toEqual([
+      expect.objectContaining({
+        contextId: 'approval',
+        display: REDACTED_DISPLAY,
+        inputFields: INPUT_FIELDS,
+      }),
+    ])
+  })
 })
@@ -85,7 +85,7 @@ export const readWorkflowRun = defineAuthorizedWorkflowUseCase({
         viewerUserId: logProjectionSubjectUserId(principal),
       })
       if (!projected) throw new OrchestrationError('not_found', 'Run not found')
-      const { status, projection } = projected
+      const { status, projection, stateExecutionId } = projected
 
       /**
        * A run whose `blockOutputs` the viewer's group withholds joins the same
@@ -153,7 +153,9 @@ export const readWorkflowRun = defineAuthorizedWorkflowUseCase({
 
       /**
        * Every pause point of a paused run, so a caller can resume any of them by
-       * `contextId`, not only the earliest one `paused` summarizes.
+       * `contextId`, not only the earliest one `paused` summarizes. Read from the
+       * execution whose state answered the status, so a resume attempt reporting its
+       * parent's pause lists the parent's points.
        *
        * A point's `display` is what the block rendered from upstream outputs, so it
        * follows `finalOutput`'s gating: withheld unless output was asked for and the
@@ -168,7 +170,7 @@ export const readWorkflowRun = defineAuthorizedWorkflowUseCase({
         ? (
             (await readPausedRunPoints({
               workflowId: context.workflowId,
-              executionId: context.runId,
+              executionId: stateExecutionId,
             })) ?? []
           ).map((point) => ({
             ...point,
 
@@ -251,6 +251,11 @@ function projectExecutionStatus(
 export interface ProjectedWorkflowExecutionStatus {
   status: WorkflowExecutionStatusResponse
   projection: LogFieldProjection
+  /**
+   * The execution whose recorded state answered: the run itself, or the parent run a settled
+   * resume attempt continued. Further reads of the run's state (its pause points) use this id.
+   */
+  stateExecutionId: string
 }
 
 /**
@@ -270,14 +275,18 @@ export interface ProjectedWorkflowExecutionStatus {
 export async function getProjectedWorkflowExecutionStatus(
   input: GetWorkflowExecutionStatusInput
 ): Promise<ProjectedWorkflowExecutionStatus | null> {
-  const status = await readWorkflowExecutionStatus(input)
-  if (!status) return null
+  const resolved = await readWorkflowExecutionStatus(input)
+  if (!resolved) return null
   const projection = await resolveLogFieldProjection(
     input.viewerUserId,
     input.workspaceId,
     input.workspaceOrganizationId
   )
-  return { status: projectExecutionStatus(status, projection), projection }
+  return {
+    status: projectExecutionStatus(resolved.status, projection),
+    projection,
+    stateExecutionId: resolved.stateExecutionId,
+  }
 }
 
 /**
@@ -330,9 +339,18 @@ async function readRunDeploymentVersion(
   return row?.version ?? null
 }
 
+/**
+ * A status resource and the execution whose recorded state answered it: the run itself, or
+ * for a settled resume attempt with no log row of its own, the parent run it continued.
+ */
+interface ResolvedExecutionStatus {
+  status: WorkflowExecutionStatusResponse
+  stateExecutionId: string
+}
+
 async function readWorkflowExecutionStatus(
   input: GetWorkflowExecutionStatusInput
-): Promise<WorkflowExecutionStatusResponse | null> {
+): Promise<ResolvedExecutionStatus | null> {
   const { workflowId, executionId, includeOutput, selectedOutputs } = input
 
   const [logRow] = await db
@@ -412,13 +430,16 @@ async function readWorkflowExecutionStatus(
     for (const jobId of queueJobIds) {
       const job = await jobQueue.getJob(jobId)
       if (!job || job.metadata.workflowId !== workflowId) continue
-      return projectQueueJob(job, { executionId, includeOutput, workflowId }, deploymentVersion)
+      return {
+        status: projectQueueJob(job, { executionId, includeOutput, workflowId }, deploymentVersion),
+        stateExecutionId: executionId,
+      }
     }
   }
 
   if (projectedResume) {
     const startedAt = projectedResume.claimedAt ?? projectedResume.queuedAt
-    return {
+    const status: WorkflowExecutionStatusResponse = {
       executionId,
       workflowId,
       status: 'queued',
@@ -434,6 +455,7 @@ async function readWorkflowExecutionStatus(
       finalOutput: null,
       blockOutputs: null,
     }
+    return { status, stateExecutionId: executionId }
   }
 
   if (!logRow) {
@@ -442,7 +464,12 @@ async function readWorkflowExecutionStatus(
       ...input,
       executionId: resumeAttempt.parentExecutionId,
     })
-    return run ? projectSettledResumeAttempt(executionId, resumeAttempt, run) : null
+    return run
+      ? {
+          status: projectSettledResumeAttempt(executionId, resumeAttempt, run.status),
+          stateExecutionId: run.stateExecutionId,
+        }
+      : null
   }
 
   const [pausedRow] = await db
@@ -509,7 +536,10 @@ async function readWorkflowExecutionStatus(
   const readsExecutionData =
     selectedOutputs.length > 0 || statusesReadingExecutionData(includeOutput).includes(status)
   if (!readsExecutionData) {
-    return { ...resource, error: null, finalOutput: null, blockOutputs: null }
+    return {
+      status: { ...resource, error: null, finalOutput: null, blockOutputs: null },
+      stateExecutionId: executionId,
+    }
   }
 
   const requestedBlockIds = [
@@ -538,7 +568,10 @@ async function readWorkflowExecutionStatus(
       ? pickSelectedOutputs(selectedOutputs, materialized.blockOutputs)
       : null
 
-  return { ...resource, error, finalOutput, blockOutputs }
+  return {
+    status: { ...resource, error, finalOutput, blockOutputs },
+    stateExecutionId: executionId,
+  }
 }
 
 /** Most pause points a run detail lists; a run over it lists its earliest registered points. */