@shipfox/api-triggers 5.0.0 → 7.0.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-triggers",
   "license": "MIT",
-  "version": "5.0.0",
+  "version": "7.0.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -26,22 +26,22 @@
     "cron-parser": "^5.6.1",
     "drizzle-orm": "^0.45.2",
     "zod": "^4.4.3",
-    "@shipfox/api-auth-context": "5.0.0",
-    "@shipfox/api-definitions-dto": "5.0.0",
-    "@shipfox/api-integration-core-dto": "5.0.0",
-    "@shipfox/api-projects": "5.0.0",
+    "@shipfox/api-auth-context": "6.0.0",
+    "@shipfox/api-definitions-dto": "6.0.0",
+    "@shipfox/api-integration-core-dto": "6.0.0",
+    "@shipfox/api-projects": "6.0.0",
     "@shipfox/api-triggers-dto": "5.0.0",
-    "@shipfox/api-workflows": "5.0.0",
-    "@shipfox/api-workflows-dto": "5.0.0",
+    "@shipfox/api-workflows-dto": "6.0.0",
     "@shipfox/config": "1.2.2",
     "@shipfox/expression": "1.1.3",
-    "@shipfox/node-drizzle": "0.3.1",
-    "@shipfox/node-fastify": "0.2.3",
-    "@shipfox/node-module": "0.3.2",
+    "@shipfox/inter-module": "0.2.0",
+    "@shipfox/node-drizzle": "0.3.2",
+    "@shipfox/node-fastify": "0.2.4",
+    "@shipfox/node-module": "0.4.0",
     "@shipfox/node-opentelemetry": "0.5.2",
-    "@shipfox/node-outbox": "0.2.3",
+    "@shipfox/node-outbox": "0.2.4",
     "@shipfox/node-postgres": "0.4.2",
