@shipfox/api-workflows 12.6.0 → 13.0.0

package/src/db/workflow-runs/run-status.test.ts

@@ -4,6 +4,7 @@ import {nextStepForJob} from '#core/job-execution.js';
 import {
   buildModel,
   createTestRun,
+  jobExecutionTerminatedEvents,
   jobTerminatedEvents,
   runCancelledEvents,
   runTerminatedEvents,
@@ -16,6 +17,7 @@ import {
   cancelWorkflowRun,
   createRerunWorkflowRun,
   createWorkflowRun,
+  getFirstJobExecutionByJobId,
   getJobsByWorkflowRunId,
   getStepsByJobId,
   getWorkflowRunById,
@@ -257,6 +259,8 @@ describe('workflow run queries', () => {
       const [runningJobExecution, succeededJob, skippedJob] = await getJobsByWorkflowRunId(run.id);
       if (!runningJobExecution || !succeededJob || !skippedJob) throw new Error('Expected jobs');
       await updateJobStatus({jobId: runningJobExecution.id, status: 'running', expectedVersion: 1});
+      const execution = await getFirstJobExecutionByJobId(runningJobExecution.id);
+      if (!execution) throw new Error('Expected running job execution');
       await nextStepForJob(runningJobExecution.id);
       await updateJobStatus({jobId: succeededJob.id, status: 'succeeded', expectedVersion: 1});
       await updateJobStatus({
@@ -299,6 +303,15 @@ describe('workflow run queries', () => {
           statusReason: 'run_cancelled',
         }),
       ]);
+      expect(await jobExecutionTerminatedEvents(execution.id)).toEqual([
+        expect.objectContaining({
+          jobId: runningJobExecution.id,
+          jobExecutionId: execution.id,
+          workflowRunId: run.id,
+          status: 'cancelled',
+          statusReason: 'run_cancelled',
+        }),
+      ]);
       expect(await stepAttemptTerminatedEvents(runningJobExecution.id)).toHaveLength(1);
       expect(await jobTerminatedEvents(succeededJob.id)).toHaveLength(1);
       expect(await jobTerminatedEvents(skippedJob.id)).toHaveLength(1);

package/src/db/workflow-runs/run-status.ts

@@ -19,6 +19,7 @@ import {steps} from '../schema/steps.js';
 import {workflowRunAttempts} from '../schema/workflow-run-attempts.js';
 import {toWorkflowRun, workflowRuns} from '../schema/workflow-runs.js';
 import {updateJobStatusAtVersion} from './jobs.js';
+import {writeJobExecutionTerminatedOutbox} from './outbox.js';
 import {
   lockWorkflowRun,
   TERMINAL_EXECUTION_STATUSES,
@@ -114,8 +115,21 @@ async function terminateRunAttempt(
           notInArray(jobExecutions.status, TERMINAL_EXECUTION_STATUSES),
         ),
       )
-      .returning({id: jobExecutions.id});
+      .returning({
+        id: jobExecutions.id,
+        jobId: jobExecutions.jobId,
+        status: jobExecutions.status,
+        statusReason: jobExecutions.statusReason,
+        statusReasonMessage: jobExecutions.statusReasonMessage,
+      });
     for (const jobExecution of terminatedExecutions) {
+      await writeJobExecutionTerminatedOutbox(tx, {
+        jobId: jobExecution.jobId,
+        jobExecutionId: jobExecution.id,
+        status: jobExecution.status,
+        statusReason: jobExecution.statusReason,
+        statusReasonMessage: jobExecution.statusReasonMessage,
+      });
       await bulkUpdateStepStatuses(
         {jobExecutionId: jobExecution.id, status: spec.terminalStatus},
         tx,

package/src/db/workflow-runs.ts

@@ -9,7 +9,7 @@ export {
   getJobExecutionsByJobId,
   getJobExecutionsByWorkflowRunAttemptId,
   getLatestJobExecutionByJobId,
-  recordJobExecutionQueuedAt,
+  queueJobExecution,
   recordJobExecutionStartedAt,
   resolveJobExecutionAfterLeaseExpiry,
   updateJobExecutionStatus,
@@ -35,6 +35,8 @@ export {
   updateJobStatusAtVersion,
 } from './workflow-runs/jobs.js';
 export {
+  writeJobExecutionQueuedOutbox,
+  writeJobExecutionTerminatedOutbox,
   writeJobStepsSettledOutbox,
   writeStepAttemptTerminatedOutbox,
   writeStepRestartEnqueuedOutbox,

package/src/index.ts

@@ -9,7 +9,6 @@ import type {ProjectsModuleClient} from '@shipfox/api-projects-dto/inter-module'
 import {
   RUNNER_JOB_CLAIMED,
   RUNNER_JOB_LEASE_EXPIRED,
-  RUNNER_JOB_QUEUED,
   type RunnersEventMap,
 } from '@shipfox/api-runners-dto';
 import type {RunnersInterModuleClient} from '@shipfox/api-runners-dto/inter-module';
@@ -35,7 +34,6 @@ import {
   onJobTerminatedFailureAnnotation,
   onRunnerJobClaimed,
   onRunnerJobLeaseExpired,
-  onRunnerJobQueued,
   onStepAttemptTerminatedFailureAnnotation,
   onWorkflowRunAttemptCreated,
   onWorkflowRunCancelled,
@@ -128,15 +126,13 @@ export function createWorkflowsModule({
       ),
       subscriber(WORKFLOWS_JOB_TERMINATED, onJobTerminatedFailureAnnotation(annotations)),
       subscriber(RUNNER_JOB_LEASE_EXPIRED, onRunnerJobLeaseExpired),
-      subscriber(RUNNER_JOB_QUEUED, onRunnerJobQueued),
       subscriber(RUNNER_JOB_CLAIMED, onRunnerJobClaimed),
     ],
     workers: [
       {
         taskQueue: WORKFLOWS_TASK_QUEUE,
         workflowsPath,
-        activities: () =>
-          createOrchestrationActivities({agent, integrations, projects, runners, secrets}),
+        activities: () => createOrchestrationActivities({agent, integrations, projects, secrets}),
         workflows: [],
       },
     ],

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: [], rawStatusCounts: []};
+const EMPTY_JOBS: WorkflowRunJobsSummary = {
+  preview: [],
+  statusCounts: [],
+  rawStatusCounts: [],
+  hasStartedJobExecution: false,
+};
 
 export function toRunListItemDto(
   run: WorkflowRun,
@@ -53,6 +58,7 @@ export function toRunListItemDto(
     })),
     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/index.ts

@@ -5,7 +5,6 @@ export {
   onJobTerminatedFailureAnnotation,
   onRunnerJobClaimed,
   onRunnerJobLeaseExpired,
-  onRunnerJobQueued,
   onStepAttemptTerminatedFailureAnnotation,
   onWorkflowRunAttemptCreated,
   onWorkflowRunCancelled,

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);
   });

package/src/presentation/subscribers/index.ts

@@ -6,6 +6,5 @@ export {onJobEventDelivered} from './on-job-event-delivered.js';
 export {onJobStepsSettled} from './on-job-steps-settled.js';
 export {onRunnerJobClaimed} from './on-runner-job-claimed.js';
 export {onRunnerJobLeaseExpired} from './on-runner-job-lease-expired.js';
-export {onRunnerJobQueued} from './on-runner-job-queued.js';
 export {onWorkflowRunAttemptCreated} from './on-workflow-run-attempt-created.js';
 export {onWorkflowRunCancelled} from './on-workflow-run-cancelled.js';

package/src/temporal/activities/index.ts

@@ -1,20 +1,17 @@
 import type {AgentInterModuleClient} from '@shipfox/api-agent-dto/inter-module';
 import type {IntegrationsModuleClient} from '@shipfox/api-integration-core-dto/inter-module';
 import type {ProjectsModuleClient} from '@shipfox/api-projects-dto/inter-module';
-import type {RunnersInterModuleClient} from '@shipfox/api-runners-dto/inter-module';
 import type {SecretsInterModuleClient} from '@shipfox/api-secrets-dto/inter-module';
 import {
   activateJobListenerActivity,
   bulkSetStepStatuses,
-  createCancelRunnerJobsActivity,
   createDrainListenerEventsActivity,
-  createEnqueueJobExecutionForRunner,
-  createReleaseLeaseActivity,
   evaluateJobActivationsActivity,
   failJobExecutionAsTimedOutActivity,
   failRunAsTimedOutActivity,
   loadRunAttemptDag,
   peekListenerBufferActivity,
+  queueJobExecutionActivity,
   recordListenerFiringOutcomeActivity,
   resolveJobListenerActivity,
   resolveJobStatusFromJobExecutionsActivity,
@@ -29,7 +26,6 @@ export function createOrchestrationActivities(params: {
   agent: AgentInterModuleClient;
   integrations: IntegrationsModuleClient;
   projects: ProjectsModuleClient;
-  runners: RunnersInterModuleClient;
   secrets: Pick<SecretsInterModuleClient, 'getVariablesByNamespace'>;
 }) {
   return {
@@ -39,8 +35,7 @@ export function createOrchestrationActivities(params: {
     setJobExecutionStatus: async (activityParams: Parameters<typeof setJobExecutionStatus>[0]) =>
       await setJobExecutionStatus(activityParams, params.secrets),
     bulkSetStepStatuses,
-    cancelRunnerJobsActivity: createCancelRunnerJobsActivity(params.runners),
-    enqueueJobExecutionForRunner: createEnqueueJobExecutionForRunner(params.runners),
+    queueJobExecutionActivity,
     evaluateJobActivationsActivity,
     failJobExecutionAsTimedOutActivity: async (
       activityParams: Parameters<typeof failJobExecutionAsTimedOutActivity>[0],
@@ -61,6 +56,5 @@ export function createOrchestrationActivities(params: {
       activityParams: Parameters<typeof resolveLeaseExpiredJobExecutionActivity>[0],
     ) => await resolveLeaseExpiredJobExecutionActivity(activityParams, params.secrets),
     resolveJobStatusFromJobExecutionsActivity,
-    releaseLeaseActivity: createReleaseLeaseActivity(params.runners),
   };
 }

package/src/temporal/activities/orchestration-activities.test.ts

@@ -8,7 +8,11 @@ import {
 import {createTestSecretsClient} from '#test/fixtures/secrets-inter-module.js';
 import {stripSetupStep} from '#test/fixtures/strip-setup-step.js';
 import {workflowModel} from '#test/index.js';
-import {resolveLeaseExpiredJobExecutionActivity, setJobStatus} from './orchestration-activities.js';
+import {
+  queueJobExecutionActivity,
+  resolveLeaseExpiredJobExecutionActivity,
+  setJobStatus,
+} from './orchestration-activities.js';
 
 let workspaceId: string;
 let projectId: string;
@@ -74,6 +78,18 @@ describe('resolveLeaseExpiredJobExecutionActivity', () => {
   });
 });
 
+describe('queueJobExecutionActivity', () => {
+  test('a missing execution fails non-retryably', async () => {
+    const error = await queueJobExecutionActivity({
+      jobId: crypto.randomUUID(),
+      jobExecutionId: crypto.randomUUID(),
+    }).catch((err: unknown) => err);
+
+    expect(error).toBeInstanceOf(ApplicationFailure);
+    expect((error as ApplicationFailure).nonRetryable).toBe(true);
+  });
+});
+
 describe('setJobStatus', () => {
   test('default-gate skipped jobs record an evaluation trace', async () => {
     const run = await createWorkflowRun({

package/src/temporal/activities/orchestration-activities.ts

@@ -1,12 +1,7 @@
 import type {AgentInterModuleClient} from '@shipfox/api-agent-dto/inter-module';
 import type {IntegrationsModuleClient} from '@shipfox/api-integration-core-dto/inter-module';
 import type {ProjectsModuleClient} from '@shipfox/api-projects-dto/inter-module';
-import {
-  type RunnersInterModuleClient,
-  runnersInterModuleContract,
-} from '@shipfox/api-runners-dto/inter-module';
 import type {SecretsInterModuleClient} from '@shipfox/api-secrets-dto/inter-module';
-import {isInterModuleKnownError} from '@shipfox/inter-module';
 import {ApplicationFailure} from '@temporalio/common';
 import {defaultJobConditionTrace} from '#core/condition-trace.js';
 import type {JobStatus, JobStatusReason, ResolutionReason} from '#core/entities/job.js';
@@ -31,6 +26,7 @@ import {
   getWorkflowRunByAttemptId,
   type JobActivationDecision,
   peekListenerBuffer,
+  queueJobExecution,
   resolveJobExecutionAfterLeaseExpiry,
   resolveJobListener,
   resolveJobStatusFromJobExecutions,
@@ -209,48 +205,19 @@ export async function resolveLeaseExpiredJobExecutionActivity(
   }
 }
 
-// Best-effort lease cleanup on job finalization. Idempotent: deleting an
-// already-released (or already-reaped) lease is a no-op. The workflow wraps the
-// call so a persistent failure never blocks the DAG result.
-export function createReleaseLeaseActivity(runners: RunnersInterModuleClient) {
-  return async function releaseLeaseActivity(params: {jobExecutionId: string}): Promise<void> {
-    await runners.releaseJobExecution({jobExecutionId: params.jobExecutionId});
-  };
-}
-
-export function createEnqueueJobExecutionForRunner(runners: RunnersInterModuleClient) {
-  return async function enqueueJobExecutionForRunner(params: {
-    workspaceId: string;
-    workflowRunId: string;
-    jobId: string;
-    jobExecutionId: string;
-    runAttemptId: string;
-    projectId: string;
-    requiredLabels: string[];
-  }): Promise<void> {
-    try {
-      await runners.enqueueJobExecution({
-        workspaceId: params.workspaceId,
-        workflowRunId: params.workflowRunId,
-        workflowRunAttemptId: params.runAttemptId,
-        jobId: params.jobId,
-        jobExecutionId: params.jobExecutionId,
-        projectId: params.projectId,
-        requiredLabels: params.requiredLabels,
-      });
-    } catch (err) {
-      if (isInterModuleKnownError(runnersInterModuleContract.methods.enqueueJobExecution, err)) {
-        throw ApplicationFailure.nonRetryable(err.message, err.name);
-      }
-      throw err;
+export async function queueJobExecutionActivity(params: {
+  jobId: string;
+  jobExecutionId: string;
+}): Promise<{newVersion: number; status: Exclude<JobStatus, 'skipped'>}> {
+  try {
+    const execution = await queueJobExecution({jobExecutionId: params.jobExecutionId});
+    return {newVersion: execution.version, status: execution.status};
+  } catch (err) {
+    if (err instanceof JobNotFoundError) {
+      throw ApplicationFailure.nonRetryable(err.message, err.name);
     }
-  };
-}
-
-export function createCancelRunnerJobsActivity(runners: RunnersInterModuleClient) {
-  return async function cancelRunnerJobsActivity(params: {jobIds: string[]}): Promise<void> {
-    await runners.cancelJobs(params);
-  };
+    throw err;
+  }
 }
 
 export async function failJobExecutionAsTimedOutActivity(

package/src/temporal/workflows/job-execution-orchestration.test.ts

@@ -107,7 +107,7 @@ async function expectEmptyRequiredLabelsFailure(input: typeof defaultJobInput):
 }
 
 describe('jobExecutionOrchestration', () => {
-  test('runner claim flips status to running, then finished releases the lease', async () => {
+  test('runner claim flips status to running, then the terminal fact finishes the execution', async () => {
     setCfg({
       dag: makeDag([dagJob('job-1', 'build')]),
       jobResults: new Map([['job-1', 'succeeded']]),
@@ -117,7 +117,6 @@ describe('jobExecutionOrchestration', () => {
 
     expect(result.status).toBe('succeeded');
     expect(finalStatusesFor('job-1')).toEqual(['running', 'succeeded']);
-    expect(callsNamed('releaseLeaseActivity')).toHaveLength(1);
     expect(callsNamed('resolveLeaseExpiredJobExecutionActivity')).toHaveLength(0);
     expect(callsNamed('bulkSetStepStatuses')).toHaveLength(0);
   });
@@ -238,7 +237,7 @@ describe('jobExecutionOrchestration', () => {
     });
 
     expect(setExecutionStatusCalls()).toHaveLength(0);
-    expect(callsNamed('enqueueJobExecutionForRunner')).toHaveLength(0);
+    expect(callsNamed('queueJobExecutionActivity')).toHaveLength(0);
   });
 
   test('whitespace-only required labels fail before the job is marked running', async () => {
@@ -254,7 +253,7 @@ describe('jobExecutionOrchestration', () => {
     });
 
     expect(setExecutionStatusCalls()).toHaveLength(0);
-    expect(callsNamed('enqueueJobExecutionForRunner')).toHaveLength(0);
+    expect(callsNamed('queueJobExecutionActivity')).toHaveLength(0);
   });
 
   test('finished signal (failed) flips status without sweeping steps', async () => {
@@ -265,7 +264,6 @@ describe('jobExecutionOrchestration', () => {
     expect(result.status).toBe('failed');
     expect(finalStatusesFor('job-2')).toEqual(['running', 'failed']);
     expect(terminalSetJobCall('job-2')?.params.statusReason).toBe('step_failed');
-    expect(callsNamed('releaseLeaseActivity')).toHaveLength(1);
     expect(callsNamed('bulkSetStepStatuses')).toHaveLength(0);
   });
 
@@ -289,10 +287,9 @@ describe('jobExecutionOrchestration', () => {
         statusReason: 'step_failed',
       },
     });
-    expect(callsNamed('releaseLeaseActivity')).toHaveLength(1);
   });
 
-  test('lease-expired signal resolves via the activity and releases the lease', async () => {
+  test('lease-expired signal resolves via the activity', async () => {
     setCfg({
       dag: makeDag([]),
       jobResults: new Map(),
@@ -304,7 +301,6 @@ describe('jobExecutionOrchestration', () => {
 
     expect(result.status).toBe('failed');
     expect(callsNamed('resolveLeaseExpiredJobExecutionActivity')).toHaveLength(1);
-    expect(callsNamed('releaseLeaseActivity')).toHaveLength(1);
     expect(callsNamed('failJobExecutionAsTimedOutActivity')).toHaveLength(0);
   });
 
@@ -400,24 +396,10 @@ describe('jobExecutionOrchestration', () => {
     const result = await executeJob({...defaultJobInput, jobId: 'job-cancelled'});
 
     expect(result).toMatchObject({status: 'cancelled'});
-    expect(callsNamed('enqueueJobExecutionForRunner')).toHaveLength(1);
-    expect(callsNamed('releaseLeaseActivity')).toHaveLength(0);
+    expect(callsNamed('queueJobExecutionActivity')).toHaveLength(1);
   });
 
-  test('releaseLease failure does not block the result (best-effort)', async () => {
-    setCfg({
-      dag: makeDag([]),
-      jobResults: new Map([['job-rl', 'succeeded']]),
-      releaseLeaseError: 'runners db down',
-    });
-
-    const result = await executeJob({...defaultJobInput, jobId: 'job-rl'});
-
-    expect(result.status).toBe('succeeded');
-    expect(callsNamed('releaseLeaseActivity').length).toBeGreaterThanOrEqual(1);
-  });
-
-  test('times out after the execution deadline and fails its steps without releasing the lease', async () => {
+  test('times out after the execution deadline and fails its steps', async () => {
     setCfg({
       dag: makeDag([dagJob('job-timeout', 'build')]),
       jobResults: new Map(),
@@ -437,7 +419,6 @@ describe('jobExecutionOrchestration', () => {
       name: 'bulkSetStepStatuses',
       params: {jobExecutionId: 'job-timeout', status: 'failed'},
     });
-    expect(callsNamed('releaseLeaseActivity')).toHaveLength(0);
     expect(callsNamed('resolveLeaseExpiredJobExecutionActivity')).toHaveLength(0);
   });
 

package/src/temporal/workflows/job-execution-orchestration.ts

@@ -26,14 +26,14 @@ import {remainingMs} from './deadline.js';
  * execution pending while it is queued, then performs the versioned pending → running
  * transition after the current claim. One deadline spans both waits; claim never resets
  * it. Signals can arrive in any order, so the precedence is finished > lease expired >
- * claimed > timeout. Lease cleanup remains best-effort: a runners DB outage must never
- * block the child workflow from returning the job outcome to run-orchestration.
+ * claimed > timeout. Workflows commits queue and terminal facts with its state transitions;
+ * runners reconciles its local queue, lease, and reservation projections asynchronously.
  */
 
 const {
   setJobStatus,
   setJobExecutionStatus,
-  enqueueJobExecutionForRunner,
+  queueJobExecutionActivity,
   bulkSetStepStatuses,
   failJobExecutionAsTimedOutActivity,
   resolveLeaseExpiredJobExecutionActivity,
@@ -48,14 +48,6 @@ const {resolveJobStatusFromJobExecutionsActivity} = proxyActivities<
   retry: {maximumAttempts: 5},
 });
 
-// Lease cleanup gets a bounded retry policy of its own: after a few attempts the
-// workflow stops waiting on it (see releaseLeaseBestEffort) rather than blocking
-// the DAG on runners-side availability.
-const {releaseLeaseActivity} = proxyActivities<ReturnType<typeof createOrchestrationActivities>>({
-  startToCloseTimeout: '30s',
-  retry: {maximumAttempts: 5},
-});
-
 const DEFAULT_EXECUTION_MAX_DURATION_MS = 6 * 60 * 60 * 1000;
 
 export const jobFinishedSignal =
@@ -71,12 +63,9 @@ export interface JobClaimedSignalPayload {
 export const jobClaimedSignal = defineSignal<[JobClaimedSignalPayload]>(JOB_CLAIMED_SIGNAL);
 
 export interface JobExecutionOrchestrationInput {
-  workspaceId: string;
-  workflowRunId: string;
   runAttemptId: string;
   jobId: string;
   jobExecutionId: string;
-  projectId: string;
   jobVersion: number;
   executionVersion: number;
   executionTimeoutMs?: number | null | undefined;
@@ -89,17 +78,6 @@ export interface JobExecutionOrchestrationResult {
   jobVersion: number;
 }
 
-async function releaseLeaseBestEffort(jobExecutionId: string): Promise<void> {
-  try {
-    await releaseLeaseActivity({jobExecutionId});
-  } catch (err) {
-    log.warn('lease release failed; stuck detector will reap the row', {
-      jobExecutionId,
-      error: String(err),
-    });
-  }
-}
-
 async function resolveJobStatusOrFailClosed(
   input: JobExecutionOrchestrationInput,
 ): Promise<{status: RuntimeCompletionStatus; jobVersion: number}> {
@@ -121,7 +99,7 @@ async function resolveJobStatusOrFailClosed(
   }
 }
 
-async function enqueueJobExecution(input: JobExecutionOrchestrationInput): Promise<void> {
+async function queueJobExecution(input: JobExecutionOrchestrationInput) {
   if (hasNoRequiredRunnerLabels(input.requiredLabels)) {
     throw ApplicationFailure.nonRetryable(
       `Job ${input.jobId} has no required runner labels`,
@@ -129,15 +107,12 @@ async function enqueueJobExecution(input: JobExecutionOrchestrationInput): Promi
     );
   }
 
-  await enqueueJobExecutionForRunner({
-    workspaceId: input.workspaceId,
-    workflowRunId: input.workflowRunId,
-    runAttemptId: input.runAttemptId,
-    jobId: input.jobId,
-    jobExecutionId: input.jobExecutionId,
-    projectId: input.projectId,
-    requiredLabels: input.requiredLabels,
-  });
+  return jobExecutionStartOutcome(
+    await queueJobExecutionActivity({
+      jobId: input.jobId,
+      jobExecutionId: input.jobExecutionId,
+    }),
+  );
 }
 
 async function markJobExecutionRunning(
@@ -218,7 +193,6 @@ async function resolveFinishedJobExecution({
       terminationReason: 'finished',
       status,
     });
-    await releaseLeaseBestEffort(input.jobExecutionId);
     return {status, jobVersion: input.jobVersion};
   }
   const resolved = await resolveJobStatusOrFailClosed(input);
@@ -228,7 +202,6 @@ async function resolveFinishedJobExecution({
     terminationReason: 'finished',
     status: resolved.status,
   });
-  await releaseLeaseBestEffort(input.jobExecutionId);
   return resolved;
 }
 
@@ -257,7 +230,6 @@ async function resolveLeaseExpiredJobExecution({
       terminationReason: 'lease_expired',
       status: leaseExpired.status,
     });
-    await releaseLeaseBestEffort(input.jobExecutionId);
     return {status: leaseExpired.status, jobVersion: input.jobVersion};
   }
   const {status, jobVersion} = await resolveJobStatusOrFailClosed(input);
@@ -267,13 +239,12 @@ async function resolveLeaseExpiredJobExecution({
     terminationReason: 'lease_expired',
     status,
   });
-  await releaseLeaseBestEffort(input.jobExecutionId);
   return {status, jobVersion};
 }
 
-// Timeout backstop. The activity atomically fails the execution, marks
-// `timed_out_at`, and enqueues WORKFLOWS_JOB_EXECUTION_TIMED_OUT; the runners subscriber
-// then asks the runner to cancel. The lease is intentionally NOT released here.
+// Timeout backstop. The activity atomically fails the execution, marks `timed_out_at`, and
+// enqueues the generic terminal execution fact. The runners subscriber then asks the runner to
+// cancel. The lease is intentionally NOT released here.
 async function resolveTimedOutJobExecution({
   input,
   runningVersion,
@@ -314,7 +285,10 @@ export async function jobExecutionOrchestration(
   // Register every signal before enqueue can block or publish a claim/outcome event. The
   // handlers retain signals that arrive while the enqueue activity is in flight.
   registerJobExecutionSignalHandlers(input.jobExecutionId, signals);
-  await enqueueJobExecution(input);
+  const queued = await queueJobExecution(input);
+  if (queued.kind === 'terminal') {
+    return {status: queued.result.status, jobVersion: input.jobVersion};
+  }
 
   const timeoutMs = input.executionTimeoutMs ?? DEFAULT_EXECUTION_MAX_DURATION_MS;
   const deadline = Date.now() + timeoutMs;

package/src/temporal/workflows/job-listener-orchestration-continuation.test.ts

@@ -63,9 +63,6 @@ describe('listener continue-as-new guard', () => {
 
   it('carries listener loop state into the continued run', () => {
     const input: JobListenerOrchestrationInput = {
-      workspaceId: 'workspace-1',
-      workflowRunId: 'run-1',
-      projectId: 'project-1',
       runAttemptId: 'attempt-1',
       jobId: 'job-1',
       jobVersion: 3,