@shipfox/api-workflows 12.7.0 → 13.0.0

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,

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

@@ -197,7 +197,7 @@ describe('jobListenerOrchestration', () => {
 
       expect(listenerFiringOutcomeCalls()).toHaveLength(0);
       expect(resolveJobListenerCalls().map((c) => c.params.reason)).toEqual(['until']);
-      expect(callsNamed('enqueueJobExecutionForRunner')).toHaveLength(0);
+      expect(callsNamed('queueJobExecutionActivity')).toHaveLength(0);
     });
 
     test('resolves with timeout when the listening deadline elapses', async () => {
@@ -233,9 +233,10 @@ describe('jobListenerOrchestration', () => {
 
       await runListener({maxExecutions: 1});
 
-      expect(callsNamed('enqueueJobExecutionForRunner')).toHaveLength(1);
-      expect(callsNamed('enqueueJobExecutionForRunner')[0]?.params).toMatchObject({
-        requiredLabels: ['gpu', 'linux'],
+      expect(callsNamed('queueJobExecutionActivity')).toHaveLength(1);
+      expect(callsNamed('queueJobExecutionActivity')[0]?.params).toMatchObject({
+        jobId,
+        jobExecutionId: 'exec-1',
       });
       expect(listenerFiringOutcomeCalls().map((c) => c.params.outcome)).toEqual(['succeeded']);
     });
@@ -250,7 +251,7 @@ describe('jobListenerOrchestration', () => {
       await runListener({maxExecutions: 1});
 
       // The child actually ran (enqueued), then returned failed.
-      expect(callsNamed('enqueueJobExecutionForRunner')).toHaveLength(1);
+      expect(callsNamed('queueJobExecutionActivity')).toHaveLength(1);
       expect(listenerFiringOutcomeCalls().map((c) => c.params.outcome)).toEqual(['failed']);
       expect(resolveJobListenerCalls().map((c) => c.params.reason)).toEqual(['max_executions']);
     });
@@ -265,7 +266,7 @@ describe('jobListenerOrchestration', () => {
       await runListener({maxExecutions: 2});
 
       // Sequence 1 failed at materialization (no child enqueued); sequence 2 ran and succeeded.
-      expect(callsNamed('enqueueJobExecutionForRunner')).toHaveLength(1);
+      expect(callsNamed('queueJobExecutionActivity')).toHaveLength(1);
       expect(listenerFiringOutcomeCalls().map((c) => c.params.outcome)).toEqual([
         'failed',
         'succeeded',
@@ -369,15 +370,12 @@ describe('jobListenerOrchestration', () => {
       });
 
       const handle = await startListener({onResolve: 'cancel'});
-      await waitForActivity('enqueueJobExecutionForRunner');
+      await waitForActivity('queueJobExecutionActivity');
       await handle.signal(LISTENER_RESOLVE_SIGNAL);
       await handle.result();
 
       expect(settleListenerCalls().map((c) => c.params.status)).toEqual(['cancelled']);
       expect(listenerFiringOutcomeCalls().map((c) => c.params.outcome)).toEqual(['cancelled']);
-      expect(callsNamed('cancelRunnerJobsActivity')).toEqual([
-        {name: 'cancelRunnerJobsActivity', params: {jobIds: [jobId]}},
-      ]);
       expect(resolveJobListenerCalls().map((c) => c.params.reason)).toEqual(['until']);
     });
 
@@ -390,7 +388,7 @@ describe('jobListenerOrchestration', () => {
       });
 
       const handle = await startListener({onResolve: 'finish'});
-      await waitForActivity('enqueueJobExecutionForRunner');
+      await waitForActivity('queueJobExecutionActivity');
       // Resolution arrives mid-firing; finish mode must wait for the child, not cancel it.
       await handle.signal(LISTENER_RESOLVE_SIGNAL);
       const child = testEnv.client.workflow.getHandle(`job:${jobId}`);
@@ -398,7 +396,6 @@ describe('jobListenerOrchestration', () => {
       await handle.result();
 
       expect(settleListenerCalls()).toHaveLength(0);
-      expect(callsNamed('cancelRunnerJobsActivity')).toHaveLength(0);
       expect(listenerFiringOutcomeCalls().map((c) => c.params.outcome)).toEqual(['succeeded']);
       expect(resolveJobListenerCalls().map((c) => c.params.reason)).toEqual(['until']);
     });

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

@@ -25,7 +25,6 @@ const {
   resolveJobListenerActivity,
   settleListenerJobExecutionActivity,
   recordListenerFiringOutcomeActivity,
-  cancelRunnerJobsActivity,
 } = proxyActivities<ReturnType<typeof createOrchestrationActivities>>({
   startToCloseTimeout: '30s',
 });
@@ -34,9 +33,6 @@ export const listenerEventsAvailableSignal = defineSignal<[]>(LISTENER_EVENTS_AV
 export const listenerResolveSignal = defineSignal<[]>(LISTENER_RESOLVE_SIGNAL);
 
 export interface JobListenerOrchestrationInput {
-  workspaceId: string;
-  workflowRunId: string;
-  projectId: string;
   runAttemptId: string;
   jobId: string;
   jobVersion: number;
@@ -413,9 +409,6 @@ async function runListenerExecution(params: {
       workflowIdReusePolicy: 'ALLOW_DUPLICATE',
       args: [
         {
-          workspaceId: params.input.workspaceId,
-          workflowRunId: params.input.workflowRunId,
-          projectId: params.input.projectId,
           jobId: params.input.jobId,
           jobExecutionId: params.jobExecutionId,
           runAttemptId: params.input.runAttemptId,
@@ -447,7 +440,6 @@ async function runListenerExecution(params: {
         status: 'cancelled',
       });
       await recordListenerFiringOutcomeActivity({outcome: 'cancelled'});
-      await cancelRunnerJobsActivity({jobIds: [params.input.jobId]});
       return;
     }
   }