@shipfox/client-workflows 17.0.0 → 19.0.0

package/src/core/entities/job-execution.ts

@@ -29,6 +29,7 @@ interface JobExecutionFields {
   name: string;
   status: JobExecutionStatus;
   statusReason: string | null;
+  statusReasonMessage: string | null;
   runner: string[] | null;
   outputs: Record<string, unknown> | null;
   triggerEvents: WorkflowExecutionEvent[];
@@ -49,6 +50,7 @@ export class JobExecution {
   name!: string;
   status!: JobExecutionStatus;
   statusReason!: string | null;
+  statusReasonMessage!: string | null;
   runner!: string[] | null;
   outputs!: Record<string, unknown> | null;
   triggerEvents!: WorkflowExecutionEvent[];

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';
 
@@ -20,8 +21,10 @@ export type JobStatusReason =
   | 'run_cancelled'
   | 'timed_out'
   | 'runner_lost'
+  | 'output_too_large'
   | 'step_failed'
-  | 'unknown';
+  | 'unknown'
+  | 'output_invalid';
 export interface JobListening {
   on: Array<{
     source: string;
@@ -138,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-display.test.ts

@@ -100,6 +100,34 @@ describe('workflowRunListItemDisplay', () => {
     expect(display.status).toBe('running');
     expect(display.duration).toMatchObject({kind: 'run'});
   });
+
+  test('uses execution-derived running counts for the row headline', () => {
+    const run = workflowRunListItem({
+      status: 'running',
+      ...workflowRunJobsFixture(['pending']),
+      job_display_status_counts: [{status: 'running', count: 1}],
+      started_at: ATTEMPT_STARTED_AT,
+    });
+
+    const display = workflowRunListItemDisplay(run);
+
+    expect(display.status).toBe('running');
+    expect(display.duration).toMatchObject({kind: 'run'});
+  });
+
+  test('uses execution-derived listening counts as started work', () => {
+    const run = workflowRunListItem({
+      status: 'running',
+      ...workflowRunJobsFixture(['pending']),
+      job_display_status_counts: [{status: 'listening', count: 1}],
+      started_at: ATTEMPT_STARTED_AT,
+    });
+
+    const display = workflowRunListItemDisplay(run);
+
+    expect(display.status).toBe('running');
+    expect(display.duration).toMatchObject({kind: 'run'});
+  });
 });
 
 describe('workflowRunBlockingJob', () => {

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

@@ -1,5 +1,16 @@
-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 {
+  elapsedTimeFromTimestamps,
+  type JobExecutionDisplayDuration,
+  type JobExecutionStatus,
+} from './job-execution.js';
 import type {WorkflowRunAttempt, WorkflowRunAttemptSummary} from './workflow-run-attempt.js';
 
 export type WorkflowRunStatus = 'pending' | 'running' | 'succeeded' | 'failed' | 'cancelled';
@@ -60,11 +71,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;
 }
 
@@ -209,7 +223,7 @@ export interface WorkflowRunProgress {
   runStatus: WorkflowRunStatus;
   startedAt: string | null;
   finishedAt: string | null;
-  jobStatuses: JobStatus[];
+  jobStatuses: JobDisplayStatus[];
   firstStartedAt?: string | null | undefined;
 }
 

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

@@ -12,6 +12,7 @@ import {
   workflowRunAttemptDto,
   workflowRunDetailDto,
   workflowRunDto,
+  workflowRunJobSummaryDto,
   workflowRunListResponseDto,
   workflowStepAttemptDto,
   workflowStepDto,
@@ -127,6 +128,18 @@ describe('workflow run model mapping', () => {
     });
   });
 
+  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/hooks/api/workflow-run-mapper.ts

@@ -96,7 +96,10 @@ export function toWorkflowRunRecord(dto: WorkflowRunResponseDto): WorkflowRunRec
 }
 
 export function toWorkflowRunListItem(dto: WorkflowRunListItemDto): WorkflowRunListItem {
-  const statusCounts = dto.job_status_counts.map(({status, count}) => ({status, count}));
+  const hasDisplayStatusCounts = dto.job_display_status_counts !== undefined;
+  const statusCounts = (dto.job_display_status_counts ?? dto.job_status_counts).map(
+    ({status, count}) => ({status, count}),
+  );
   return {
     ...toWorkflowRunRecord(dto),
     jobs: {
@@ -105,6 +108,14 @@ export function toWorkflowRunListItem(dto: WorkflowRunListItemDto): WorkflowRunL
         key: job.key,
         name: job.name,
         status: job.status,
+        mode: job.mode ?? 'one_shot',
+        listenerStatus: job.listener_status ?? 'inactive',
+        // The optional display-count field is the rollout capability signal. Pre-display API
+        // responses only carry raw verdict counts, so mirror their non-terminal verdict into
+        // execution evidence to keep each legacy glyph aligned with those fallback counts.
+        executionStatus: hasDisplayStatusCounts
+          ? (job.execution_status ?? null)
+          : legacyExecutionStatus(job.status),
         position: job.position,
       })),
       statusCounts,
@@ -115,6 +126,12 @@ export function toWorkflowRunListItem(dto: WorkflowRunListItemDto): WorkflowRunL
   };
 }
 
