@shipfox/api-workflows 9.2.0 → 10.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-workflows",
   "license": "MIT",
-  "version": "9.2.0",
+  "version": "10.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -22,28 +22,29 @@
     "@temporalio/workflow": "1.18.1",
     "drizzle-orm": "^0.45.2",
     "zod": "^4.4.3",
-    "@shipfox/api-auth-context": "9.2.0",
-    "@shipfox/api-auth-dto": "9.2.0",
-    "@shipfox/api-agent-dto": "9.0.2",
-    "@shipfox/annotations-dto": "9.0.2",
-    "@shipfox/api-definitions-dto": "9.0.2",
-    "@shipfox/api-projects-dto": "9.2.0",
+    "@shipfox/api-definitions-dto": "10.0.0",
+    "@shipfox/api-auth-context": "10.0.0",
     "@shipfox/api-integration-core-dto": "9.0.2",
-    "@shipfox/api-runners-dto": "9.0.2",
+    "@shipfox/api-projects-dto": "10.0.0",
+    "@shipfox/api-runners-dto": "10.0.0",
     "@shipfox/api-secrets-dto": "9.0.2",
-    "@shipfox/api-workflows-dto": "9.0.2",
+    "@shipfox/api-workflows-dto": "10.0.0",
+    "@shipfox/api-workspaces-dto": "10.0.0",
     "@shipfox/inter-module": "0.2.2",
-    "@shipfox/expression": "1.1.5",
-    "@shipfox/node-drizzle": "0.3.4",
+    "@shipfox/expression": "1.2.0",
     "@shipfox/node-error-monitoring": "0.3.0",
-    "@shipfox/node-fastify": "0.3.3",
-    "@shipfox/node-module": "1.0.2",
-    "@shipfox/node-opentelemetry": "0.6.2",
+    "@shipfox/node-fastify": "0.4.0",
+    "@shipfox/node-module": "1.0.4",
+    "@shipfox/node-opentelemetry": "0.6.3",
     "@shipfox/node-outbox": "0.2.6",
     "@shipfox/node-postgres": "0.4.4",
-    "@shipfox/node-temporal": "0.4.3",
+    "@shipfox/node-temporal": "0.4.4",
     "@shipfox/runner-labels": "0.1.3",
-    "@shipfox/workflow-document": "2.1.3"
+    "@shipfox/workflow-document": "2.1.3",
+    "@shipfox/api-auth-dto": "10.0.0",
+    "@shipfox/api-agent-dto": "10.0.0",
+    "@shipfox/annotations-dto": "9.0.2",
+    "@shipfox/node-drizzle": "0.3.4"
   },
   "imports": {
     "#*": "./dist/*"

package/src/core/errors.ts

@@ -17,6 +17,27 @@ export class ProjectMismatchError extends Error {
   }
 }
 
