@shipfox/client-workflows 18.0.0 → 20.0.0

package/src/components/workflow-run-summary/workflow-run-summary.test.tsx

@@ -159,6 +159,17 @@ describe('WorkflowRunSummary', () => {
   test('shows a live selected attempt duration for running runs', async () => {
     vi.spyOn(Date, 'now').mockReturnValue(Date.parse('2026-05-07T01:02:14.000Z'));
     renderSummary({
+      jobs: [
+        workflowJobDto({
+          status: 'running',
+          job_executions: [
+            workflowJobExecutionDto({
+              status: 'running',
+              started_at: '2026-05-07T01:02:00.000Z',
+            }),
+          ],
+        }),
+      ],
       run_attempt: {
         id: '11111111-1111-4111-8111-000000000001',
         workflow_run_id: RUN_ID,
@@ -178,7 +189,9 @@ describe('WorkflowRunSummary', () => {
     expect(duration).toHaveAttribute('aria-label', 'running 2m 14s');
   });
 
-  test('reads a running run whose jobs have not started as queued', async () => {
+  // The header reports the attempt the API returned. Whether a job has reached a runner yet is
+  // the job surfaces' business, so an attempt whose jobs are all pending still reads as running.
+  test('reads a running attempt as running whatever its jobs have reached', async () => {
     vi.spyOn(Date, 'now').mockReturnValue(Date.parse('2026-05-07T01:02:14.000Z'));
     renderSummary({
       jobs: [workflowJobDto({status: 'pending'})],
@@ -187,50 +200,89 @@ describe('WorkflowRunSummary', () => {
 
     const summary = await screen.findByRole('region', {name: 'deploy-web'});
 
-    expect(within(summary).getAllByText('Queued')).not.toHaveLength(0);
-    expect(within(summary).queryByText('Running')).not.toBeInTheDocument();
-    expect(within(summary).getByText('2m 14s')).toHaveAttribute('aria-label', 'queued 2m 14s');
+    expect(within(summary).getAllByText('Running')).not.toHaveLength(0);
+    expect(within(summary).queryByText('Queued')).not.toBeInTheDocument();
+    expect(within(summary).getByText('2m 14s')).toHaveAttribute('aria-label', 'running 2m 14s');
   });
 
-  test('names the job a queued run is waiting on when there is more than one', async () => {
+  test('uses a neutral verb when an attempt finished before any job execution started', async () => {
     renderSummary({
+      status: 'cancelled',
       jobs: [
         workflowJobDto({
-          name: 'lint',
           status: 'pending',
           job_executions: [workflowJobExecutionDto({queued_at: '2026-05-07T01:00:00.000Z'})],
         }),
-        workflowJobDto({
-          name: 'build',
-          status: 'pending',
-          job_executions: [workflowJobExecutionDto({queued_at: '2026-05-07T00:59:00.000Z'})],
-        }),
       ],
-      run_attempt: runningAttemptDto(),
+      run_attempt: {
+        id: '11111111-1111-4111-8111-000000000001',
+        workflow_run_id: RUN_ID,
+        attempt: 1,
+        status: 'cancelled',
+        created_at: '2026-05-07T01:00:00.000Z',
+        started_at: '2026-05-07T01:00:00.000Z',
+        finished_at: '2026-05-07T01:02:14.000Z',
+        rerun_mode: null,
+      },
     });
 
     const summary = await screen.findByRole('region', {name: 'deploy-web'});
 
-    expect(within(summary).getByText('waiting on')).toBeInTheDocument();
-    expect(within(summary).getByText('build')).toBeInTheDocument();
+    expect(within(summary).getAllByText('Cancelled')).not.toHaveLength(0);
+    expect(within(summary).getByText('2m 14s')).toHaveAttribute('aria-label', 'lasted 2m 14s');
   });
 
-  test('leaves the waiting job unnamed when the run has a single job', async () => {
+  test('uses the run verb when a cancelled job execution started', async () => {
     renderSummary({
+      status: 'cancelled',
       jobs: [
         workflowJobDto({
-          name: 'build',
-          status: 'pending',
-          job_executions: [workflowJobExecutionDto({queued_at: '2026-05-07T01:00:00.000Z'})],
+          status: 'cancelled',
+          job_executions: [
+            workflowJobExecutionDto({
+              status: 'cancelled',
+              started_at: '2026-05-07T01:00:05.000Z',
+            }),
+          ],
         }),
       ],
-      run_attempt: runningAttemptDto(),
+      run_attempt: {
+        id: '11111111-1111-4111-8111-000000000001',
+        workflow_run_id: RUN_ID,
+        attempt: 1,
+        status: 'cancelled',
+        created_at: '2026-05-07T01:00:00.000Z',
+        started_at: '2026-05-07T01:00:00.000Z',
+        finished_at: '2026-05-07T01:02:14.000Z',
+        rerun_mode: null,
+      },
+    });
+
+    const summary = await screen.findByRole('region', {name: 'deploy-web'});
+
+    expect(within(summary).getByText('2m 14s')).toHaveAttribute('aria-label', 'ran 2m 14s');
+  });
+
+  test('uses a neutral verb when every job was skipped', async () => {
+    renderSummary({
+      status: 'succeeded',
+      jobs: [workflowJobDto({status: 'skipped'})],
+      run_attempt: {
+        id: '11111111-1111-4111-8111-000000000001',
+        workflow_run_id: RUN_ID,
+        attempt: 1,
+        status: 'succeeded',
+        created_at: '2026-05-07T01:00:00.000Z',
+        started_at: '2026-05-07T01:00:00.000Z',
+        finished_at: '2026-05-07T01:02:14.000Z',
+        rerun_mode: null,
+      },
     });
 
     const summary = await screen.findByRole('region', {name: 'deploy-web'});
 
-    expect(within(summary).getAllByText('Queued')).not.toHaveLength(0);
-    expect(within(summary).queryByText('waiting on')).not.toBeInTheDocument();
+    expect(within(summary).getAllByText('Succeeded')).not.toHaveLength(0);
+    expect(within(summary).getByText('2m 14s')).toHaveAttribute('aria-label', 'lasted 2m 14s');
   });
 
   test('does not render a whole-run source control', async () => {

package/src/components/workflow-run-summary/workflow-run-summary.tsx

@@ -12,7 +12,7 @@ import {useIsTextTruncated} from '@shipfox/react-ui/hooks';
 import {RelativeTime} from '@shipfox/react-ui/relative-time';
 import {TimeTickerProvider} from '@shipfox/react-ui/time-ticker';
 import {Tooltip, TooltipContent, TooltipTrigger} from '@shipfox/react-ui/tooltip';
-import {Code, Header, Text} from '@shipfox/react-ui/typography';
+import {Header, Text} from '@shipfox/react-ui/typography';
 import {useId} from 'react';
 import {WorkflowRunNumberLabel} from '#components/workflow-run-number-label.js';
 import {
@@ -21,17 +21,13 @@ import {
   WORKFLOW_RUN_STATUSES,
   type WorkflowRunDetail,
   type WorkflowRunRerunMode,
-  workflowRunBlockingJob,
-  workflowRunDetailDisplay,
 } from '#core/workflow-run.js';
 import {WorkflowRunDurationLabel} from '../workflow-run-duration-label.js';
 import {getWorkflowStatusVisual} from '../workflow-status/status-visuals.js';
 import {WorkflowRunAttemptSwitcher} from './workflow-run-attempt-switcher.js';
 
 const STATUS_BADGE_LABEL_WIDTH_CH = Math.max(
-  ...[...WORKFLOW_RUN_STATUSES, 'queued' as const].map(
-    (status) => getWorkflowStatusVisual(status).label.length,
-  ),
+  ...WORKFLOW_RUN_STATUSES.map((status) => getWorkflowStatusVisual(status).label.length),
 );
 const RERUN_BUTTON_SURFACE_CLASS_NAME =
   'bg-background-neutral-base hover:bg-background-neutral-hover active:bg-background-neutral-pressed';
@@ -60,19 +56,15 @@ export function WorkflowRunSummary({
   latestAttempt,
 }: WorkflowRunSummaryProps) {
   const headingId = useId();
-  const display = workflowRunDetailDisplay(run);
-  const status = getWorkflowStatusVisual(display.status);
+  const status = getWorkflowStatusVisual(run.runAttempt.status);
   const action = workflowRunActionForRun(run);
   const hasAction = canRenderWorkflowRunAction(action, onCancel, onRerun);
   const attemptSwitcher =
     latestAttempt && latestAttempt > 1 && workspaceSlug && projectSlug
       ? {workspaceSlug, projectSlug, latestAttempt}
       : null;
-  const displayDuration = display.duration;
-  // Named only while the run is waiting and has more than one job: with a single job the rail
-  // and the graph already say which one it is.
-  const blockingJob =
-    display.status === 'queued' && run.jobs.length > 1 ? workflowRunBlockingJob(run.jobs) : null;
+  const displayDuration = run.runAttempt.displayDuration;
+  const hasStarted = run.hasStartedJobExecution;
   const {ref: headingTextRef, isTruncated: isHeadingTruncated} =
     useIsTextTruncated<HTMLSpanElement>(run.name);
 
@@ -184,24 +176,11 @@ export function WorkflowRunSummary({
                 <MetadataSeparator />
                 <WorkflowRunDurationLabel
                   duration={displayDuration}
+                  hasStarted={hasStarted}
                   className="text-foreground-neutral-subtle"
                 />
               </>
             ) : null}
-
-            {blockingJob ? (
-              <>
-                <MetadataSeparator />
-                <span className="flex min-w-0 items-center gap-tight">
-                  <Text as="span" size="xs" className="shrink-0">
-                    waiting on
-                  </Text>
-                  <Code as="span" variant="label" className="min-w-0 truncate">
-                    {blockingJob.displayName}
-                  </Code>
-                </span>
-              </>
-            ) : null}
           </div>
         </div>
       </section>

package/src/components/workflow-status/status-visuals.ts

@@ -18,10 +18,6 @@ export function getWorkflowStatusVisual(status: WorkflowDisplayStatus): Workflow
   switch (status) {
     case 'pending':
       return {kind: 'pending', label: 'Pending', dot: 'neutral', badge: 'neutral'};
-    // Waiting on a runner is the awaiting-* state the warning tone was held for: the run is
-    // live but nothing is executing, which is the operator's problem to see, not ours to hide.
-    case 'queued':
-      return {kind: 'queued', label: 'Queued', dot: 'warning', badge: 'warning'};
     case 'running':
       return {kind: 'running', label: 'Running', dot: 'info', badge: 'info'};
     case 'listening':

package/src/components/workflow-status/workflow-status-icon.stories.tsx

@@ -6,7 +6,6 @@ import {WorkflowStatusIcon} from './workflow-status-icon.js';
 
 const statuses: WorkflowDisplayStatus[] = [
   'pending',
-  'queued',
   'running',
   'listening',
   'succeeded',

package/src/components/workflow-status/workflow-status-icon.tsx

@@ -89,24 +89,6 @@ export function WorkflowStatusIcon({
         <Icon name="pulseLine" size={Math.max(8, Math.round(size * 0.7))} className="text-white" />
       </span>
     );
-  } else if (visual.kind === 'queued') {
-    // An hourglass in the same filled disc the listening state uses, so waiting reads as its
-    // own shape rather than as a pending ring that happens to be a different colour.
-    glyph = (
-      <span
-        className={cn(
-          'inline-flex shrink-0 items-center justify-center rounded-full bg-current',
-          box,
-          toneByVariant.warning,
-        )}
-      >
-        <Icon
-          name="hourglassLine"
-          size={Math.max(8, Math.round(size * 0.7))}
-          className="text-white"
-        />
-      </span>
-    );
   } else if (visual.kind === 'running') {
     glyph = <Dot variant="info" ripple={ripple} className={box} />;
   } else if (visual.kind === 'pending') {

package/src/core/entities/job-status.test.ts

@@ -42,7 +42,7 @@ describe('deriveJobDisplayStatus', () => {
     const statuses: Array<[JobExecutionStatus, string[], JobDisplayStatus]> = [
       ['pending', [], 'pending'],
       ['pending', ['running'], 'running'],
-      ['running', [], 'pending'],
+      ['running', [], 'running'],
       ['running', ['running'], 'running'],
     ];
 
@@ -91,6 +91,52 @@ describe('deriveJobDisplayStatus', () => {
     ).toBe('listening');
   });
 
+  test.each([
+    ['pending', 'pending'],
+    ['failed', 'failed'],
+    [null, 'pending'],
+  ] as const)('uses list execution evidence for %s', (executionStatus, expected) => {
+    expect(
+      deriveJobDisplayStatus({
+        mode: 'one_shot',
+        status: 'pending',
+        listenerStatus: 'inactive',
+        executionStatus,
+        jobExecutions: [],
+      }),
+    ).toBe(expected);
+  });
+
+  test('does not infer execution from a running verdict without execution evidence', () => {
+    expect(
+      deriveJobDisplayStatus({
+        mode: 'one_shot',
+        status: 'running',
+        listenerStatus: 'inactive',
+        executionStatus: null,
+        jobExecutions: [],
+      }),
+    ).toBe('pending');
+  });
+
+  test('uses the same running execution evidence with and without a step tree', () => {
+    const detailStatus = deriveJobDisplayStatus({
+      mode: 'one_shot',
+      status: 'pending',
+      listenerStatus: 'inactive',
+      jobExecutions: [{status: 'running', steps: [], sequence: 1}] as never,
+    });
+    const listStatus = deriveJobDisplayStatus({
+      mode: 'one_shot',
+      status: 'pending',
+      listenerStatus: 'inactive',
+      executionStatus: 'running',
+      jobExecutions: [],
+    });
+
+    expect(listStatus).toBe(detailStatus);
+  });
+
   test('uses the terminal job status when an active listener has resolved', () => {
     expect(
       deriveJobDisplayStatus({

package/src/core/entities/job.ts

@@ -2,6 +2,7 @@ import {
   deriveJobExecutionDisplayStatus,
   type JobExecution,
   type JobExecutionDisplayDuration,
+  type JobExecutionStatus,
 } from './job-execution.js';
 import type {EvaluationTraceEntry} from './step-attempt.js';
 
@@ -140,12 +141,23 @@ export function isTerminalJobStatus(status: JobStatus): boolean {
 }
 
 export function deriveJobDisplayStatus(
-  job: Pick<Job, 'mode' | 'status' | 'listenerStatus' | 'jobExecutions'>,
+  job: Pick<Job, 'mode' | 'status' | 'listenerStatus' | 'jobExecutions'> & {
+    /** List previews carry the selected execution state without its step tree. */
+    executionStatus?: JobExecutionStatus | null | undefined;
+  },
 ): JobDisplayStatus {
   if (isTerminalJobStatus(job.status)) return job.status;
   if (job.mode === 'listening' && job.listenerStatus === 'listening') return 'listening';
-
-  const execution = defaultJobExecution(job);
+  const execution =
+    job.executionStatus === undefined
+      ? defaultJobExecution(job)
+      : job.executionStatus === null
+        ? undefined
+        : {status: job.executionStatus, steps: []};
+  // A running execution is the shared display rule for both list previews and detail jobs.
+  // The list has no step tree, while the detail path can still use the execution's steps for
+  // other non-running states.
+  if (execution?.status === 'running') return 'running';
   return execution ? deriveJobExecutionDisplayStatus(execution) : 'pending';
 }
 

package/src/core/entities/workflow-run.ts

@@ -1,15 +1,22 @@
-import {type Job, type JobStatus, WORKFLOW_JOB_STATUSES} from './job.js';
-import {elapsedTimeFromTimestamps, type JobExecutionDisplayDuration} from './job-execution.js';
+import {
+  type Job,
+  type JobDisplayStatus,
+  type JobMode,
+  type JobStatus,
+  type ListenerStatus,
+  WORKFLOW_JOB_STATUSES,
+} from './job.js';
+import type {JobExecutionStatus} from './job-execution.js';
 import type {WorkflowRunAttempt, WorkflowRunAttemptSummary} from './workflow-run-attempt.js';
 
 export type WorkflowRunStatus = 'pending' | 'running' | 'succeeded' | 'failed' | 'cancelled';
 export type WorkflowRunRerunMode = 'all' | 'failed';
 export type WorkflowStatus = WorkflowRunStatus | (typeof WORKFLOW_JOB_STATUSES)[number];
 /**
- * `listening` and `queued` are display-only: the API never returns them, and both are derived
- * from the jobs a run already carries.
+ * `listening` is display-only: the API never returns it, and it is derived from the listener
+ * state a job already carries.
  */
-export type WorkflowDisplayStatus = WorkflowStatus | 'listening' | 'queued';
+export type WorkflowDisplayStatus = WorkflowStatus | 'listening';
 
 export const WORKFLOW_RUN_STATUSES = [
   'pending',
@@ -23,7 +30,6 @@ export const WORKFLOW_DISPLAY_STATUSES = [
   ...WORKFLOW_RUN_STATUSES,
   ...WORKFLOW_JOB_STATUSES,
   'listening',
-  'queued',
 ] as const satisfies readonly WorkflowDisplayStatus[];
 
 export const TERMINAL_WORKFLOW_RUN_STATUSES = [
@@ -60,11 +66,14 @@ export interface WorkflowRunJobSummary {
   key: string;
   name: string | null;
   status: JobStatus;
+  mode: JobMode;
+  listenerStatus: ListenerStatus;
+  executionStatus: JobExecutionStatus | null;
   position: number;
 }
 
 export interface WorkflowRunJobStatusCount {
-  status: JobStatus;
+  status: JobDisplayStatus;
   count: number;
 }
 
@@ -73,11 +82,14 @@ export interface WorkflowRunJobStatusCount {
  * of them.
  *
  * `preview` is capped by the API, so `preview.length` is not the job count and the strip
- * reads `total` and `statusCounts` for anything it says rather than anything it draws.
+ * reads `total` and `statusCounts` for anything it says rather than anything it draws. The API
+ * also reports whether any job execution has started because a terminal `cancelled` job can have
+ * started work even though its job status does not preserve that distinction.
  */
 export interface WorkflowRunJobs {
   preview: WorkflowRunJobSummary[];
   statusCounts: WorkflowRunJobStatusCount[];
+  hasStartedJobExecution: boolean;
   total: number;
 }
 
@@ -118,6 +130,7 @@ export interface WorkflowRunDetail extends WorkflowRun {
   latestAttempt: number;
   runAttempt: WorkflowRunAttempt;
   jobs: Job[];
+  hasStartedJobExecution: boolean;
 }
 
 export interface WorkflowRunListPage {
@@ -184,129 +197,3 @@ export function isWorkflowRunTerminal(status: WorkflowRunStatus): boolean {
 export function isWorkflowStatus(status: string): status is WorkflowStatus {
   return WORKFLOW_STATUSES.has(status as WorkflowStatus);
 }
-
-/**
- * A run's headline duration, split the way a job's already is. An attempt's `startedAt` marks
- * when the orchestrator picked the run up, not when work began, so a run whose jobs are all
- * still waiting for a runner reads as queue time rather than as run time.
- */
-export type WorkflowRunDisplayDuration = JobExecutionDisplayDuration;
-
-/** What every surface shows for a run, derived together so status and duration cannot disagree. */
-export interface WorkflowRunDisplay {
-  status: WorkflowDisplayStatus;
-  duration: WorkflowRunDisplayDuration | null;
-}
-
-/**
- * The evidence a surface can offer about a run's progress.
- *
- * `jobStatuses` is what every surface has: the list carries status counts, the detail carries
- * whole jobs. `firstStartedAt` is the detail's extra precision, and where it is absent the
- * attempt's own mark stands in.
- */
-export interface WorkflowRunProgress {
-  runStatus: WorkflowRunStatus;
-  startedAt: string | null;
-  finishedAt: string | null;
-  jobStatuses: JobStatus[];
-  firstStartedAt?: string | null | undefined;
-}
-
-/** When the run's earliest execution began, or null while none of them has. */
-export function workflowRunFirstStartedAt(jobs: Job[]): string | null {
-  let earliest: string | null = null;
-  let earliestMs = Number.POSITIVE_INFINITY;
-
-  for (const job of jobs) {
-    for (const {startedAt} of job.jobExecutions) {
-      if (startedAt === null) continue;
-      const startedMs = new Date(startedAt).getTime();
-      if (!Number.isFinite(startedMs) || startedMs >= earliestMs) continue;
-      earliest = startedAt;
-      earliestMs = startedMs;
-    }
-  }
-
-  return earliest;
-}
-
-/**
- * Whether any work has begun. A run with no jobs on hand is a run whose jobs were not fetched,
- * which is no evidence that nothing started, so it counts as started rather than claiming a
- * queue this surface cannot see.
- */
-function workflowRunHasStarted({jobStatuses, firstStartedAt}: WorkflowRunProgress): boolean {
-  if (firstStartedAt != null) return true;
-  if (jobStatuses.length === 0) return true;
-  return jobStatuses.some((status) => status !== 'pending' && status !== 'skipped');
-}
-
-/**
- * The single rule behind every run readout. An attempt's `startedAt` marks when the
- * orchestrator picked the run up, not when work began, so a run whose jobs are all still
- * waiting reads as `Queued` for queue time. Calling that "running for 2h" sends an operator to
- * debug a build that never began.
- */
-export function deriveWorkflowRunDisplay(progress: WorkflowRunProgress): WorkflowRunDisplay {
-  const {runStatus, startedAt, finishedAt, firstStartedAt} = progress;
-  const hasStarted = workflowRunHasStarted(progress);
-  const status = runStatus === 'running' && !hasStarted ? 'queued' : runStatus;
-
-  if (startedAt === null) return {status, duration: null};
-
-  // A run cancelled before anything started keeps its queue reading rather than reporting a
-  // run that never was.
-  const time = elapsedTimeFromTimestamps({from: firstStartedAt ?? startedAt, to: finishedAt});
-  if (time === null) return {status, duration: null};
-
-  return {status, duration: {kind: hasStarted ? 'run' : 'queue', ...time}};
-}
-
-/** The run detail's reading: whole jobs, so queue and run time split on the first execution. */
-export function workflowRunDetailDisplay(run: {
-  runAttempt: Pick<WorkflowRunAttemptSummary, 'status' | 'startedAt' | 'finishedAt'>;
-  jobs: Job[];
-}): WorkflowRunDisplay {
-  return deriveWorkflowRunDisplay({
-    runStatus: run.runAttempt.status,
-    startedAt: run.runAttempt.startedAt,
-    finishedAt: run.runAttempt.finishedAt,
-    jobStatuses: run.jobs.map((job) => job.status),
-    firstStartedAt: workflowRunFirstStartedAt(run.jobs),
-  });
-}
-
-/**
- * The run list's reading: status counts cover every job, not just the drawn preview, so a row
- * reaches the same verdict as the detail page without fetching a single timestamp more.
- */
-export function workflowRunListItemDisplay(run: WorkflowRunListItem): WorkflowRunDisplay {
-  return deriveWorkflowRunDisplay({
-    runStatus: run.status,
-    startedAt: run.runAttempt.startedAt,
-    finishedAt: run.runAttempt.finishedAt,
-    jobStatuses: run.jobs.statusCounts.filter(({count}) => count > 0).map(({status}) => status),
-  });
-}
-
-/**
- * The job the run is waiting on: the one queued longest without starting. Named only so a
- * queued run says what it waits for instead of showing a number with no subject.
- */
-export function workflowRunBlockingJob(jobs: Job[]): Job | null {
-  let blocking: Job | null = null;
-  let queuedMs = Number.POSITIVE_INFINITY;
-
-  for (const job of jobs) {
-    for (const {queuedAt, startedAt, finishedAt} of job.jobExecutions) {
-      if (queuedAt === null || startedAt !== null || finishedAt !== null) continue;
-      const candidateMs = new Date(queuedAt).getTime();
-      if (!Number.isFinite(candidateMs) || candidateMs >= queuedMs) continue;
-      blocking = job;
-      queuedMs = candidateMs;
-    }
-  }
-
-  return blocking;
-}

package/src/core/workflow-run.test.ts

@@ -12,6 +12,7 @@ import {
   workflowRunAttemptDto,
   workflowRunDetailDto,
   workflowRunDto,
+  workflowRunJobSummaryDto,
   workflowRunListResponseDto,
   workflowStepAttemptDto,
   workflowStepDto,
@@ -102,6 +103,7 @@ describe('workflow run model mapping', () => {
       latest_attempt: 4,
       started_at: '2026-05-07T01:01:10.000Z',
       finished_at: null,
+      has_started_job_execution: true,
     });
 
     const run = toWorkflowRunListItem(dto);
@@ -121,12 +123,25 @@ describe('workflow run model mapping', () => {
     expect(run).not.toHaveProperty('startedAt');
     expect(run).not.toHaveProperty('finishedAt');
     expect(run).not.toHaveProperty('displayDuration');
+    expect(run.jobs.hasStartedJobExecution).toBe(true);
     expect(run.runAttempt.displayDuration).toEqual({
       state: 'live',
       fromIso: '2026-05-07T01:01:10.000Z',
     });
   });
 
+  test('keeps legacy raw-status counts aligned with preview glyphs', () => {
+    const {job_display_status_counts: _displayCounts, ...legacyDto} = workflowRunDto({
+      jobs: [workflowRunJobSummaryDto({status: 'running', execution_status: null})],
+      job_status_counts: [{status: 'running', count: 1}],
+    });
+
+    const run = toWorkflowRunListItem(legacyDto);
+
+    expect(run.jobs.preview[0]?.executionStatus).toBe('running');
+    expect(run.jobs.statusCounts).toEqual([{status: 'running', count: 1}]);
+  });
+
   test('maps run list pagination fields', () => {
     const dto = workflowRunListResponseDto({
       runs: [

package/src/core/workflow-run.ts

@@ -59,14 +59,11 @@ export type {
   WorkflowDisplayStatus,
   WorkflowRun,
   WorkflowRunDetail,
-  WorkflowRunDisplay,
-  WorkflowRunDisplayDuration,
   WorkflowRunJobStatusCount,
   WorkflowRunJobSummary,
   WorkflowRunJobs,
   WorkflowRunListItem,
   WorkflowRunListPage,
-  WorkflowRunProgress,
   WorkflowRunRecord,
   WorkflowRunRerunMode,
   WorkflowRunStatus,
@@ -75,19 +72,14 @@ export type {
   WorkflowStatus,
 } from './entities/workflow-run.js';
 export {
-  deriveWorkflowRunDisplay,
   isWorkflowRunTerminal,
   isWorkflowStatus,
   TERMINAL_WORKFLOW_RUN_STATUSES,
   WORKFLOW_DISPLAY_STATUSES,
   WORKFLOW_RUN_STATUSES,
   workflowRunActor,
-  workflowRunBlockingJob,
   workflowRunBranchLabel,
   workflowRunCommitLabel,
-  workflowRunDetailDisplay,
-  workflowRunFirstStartedAt,
-  workflowRunListItemDisplay,
   workflowRunTriggerDisplayLabel,
   workflowRunTriggerLabel,
 } from './entities/workflow-run.js';