-    "@shipfox/node-temporal": "0.3.1",
+    "@shipfox/node-temporal": "0.3.2",
     "@shipfox/workflow-document": "2.1.1"
   },
   "devDependencies": {
@@ -56,6 +56,7 @@
     "fastify-type-provider-zod": "^6.0.0",
     "fishery": "^2.4.0",
     "@shipfox/biome": "1.8.2",
+    "@shipfox/depcruise": "1.0.2",
     "@shipfox/swc": "1.2.6",
     "@shipfox/ts-config": "1.3.8",
     "@shipfox/typescript": "1.1.7",
@@ -65,6 +66,7 @@
     "build": "shipfox-swc && shipfox-temporal-bundle dist/temporal/workflows/index.js",
     "check": "shipfox-biome-check",
     "check:fix": "shipfox-biome-check --write",
+    "depcruise": "shipfox-depcruise",
     "test": "shipfox-vitest-run",
     "test:watch": "shipfox-vitest-watch",
     "type": "shipfox-tsc-check",

package/src/core/dispatch-integration-event.history-failure.test.ts

@@ -4,12 +4,6 @@ const runWorkflow = vi.fn();
 const deliverEventToListener = vi.fn();
 const insertReceivedEvent = vi.fn();
 
-vi.mock('@shipfox/api-workflows', () => ({
-  runWorkflow: (...args: unknown[]) => runWorkflow(...args),
-  deliverEventToListener: (...args: unknown[]) => deliverEventToListener(...args),
-  isPermanentRunWorkflowError: () => false,
-}));
-
 vi.mock('#db/event-history.js', () => ({
   insertReceivedEvent: (...args: unknown[]) => insertReceivedEvent(...args),
   markReceivedEventDiscarded: vi.fn(),
@@ -27,6 +21,16 @@ vi.mock('#db/event-history.js', () => ({
 // Import after mocks so the code under test sees the spies.
 const {dispatchIntegrationEvent} = await import('./dispatch-integration-event.js');
 
+const workflows = {
+  startRunFromTrigger: (...args: unknown[]) => runWorkflow(...args),
+  deliverEventToJobListener: (...args: unknown[]) => deliverEventToListener(...args),
+  getStepLogContext: async () => ({harness: 'pi' as const}),
+  getLeasedAgentToolContext: async () => ({
+    workspaceId: crypto.randomUUID(),
+    integrations: [],
+  }),
+};
+
 describe('dispatchIntegrationEvent resilience to history-write failure', () => {
   beforeEach(() => {
     runWorkflow.mockReset();
@@ -48,6 +52,7 @@ describe('dispatchIntegrationEvent resilience to history-write failure', () => {
 
     await expect(
       dispatchIntegrationEvent({
+        workflows,
         eventRef: crypto.randomUUID(),
         workspaceId,
         provider: 'github',

package/src/core/dispatch-integration-event.test.ts

@@ -1,3 +1,5 @@
+import {workflowsInterModuleContract} from '@shipfox/api-workflows-dto/inter-module';
+import {createInterModuleKnownError} from '@shipfox/inter-module';
 import {eq} from 'drizzle-orm';
 import {db} from '#db/db.js';
 import {triggersDecisions} from '#db/schema/decisions.js';
@@ -7,37 +9,33 @@ import {jobListenerSubscriptionFactory, triggerSubscriptionFactory} from '#test/
 const runWorkflow = vi.fn();
 const deliverEventToListener = vi.fn();
 
-// Mock the package root but keep real-enough permanent-error classes + the classifier, so the
-// dispatcher's permanent/transient branching is exercised without loading the workflows module graph.
-vi.mock('@shipfox/api-workflows', () => {
-  class DefinitionNotFoundError extends Error {
-    constructor(definitionId: string) {
-      super(`Definition not found: ${definitionId}`);
-      this.name = 'DefinitionNotFoundError';
-    }
-  }
-  class ProjectMismatchError extends Error {
-    constructor(definitionProjectId: string, requestProjectId: string) {
-      super(
-        `Definition belongs to project ${definitionProjectId}, but request targets project ${requestProjectId}`,
-      );
-      this.name = 'ProjectMismatchError';
-    }
-  }
-  return {
-    runWorkflow: (...args: unknown[]) => runWorkflow(...args),
-    deliverEventToListener: (...args: unknown[]) => deliverEventToListener(...args),
-    DefinitionNotFoundError,
-    ProjectMismatchError,
-    isPermanentRunWorkflowError: (error: unknown) =>
-      error instanceof DefinitionNotFoundError || error instanceof ProjectMismatchError,
-  };
-});
+const {dispatchIntegrationEvent} = await import('./dispatch-integration-event.js');
 
-import {DefinitionNotFoundError, ProjectMismatchError} from '@shipfox/api-workflows';
+const workflows = {
+  startRunFromTrigger: (...args: unknown[]) => runWorkflow(...args),
+  deliverEventToJobListener: (...args: unknown[]) => deliverEventToListener(...args),
+  getStepLogContext: async () => ({harness: 'pi' as const}),
+  getLeasedAgentToolContext: async () => ({
+    workspaceId: crypto.randomUUID(),
+    integrations: [],
+  }),
+};
+
+function definitionNotFound(_definitionId: string) {
+  return createInterModuleKnownError(
+    workflowsInterModuleContract.methods.startRunFromTrigger,
+    'definition-not-found',
+    {definitionId: crypto.randomUUID()},
+  );
+}
 
-// Import after mocks so the core dispatcher sees the spy.
-const {dispatchIntegrationEvent} = await import('./dispatch-integration-event.js');
+function projectMismatch() {
+  return createInterModuleKnownError(
+    workflowsInterModuleContract.methods.startRunFromTrigger,
+    'project-mismatch',
+    {},
+  );
+}
 
 interface DispatchOverrides {
   eventRef?: string;
@@ -53,6 +51,7 @@ interface DispatchOverrides {
 
 function dispatch(overrides: DispatchOverrides = {}): Promise<void> {
   return dispatchIntegrationEvent({
+    workflows,
     eventRef: overrides.eventRef ?? crypto.randomUUID(),
     provider: overrides.provider ?? overrides.source ?? 'github',
     source: overrides.source ?? 'github',
@@ -317,7 +316,7 @@ describe('dispatchIntegrationEvent', () => {
     await dispatch({workspaceId, eventRef});
 
     expect(runWorkflow).toHaveBeenCalledWith(
-      expect.objectContaining({triggerIdempotencyKey: `${subscription.id}:${eventRef}`}),
+      expect.objectContaining({idempotencyKey: `${subscription.id}:${eventRef}`}),
     );
   });
 
@@ -335,6 +334,21 @@ describe('dispatchIntegrationEvent', () => {
     expect(runWorkflow).toHaveBeenCalledWith(expect.objectContaining({inputs: {env: 'staging'}}));
   });
 
+  test('omits inputs when the subscription has no configured inputs', async () => {
+    const workspaceId = crypto.randomUUID();
+    await triggerSubscriptionFactory.create({
+      workspaceId,
+      source: 'github',
+      event: 'push',
+      config: {},
+    });
+
+    await dispatch({workspaceId});
+
+    const [payload] = runWorkflow.mock.calls[0] as [Record<string, unknown>];
+    expect(payload).not.toHaveProperty('inputs');
+  });
+
   test('runs only subscriptions whose trigger filter matches the payload', async () => {
     const workspaceId = crypto.randomUUID();
     const matching = await triggerSubscriptionFactory.create({
@@ -789,7 +803,7 @@ describe('dispatchIntegrationEvent trigger history', () => {
     });
     const run = {id: crypto.randomUUID(), name: 'Build and test'};
     runWorkflow.mockImplementation(({projectId}: {projectId: string}) => {
-      if (projectId === poison.projectId) throw new DefinitionNotFoundError('def-gone');
+      if (projectId === poison.projectId) throw definitionNotFound('def-gone');
       return run;
     });
 
@@ -805,7 +819,7 @@ describe('dispatchIntegrationEvent trigger history', () => {
     const errored = decisions.find((d) => d.subscriptionId === poison.id);
     const triggered = decisions.find((d) => d.subscriptionId === healthy.id);
     expect(errored?.decision).toBe('dispatch-error');
-    expect(errored?.reason).toContain('Definition not found');
+    expect(errored?.reason).toContain('definition-not-found');
     expect(triggered?.decision).toBe('triggered');
     expect(triggered?.runId).toBe(run.id);
   });
@@ -826,7 +840,7 @@ describe('dispatchIntegrationEvent trigger history', () => {
       config: {},
     });
     runWorkflow.mockImplementation(() => {
-      throw new ProjectMismatchError('proj-a', 'proj-b');
+      throw projectMismatch();
     });
 
     await dispatch({workspaceId, eventRef});
@@ -858,7 +872,7 @@ describe('dispatchIntegrationEvent trigger history', () => {
       config: {},
     });
     runWorkflow.mockImplementation(({projectId}: {projectId: string}) => {
-      if (projectId === permanent.projectId) throw new DefinitionNotFoundError('def-gone');
+      if (projectId === permanent.projectId) throw definitionNotFound('def-gone');
       throw new Error('transient boom');
     });
 
@@ -900,7 +914,7 @@ describe('dispatchIntegrationEvent trigger history', () => {
     // A later permanent failure must not downgrade a run recorded during a prior
     // transiently failed attempt.
     runWorkflow.mockImplementation(() => {
-      throw new DefinitionNotFoundError('def-gone');
+      throw definitionNotFound('def-gone');
     });
     await dispatch({workspaceId, eventRef});
 
@@ -939,7 +953,7 @@ describe('dispatchIntegrationEvent trigger history', () => {
     if (!event) throw new Error('received event not found');
     expect(await decisionsForEvent(event.id)).toHaveLength(1);
     // `runWorkflow` is mocked here; run-row dedup depends on stable keys at its boundary.
-    const keys = runWorkflow.mock.calls.map(([params]) => params.triggerIdempotencyKey);
+    const keys = runWorkflow.mock.calls.map(([params]) => params.idempotencyKey);
     expect(keys).toEqual([`${subscription.id}:${eventRef}`, `${subscription.id}:${eventRef}`]);
   });
 

package/src/core/dispatch-integration-event.ts

@@ -1,4 +1,3 @@
-import {isPermanentRunWorkflowError, runWorkflow} from '@shipfox/api-workflows';
 import {findMatchingSubscriptions} from '#db/subscriptions.js';
 import {
   eventOutcomeCount,
@@ -8,8 +7,10 @@ import {
 import {evaluateTriggerFilter, readConfigInputs} from './config.js';
 import {beginTriggerHistory, toReason} from './record-trigger-history.js';
 import {routeEventToJobListeners} from './route-event-to-job-listeners.js';
+import {isPermanentStartRunError, type WorkflowsModuleClient} from './workflows-client.js';
 
 export interface DispatchIntegrationEventParams {
+  workflows: WorkflowsModuleClient;
   eventRef: string;
   workspaceId: string;
   provider: string;
@@ -79,8 +80,9 @@ export async function dispatchIntegrationEvent(
     }
     triggerEngagedCount += 1;
 
+    const inputs = readConfigInputs(subscription);
     try {
-      const run = await runWorkflow({
+      const run = await params.workflows.startRunFromTrigger({
         workspaceId: subscription.workspaceId,
         projectId: subscription.projectId,
         definitionId: subscription.workflowDefinitionId,
@@ -91,8 +93,8 @@ export async function dispatchIntegrationEvent(
           deliveryId: params.deliveryId,
           data: params.payload,
         },
-        inputs: readConfigInputs(subscription),
-        triggerIdempotencyKey: `${subscription.id}:${params.eventRef}`,
+        ...(inputs === undefined ? {} : {inputs}),
+        idempotencyKey: `${subscription.id}:${params.eventRef}`,
       });
       await history.triggered(subscription, run);
       triggeredCount += 1;
@@ -101,7 +103,7 @@ export async function dispatchIntegrationEvent(
       await history.dispatchErrored(subscription, toReason(error));
       // Track presence with a flag, not `firstTransientError === undefined`: a thrown
       // value of `undefined` is still a transient failure and must drive the replay.
-      if (!isPermanentRunWorkflowError(error) && !sawTransientError) {
+      if (!isPermanentStartRunError(error) && !sawTransientError) {
         sawTransientError = true;
         firstTransientError = error;
       }
@@ -109,6 +111,7 @@ export async function dispatchIntegrationEvent(
   }
 
   const listenerResult = await routeEventToJobListeners({
+    workflows: params.workflows,
     history,
     eventRef: params.eventRef,
     workspaceId: params.workspaceId,

package/src/core/drain-cron-schedules.test.ts

@@ -1,3 +1,5 @@
+import {workflowsInterModuleContract} from '@shipfox/api-workflows-dto/inter-module';
+import {createInterModuleKnownError} from '@shipfox/inter-module';
 import {eq} from 'drizzle-orm';
 import type {CronSchedule} from '#core/entities/cron-schedule.js';
 import type {TriggerSubscription} from '#core/entities/subscription.js';
@@ -10,24 +12,17 @@ import {cronScheduleFactory, triggerSubscriptionFactory} from '#test/index.js';
 
 const runWorkflow = vi.fn();
 
-vi.mock('@shipfox/api-workflows', () => {
-  class DefinitionNotFoundError extends Error {
-    constructor(definitionId: string) {
-      super(`Definition not found: ${definitionId}`);
-      this.name = 'DefinitionNotFoundError';
-    }
-  }
-  return {
-    runWorkflow: (...args: unknown[]) => runWorkflow(...args),
-    DefinitionNotFoundError,
-    isPermanentRunWorkflowError: (error: unknown) => error instanceof DefinitionNotFoundError,
-  };
-});
+const {drainDueCronSchedules} = await import('./drain-cron-schedules.js');
 
-import {DefinitionNotFoundError} from '@shipfox/api-workflows';
+const workflows = {startRunFromTrigger: (...args: unknown[]) => runWorkflow(...args)} as never;
 
-// Import after mocks so the function under test sees the spy.
-const {drainDueCronSchedules} = await import('./drain-cron-schedules.js');
+function drain(params: {
+  batchSize: number;
+  jitterWindowSeconds: number;
+  onScheduleProcessed?: () => void;
+}) {
+  return drainDueCronSchedules({workflows, ...params});
+}
 
 const MINUTE_MS = 60 * 1000;
 
@@ -62,7 +57,7 @@ async function createCronSchedule(params: {
 
 function callsWithKey(key: string) {
   return runWorkflow.mock.calls.filter(
-    ([params]) => (params as {triggerIdempotencyKey?: string}).triggerIdempotencyKey === key,
+    ([params]) => (params as {idempotencyKey?: string}).idempotencyKey === key,
   );
 }
 
@@ -87,7 +82,7 @@ describe('drainDueCronSchedules', () => {
     const run = {id: crypto.randomUUID(), name: 'Cron run'};
     runWorkflow.mockResolvedValue(run);
 
-    const summary = await drainDueCronSchedules({batchSize: 1000, jitterWindowSeconds: 0});
+    const summary = await drain({batchSize: 1000, jitterWindowSeconds: 0});
 
     expect(callsWithKey(key)).toHaveLength(1);
     expect(summary.fired).toBeGreaterThanOrEqual(1);
@@ -114,7 +109,7 @@ describe('drainDueCronSchedules', () => {
     const {subscription, key} = await createCronSchedule({nextFireAt: future});
     runWorkflow.mockResolvedValue({id: crypto.randomUUID(), name: 'r'});
 
-    await drainDueCronSchedules({batchSize: 1000, jitterWindowSeconds: 0});
+    await drain({batchSize: 1000, jitterWindowSeconds: 0});
 
     expect(callsWithKey(key)).toHaveLength(0);
     const row = await reload(subscription.id);
@@ -129,7 +124,7 @@ describe('drainDueCronSchedules', () => {
     });
     runWorkflow.mockResolvedValue({id: crypto.randomUUID(), name: 'r'});
 
-    await drainDueCronSchedules({batchSize: 1000, jitterWindowSeconds: 0});
+    await drain({batchSize: 1000, jitterWindowSeconds: 0});
 
     expect(callsWithKey(key)).toHaveLength(1);
     const row = await reload(subscription.id);
@@ -145,10 +140,10 @@ describe('drainDueCronSchedules', () => {
     });
     runWorkflow.mockResolvedValue({id: crypto.randomUUID(), name: 'r'});
 
-    await drainDueCronSchedules({batchSize: 1000, jitterWindowSeconds: 0});
+    await drain({batchSize: 1000, jitterWindowSeconds: 0});
 
     const [params] = callsWithKey(key)[0] as [Record<string, unknown>];
-    expect(params.triggerIdempotencyKey).toBe(key);
+    expect(params.idempotencyKey).toBe(key);
     expect(params.inputs).toEqual({environment: 'staging'});
     expect(params.triggerPayload).toEqual({
       provider: 'cron',
@@ -162,9 +157,15 @@ describe('drainDueCronSchedules', () => {
     const {subscription, key} = await createCronSchedule({
       nextFireAt: new Date(Date.now() - MINUTE_MS),
     });
-    runWorkflow.mockRejectedValue(new DefinitionNotFoundError('def-gone'));
+    runWorkflow.mockRejectedValue(
+      createInterModuleKnownError(
+        workflowsInterModuleContract.methods.startRunFromTrigger,
+        'definition-not-found',
+        {definitionId: crypto.randomUUID()},
+      ),
+    );
 
-    await drainDueCronSchedules({batchSize: 1000, jitterWindowSeconds: 0});
+    await drain({batchSize: 1000, jitterWindowSeconds: 0});
 
     const [event] = await db()
       .select()
@@ -187,7 +188,7 @@ describe('drainDueCronSchedules', () => {
     });
     runWorkflow.mockRejectedValue(new Error('database unavailable'));
 
-    await drainDueCronSchedules({batchSize: 1000, jitterWindowSeconds: 0});
+    await drain({batchSize: 1000, jitterWindowSeconds: 0});
 
     const row = await reload(subscription.id);
     expect(row.nextFireAt.getTime()).toBe(schedule.nextFireAt.getTime());
@@ -199,7 +200,7 @@ describe('drainDueCronSchedules', () => {
     runWorkflow.mockResolvedValue({id: crypto.randomUUID(), name: 'r'});
     const onScheduleProcessed = vi.fn();
 
-    const summary = await drainDueCronSchedules({
+    const summary = await drain({
       batchSize: 1000,
       jitterWindowSeconds: 0,
       onScheduleProcessed,
@@ -216,7 +217,7 @@ describe('drainDueCronSchedules', () => {
     }
     runWorkflow.mockResolvedValue({id: crypto.randomUUID(), name: 'r'});
 
-    const summary = await drainDueCronSchedules({batchSize: 3, jitterWindowSeconds: 0});
+    const summary = await drain({batchSize: 3, jitterWindowSeconds: 0});
 
     expect(summary.claimed).toBe(3);
     expect(runWorkflow).toHaveBeenCalledTimes(3);
@@ -241,8 +242,8 @@ describe('drainDueCronSchedules', () => {
     });
 
     await Promise.all([
-      drainDueCronSchedules({batchSize: 1000, jitterWindowSeconds: 0}),
-      drainDueCronSchedules({batchSize: 1000, jitterWindowSeconds: 0}),
+      drain({batchSize: 1000, jitterWindowSeconds: 0}),
+      drain({batchSize: 1000, jitterWindowSeconds: 0}),
     ]);
 
     for (const {subscription, schedule, key} of mine) {

package/src/core/drain-cron-schedules.ts

@@ -3,8 +3,10 @@ import {advanceCronSchedule, claimDueCronSchedules, selectDbNow} from '#db/cron-
 import {db} from '#db/db.js';
 import {computeNextFireAt} from './compute-next-fire-at.js';
 import {fireCronSubscription} from './fire-cron.js';
+import type {WorkflowsModuleClient} from './workflows-client.js';
 
 export interface DrainDueCronSchedulesParams {
+  readonly workflows: WorkflowsModuleClient;
   readonly batchSize: number;
   readonly jitterWindowSeconds: number;
   /**
@@ -67,6 +69,7 @@ export async function drainDueCronSchedules(
             lastFiredAt: scheduledSlot,
           });
           return await fireCronSubscription({
+            workflows: params.workflows,
             subscriptionId: schedule.subscriptionId,
             scheduledSlot,
           });

package/src/core/fire-cron.test.ts

@@ -1,3 +1,5 @@
+import {workflowsInterModuleContract} from '@shipfox/api-workflows-dto/inter-module';
+import {createInterModuleKnownError} from '@shipfox/inter-module';
 import {eq} from 'drizzle-orm';
 import {db} from '#db/db.js';
 import {triggersDecisions} from '#db/schema/decisions.js';
@@ -7,27 +9,10 @@ import {TriggerSubscriptionNotCronError} from './errors.js';
 
 const runWorkflow = vi.fn();
 
-// Keep a real-enough permanent-error class + the classifier so the cron path's
-// permanent/transient branching is exercised without loading the workflows module graph.
-vi.mock('@shipfox/api-workflows', () => {
-  class DefinitionNotFoundError extends Error {
-    constructor(definitionId: string) {
-      super(`Definition not found: ${definitionId}`);
-      this.name = 'DefinitionNotFoundError';
-    }
-  }
-  return {
-    runWorkflow: (...args: unknown[]) => runWorkflow(...args),
-    DefinitionNotFoundError,
-    isPermanentRunWorkflowError: (error: unknown) => error instanceof DefinitionNotFoundError,
-  };
-});
-
-import {DefinitionNotFoundError} from '@shipfox/api-workflows';
-
-// Import after mocks so the function under test sees the spy.
 const {fireCronSubscription} = await import('./fire-cron.js');
 
+const workflows = {startRunFromTrigger: (...args: unknown[]) => runWorkflow(...args)} as never;
+
 const SLOT = new Date('2026-07-05T02:00:00.000Z');
 
 function eventsForWorkspace(workspaceId: string) {
@@ -59,6 +44,7 @@ describe('fireCronSubscription', () => {
     runWorkflow.mockResolvedValue(run);
 
     const result = await fireCronSubscription({
+      workflows,
       subscriptionId: subscription.id,
       scheduledSlot: SLOT,
     });
@@ -72,7 +58,7 @@ describe('fireCronSubscription', () => {
       scheduleId: subscription.id,
     });
     expect(payload.inputs).toEqual({environment: 'staging'});
-    expect(payload.triggerIdempotencyKey).toBe(`${subscription.id}:${SLOT.toISOString()}`);
+    expect(payload.idempotencyKey).toBe(`${subscription.id}:${SLOT.toISOString()}`);
     const [event] = await eventsForWorkspace(subscription.workspaceId);
     if (!event) throw new Error('received event not found');
     expect(event.origin).toBe('cron');
@@ -92,9 +78,16 @@ describe('fireCronSubscription', () => {
       event: 'tick',
       config: {},
     });
-    runWorkflow.mockRejectedValue(new DefinitionNotFoundError('def-gone'));
+    runWorkflow.mockRejectedValue(
+      createInterModuleKnownError(
+        workflowsInterModuleContract.methods.startRunFromTrigger,
+        'definition-not-found',
+        {definitionId: crypto.randomUUID()},
+      ),
+    );
 
     const result = await fireCronSubscription({
+      workflows,
       subscriptionId: subscription.id,
       scheduledSlot: SLOT,
     });
@@ -106,7 +99,25 @@ describe('fireCronSubscription', () => {
     expect(event.processedAt).toBeInstanceOf(Date);
     const decisions = await decisionsForEvent(event.id);
     expect(decisions[0]?.decision).toBe('dispatch-error');
-    expect(decisions[0]?.reason).toContain('Definition not found');
+    expect(decisions[0]?.reason).toContain('definition-not-found');
+  });
+
+  test('omits inputs when the subscription has no configured inputs', async () => {
+    const subscription = await triggerSubscriptionFactory.create({
+      source: 'cron',
+      event: 'tick',
+      config: {},
+    });
+    runWorkflow.mockResolvedValue({id: crypto.randomUUID(), name: 'Cron run'});
+
+    await fireCronSubscription({
+      workflows,
+      subscriptionId: subscription.id,
+      scheduledSlot: SLOT,
+    });
+
+    const [payload] = runWorkflow.mock.calls[0] as [Record<string, unknown>];
+    expect(payload).not.toHaveProperty('inputs');
   });
 
   test('re-throws and leaves the event non-terminal on a transient failure', async () => {
@@ -118,7 +129,7 @@ describe('fireCronSubscription', () => {
     runWorkflow.mockRejectedValue(new Error('cron boom'));
 
     await expect(
-      fireCronSubscription({subscriptionId: subscription.id, scheduledSlot: SLOT}),
+      fireCronSubscription({workflows, subscriptionId: subscription.id, scheduledSlot: SLOT}),
     ).rejects.toThrow('cron boom');
 
     const [event] = await eventsForWorkspace(subscription.workspaceId);
@@ -137,7 +148,7 @@ describe('fireCronSubscription', () => {
     });
 
     await expect(
-      fireCronSubscription({subscriptionId: subscription.id, scheduledSlot: SLOT}),
+      fireCronSubscription({workflows, subscriptionId: subscription.id, scheduledSlot: SLOT}),
     ).rejects.toThrow(TriggerSubscriptionNotCronError);
 
     expect(await eventsForWorkspace(subscription.workspaceId)).toHaveLength(0);

package/src/core/fire-cron.ts

@@ -1,11 +1,12 @@
-import {isPermanentRunWorkflowError, runWorkflow, type WorkflowRun} from '@shipfox/api-workflows';
 import {getTriggerSubscriptionById} from '#db/subscriptions.js';
 import {cronFiredCount, cronFireLag} from '#metrics/instance.js';
 import {readConfigInputs} from './config.js';
 import {TriggerSubscriptionNotCronError, TriggerSubscriptionNotFoundError} from './errors.js';
 import {beginTriggerHistory, toReason} from './record-trigger-history.js';
+import {isPermanentStartRunError, type WorkflowsModuleClient} from './workflows-client.js';
 
 export interface FireCronSubscriptionParams {
+  workflows: WorkflowsModuleClient;
   subscriptionId: string;
   /**
    * The `next_fire_at` value the schedule held when it was claimed. Anchoring the
@@ -16,7 +17,7 @@ export interface FireCronSubscriptionParams {
 }
 
 export type FireCronSubscriptionResult =
-  | {outcome: 'fired'; run: WorkflowRun}
+  | {outcome: 'fired'; run: {id: string; name: string}}
   | {outcome: 'errored'};
 
 /**
@@ -56,9 +57,10 @@ export async function fireCronSubscription(
     eventRef,
   };
 
-  let run: WorkflowRun;
+  const inputs = readConfigInputs(subscription);
+  let run: {id: string; name: string};
   try {
-    run = await runWorkflow({
+    run = await params.workflows.startRunFromTrigger({
       workspaceId: subscription.workspaceId,
       projectId: subscription.projectId,
       definitionId: subscription.workflowDefinitionId,
@@ -68,13 +70,13 @@ export async function fireCronSubscription(
         event: 'tick',
         scheduleId: subscription.id,
       },
-      inputs: readConfigInputs(subscription),
-      triggerIdempotencyKey: eventRef,
+      ...(inputs === undefined ? {} : {inputs}),
+      idempotencyKey: eventRef,
     });
   } catch (error) {
     const failure = await beginTriggerHistory(historyBase);
     await failure.dispatchErrored(subscription, toReason(error));
-    if (isPermanentRunWorkflowError(error)) {
+    if (isPermanentStartRunError(error)) {
       recordFire('errored', params.scheduledSlot);
       await failure.allErrored(1);
       return {outcome: 'errored'};