+export class WorkspaceSuspendedError extends Error {
+  constructor(readonly workspaceId: string) {
+    super(`Workspace is suspended: ${workspaceId}`);
+    this.name = 'WorkspaceSuspendedError';
+  }
+}
+
+export class WorkspaceDeletedError extends Error {
+  constructor(readonly workspaceId: string) {
+    super(`Workspace is deleted: ${workspaceId}`);
+    this.name = 'WorkspaceDeletedError';
+  }
+}
+
+export class WorkspaceNotFoundError extends Error {
+  constructor(readonly workspaceId: string) {
+    super(`Workspace not found: ${workspaceId}`);
+    this.name = 'WorkspaceNotFoundError';
+  }
+}
+
 export class AgentConfigUnresolvableError extends Error {
   constructor(
     readonly definitionId: string,

package/src/core/workspace-admission.test.ts

@@ -0,0 +1,64 @@
+import {workspacesInterModuleContract} from '@shipfox/api-workspaces-dto/inter-module';
+import {createInterModuleKnownError} from '@shipfox/inter-module';
+import {WorkspaceDeletedError, WorkspaceNotFoundError, WorkspaceSuspendedError} from './errors.js';
+import {assertWorkspaceAdmitsNewJobs} from './workspace-admission.js';
+
+const workspaceId = '00000000-0000-4000-8000-000000000001';
+
+describe('assertWorkspaceAdmitsNewJobs', () => {
+  test('allows active workspaces', async () => {
+    const getWorkspaceOperatingState = vi.fn().mockResolvedValue({status: 'active'});
+
+    await assertWorkspaceAdmitsNewJobs({getWorkspaceOperatingState}, workspaceId);
+
+    expect(getWorkspaceOperatingState).toHaveBeenCalledWith({workspaceId});
+  });
+
+  test.each([
+    ['suspended', WorkspaceSuspendedError],
+    ['deleted', WorkspaceDeletedError],
+  ] as const)('rejects %s workspaces', async (status, errorType) => {
+    const getWorkspaceOperatingState = vi.fn().mockResolvedValue({status});
+
+    await expect(
+      assertWorkspaceAdmitsNewJobs({getWorkspaceOperatingState}, workspaceId),
+    ).rejects.toBeInstanceOf(errorType);
+  });
+
+  test('translates a missing workspace from the Workspaces contract', async () => {
+    const error = createInterModuleKnownError(
+      workspacesInterModuleContract.methods.getWorkspaceOperatingState,
+      'workspace-not-found',
+      {workspaceId},
+    );
+    const getWorkspaceOperatingState = vi.fn().mockRejectedValue(error);
+
+    const caught = await assertWorkspaceAdmitsNewJobs(
+      {getWorkspaceOperatingState},
+      workspaceId,
+    ).catch((error: unknown) => error);
+
+    expect(caught).toBeInstanceOf(WorkspaceNotFoundError);
+    expect(caught).toMatchObject({
+      workspaceId,
+      name: 'WorkspaceNotFoundError',
+    });
+  });
+
+  test('rethrows transient Workspaces failures', async () => {
+    const error = new Error('workspace service unavailable');
+    const getWorkspaceOperatingState = vi.fn().mockRejectedValue(error);
+
+    await expect(
+      assertWorkspaceAdmitsNewJobs({getWorkspaceOperatingState}, workspaceId),
+    ).rejects.toBe(error);
+  });
+
+  test('fails closed for an unknown workspace status', async () => {
+    const getWorkspaceOperatingState = vi.fn().mockResolvedValue({status: 'unknown'});
+
+    await expect(
+      assertWorkspaceAdmitsNewJobs({getWorkspaceOperatingState}, workspaceId),
+    ).rejects.toThrow('Unhandled workspace status');
+  });
+});

package/src/core/workspace-admission.ts

@@ -0,0 +1,43 @@
+import {
+  type WorkspacesInterModuleClient,
+  workspacesInterModuleContract,
+} from '@shipfox/api-workspaces-dto/inter-module';
+import {isInterModuleKnownError} from '@shipfox/inter-module';
+import {WorkspaceDeletedError, WorkspaceNotFoundError, WorkspaceSuspendedError} from './errors.js';
+
+export async function assertWorkspaceAdmitsNewJobs(
+  workspaces: Pick<WorkspacesInterModuleClient, 'getWorkspaceOperatingState'>,
+  workspaceId: string,
+): Promise<void> {
+  let state: Awaited<ReturnType<WorkspacesInterModuleClient['getWorkspaceOperatingState']>>;
+  try {
+    state = await workspaces.getWorkspaceOperatingState({workspaceId});
+  } catch (error) {
+    if (
+      isInterModuleKnownError(
+        workspacesInterModuleContract.methods.getWorkspaceOperatingState,
+        error,
+      ) &&
+      error.code === 'workspace-not-found'
+    ) {
+      throw new WorkspaceNotFoundError(error.details.workspaceId);
+    }
+    throw error;
+  }
+
+  const {status} = state;
+  switch (status) {
+    case 'active':
+      return;
+    case 'suspended':
+      throw new WorkspaceSuspendedError(workspaceId);
+    case 'deleted':
+      throw new WorkspaceDeletedError(workspaceId);
+    default:
+      return assertNever(status);
+  }
+}
+
+function assertNever(value: never): never {
+  throw new Error(`Unhandled workspace status: ${JSON.stringify(value)}`);
+}

package/src/index.ts

@@ -22,6 +22,7 @@ import {
   type WorkflowsEventMapDto,
   workflowsEventSchemas,
 } from '@shipfox/api-workflows-dto';
+import type {WorkspacesInterModuleClient} from '@shipfox/api-workspaces-dto/inter-module';
 import {type ShipfoxModule, subscriberFactory} from '@shipfox/node-module';
 import {db, migrationsPath, workflowsOutbox} from '#db/index.js';
 import {registerWorkflowsServiceMetrics} from '#metrics/index.js';
@@ -83,6 +84,7 @@ export function createWorkflowsModule({
   projects,
   runners,
   secrets,
+  workspaces,
 }: {
   agent: AgentInterModuleClient;
   definitions: DefinitionsInterModuleClient;
@@ -92,6 +94,7 @@ export function createWorkflowsModule({
   projects: ProjectsModuleClient;
   runners: RunnersInterModuleClient;
   secrets: SecretsInterModuleClient;
+  workspaces: WorkspacesInterModuleClient;
 }): ShipfoxModule {
   return {
     name: 'workflows',
@@ -104,6 +107,7 @@ export function createWorkflowsModule({
       projects,
       runners,
       secrets,
+      workspaces,
     }),
     metrics: registerWorkflowsServiceMetrics,
     publishers: [
@@ -135,6 +139,7 @@ export function createWorkflowsModule({
         projects,
         runners,
         secrets,
+        workspaces,
       }),
     ],
   };

package/src/presentation/dto/step.test.ts

@@ -49,6 +49,26 @@ describe('fromStepErrorDto', () => {
     });
   });
 
+  it('round-trips an agent harness availability failure without inventing an issue code', () => {
+    const persisted = fromStepErrorDto({
+      message: 'Pi extension setup failed: Unknown option: --mcp-config',
+      reason: 'agent_harness_unavailable',
+    });
+
+    expect(persisted).toEqual({
+      message: 'Pi extension setup failed: Unknown option: --mcp-config',
+      reason: 'agent_harness_unavailable',
+    });
+
+    const dto = toStepDto(step({type: 'agent', error: persisted}));
+
+    expect(dto.error).toEqual({
+      message: 'Pi extension setup failed: Unknown option: --mcp-config',
+      reason: 'agent_harness_unavailable',
+      category: 'user',
+    });
+  });
+
   it('persists config error field and source diagnostics', () => {
     const persisted = fromStepErrorDto({
       message: 'Could not resolve env.VERSION',

package/src/presentation/inter-module.test.ts

@@ -1,5 +1,6 @@
 import {workflowsInterModuleContract} from '@shipfox/api-workflows-dto/inter-module';
-import {isInterModuleKnownError} from '@shipfox/inter-module';
+import {workspacesInterModuleContract} from '@shipfox/api-workspaces-dto/inter-module';
+import {createInterModuleKnownError, isInterModuleKnownError} from '@shipfox/inter-module';
 import {InvalidJobRunnerLabelsError} from '#core/errors.js';
 import {
   AgentConfigUnresolvableError,
@@ -11,12 +12,16 @@ import {
 import {createWorkflowsInterModulePresentation, toStartRunKnownError} from './inter-module.js';
 
 const mocks = vi.hoisted(() => ({
+  deliverEventToListener: vi.fn(),
   getJobScope: vi.fn(),
   getStepById: vi.fn(),
   getStepByIdForJobExecution: vi.fn(),
 }));
 
 vi.mock('#db/index.js', () => mocks);
+vi.mock('#db/job-listener-events.js', () => ({
+  deliverEventToListener: mocks.deliverEventToListener,
+}));
 
 const input = {
   workspaceId: '00000000-0000-4000-8000-000000000001',
@@ -37,6 +42,8 @@ describe('Workflows inter-module presentation', () => {
     mocks.getJobScope.mockReset();
     mocks.getStepById.mockReset();
     mocks.getStepByIdForJobExecution.mockReset();
+    mocks.deliverEventToListener.mockReset();
+    mocks.deliverEventToListener.mockResolvedValue({buffered: true, skipped: false});
   });
 
   it('returns only the resolved harness for Logs', async () => {
@@ -48,6 +55,7 @@ describe('Workflows inter-module presentation', () => {
       projects: {} as never,
       runners: {} as never,
       secrets: {} as never,
+      workspaces: {getWorkspaceOperatingState: vi.fn()} as never,
     });
 
     const result = await presentation.handlers.getStepLogContext(
@@ -103,6 +111,7 @@ describe('Workflows inter-module presentation', () => {
       projects: {} as never,
       runners: runners as never,
       secrets: {} as never,
+      workspaces: {getWorkspaceOperatingState: vi.fn()} as never,
     });
 
     const result = await presentation.handlers.getLeasedAgentToolContext(input, {
@@ -146,4 +155,192 @@ describe('Workflows inter-module presentation', () => {
         result.code,
     ).toBe(code);
   });
+
+  test('maps a missing workspace from the Workspace contract for start-run', async () => {
+    const getWorkspaceOperatingState = vi
+      .fn()
+      .mockRejectedValue(
+        createInterModuleKnownError(
+          workspacesInterModuleContract.methods.getWorkspaceOperatingState,
+          'workspace-not-found',
+          {workspaceId: input.workspaceId},
+        ),
+      );
+    const presentation = createWorkflowsInterModulePresentation({
+      agent: {} as never,
+      definitions: {} as never,
+      integrations: {} as never,
+      projects: {} as never,
+      runners: {} as never,
+      secrets: {} as never,
+      workspaces: {getWorkspaceOperatingState} as never,
+    });
+
+    const error = await Promise.resolve(
+      presentation.handlers.startRunFromTrigger(input, {
+        signal: new AbortController().signal,
+      }),
+    ).catch((caught: unknown) => caught);
+
+    expect(
+      isInterModuleKnownError(workflowsInterModuleContract.methods.startRunFromTrigger, error) &&
+        error.code,
+    ).toBe('workspace-not-found');
+  });
+
+  test.each([
+    ['suspended', 'workspace-suspended'],
+    ['deleted', 'workspace-deleted'],
+  ] as const)('rejects new workflow runs for %s workspaces before loading the definition', async (status, code) => {
+    const getWorkspaceOperatingState = vi.fn().mockResolvedValue({status});
+    const presentation = createWorkflowsInterModulePresentation({
+      agent: {} as never,
+      definitions: {} as never,
+      integrations: {} as never,
+      projects: {} as never,
+      runners: {} as never,
+      secrets: {} as never,
+      workspaces: {getWorkspaceOperatingState} as never,
+    });
+
+    const error = await Promise.resolve(
+      presentation.handlers.startRunFromTrigger(input, {
+        signal: new AbortController().signal,
+      }),
+    ).catch((caught: unknown) => caught);
+
+    expect(getWorkspaceOperatingState).toHaveBeenCalledWith({workspaceId: input.workspaceId});
+    expect(
+      isInterModuleKnownError(workflowsInterModuleContract.methods.startRunFromTrigger, error) &&
+        error.code,
+    ).toBe(code);
+  });
+
+  test('maps a missing workspace from the Workspace contract for listener delivery', async () => {
+    const jobId = '00000000-0000-4000-8000-000000000006';
+    const workspaceId = '00000000-0000-4000-8000-000000000007';
+    mocks.getJobScope.mockResolvedValue({workspaceId, projectId: input.projectId});
+    const getWorkspaceOperatingState = vi
+      .fn()
+      .mockRejectedValue(
+        createInterModuleKnownError(
+          workspacesInterModuleContract.methods.getWorkspaceOperatingState,
+          'workspace-not-found',
+          {workspaceId},
+        ),
+      );
+    const presentation = createWorkflowsInterModulePresentation({
+      agent: {} as never,
+      definitions: {} as never,
+      integrations: {} as never,
+      projects: {} as never,
+      runners: {} as never,
+      secrets: {} as never,
+      workspaces: {getWorkspaceOperatingState} as never,
+    });
+
+    const error = await Promise.resolve(
+      presentation.handlers.deliverEventToJobListener(
+        {
+          jobId,
+          disposition: 'fire',
+          eventRef: 'event-1',
+          deliveryId: 'delivery-1',
+          source: 'github',
+          event: 'push',
+          provider: 'github',
+          payload: {},
+          receivedAt: '2026-07-20T12:00:00.000Z',
+        },
+        {signal: new AbortController().signal},
+      ),
+    ).catch((caught: unknown) => caught);
+
+    expect(
+      isInterModuleKnownError(
+        workflowsInterModuleContract.methods.deliverEventToJobListener,
+        error,
+      ) && error.code,
+    ).toBe('workspace-not-found');
+  });
+
+  test.each([
+    ['suspended', 'workspace-suspended'],
+    ['deleted', 'workspace-deleted'],
+  ] as const)('rejects listener execution materialization for %s workspaces', async (status, code) => {
+    const jobId = '00000000-0000-4000-8000-000000000006';
+    const workspaceId = '00000000-0000-4000-8000-000000000007';
+    mocks.getJobScope.mockResolvedValue({workspaceId, projectId: input.projectId});
+    const getWorkspaceOperatingState = vi.fn().mockResolvedValue({status});
+    const presentation = createWorkflowsInterModulePresentation({
+      agent: {} as never,
+      definitions: {} as never,
+      integrations: {} as never,
+      projects: {} as never,
+      runners: {} as never,
+      secrets: {} as never,
+      workspaces: {getWorkspaceOperatingState} as never,
+    });
+
+    const error = await Promise.resolve(
+      presentation.handlers.deliverEventToJobListener(
+        {
+          jobId,
+          disposition: 'fire',
+          eventRef: 'event-1',
+          deliveryId: 'delivery-1',
+          source: 'github',
+          event: 'push',
+          provider: 'github',
+          payload: {},
+          receivedAt: '2026-07-20T12:00:00.000Z',
+        },
+        {signal: new AbortController().signal},
+      ),
+    ).catch((caught: unknown) => caught);
+
+    expect(getWorkspaceOperatingState).toHaveBeenCalledWith({workspaceId});
+    expect(mocks.deliverEventToListener).not.toHaveBeenCalled();
+    expect(
+      isInterModuleKnownError(
+        workflowsInterModuleContract.methods.deliverEventToJobListener,
+        error,
+      ) && error.code,
+    ).toBe(code);
+  });
+
+  test('allows resolve deliveries for suspended workspaces', async () => {
+    const jobId = '00000000-0000-4000-8000-000000000006';
+    mocks.getJobScope.mockResolvedValue({workspaceId: input.workspaceId});
+    const getWorkspaceOperatingState = vi.fn().mockResolvedValue({status: 'suspended'});
+    const presentation = createWorkflowsInterModulePresentation({
+      agent: {} as never,
+      definitions: {} as never,
+      integrations: {} as never,
+      projects: {} as never,
+      runners: {} as never,
+      secrets: {} as never,
+      workspaces: {getWorkspaceOperatingState} as never,
+    });
+
+    await expect(
+      presentation.handlers.deliverEventToJobListener(
+        {
+          jobId,
+          disposition: 'resolve',
+          eventRef: 'event-1',
+          deliveryId: 'delivery-1',
+          source: 'github',
+          event: 'push',
+          provider: 'github',
+          payload: {},
+          receivedAt: '2026-07-20T12:00:00.000Z',
+        },
+        {signal: new AbortController().signal},
+      ),
+    ).resolves.toEqual({buffered: true, skipped: false});
+    expect(mocks.getJobScope).not.toHaveBeenCalled();
+    expect(getWorkspaceOperatingState).not.toHaveBeenCalled();
+    expect(mocks.deliverEventToListener).toHaveBeenCalled();
+  });
 });

package/src/presentation/inter-module.ts

@@ -6,13 +6,20 @@ 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 {workflowsInterModuleContract} from '@shipfox/api-workflows-dto/inter-module';
+import type {WorkspacesInterModuleClient} from '@shipfox/api-workspaces-dto/inter-module';
 import {
   createInterModuleKnownError,
   defineInterModulePresentation,
+  type InterModuleKnownErrorFor,
   type InterModulePresentation,
 } from '@shipfox/inter-module';
 import {DEFAULT_HARNESS, harnessSchema} from '@shipfox/workflow-document';
-import {InvalidJobRunnerLabelsError} from '#core/errors.js';
+import {
+  InvalidJobRunnerLabelsError,
+  WorkspaceDeletedError,
+  WorkspaceNotFoundError,
+  WorkspaceSuspendedError,
+} from '#core/errors.js';
 import {
   AgentConfigUnresolvableError,
   AgentIntegrationMaterializationError,
@@ -21,12 +28,18 @@ import {
   ProjectMismatchError,
   runWorkflow,
 } from '#core/index.js';
+import {assertWorkspaceAdmitsNewJobs} from '#core/workspace-admission.js';
 import {getJobScope, getStepById, getStepByIdForJobExecution} from '#db/index.js';
 import {deliverEventToListener} from '#db/job-listener-events.js';
 
+type WorkspaceAdmissionKnownError = InterModuleKnownErrorFor<
+  typeof workflowsInterModuleContract.methods.deliverEventToJobListener
+>;
+
 export function createWorkflowsInterModulePresentation(params: {
   agent: AgentInterModuleClient;
   definitions: DefinitionsInterModuleClient;
+  workspaces: WorkspacesInterModuleClient;
   secrets: Pick<SecretsInterModuleClient, 'getVariablesByNamespace'>;
   runners: RunnersInterModuleClient;
   integrations: IntegrationsModuleClient;
@@ -35,6 +48,7 @@ export function createWorkflowsInterModulePresentation(params: {
   return defineInterModulePresentation(workflowsInterModuleContract, {
     startRunFromTrigger: async (input) => {
       try {
+        await assertWorkspaceAdmitsNewJobs(params.workspaces, input.workspaceId);
         const run = await runWorkflow(
           params.definitions,
           {
@@ -55,8 +69,20 @@ export function createWorkflowsInterModulePresentation(params: {
         throw toStartRunKnownError(error, input.definitionId);
       }
     },
-    deliverEventToJobListener: async (input) =>
-      await deliverEventToListener({...input, receivedAt: new Date(input.receivedAt)}),
+    deliverEventToJobListener: async (input) => {
+      const method = workflowsInterModuleContract.methods.deliverEventToJobListener;
+      try {
+        if (input.disposition === 'fire') {
+          const scope = await getJobScope(input.jobId);
+          if (scope) await assertWorkspaceAdmitsNewJobs(params.workspaces, scope.workspaceId);
+        }
+        return await deliverEventToListener({...input, receivedAt: new Date(input.receivedAt)});
+      } catch (error) {
+        const workspaceError = toWorkspaceAdmissionKnownError(method, error);
+        if (workspaceError !== undefined) throw workspaceError;
+        throw error;
+      }
+    },
     getStepLogContext: async ({stepId}) => {
       const step = await getStepById(stepId);
       const parsed = harnessSchema.safeParse(step?.config.harness);
@@ -98,6 +124,8 @@ export function createWorkflowsInterModulePresentation(params: {
 
 export function toStartRunKnownError(error: unknown, definitionId: string): unknown {
   const method = workflowsInterModuleContract.methods.startRunFromTrigger;
+  const workspaceError = toWorkspaceAdmissionKnownError(method, error);
+  if (workspaceError !== undefined) return workspaceError;
   if (error instanceof DefinitionNotFoundError) {
     return createInterModuleKnownError(method, 'definition-not-found', {definitionId});
   }
@@ -127,3 +155,27 @@ export function toStartRunKnownError(error: unknown, definitionId: string): unkn
   }
   return error;
 }
+
+function toWorkspaceAdmissionKnownError(
+  method:
+    | typeof workflowsInterModuleContract.methods.startRunFromTrigger
+    | typeof workflowsInterModuleContract.methods.deliverEventToJobListener,
+  error: unknown,
+): WorkspaceAdmissionKnownError | undefined {
+  if (error instanceof WorkspaceSuspendedError) {
+    return createInterModuleKnownError(method, 'workspace-suspended', {
+      workspaceId: error.workspaceId,
+    });
+  }
+  if (error instanceof WorkspaceDeletedError) {
+    return createInterModuleKnownError(method, 'workspace-deleted', {
+      workspaceId: error.workspaceId,
+    });
+  }
+  if (error instanceof WorkspaceNotFoundError) {
+    return createInterModuleKnownError(method, 'workspace-not-found', {
+      workspaceId: error.workspaceId,
+    });
+  }
+  return undefined;
+}

package/src/presentation/routes/index.test.ts

@@ -43,6 +43,7 @@ describe('workflow route auth', () => {
     projects: projectsTestClient,
     runners: runnersTestClient,
     secrets: createTestSecretsClient(),
+    workspaces: {getWorkspaceOperatingState: vi.fn()} as never,
   });
   test('uses user auth', () => {
     expect(workflowRoutes[0]?.auth).toBe(AUTH_USER);

package/src/presentation/routes/index.ts

@@ -6,6 +6,7 @@ import type {IntegrationsModuleClient} from '@shipfox/api-integration-core-dto/i
 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 type {WorkspacesInterModuleClient} from '@shipfox/api-workspaces-dto/inter-module';
 import type {RouteGroup} from '@shipfox/node-fastify';
 import {createAgentRuntimeConfigRoute} from './agent-runtime-config.js';
 import {cancelRunRoute} from './cancel-run.js';
@@ -27,9 +28,12 @@ type WorkflowRouteClients = {
   projects: ProjectsModuleClient;
   runners: RunnersInterModuleClient;
   secrets: SecretsInterModuleClient;
+  workspaces: WorkspacesInterModuleClient;
 };
 
-export function createLeaseTokenRouteGroup(params: WorkflowRouteClients): RouteGroup {
+type LeaseTokenRouteClients = Omit<WorkflowRouteClients, 'workspaces'>;
+
+export function createLeaseTokenRouteGroup(params: LeaseTokenRouteClients): RouteGroup {
   return {
     // The lease token names the job, so the path carries no job id ("current").
     prefix: '/runs/jobs/current',
@@ -59,7 +63,7 @@ export function createWorkflowRoutes(params: WorkflowRouteClients): RouteGroup[]
         listRunAttemptsRoute(params.projects),
         getRunRoute(params.projects),
         cancelRunRoute(params.projects),
-        rerunRunRoute(params.projects),
+        rerunRunRoute(params.projects, params.workspaces),
       ],
     },
     createLeaseTokenRouteGroup(params),