@shipfox/api-workflows 12.7.0 → 13.1.0

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

@@ -10,6 +10,7 @@ import {
 } from '../schema/job-executions.js';
 import {type JobCreateDb, type JobDb, jobs} from '../schema/jobs.js';
 import {type StepCreateDb, steps} from '../schema/steps.js';
+import {writeJobExecutionTerminatedOutbox} from './outbox.js';
 
 type MaterializedRunGraphJobExecution = Omit<JobExecutionCreateDb, 'finishedAt' | 'jobId'> & {
   readonly finishedAt?: JobExecutionCreateDb['finishedAt'] | SQL | undefined;
@@ -59,6 +60,22 @@ export async function persistMaterializedRunGraph(
       ? []
       : await tx.insert(jobExecutions).values(jobExecutionValues).returning();
 
+  for (const jobExecution of jobExecutionRows) {
+    if (
+      jobExecution.status === 'succeeded' ||
+      jobExecution.status === 'failed' ||
+      jobExecution.status === 'cancelled'
+    ) {
+      await writeJobExecutionTerminatedOutbox(tx, {
+        jobId: jobExecution.jobId,
+        jobExecutionId: jobExecution.id,
+        status: jobExecution.status,
+        statusReason: jobExecution.statusReason,
+        statusReasonMessage: jobExecution.statusReasonMessage,
+      });
+    }
+  }
+
   const jobById = new Map(jobRows.map((job) => [job.id, job]));
   const materializedJobByJobId = new Map(
     jobRows.flatMap((jobRow, index) => {

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/step.test.ts

@@ -43,12 +43,16 @@ describe('fromStepErrorDto', () => {
   it('persists the machine-readable agent config issue in camelCase', () => {
     const persisted = fromStepErrorDto({
       message: 'Missing credentials',
+      code: 'workspace-providers-disabled',
+      managed_provider_id: 'shipfox',
       reason: 'agent_config_invalid',
       agent_config_issue: 'provider_not_configured',
     });
 
     expect(persisted).toEqual({
       message: 'Missing credentials',
+      code: 'workspace-providers-disabled',
+      managedProviderId: 'shipfox',
       reason: 'agent_config_invalid',
       agentConfigIssue: 'provider_not_configured',
     });
@@ -180,6 +184,8 @@ describe('toStepDto error category', () => {
         type: 'agent',
         error: {
           message: 'Unknown provider "foo" for agent step.',
+          code: 'workspace-providers-disabled',
+          managedProviderId: 'shipfox',
           reason: 'agent_config_invalid',
           agentConfigIssue: 'provider_unsupported',
         },
@@ -188,6 +194,8 @@ describe('toStepDto error category', () => {
 
     expect(dto.error).toEqual({
       message: 'Unknown provider "foo" for agent step.',
+      code: 'workspace-providers-disabled',
+      managed_provider_id: 'shipfox',
       reason: 'agent_config_invalid',
       agent_config_issue: 'provider_unsupported',
       category: 'user',

package/src/presentation/dto/step.ts

@@ -22,6 +22,9 @@ function toStepErrorDto(
 ): StepErrorDto {
   if (error === null) return null;
   const message = typeof error.message === 'string' ? error.message : '';
+  const code = typeof error.code === 'string' ? error.code : undefined;
+  const managedProviderId =
+    typeof error.managedProviderId === 'string' ? error.managedProviderId : undefined;
   const exitCode = error.exitCode;
   const signal = typeof error.signal === 'string' ? error.signal : undefined;
   const field = typeof error.field === 'string' ? error.field : undefined;
@@ -30,6 +33,8 @@ function toStepErrorDto(
   const agentConfigIssue = agentConfigIssueSchema.safeParse(error.agentConfigIssue);
   return {
     message,
+    ...(code === undefined ? {} : {code}),
+    ...(managedProviderId === undefined ? {} : {managed_provider_id: managedProviderId}),
     ...(exitCode === null || typeof exitCode === 'number' ? {exit_code: exitCode} : {}),
     ...(signal === undefined ? {} : {signal}),
     ...(reason.success ? {reason: reason.data} : {}),
@@ -48,6 +53,10 @@ export function fromStepErrorDto(error: StepErrorDto | undefined): Record<string
   if (!error) return null;
   return {
     message: error.message,
+    ...(error.code === undefined ? {} : {code: error.code}),
+    ...(error.managed_provider_id === undefined
+      ? {}
+      : {managedProviderId: error.managed_provider_id}),
     ...(error.exit_code === null || typeof error.exit_code === 'number'
       ? {exitCode: error.exit_code}
       : {}),

package/src/presentation/index.ts

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

package/src/presentation/routes/agent-runtime-config.test.ts

@@ -8,10 +8,15 @@ import {closeApp, createApp, type FastifyInstance} from '@shipfox/node-fastify';
 import {createCapturingLogger} from '@shipfox/node-log/test';
 import {eq} from 'drizzle-orm';
 import type {StepStatus} from '#core/entities/step.js';
-import {db} from '#db/db.js';
+import {db, withTransaction} from '#db/db.js';
 import {jobs} from '#db/schema/jobs.js';
 import {steps as stepsTable} from '#db/schema/steps.js';
-import {createWorkflowRun, getJobsByWorkflowRunId, getStepsByJobId} from '#db/workflow-runs.js';
+import {
+  createWorkflowRun,
+  getJobsByWorkflowRunId,
+  getStepsByJobId,
+  insertRunningStepAttempt,
+} from '#db/workflow-runs.js';
 import {workflowModel} from '#test/factories/workflow-model.js';
 import {insertRunningJobLease, mintActiveLeaseToken} from '#test/fixtures/active-lease-token.js';
 import {resolveTestAgentDefaults} from '#test/fixtures/agent-inter-module.js';
@@ -115,6 +120,13 @@ describe('GET /runs/jobs/current/agent-runtime-config', () => {
       thinking: 'xhigh',
       credentials: {api_key: 'sk-workspace-secret'},
     });
+    expect(resolveRuntimeCredentials).toHaveBeenCalledWith(
+      expect.objectContaining({
+        workspaceId: run.workspaceId,
+        runId: run.id,
+        stepAttemptId: expect.any(String),
+      }),
+    );
   });
 
   test('derives the credential workspace from the leased job instead of hostile lease claims', async () => {
@@ -288,6 +300,63 @@ describe('GET /runs/jobs/current/agent-runtime-config', () => {
     expect(res.json().code).toBe('model-provider-not-configured');
   });
 
+  test('returns managed provider policy details when workspace providers are disabled', async () => {
+    const {job, step} = await createRunningAgentStep();
+    resolveRuntimeCredentials.mockRejectedValueOnce(
+      createInterModuleKnownError(
+        agentInterModuleContract.methods.resolveRuntimeCredentials,
+        'workspace-providers-disabled',
+        {
+          message: 'This instance only supports provider `shipfox`.',
+          managed_provider_id: 'shipfox',
+        },
+      ),
+    );
+    const token = await mintActiveLeaseToken({jobId: job.id});
+
+    const res = await app.inject({
+      method: 'GET',
+      url: runtimeConfigUrl(step.id, step.currentAttempt),
+      headers: {authorization: `Bearer ${token}`},
+    });
+
+    expect(res.statusCode).toBe(422);
+    expect(res.json()).toMatchObject({
+      code: 'workspace-providers-disabled',
+      details: {
+        message: 'This instance only supports provider `shipfox`.',
+        managed_provider_id: 'shipfox',
+      },
+    });
+  });
+
+  test('includes a fallback message when managed provider details omit one', async () => {
+    const {job, step} = await createRunningAgentStep();
+    resolveRuntimeCredentials.mockRejectedValueOnce(
+      createInterModuleKnownError(
+        agentInterModuleContract.methods.resolveRuntimeCredentials,
+        'workspace-providers-disabled',
+        {managed_provider_id: 'shipfox'},
+      ),
+    );
+    const token = await mintActiveLeaseToken({jobId: job.id});
+
+    const res = await app.inject({
+      method: 'GET',
+      url: runtimeConfigUrl(step.id, step.currentAttempt),
+      headers: {authorization: `Bearer ${token}`},
+    });
+
+    expect(res.statusCode).toBe(422);
+    expect(res.json()).toMatchObject({
+      code: 'workspace-providers-disabled',
+      details: {
+        message: 'Workspace provider configuration is disabled',
+        managed_provider_id: 'shipfox',
+      },
+    });
+  });
+
   test('returns 409 and reports when workspace credentials cannot be decrypted', async () => {
     const {job, step} = await createRunningAgentStep();
     resolveRuntimeCredentials.mockRejectedValueOnce(
@@ -420,6 +489,19 @@ async function createStep(params: {
   const step = stepRows.find((candidate) => candidate.type === params.targetType);
   if (!step) throw new Error(`createStep: ${params.targetType} step not found`);
   await db().update(stepsTable).set({status: params.status}).where(eq(stepsTable.id, step.id));
+  if (params.status === 'running') {
+    await withTransaction((tx) =>
+      insertRunningStepAttempt(
+        {
+          jobExecutionId: step.jobExecutionId,
+          stepId: step.id,
+          attempt: step.currentAttempt,
+          config: step.config,
+        },
+        tx,
+      ),
+    );
+  }
 
   return {
     run,

package/src/presentation/routes/agent-runtime-config.ts

@@ -13,6 +13,7 @@ import {isInterModuleKnownError} from '@shipfox/inter-module';
 import {captureException} from '@shipfox/node-error-monitoring';
 import {ClientError, defineRoute} from '@shipfox/node-fastify';
 import {ZodError} from 'zod';
+import {getStepAttemptDetail} from '#db/index.js';
 import {loadRunningLeasedStep} from './leased-step.js';
 
 export function createAgentRuntimeConfigRoute(params: {
@@ -63,6 +64,22 @@ export function createAgentRuntimeConfigRoute(params: {
           },
         );
       }
+      if (
+        isInterModuleKnownError(
+          agentInterModuleContract.methods.resolveRuntimeCredentials,
+          error,
+        ) &&
+        error.code === 'workspace-providers-disabled'
+      ) {
+        const message = error.details.message ?? 'Workspace provider configuration is disabled';
+        throw new ClientError(message, 'workspace-providers-disabled', {
+          status: 422,
+          details: {
+            managed_provider_id: error.details.managed_provider_id,
+            message,
+          },
+        });
+      }
       throw error;
     },
     handler: async (request, reply) => {
@@ -91,8 +108,15 @@ export function createAgentRuntimeConfigRoute(params: {
         throw error;
       }
 
+      const stepAttempt = await getStepAttemptDetail({stepId, attempt});
+      if (!stepAttempt) {
+        throw new ClientError('Step attempt not found', 'step-attempt-not-found', {status: 409});
+      }
+
       const runtimeConfig = await params.agent.resolveRuntimeCredentials({
         workspaceId,
+        runId: stepAttempt.workflowRunId,
+        stepAttemptId: stepAttempt.attempt.id,
         harness: agentConfig.harness,
         provider: agentConfig.provider,
         model: agentConfig.model,

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