+function legacyExecutionStatus(
+  status: WorkflowRunListItemDto['jobs'][number]['status'],
+): 'pending' | 'running' | null {
+  return status === 'pending' || status === 'running' ? status : null;
+}
+
 export function toWorkflowRunListPage(dto: WorkflowRunListResponseDto): WorkflowRunListPage {
   return {
     runs: dto.runs.map(toWorkflowRunListItem),
@@ -165,6 +182,7 @@ export function toJobExecution(dto: WorkflowRunJobExecutionDetailDto): JobExecut
     name: dto.name,
     status: dto.status,
     statusReason: dto.status_reason,
+    statusReasonMessage: dto.status_reason_message ?? null,
     runner: dto.runner ?? null,
     outputs: dto.outputs ?? null,
     triggerEvents: (dto.trigger_events ?? []).map(toWorkflowExecutionEvent),

package/test/fixtures/workflow-run.ts

@@ -81,6 +81,7 @@ export function workflowRunDto(
     finished_at: null,
     jobs: [],
     job_status_counts: [],
+    job_display_status_counts: [],
     ...overrides,
   };
 }
@@ -89,11 +90,15 @@ export function workflowRunJobSummaryDto(
   overrides: Partial<WorkflowRunJobSummaryDto> = {},
 ): WorkflowRunJobSummaryDto {
   jobSummarySequence += 1;
+  const status = overrides.status ?? 'succeeded';
   return {
     id: `${JOB_SUMMARY_ID_PREFIX}${String(jobSummarySequence).padStart(11, '0')}`,
     key: `job-${jobSummarySequence}`,
     name: null,
-    status: 'succeeded',
+    status,
+    mode: 'one_shot',
+    listener_status: 'inactive',
+    execution_status: executionStatusForFixtureStatus(status),
     position: jobSummarySequence - 1,
     ...overrides,
   };
@@ -104,13 +109,25 @@ export function workflowRunJobSummaryDtos(
   count: number,
   statuses: readonly JobStatusDto[] = [],
 ): WorkflowRunJobSummaryDto[] {
-  return Array.from({length: count}, (_, index) =>
-    workflowRunJobSummaryDto({
+  return Array.from({length: count}, (_, index) => {
+    const status = statuses[index];
+    return workflowRunJobSummaryDto({
       key: `job-${index + 1}`,
       position: index,
-      ...(statuses[index] ? {status: statuses[index]} : {}),
-    }),
-  );
+      ...(status
+        ? {
+            status,
+            execution_status: executionStatusForFixtureStatus(status),
+          }
+        : {}),
+    });
+  });
+}
+
+function executionStatusForFixtureStatus(
+  status: JobStatusDto,
+): WorkflowRunJobSummaryDto['execution_status'] {
+  return status === 'pending' || status === 'running' ? status : null;
 }
 
 /**
@@ -122,16 +139,19 @@ export function workflowRunJobSummaryDtos(
  */
 export function workflowRunJobsFixture(
   statuses: readonly JobStatusDto[],
-): Pick<WorkflowRunListItemDto, 'jobs' | 'job_status_counts'> {
+): Pick<WorkflowRunListItemDto, 'jobs' | 'job_status_counts' | 'job_display_status_counts'> {
   const counts = new Map<JobStatusDto, number>();
   for (const status of statuses) counts.set(status, (counts.get(status) ?? 0) + 1);
 
+  const preview = workflowRunJobSummaryDtos(
+    Math.min(statuses.length, WORKFLOW_RUN_JOB_PREVIEW_LIMIT),
+    statuses,
+  );
+
   return {
-    jobs: workflowRunJobSummaryDtos(
-      Math.min(statuses.length, WORKFLOW_RUN_JOB_PREVIEW_LIMIT),
-      statuses,
-    ),
+    jobs: preview,
     job_status_counts: [...counts.entries()].map(([status, count]) => ({status, count})),
+    job_display_status_counts: [...counts.entries()].map(([status, count]) => ({status, count})),
   };
 }
 
@@ -139,7 +159,7 @@ export function workflowRunJobsFixture(
 export function workflowRunJobsOfStatus(
   count: number,
   status: JobStatusDto = 'succeeded',
-): Pick<WorkflowRunListItemDto, 'jobs' | 'job_status_counts'> {
+): Pick<WorkflowRunListItemDto, 'jobs' | 'job_status_counts' | 'job_display_status_counts'> {
   return workflowRunJobsFixture(Array.from({length: count}, () => status));
 }