@shipfox/client-workflows 12.0.2 → 14.0.0

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

@@ -1,11 +1,11 @@
 import type {BadgeVariant} from '@shipfox/react-ui/badge';
 import type {DotVariant} from '@shipfox/react-ui/dot';
-import type {WorkflowStatus} from '#core/workflow-run.js';
+import type {WorkflowDisplayStatus} from '#core/workflow-run.js';
 
-export type {WorkflowStatus};
+export type {WorkflowDisplayStatus};
 
 export interface WorkflowStatusVisual {
-  kind: WorkflowStatus;
+  kind: WorkflowDisplayStatus;
   label: string;
   dot: DotVariant;
   badge: BadgeVariant;
@@ -15,12 +15,14 @@ export interface WorkflowStatusVisual {
 // WorkflowStatusIcon (which renders the glyph per kind). The exhaustive switch turns any new
 // status the API grows into (DESIGN.md section 9) into a compile error; reserve the `warning`
 // tone for the queued/awaiting-* states when they land.
-export function getWorkflowStatusVisual(status: WorkflowStatus): WorkflowStatusVisual {
+export function getWorkflowStatusVisual(status: WorkflowDisplayStatus): WorkflowStatusVisual {
   switch (status) {
     case 'pending':
       return {kind: 'pending', label: 'Pending', dot: 'neutral', badge: 'neutral'};
     case 'running':
       return {kind: 'running', label: 'Running', dot: 'info', badge: 'info'};
+    case 'listening':
+      return {kind: 'listening', label: 'Listening', dot: 'info', badge: 'info'};
     case 'succeeded':
       return {kind: 'succeeded', label: 'Succeeded', dot: 'success', badge: 'success'};
     case 'failed':

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

@@ -1,10 +1,18 @@
 import {Code, Text} from '@shipfox/react-ui/typography';
 import type {Meta, StoryObj} from '@storybook/react';
-import type {JobStatus} from '#core/workflow-run.js';
+import type {WorkflowDisplayStatus} from '#core/workflow-run.js';
 import {getWorkflowStatusVisual} from './status-visuals.js';
 import {WorkflowStatusIcon} from './workflow-status-icon.js';
 
-const statuses: JobStatus[] = ['pending', 'running', 'succeeded', 'failed', 'cancelled', 'skipped'];
+const statuses: WorkflowDisplayStatus[] = [
+  'pending',
+  'running',
+  'listening',
+  'succeeded',
+  'failed',
+  'cancelled',
+  'skipped',
+];
 
 const meta = {
   title: 'Workflows/StatusIcon',

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

@@ -0,0 +1,18 @@
+import {render, screen} from '@testing-library/react';
+import {WorkflowStatusIcon} from './workflow-status-icon.js';
+
+describe('WorkflowStatusIcon', () => {
+  test('keeps a running status as a dot', () => {
+    const {container} = render(<WorkflowStatusIcon status="running" tooltip={false} />);
+
+    expect(screen.getByRole('img', {name: 'Running'})).toBeInTheDocument();
+    expect(container.querySelector('svg')).toBeNull();
+  });
+
+  test('uses the pulse glyph for the listening status', () => {
+    const {container} = render(<WorkflowStatusIcon status="listening" tooltip={false} />);
+
+    expect(screen.getByRole('img', {name: 'Listening'})).toBeInTheDocument();
+    expect(container.querySelector('svg')).not.toBeNull();
+  });
+});

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

@@ -3,7 +3,7 @@ import {Icon, type IconName} from '@shipfox/react-ui/icon';
 import {Tooltip, TooltipContent, TooltipTrigger} from '@shipfox/react-ui/tooltip';
 import {cn} from '@shipfox/react-ui/utils';
 import type {ReactNode} from 'react';
-import {getWorkflowStatusVisual, type WorkflowStatus} from './status-visuals.js';
+import {getWorkflowStatusVisual, type WorkflowDisplayStatus} from './status-visuals.js';
 
 // Status glyphs use the same saturated accent tokens as IconBadge/StatusBadge.
 const toneByVariant: Record<DotVariant, string> = {
@@ -17,7 +17,7 @@ const toneByVariant: Record<DotVariant, string> = {
 
 // Terminal states are self-contained solid discs; the shape names the state. Running and
 // pending render their own shapes (the live Dot and a bold ring), so they aren't here.
-const glyphByKind: Partial<Record<WorkflowStatus, IconName>> = {
+const glyphByKind: Partial<Record<WorkflowDisplayStatus, IconName>> = {
   succeeded: 'checkCircleSolid',
   failed: 'xCircleSolid',
   cancelled: 'forbid2Fill',
@@ -45,8 +45,7 @@ const dotSizeClass: Record<number, string> = {
 const PENDING_RING_MASK = 'radial-gradient(circle closest-side, transparent 0 52%, #000 56%)';
 
 export interface WorkflowStatusIconProps {
-  status: WorkflowStatus;
-  jobMode?: 'one_shot' | 'listening';
+  status: WorkflowDisplayStatus;
   /** Optical diameter in px: 14 in the DAG node and run row. */
   size?: number;
   /** Pulsing halo for the running state. */
@@ -66,7 +65,6 @@ export interface WorkflowStatusIconProps {
  */
 export function WorkflowStatusIcon({
   status,
-  jobMode = 'one_shot',
   size = 14,
   ripple = true,
   tooltip = true,
@@ -76,25 +74,20 @@ export function WorkflowStatusIcon({
   const box = dotSizeClass[size] ?? 'size-14';
 
   let glyph: ReactNode;
-  if (visual.kind === 'running') {
-    glyph =
-      jobMode === 'listening' ? (
-        <span
-          className={cn(
-            'inline-flex shrink-0 items-center justify-center rounded-full bg-current',
-            box,
-            toneByVariant.info,
-          )}
-        >
-          <Icon
-            name="pulseLine"
-            size={Math.max(8, Math.round(size * 0.7))}
-            className="text-white"
-          />
-        </span>
-      ) : (
-        <Dot variant="info" ripple={ripple} className={box} />
-      );
+  if (visual.kind === 'listening') {
+    glyph = (
+      <span
+        className={cn(
+          'inline-flex shrink-0 items-center justify-center rounded-full bg-current',
+          box,
+          toneByVariant.info,
+        )}
+      >
+        <Icon name="pulseLine" 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') {
     glyph = (
       <span

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

@@ -2,11 +2,16 @@ import {type Duration, intervalToDuration} from 'date-fns';
 import type {Step} from './step.js';
 
 export type JobExecutionStatus = 'pending' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+export type JobExecutionDisplayStatus = JobExecutionStatus;
 export interface WorkflowExecutionEvent {
   source: string;
   event: string;
   deliveryId: string;
   receivedAt: string;
+  project: {id: string} | null;
+  repository: string | null;
+  ref: string | null;
+  commit: string | null;
   data: unknown;
 }
 export type JobExecutionTime =
@@ -53,6 +58,10 @@ export class JobExecution {
     Object.assign(this, fields);
   }
 
+  get displayName(): string {
+    return this.name;
+  }
+
   get queueTime(): JobExecutionTime | null {
     return jobExecutionQueueTimeFromTimestamps(this);
   }
@@ -66,6 +75,19 @@ export class JobExecution {
   }
 }
 
+export function deriveJobExecutionDisplayStatus({
+  status,
+  steps,
+}: Pick<JobExecution, 'status' | 'steps'>): JobExecutionDisplayStatus {
+  if (isTerminalJobExecutionStatus(status)) return status;
+  if (steps.some((step) => step.status === 'running')) return 'running';
+  return 'pending';
+}
+
+export function isTerminalJobExecutionStatus(status: JobExecutionStatus): boolean {
+  return status === 'succeeded' || status === 'failed' || status === 'cancelled';
+}
+
 export function jobExecutionQueueTimeFromTimestamps({
   queuedAt,
   startedAt,

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

@@ -0,0 +1,104 @@
+import {deriveJobDisplayStatus, type JobDisplayStatus} from './job.js';
+import {deriveJobExecutionDisplayStatus, type JobExecutionStatus} from './job-execution.js';
+
+type DisplayStep = Parameters<typeof deriveJobExecutionDisplayStatus>[0]['steps'][number];
+
+function displayStep(status: string): DisplayStep {
+  return {status} as DisplayStep;
+}
+
+const EXECUTION_STATUSES = ['pending', 'running', 'succeeded', 'failed', 'cancelled'] as const;
+const TERMINAL_EXECUTION_STATUSES = ['succeeded', 'failed', 'cancelled'] as const;
+
+describe('deriveJobExecutionDisplayStatus', () => {
+  test.each(
+    EXECUTION_STATUSES,
+  )('%s without a running step displays Pending unless terminal', (status) => {
+    const displayStatus = deriveJobExecutionDisplayStatus({status, steps: []});
+
+    expect(displayStatus).toBe(
+      TERMINAL_EXECUTION_STATUSES.includes(status as (typeof TERMINAL_EXECUTION_STATUSES)[number])
+        ? status
+        : 'pending',
+    );
+  });
+
+  test.each([
+    'pending',
+    'running',
+  ] as const)('%s with a running step displays Running', (status) => {
+    expect(deriveJobExecutionDisplayStatus({status, steps: [displayStep('running')]})).toBe(
+      'running',
+    );
+  });
+
+  test.each(TERMINAL_EXECUTION_STATUSES)('%s wins over a running child step', (status) => {
+    expect(deriveJobExecutionDisplayStatus({status, steps: [displayStep('running')]})).toBe(status);
+  });
+});
+
+describe('deriveJobDisplayStatus', () => {
+  test('uses the execution activity for a one-shot job', () => {
+    const statuses: Array<[JobExecutionStatus, string[], JobDisplayStatus]> = [
+      ['pending', [], 'pending'],
+      ['pending', ['running'], 'running'],
+      ['running', [], 'pending'],
+      ['running', ['running'], 'running'],
+    ];
+
+    for (const [status, stepStatuses, expected] of statuses) {
+      expect(
+        deriveJobDisplayStatus({
+          mode: 'one_shot',
+          status: 'running',
+          listenerStatus: 'inactive',
+          jobExecutions: [
+            {
+              status,
+              steps: stepStatuses.map(displayStep),
+              sequence: 1,
+            },
+          ] as never,
+        }),
+      ).toBe(expected);
+    }
+  });
+
+  test.each([
+    'succeeded',
+    'failed',
+    'cancelled',
+    'skipped',
+  ] as const)('terminal job status %s wins over child activity', (status) => {
+    expect(
+      deriveJobDisplayStatus({
+        mode: 'one_shot',
+        status,
+        listenerStatus: 'inactive',
+        jobExecutions: [{status: 'running', steps: [{status: 'running'}], sequence: 1}] as never,
+      }),
+    ).toBe(status);
+  });
+
+  test('keeps an active listener as Listening without executions', () => {
+    expect(
+      deriveJobDisplayStatus({
+        mode: 'listening',
+        status: 'running',
+        listenerStatus: 'listening',
+        jobExecutions: [],
+      }),
+    ).toBe('listening');
+  });
+
+  test('uses the terminal job status when an active listener has resolved', () => {
+    expect(
+      deriveJobDisplayStatus({
+        mode: 'listening',
+        status: 'succeeded',
+        listenerStatus: 'listening',
+        jobExecutions: [],
+      }),
+    ).toBe('succeeded');
+  });
+});

package/src/core/entities/job.ts

@@ -1,6 +1,11 @@
-import type {JobExecution, JobExecutionDisplayDuration} from './job-execution.js';
+import {
+  deriveJobExecutionDisplayStatus,
+  type JobExecution,
+  type JobExecutionDisplayDuration,
+} from './job-execution.js';
 
 export type JobStatus = 'pending' | 'running' | 'succeeded' | 'failed' | 'cancelled' | 'skipped';
+export type JobDisplayStatus = JobStatus | 'listening';
 export type JobMode = 'one_shot' | 'listening';
 export type ListenerStatus = 'inactive' | 'listening' | 'resolved';
 export type ResolutionReason = 'until' | 'timeout' | 'max_executions' | 'cancelled';
@@ -103,7 +108,7 @@ export class Job {
   }
 
   get displayName(): string {
-    return this.name || this.key;
+    return this.name ?? this.key;
   }
 
   get displayDuration(): JobDisplayDuration | null {
@@ -123,6 +128,16 @@ export function isTerminalJobStatus(status: JobStatus): boolean {
   return TERMINAL_JOB_STATUS_SET.has(status);
 }
 
+export function deriveJobDisplayStatus(
+  job: Pick<Job, 'mode' | 'status' | 'listenerStatus' | 'jobExecutions'>,
+): JobDisplayStatus {
+  if (isTerminalJobStatus(job.status)) return job.status;
+  if (job.mode === 'listening' && job.listenerStatus === 'listening') return 'listening';
+
+  const execution = defaultJobExecution(job);
+  return execution ? deriveJobExecutionDisplayStatus(execution) : 'pending';
+}
+
 export function resolveJobExecution(
   job: Job,
   jobExecutionId: string | undefined,
@@ -135,7 +150,7 @@ export function resolveJobExecution(
   return defaultJobExecution(job);
 }
 
-export function defaultJobExecution(job: Job): JobExecution | undefined {
+export function defaultJobExecution(job: Pick<Job, 'jobExecutions'>): JobExecution | undefined {
   const runningExecution = job.jobExecutions.find(
     (jobExecution) => jobExecution.status === 'running',
   );

package/src/core/entities/step.ts

@@ -4,6 +4,8 @@ export type StepErrorReason =
   | 'checkout_failed'
   | 'checkout_auth_failed'
   | 'checkout_unavailable'
+  | 'checkout_path_invalid'
+  | 'checkout_destination_occupied'
   | 'git_unavailable'
   | 'workspace_prep_failed'
   | 'setup_aborted'
@@ -23,6 +25,8 @@ export const STEP_ERROR_REASONS = new Set<StepErrorReason>([
   'checkout_failed',
   'checkout_auth_failed',
   'checkout_unavailable',
+  'checkout_path_invalid',
+  'checkout_destination_occupied',
   'git_unavailable',
   'workspace_prep_failed',
   'setup_aborted',

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

@@ -1,9 +1,10 @@
-import {type Job, WORKFLOW_JOB_STATUSES} from './job.js';
+import {type Job, type JobStatus, WORKFLOW_JOB_STATUSES} from './job.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];
+export type WorkflowDisplayStatus = WorkflowStatus | 'listening';
 
 export const WORKFLOW_RUN_STATUSES = [
   'pending',
@@ -30,11 +31,51 @@ export interface WorkflowSourceSnapshot {
   format: 'yaml';
 }
 
+/**
+ * Provider-neutral trigger facts. Every field is nullable: only source-control triggers
+ * resolve a reference at all, and a payload can name a ref without naming an actor.
+ */
+export interface WorkflowRunTriggerReference {
+  repository: string | null;
+  ref: string | null;
+  commit: string | null;
+  actor: string | null;
+}
+
+/** One glyph in a run row's job status strip: enough to draw and label it, nothing more. */
+export interface WorkflowRunJobSummary {
+  id: string;
+  key: string;
+  name: string | null;
+  status: JobStatus;
+  position: number;
+}
+
+export interface WorkflowRunJobStatusCount {
+  status: JobStatus;
+  count: number;
+}
+
+/**
+ * A run's jobs as the list receives them: a bounded slice to draw, plus totals covering all
+ * 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.
+ */
+export interface WorkflowRunJobs {
+  preview: WorkflowRunJobSummary[];
+  statusCounts: WorkflowRunJobStatusCount[];
+  total: number;
+}
+
 export interface WorkflowRun {
   id: string;
   projectId: string;
   definitionId: string;
+  number: number | null;
   name: string;
+  workflowName: string;
   currentAttempt: number;
   triggerProvider: string | null;
   triggerSource: string;
@@ -42,20 +83,25 @@ export interface WorkflowRun {
   triggerDisplayLabel: string;
   triggerLabel: string;
   triggerPayload: Record<string, unknown>;
+  triggerReference: WorkflowRunTriggerReference | null;
   inputs: Record<string, unknown> | null;
   sourceSnapshot: WorkflowSourceSnapshot | null;
   createdAt: string;
   updatedAt: string;
-  shortId: string;
   isTemporary: boolean;
 }
 
-export interface WorkflowRunListItem extends WorkflowRun {
+/** A run as the API returns it outside the list: no job strip, because none was fetched. */
+export interface WorkflowRunRecord extends WorkflowRun {
   status: WorkflowRunStatus;
   latestAttempt: number;
   runAttempt: WorkflowRunAttemptSummary;
 }
 
+export interface WorkflowRunListItem extends WorkflowRunRecord {
+  jobs: WorkflowRunJobs;
+}
+
 export interface WorkflowRunDetail extends WorkflowRun {
   latestAttempt: number;
   runAttempt: WorkflowRunAttempt;
@@ -72,10 +118,6 @@ export interface ManualWorkflowLaunch {
   workflowRunId: string;
 }
 
-export function workflowRunShortId(id: string): string {
-  return id.length <= 8 ? id : id.slice(0, 8);
-}
-
 export function workflowRunTriggerLabel({
   triggerSource,
   triggerEvent,
@@ -96,6 +138,33 @@ export function workflowRunTriggerDisplayLabel({
   return triggerEvent || triggerSource;
 }
 
+const SHORT_COMMIT_LENGTH = 7;
+const PULL_REQUEST_REF_PATTERN = /^refs\/pull\/(\d+)\/head$/u;
+
+/**
+ * The ref as a person names it: `main` for a branch, `#42` for a pull request, the tag for a
+ * tag. An unrecognized ref is shown verbatim rather than hidden, since a ref nobody can read
+ * is still better evidence than a blank cell.
+ */
+export function workflowRunBranchLabel(run: Pick<WorkflowRun, 'triggerReference'>): string | null {
+  const ref = run.triggerReference?.ref;
+  if (!ref) return null;
+  const pullRequest = PULL_REQUEST_REF_PATTERN.exec(ref);
+  if (pullRequest) return `#${pullRequest[1]}`;
+  if (ref.startsWith('refs/heads/')) return ref.slice('refs/heads/'.length);
+  if (ref.startsWith('refs/tags/')) return ref.slice('refs/tags/'.length);
+  return ref;
+}
+
+export function workflowRunCommitLabel(run: Pick<WorkflowRun, 'triggerReference'>): string | null {
+  const commit = run.triggerReference?.commit;
+  return commit ? commit.slice(0, SHORT_COMMIT_LENGTH) : null;
+}
+
+export function workflowRunActor(run: Pick<WorkflowRun, 'triggerReference'>): string | null {
+  return run.triggerReference?.actor ?? null;
+}
+
 export function isWorkflowRunTerminal(status: WorkflowRunStatus): boolean {
   return TERMINAL_WORKFLOW_RUN_STATUS_SET.has(status);
 }

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

@@ -0,0 +1,8 @@
+/** Counts used by the run detail tab strip before the annotations query owns the data. */
+export interface RunAnnotationSummary {
+  total: number;
+  error: number;
+  warning: number;
+  info: number;
+  success: number;
+}

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

@@ -6,6 +6,7 @@ import {
   toWorkflowRunListPage,
 } from '#hooks/api/workflow-run-mapper.js';
 import {
+  workflowJob,
   workflowJobDto,
   workflowJobExecutionDto,
   workflowRunAttemptDto,
@@ -18,7 +19,6 @@ import {
 import {
   isWorkflowRunTerminal,
   isWorkflowStatus,
-  workflowRunShortId,
   workflowRunTriggerDisplayLabel,
   workflowRunTriggerLabel,
 } from './workflow-run.js';
@@ -51,7 +51,9 @@ describe('workflow run model mapping', () => {
       id: '66666666-6666-4666-8666-666666666666',
       projectId: '44444444-4444-4444-8444-444444444444',
       definitionId: '55555555-5555-4555-8555-555555555555',
+      number: 1,
       name: 'deploy-web',
+      workflowName: 'deploy-web',
       currentAttempt: 3,
       triggerProvider: 'github',
       triggerSource: 'github_acme',
@@ -63,7 +65,6 @@ describe('workflow run model mapping', () => {
       sourceSnapshot: {format: 'yaml', content: 'jobs: {}'},
       createdAt: '2026-05-07T01:01:00.000Z',
       updatedAt: '2026-05-07T01:02:00.000Z',
-      shortId: '66666666',
       isTemporary: false,
     });
     expect(run).not.toHaveProperty('status');
@@ -91,7 +92,6 @@ describe('workflow run model mapping', () => {
       triggerLabel: '',
       inputs: null,
       sourceSnapshot: null,
-      shortId: 'temp-123',
       isTemporary: true,
     });
   });
@@ -299,6 +299,10 @@ describe('workflow run model mapping', () => {
               event: 'deployment_status',
               delivery_id: 'delivery-1',
               received_at: '2026-05-07T01:00:00.000Z',
+              project: {id: '44444444-4444-4444-8444-444444444444'},
+              repository: 'acme/api',
+              ref: 'refs/heads/main',
+              commit: 'a'.repeat(40),
               data: {state: 'success'},
             },
           ],
@@ -332,6 +336,10 @@ describe('workflow run model mapping', () => {
           event: 'deployment_status',
           deliveryId: 'delivery-1',
           receivedAt: '2026-05-07T01:00:00.000Z',
+          project: {id: '44444444-4444-4444-8444-444444444444'},
+          repository: 'acme/api',
+          ref: 'refs/heads/main',
+          commit: 'a'.repeat(40),
           data: {state: 'success'},
         },
       ],
@@ -376,6 +384,18 @@ describe('workflow run model mapping', () => {
     });
   });
 
+  test('exposes display names for jobs and job executions', () => {
+    const job = workflowJob({
+      name: 'Deploy',
+      key: 'deploy',
+      job_executions: [workflowJobExecutionDto({name: 'Deploy production'})],
+    });
+
+    expect(job.displayName).toBe('Deploy');
+    expect(job.jobExecutions[0]?.displayName).toBe('Deploy production');
+    expect(workflowJob({name: null, key: 'deploy-prod'}).displayName).toBe('deploy-prod');
+  });
+
   test('returns no job display duration when a job has multiple executions', () => {
     const job = workflowJobDto({
       job_executions: [
@@ -628,12 +648,7 @@ describe('workflow run helpers', () => {
     expect(neither).toBe('');
   });
 
-  test('formats short ids and classifies workflow statuses', () => {
-    const short = workflowRunShortId('abc123');
-    const long = workflowRunShortId('66666666-6666-4666-8666-666666666666');
-
-    expect(short).toBe('abc123');
-    expect(long).toBe('66666666');
+  test('classifies workflow statuses', () => {
     expect(isWorkflowRunTerminal('succeeded')).toBe(true);
     expect(isWorkflowRunTerminal('running')).toBe(false);
     expect(isWorkflowStatus('pending')).toBe(true);

package/src/core/workflow-run.ts

@@ -1,5 +1,6 @@
 export type {
   JobDisplayDuration,
+  JobDisplayStatus,
   JobListening,
   JobMode,
   JobStatus,
@@ -9,6 +10,7 @@ export type {
 } from './entities/job.js';
 export {
   defaultJobExecution,
+  deriveJobDisplayStatus,
   isTerminalJobStatus,
   Job,
   resolveJobExecution,
@@ -17,11 +19,16 @@ export {
 } from './entities/job.js';
 export type {
   JobExecutionDisplayDuration,
+  JobExecutionDisplayStatus,
   JobExecutionStatus,
   JobExecutionTime,
   WorkflowExecutionEvent,
 } from './entities/job-execution.js';
-export {JobExecution} from './entities/job-execution.js';
+export {
+  deriveJobExecutionDisplayStatus,
+  isTerminalJobExecutionStatus,
+  JobExecution,
+} from './entities/job-execution.js';
 export type {
   AgentConfigIssue,
   AgentStepConfig,
@@ -39,12 +46,18 @@ export type {
 export {StepAttempt} from './entities/step-attempt.js';
 export type {
   ManualWorkflowLaunch,
+  WorkflowDisplayStatus,
   WorkflowRun,
   WorkflowRunDetail,
+  WorkflowRunJobStatusCount,
+  WorkflowRunJobSummary,
+  WorkflowRunJobs,
   WorkflowRunListItem,
   WorkflowRunListPage,
+  WorkflowRunRecord,
   WorkflowRunRerunMode,
   WorkflowRunStatus,
+  WorkflowRunTriggerReference,
   WorkflowSourceSnapshot,
   WorkflowStatus,
 } from './entities/workflow-run.js';
@@ -53,7 +66,9 @@ export {
   isWorkflowStatus,
   TERMINAL_WORKFLOW_RUN_STATUSES,
   WORKFLOW_RUN_STATUSES,
-  workflowRunShortId,
+  workflowRunActor,
+  workflowRunBranchLabel,
+  workflowRunCommitLabel,
   workflowRunTriggerDisplayLabel,
   workflowRunTriggerLabel,
 } from './entities/workflow-run.js';