@shipfox/api-workflows 12.5.0 → 12.7.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-workflows",
   "license": "MIT",
-  "version": "12.5.0",
+  "version": "12.7.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -32,7 +32,7 @@
     "@shipfox/api-integration-core-dto": "12.2.0",
     "@shipfox/api-runners-dto": "12.4.0",
     "@shipfox/api-secrets-dto": "12.0.0",
-    "@shipfox/api-workflows-dto": "12.5.0",
+    "@shipfox/api-workflows-dto": "12.7.0",
     "@shipfox/api-workspaces-dto": "12.0.0",
     "@shipfox/config": "1.2.4",
     "@shipfox/inter-module": "0.2.3",

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

@@ -107,4 +107,7 @@ export interface WorkflowRunDetail extends WorkflowRun {
   runAttempt: WorkflowRunAttempt;
   latestAttempt: number;
   jobs: WorkflowJobDetail[];
+  /** Whether any job execution of this attempt reached its runner, decided here so the detail
+   * and the list cannot answer it differently. */
+  hasStartedJobExecution: boolean;
 }

package/src/db/index.ts

@@ -42,6 +42,7 @@ export type {
   WorkflowJobExecutionDepthParams,
   WorkflowRunAggregates,
   WorkflowRunFilters,
+  WorkflowRunJobRawStatusCount,
   WorkflowRunJobStatusCount,
   WorkflowRunJobSummary,
   WorkflowRunJobSummaryTarget,

package/src/db/schema/jobs.ts

@@ -61,6 +61,9 @@ export const jobs = pgTable(
     key: text('key').notNull(),
     mode: jobModeEnum('mode').notNull().default('one_shot'),
     name: text('name'),
+    // This is the job's execution verdict, not its runtime lifecycle. Active execution state
+    // lives on job_executions and must be read there when a surface needs to distinguish
+    // waiting from executing.
     status: jobStatusEnum('status').notNull().default('pending'),
     statusReason: jobStatusReasonEnum('status_reason'),
     carriedOver: boolean('carried_over').notNull().default(false),

package/src/db/workflow-runs/queries.test.ts

@@ -1,5 +1,8 @@
 import {WORKFLOW_RUN_JOB_PREVIEW_LIMIT} from '@shipfox/api-workflows-dto';
+import {eq} from 'drizzle-orm';
 import {buildModel, createTestRun} from '#test/helpers/workflow-runs.js';
+import {db} from '../db.js';
+import {jobs} from '../schema/jobs.js';
 import {
   createRerunWorkflowRun,
   createWorkflowRun,
@@ -11,6 +14,7 @@ import {
   listRunAttempts,
   listWorkflowRunJobSummaries,
   listWorkflowRunsByProject,
+  recordJobExecutionStartedAt,
   updateJobExecutionStatus,
   updateJobStatus,
   updateWorkflowRunStatus,
@@ -270,6 +274,173 @@ describe('workflow run queries', () => {
       ]);
 
       expect(summary.get(run.id)?.statusCounts).toEqual([{status: 'pending', count: 2}]);
+      expect(summary.get(run.id)?.hasStartedJobExecution).toBe(false);
+    });
+
+    test('reports when any current-attempt job execution has started', async () => {
+      const run = await createWorkflowRun({
+        workspaceId,
+        projectId,
+        definitionId,
+        model: buildModel({jobs: {build: {steps: [{run: 'echo build'}]}}}),
+        triggerPayload: manualTrigger(),
+      });
+      const [job] = await getJobsByWorkflowRunId(run.id);
+      if (!job) throw new Error('Expected workflow job');
+      const execution = await getFirstJobExecutionByJobId(job.id);
+      if (!execution) throw new Error('Expected workflow job execution');
+
+      await recordJobExecutionStartedAt({
+        jobExecutionId: execution.id,
+        startedAt: new Date('2026-05-07T01:00:05.000Z'),
+      });
+
+      const summary = await listWorkflowRunJobSummaries([
+        {id: run.id, currentAttempt: run.currentAttempt},
+      ]);
+
+      expect(summary.get(run.id)?.hasStartedJobExecution).toBe(true);
+    });
+
+    test('returns execution evidence and counts its display status', async () => {
+      const run = await createWorkflowRun({
+        workspaceId,
+        projectId,
+        definitionId,
+        model: buildModel({jobs: {build: {steps: [{run: 'echo build'}]}}}),
+        triggerPayload: manualTrigger(),
+      });
+      const [job] = await getJobsByWorkflowRunId(run.id);
+      if (!job) throw new Error('expected the run to have a job');
+      const execution = await getFirstJobExecutionByJobId(job.id);
+      if (!execution) throw new Error('expected the job to have an execution');
+
+      await updateJobExecutionStatus({
+        jobExecutionId: execution.id,
+        status: 'running',
+        expectedVersion: execution.version,
+      });
+
+      const summary = await listWorkflowRunJobSummaries([
+        {id: run.id, currentAttempt: run.currentAttempt},
+      ]);
+
+      expect(summary.get(run.id)?.preview).toMatchObject([
+        {
+          status: 'pending',
+          mode: 'one_shot',
+          listenerStatus: 'inactive',
+          executionStatus: 'running',
+        },
+      ]);
+      expect(summary.get(run.id)?.statusCounts).toEqual([{status: 'running', count: 1}]);
+      expect(summary.get(run.id)?.rawStatusCounts).toEqual([{status: 'pending', count: 1}]);
+    });
+
+    test('counts an active listener without an execution', async () => {
+      const run = await createWorkflowRun({
+        workspaceId,
+        projectId,
+        definitionId,
+        model: buildModel({
+          jobs: {
+            listen: {
+              listening: {
+                on: [{source: 'github', event: 'push'}],
+                onResolve: 'finish',
+              },
+              steps: [{run: 'echo listen'}],
+            },
+          },
+        }),
+        triggerPayload: manualTrigger(),
+      });
+      const [job] = await getJobsByWorkflowRunId(run.id);
+      if (!job) throw new Error('expected the run to have a listener job');
+
+      await db().update(jobs).set({listenerStatus: 'listening'}).where(eq(jobs.id, job.id));
+
+      const summary = await listWorkflowRunJobSummaries([
+        {id: run.id, currentAttempt: run.currentAttempt},
+      ]);
+
+      expect(summary.get(run.id)?.preview).toMatchObject([
+        {
+          mode: 'listening',
+          listenerStatus: 'listening',
+          executionStatus: null,
+        },
+      ]);
+      expect(summary.get(run.id)?.statusCounts).toEqual([{status: 'listening', count: 1}]);
+      expect(summary.get(run.id)?.rawStatusCounts).toEqual([{status: 'pending', count: 1}]);
+    });
+
+    test('keeps a terminal verdict ahead of a running execution', async () => {
+      const run = await createWorkflowRun({
+        workspaceId,
+        projectId,
+        definitionId,
+        model: buildModel({jobs: {build: {steps: [{run: 'echo build'}]}}}),
+        triggerPayload: manualTrigger(),
+      });
+      const [job] = await getJobsByWorkflowRunId(run.id);
+      if (!job) throw new Error('expected the run to have a job');
+      const execution = await getFirstJobExecutionByJobId(job.id);
+      if (!execution) throw new Error('expected the job to have an execution');
+
+      await updateJobExecutionStatus({
+        jobExecutionId: execution.id,
+        status: 'running',
+        expectedVersion: execution.version,
+      });
+      await updateJobStatus({jobId: job.id, status: 'failed', expectedVersion: job.version});
+
+      const summary = await listWorkflowRunJobSummaries([
+        {id: run.id, currentAttempt: run.currentAttempt},
+      ]);
+
+      expect(summary.get(run.id)?.preview).toMatchObject([
+        {status: 'failed', executionStatus: 'running'},
+      ]);
+      expect(summary.get(run.id)?.statusCounts).toEqual([{status: 'failed', count: 1}]);
+      expect(summary.get(run.id)?.rawStatusCounts).toEqual([{status: 'failed', count: 1}]);
+    });
+
+    test('counts a skipped zero-execution job from its terminal verdict', async () => {
+      const run = await createWorkflowRun({
+        workspaceId,
+        projectId,
+        definitionId,
+        model: buildModel({
+          jobs: {
+            listen: {
+              listening: {
+                on: [{source: 'github', event: 'push'}],
+                onResolve: 'finish',
+              },
+              steps: [{run: 'echo listen'}],
+            },
+          },
+        }),
+        triggerPayload: manualTrigger(),
+      });
+      const [job] = await getJobsByWorkflowRunId(run.id);
+      if (!job) throw new Error('expected the run to have a listener job');
+
+      await db()
+        .update(jobs)
+        .set({status: 'skipped', listenerStatus: 'resolved'})
+        .where(eq(jobs.id, job.id));
+
+      const summary = await listWorkflowRunJobSummaries([
+        {id: run.id, currentAttempt: run.currentAttempt},
+      ]);
+
+      expect(summary.get(run.id)?.preview).toMatchObject([
+        {status: 'skipped', executionStatus: null},
+      ]);
+      expect(summary.get(run.id)?.statusCounts).toEqual([{status: 'skipped', count: 1}]);
+      expect(summary.get(run.id)?.rawStatusCounts).toEqual([{status: 'skipped', count: 1}]);
     });
 
     // Checks the invariant the snapshot exists to protect: for a run inside the preview
@@ -445,13 +616,36 @@ function totalOf(summary: {statusCounts: Array<{count: number}>} | undefined): n
 
 /** Statuses the preview actually drew, counted. */
 function previewCounts(
-  summary: {preview: Array<{status: string}>} | undefined,
+  summary:
+    | {
+        preview: Array<{
+          status: string;
+          mode: string;
+          listenerStatus: string;
+          executionStatus: string | null;
+        }>;
+      }
+    | undefined,
 ): Record<string, number> {
   const counts: Record<string, number> = {};
-  for (const job of summary?.preview ?? []) counts[job.status] = (counts[job.status] ?? 0) + 1;
+  for (const job of summary?.preview ?? []) {
+    const status = previewDisplayStatus(job);
+    counts[status] = (counts[status] ?? 0) + 1;
+  }
   return counts;
 }
 
+function previewDisplayStatus(job: {
+  status: string;
+  mode: string;
+  listenerStatus: string;
+  executionStatus: string | null;
+}): string {
+  if (['succeeded', 'failed', 'cancelled', 'skipped'].includes(job.status)) return job.status;
+  if (job.mode === 'listening' && job.listenerStatus === 'listening') return 'listening';
+  return job.executionStatus ?? 'pending';
+}
+
 /** The same shape read off the totals, so the two halves can be compared directly. */
 function statusCountMap(
   summary: {statusCounts: Array<{status: string; count: number}>} | undefined,

package/src/db/workflow-runs/queries.ts

@@ -5,7 +5,8 @@ import {
   timestampIdCursorWhere,
 } from '@shipfox/node-drizzle';
 import {and, asc, count, desc, eq, gte, lte, type SQL, sql} from 'drizzle-orm';
-import type {JobStatus} from '#core/entities/job.js';
+import type {JobMode, JobStatus, ListenerStatus} from '#core/entities/job.js';
+import type {JobExecutionStatus} from '#core/entities/job-execution.js';
 import type {
   JobExecutionDetail,
   StepDetail,
@@ -52,6 +53,9 @@ export interface WorkflowRunJobSummary {
   key: string;
   name: string | null;
   status: JobStatus;
+  mode: JobMode;
+  listenerStatus: ListenerStatus;
+  executionStatus: JobExecutionStatus | null;
   position: number;
 }
 
@@ -209,17 +213,28 @@ export interface WorkflowRunJobSummaryTarget {
 }
 
 /**
- * A page row's jobs: a bounded slice to draw, and totals describing all of them.
+ * A page row's jobs: a bounded slice to draw, totals describing all of them, and whether any
+ * execution has reached a runner.
  *
  * The preview is what a row can show; `statusCounts` is what it can say. Keeping the counts
- * server-side is what lets a row report a failure that sits past the preview.
+ * server-side is what lets a row report a failure that sits past the preview. Counts use the
+ * display status derived from the job verdict, listener state, and selected execution state;
+ * the row keeps the verdict and evidence separate so the client can apply the same display
+ * rule as run detail.
  */
 export interface WorkflowRunJobsSummary {
   preview: WorkflowRunJobSummary[];
   statusCounts: WorkflowRunJobStatusCount[];
+  rawStatusCounts: WorkflowRunJobRawStatusCount[];
+  hasStartedJobExecution: boolean;
 }
 
 export interface WorkflowRunJobStatusCount {
+  status: JobStatus | 'listening';
+  count: number;
+}
+
+export interface WorkflowRunJobRawStatusCount {
   status: JobStatus;
   count: number;
 }
@@ -240,8 +255,8 @@ export interface WorkflowRunJobStatusCount {
  * attempt 1's run metadata with attempt 2's jobs, and the row would report a status its strip
  * contradicts.
  *
- * The two reads share one repeatable-read snapshot. They describe the same jobs at the same
- * instant, and the strip combines them into a single glyph row, so under the default
+ * The reads share one repeatable-read snapshot. They describe the same jobs and executions at
+ * the same instant, and the strip combines them into a single glyph row, so under the default
  * read-committed isolation a job settling between the statements would draw a pending glyph
  * beside a summary counting it as failed. Sequential inside one transaction is the cost of
  * that; at a four-second poll the extra round trip does not register.
@@ -262,23 +277,72 @@ export async function listWorkflowRunJobSummaries(
 
   const {previewRows, countRows} = await db().transaction(
     async (tx) => {
+      // Pick the execution the detail view would display once per job before either list
+      // statement touches it. The existing (job_id, sequence) index supports the latest
+      // execution ordering, while the status-first expression preserves the rule that an
+      // active execution wins over a newer completed retry.
+      const selectedExecution = tx.$with('selected_execution').as(
+        tx
+          .selectDistinctOn([jobExecutions.jobId], {
+            jobId: jobExecutions.jobId,
+            executionStatus: sql<JobExecutionStatus>`${jobExecutions.status}`.as(
+              'execution_status',
+            ),
+          })
+          .from(jobExecutions)
+          .innerJoin(jobs, eq(jobExecutions.jobId, jobs.id))
+          .innerJoin(workflowRunAttempts, eq(jobs.workflowRunAttemptId, workflowRunAttempts.id))
+          .where(attemptFilter)
+          .orderBy(
+            asc(jobExecutions.jobId),
+            sql`case when ${jobExecutions.status} = 'running' then 0 else 1 end`,
+            desc(jobExecutions.sequence),
+            desc(jobExecutions.id),
+          ),
+      );
+
       const ranked = tx
+        .with(selectedExecution)
         .select({
           workflowRunId: workflowRunAttempts.workflowRunId,
           id: jobs.id,
           key: jobs.key,
           name: jobs.name,
           status: jobs.status,
+          mode: jobs.mode,
+          listenerStatus: jobs.listenerStatus,
+          executionStatus: selectedExecution.executionStatus,
           position: jobs.position,
-          rank: sql<number>`row_number() over (partition by ${workflowRunAttempts.workflowRunId} order by ${jobs.position} asc, ${jobs.id} asc)`.as(
-            'rank',
-          ),
+          jobRank:
+            sql<number>`row_number() over (partition by ${workflowRunAttempts.workflowRunId} order by ${jobs.position} asc, ${jobs.id} asc)`.as(
+              'job_rank',
+            ),
         })
         .from(jobs)
         .innerJoin(workflowRunAttempts, eq(jobs.workflowRunAttemptId, workflowRunAttempts.id))
+        .leftJoin(selectedExecution, eq(selectedExecution.jobId, jobs.id))
         .where(attemptFilter)
         .as('ranked');
-
+      // Correlated per job rather than a grouped scan of `job_executions`: an aggregate over the
+      // whole table cannot have the page's filter pushed into it, so it would read every execution
+      // ever recorded on each poll and grow with history rather than with the page.
+      const hasStartedJobExecution = sql<boolean>`bool_or(exists (
+        select 1
+        from ${jobExecutions}
+        where ${jobExecutions.jobId} = ${jobs.id} and ${jobExecutions.startedAt} is not null
+      ))`;
+
+      const executionDisplayStatus = sql<JobExecutionStatus | null>`
+        ${selectedExecution.executionStatus}
+      `;
+      const displayStatus = sql<WorkflowRunJobStatusCount['status']>`
+        case
+          when ${jobs.status} in ('succeeded', 'failed', 'cancelled', 'skipped') then ${jobs.status}::text
+          when ${jobs.mode} = 'listening' and ${jobs.listenerStatus} = 'listening' then 'listening'
+          when ${executionDisplayStatus} is not null then ${executionDisplayStatus}::text
+          else 'pending'
+        end
+      `;
       return {
         previewRows: await tx
           .select({
@@ -287,21 +351,28 @@ export async function listWorkflowRunJobSummaries(
             key: ranked.key,
             name: ranked.name,
             status: ranked.status,
+            mode: ranked.mode,
+            listenerStatus: ranked.listenerStatus,
+            executionStatus: ranked.executionStatus,
             position: ranked.position,
           })
           .from(ranked)
-          .where(lte(ranked.rank, WORKFLOW_RUN_JOB_PREVIEW_LIMIT))
+          .where(lte(ranked.jobRank, WORKFLOW_RUN_JOB_PREVIEW_LIMIT))
           .orderBy(asc(ranked.workflowRunId), asc(ranked.position), asc(ranked.id)),
         countRows: await tx
+          .with(selectedExecution)
           .select({
             workflowRunId: workflowRunAttempts.workflowRunId,
-            status: jobs.status,
+            rawStatus: jobs.status,
+            status: displayStatus,
             count: count(),
+            hasStartedJobExecution,
           })
           .from(jobs)
           .innerJoin(workflowRunAttempts, eq(jobs.workflowRunAttemptId, workflowRunAttempts.id))
+          .leftJoin(selectedExecution, eq(selectedExecution.jobId, jobs.id))
           .where(attemptFilter)
-          .groupBy(workflowRunAttempts.workflowRunId, jobs.status),
+          .groupBy(workflowRunAttempts.workflowRunId, jobs.status, displayStatus),
       };
     },
     {isolationLevel: 'repeatable read', accessMode: 'read only'},
@@ -310,8 +381,18 @@ export async function listWorkflowRunJobSummaries(
   for (const {workflowRunId, ...summary} of previewRows) {
     summaryFor(summaries, workflowRunId).preview.push(summary);
   }
-  for (const {workflowRunId, status, count: statusCount} of countRows) {
-    summaryFor(summaries, workflowRunId).statusCounts.push({status, count: statusCount});
+  for (const {
+    workflowRunId,
+    rawStatus,
+    status,
+    count: statusCount,
+    hasStartedJobExecution,
+  } of countRows) {
+    const summary = summaryFor(summaries, workflowRunId);
+    appendStatusCount(summary.rawStatusCounts, rawStatus, statusCount);
+    appendStatusCount(summary.statusCounts, status, statusCount);
+    // One row per (run, verdict, display status), so the run's answer is the OR of its groups.
+    summary.hasStartedJobExecution ||= hasStartedJobExecution;
   }
 
   return summaries;
@@ -323,11 +404,29 @@ function summaryFor(
 ): WorkflowRunJobsSummary {
   const existing = summaries.get(workflowRunId);
   if (existing) return existing;
-  const created: WorkflowRunJobsSummary = {preview: [], statusCounts: []};
+  const created: WorkflowRunJobsSummary = {
+    preview: [],
+    statusCounts: [],
+    rawStatusCounts: [],
+    hasStartedJobExecution: false,
+  };
   summaries.set(workflowRunId, created);
   return created;
 }
 
+function appendStatusCount<T extends string>(
+  counts: Array<{status: T; count: number}>,
+  status: T,
+  count: number,
+): void {
+  const existing = counts.find((entry) => entry.status === status);
+  if (existing) {
+    existing.count += count;
+  } else {
+    counts.push({status, count});
+  }
+}
+
 export async function listWorkflowRunsByProject(projectId: string): Promise<WorkflowRun[]> {
   const result = await listWorkflowRuns({projectId, limit: 100});
   return result.runs;
@@ -531,6 +630,8 @@ function hydrateWorkflowRunDetail(
     runAttempt: toWorkflowRunAttempt(attempt),
     latestAttempt,
     jobs: [],
+    // Read off the same rows the executions come from, so the flag cannot contradict them.
+    hasStartedJobExecution: rows.some((row) => row.jobExecution?.startedAt != null),
   };
   const jobById = new Map<string, WorkflowJobDetail>();
   const jobExecutionById = new Map<string, JobExecutionDetail>();

package/src/db/workflow-runs.ts

@@ -47,6 +47,7 @@ export type {
   WorkflowRunAggregates,
   WorkflowRunCursor,
   WorkflowRunFilters,
+  WorkflowRunJobRawStatusCount,
   WorkflowRunJobStatusCount,
   WorkflowRunJobSummary,
   WorkflowRunJobSummaryTarget,

package/src/presentation/dto/workflow-run.ts

@@ -33,7 +33,12 @@ export function toRunDto(run: WorkflowRun, latestAttempt = run.currentAttempt):
   };
 }
 
-const EMPTY_JOBS: WorkflowRunJobsSummary = {preview: [], statusCounts: []};
+const EMPTY_JOBS: WorkflowRunJobsSummary = {
+  preview: [],
+  statusCounts: [],
+  rawStatusCounts: [],
+  hasStartedJobExecution: false,
+};
 
 export function toRunListItemDto(
   run: WorkflowRun,
@@ -46,9 +51,14 @@ export function toRunListItemDto(
       key: job.key,
       name: job.name,
       status: job.status,
+      mode: job.mode,
+      listener_status: job.listenerStatus,
+      execution_status: job.executionStatus,
       position: job.position,
     })),
-    job_status_counts: jobs.statusCounts.map(({status, count}) => ({status, count})),
+    job_status_counts: jobs.rawStatusCounts.map(({status, count}) => ({status, count})),
+    job_display_status_counts: jobs.statusCounts.map(({status, count}) => ({status, count})),
+    has_started_job_execution: jobs.hasStartedJobExecution,
   };
 }
 

package/src/presentation/routes/get-run.test.ts

@@ -21,6 +21,7 @@ import {
   getJobExecutionsByJobId,
   getJobsByWorkflowRunId,
   getStepsByJobId,
+  recordJobExecutionStartedAt,
   updateWorkflowRunStatus,
 } from '#db/workflow-runs.js';
 import {workflowModel} from '#test/index.js';
@@ -137,6 +138,36 @@ describe('GET /api/workflows/runs/:id', () => {
     expect(body.jobs[0]).not.toHaveProperty('finished_at');
   });
 
+  // The run list decides this from the same executions, so a run detail that answered it from
+  // its own payload could drift from the row the user clicked through.
+  test('reports whether any job execution of the attempt reached its runner', async () => {
+    const run = await createWorkflowRun({
+      workspaceId,
+      projectId: crypto.randomUUID(),
+      definitionId: crypto.randomUUID(),
+      model: workflowModel({name: 'Test', jobs: {build: {steps: [{run: 'npm build'}]}}}),
+      triggerPayload: {
+        source: 'manual',
+        event: 'fire',
+        subscriptionId: crypto.randomUUID(),
+        userId: crypto.randomUUID(),
+      },
+    });
+
+    const before = await app.inject({method: 'GET', url: `/api/workflows/runs/${run.id}`});
+    expect(before.json().has_started_job_execution).toBe(false);
+
+    const [job] = await getJobsByWorkflowRunId(run.id);
+    const [execution] = await getJobExecutionsByJobId(job?.id ?? '');
+    await recordJobExecutionStartedAt({
+      jobExecutionId: execution?.id ?? '',
+      startedAt: new Date('2026-05-07T01:00:05.000Z'),
+    });
+
+    const after = await app.inject({method: 'GET', url: `/api/workflows/runs/${run.id}`});
+    expect(after.json().has_started_job_execution).toBe(true);
+  });
+
   test('does not aggregate latest_attempt for a first attempt without lineage', async () => {
     const latestAttemptSpy = vi.spyOn(dbIndex, 'getLatestAttempt');
     const run = await createWorkflowRun({

package/src/presentation/routes/get-run.ts

@@ -63,6 +63,7 @@ export function getRunRoute(projects: ProjectsModuleClient) {
         ...toRunDto(run, run.latestAttempt),
         run_attempt: toRunAttemptDto(run.runAttempt),
         jobs: jobDtos,
+        has_started_job_execution: run.hasStartedJobExecution,
       };
     },
   });

package/src/presentation/routes/list-runs.test.ts

@@ -99,7 +99,11 @@ describe('GET /api/workflows/runs', () => {
     expect(body.runs[0].workflow_name).toBeDefined();
     expect(body.runs[0].trigger_source).toBe('manual');
     // The runs list carries run-level timing (null until the run starts).
-    expect(body.runs[0]).toMatchObject({started_at: null, finished_at: null});
+    expect(body.runs[0]).toMatchObject({
+      started_at: null,
+      finished_at: null,
+      has_started_job_execution: false,
+    });
     expect(body.next_cursor).toBeNull();
     expect(body.filtered_total_count).toBe(2);
   });