@shipfox/api-definitions 5.0.0 → 7.1.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-definitions",
   "license": "MIT",
-  "version": "5.0.0",
+  "version": "7.1.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -30,47 +30,31 @@
     "js-yaml": "^4.1.0",
     "yaml": "^2.8.3",
     "zod": "^4.4.3",
-    "@shipfox/api-agent-dto": "5.0.0",
-    "@shipfox/api-auth-context": "5.0.0",
-    "@shipfox/api-definitions-dto": "5.0.0",
-    "@shipfox/api-integration-core": "5.0.0",
-    "@shipfox/api-integration-core-dto": "5.0.0",
-    "@shipfox/api-projects": "5.0.0",
-    "@shipfox/api-projects-dto": "5.0.0",
-    "@shipfox/api-secrets-dto": "5.0.0",
+    "@shipfox/api-agent-dto": "6.0.0",
+    "@shipfox/api-auth-context": "7.1.0",
+    "@shipfox/api-definitions-dto": "6.0.0",
+    "@shipfox/api-integration-core-dto": "6.0.0",
+    "@shipfox/api-projects-dto": "6.0.0",
+    "@shipfox/api-secrets-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/node-opentelemetry": "0.5.2",
-    "@shipfox/node-outbox": "0.2.3",
+    "@shipfox/inter-module": "0.2.0",
+    "@shipfox/node-drizzle": "0.3.2",
+    "@shipfox/node-fastify": "0.3.0",
+    "@shipfox/node-error-monitoring": "0.2.0",
+    "@shipfox/node-module": "0.5.0",
+    "@shipfox/node-opentelemetry": "0.6.0",
+    "@shipfox/node-outbox": "0.2.4",
     "@shipfox/node-postgres": "0.4.2",
-    "@shipfox/node-temporal": "0.3.1",
+    "@shipfox/node-temporal": "0.4.0",
     "@shipfox/runner-labels": "0.1.1",
     "@shipfox/workflow-document": "2.1.1"
   },
-  "devDependencies": {
-    "@temporalio/client": "1.18.1",
-    "@temporalio/testing": "1.18.1",
-    "@temporalio/worker": "1.18.1",
-    "@types/js-yaml": "^4.0.9",
-    "@types/pg": "^8.15.5",
-    "drizzle-kit": "^0.31.10",
-    "fastify": "^5.3.3",
-    "fastify-type-provider-zod": "^6.0.0",
-    "fishery": "^2.4.0",
-    "@shipfox/biome": "1.8.2",
-    "@shipfox/regex": "0.2.2",
-    "@shipfox/swc": "1.2.6",
-    "@shipfox/ts-config": "1.3.8",
-    "@shipfox/typescript": "1.1.7",
-    "@shipfox/vitest": "1.2.3"
-  },
   "scripts": {
     "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/entities/workflow-definition.ts

@@ -1,12 +1,9 @@
+import type {WorkflowModel, WorkflowSourceSnapshot} from '@shipfox/api-definitions-dto';
 import type {WorkflowDocument} from '@shipfox/workflow-document';
-import type {WorkflowModel} from './workflow-model.js';
 
-export type WorkflowSpec = WorkflowDocument;
+export type {WorkflowSourceSnapshot};
 
-export interface WorkflowSourceSnapshot {
-  content: string;
-  format: 'yaml';
-}
+export type WorkflowSpec = WorkflowDocument;
 
 export interface WorkflowDefinitionPayload {
   document: WorkflowDocument;

package/src/core/entities/workflow-model.ts

@@ -1,162 +1 @@
-import type {
-  ExpressionType,
-  OutputDeclarations,
-  ResolvedFieldSegment,
-  WorkflowExpression,
-} from '@shipfox/expression';
-import type {AgentThinking, Harness} from '@shipfox/workflow-document';
-
-export type WorkflowFieldTemplate = readonly ResolvedFieldSegment[];
-export type WorkflowEnvTemplates = Readonly<Record<string, WorkflowFieldTemplate>>;
-export type WorkflowOutputTemplates = Readonly<Record<string, WorkflowFieldTemplate>>;
-
-export interface WorkflowModel {
-  readonly kind: 'workflow';
-  readonly name: string;
-  readonly env?: Readonly<Record<string, string>>;
-  readonly templates?: {
-    readonly env?: WorkflowEnvTemplates;
-  };
-  readonly triggers: readonly WorkflowModelTrigger[];
-  readonly jobs: readonly WorkflowModelJob[];
-  readonly dependencies: readonly WorkflowModelDependency[];
-}
-
-export interface WorkflowModelTrigger {
-  readonly id: string;
-  readonly key: string;
-  readonly source: string;
-  readonly event: string;
-  readonly inputs?: Readonly<Record<string, unknown>>;
-  readonly filter?: string;
-  readonly config?: Readonly<Record<string, unknown>>;
-}
-
-export interface WorkflowModelJob {
-  readonly id: string;
-  readonly key: string;
-  readonly mode: WorkflowModelJobMode;
-  readonly runner: readonly string[];
-  readonly runnerTemplates?: readonly WorkflowFieldTemplate[];
-  readonly checkout: WorkflowModelJobCheckout;
-  readonly if?: WorkflowExpression;
-  readonly success?: string;
-  readonly outputs?: WorkflowOutputTemplates;
-  readonly outputTypes?: Readonly<Record<string, ExpressionType>>;
-  readonly executionTimeoutMs?: number;
-  readonly listening?: WorkflowModelJobListening;
-  readonly name?: WorkflowFieldTemplate;
-  readonly env?: Readonly<Record<string, string>>;
-  readonly templates?: {
-    readonly env?: WorkflowEnvTemplates;
-  };
-  readonly dependencies: readonly string[];
-  readonly steps: readonly WorkflowModelStep[];
-}
-
-export type WorkflowModelJobMode = 'one_shot' | 'listening';
-
-export interface WorkflowModelJobListening {
-  readonly on: readonly WorkflowModelListeningTrigger[];
-  readonly until?: readonly WorkflowModelListeningTrigger[];
-  readonly timeoutMs?: number;
-  readonly maxExecutions?: number;
-  readonly batch?: WorkflowModelListeningBatch;
-  readonly onResolve: 'finish' | 'cancel';
-}
-
-export interface WorkflowModelListeningTrigger {
-  readonly source: string;
-  readonly event: string;
-  readonly inputs?: Readonly<Record<string, unknown>>;
-  readonly filter?: string;
-}
-
-export interface WorkflowModelListeningBatch {
-  readonly debounceMs?: number;
-  readonly maxSize?: number;
-  readonly maxWaitMs?: number;
-}
-
-export interface WorkflowModelJobCheckout {
-  readonly permissions: {readonly contents: 'read' | 'write'};
-  readonly persistCredentials: boolean;
-}
-
-export type WorkflowModelStep = WorkflowModelRunStep | WorkflowModelAgentStep;
-
-interface WorkflowModelStepBase {
-  readonly id: string;
-  readonly key?: string;
-  readonly if?: WorkflowExpression;
-  readonly name?: string;
-  readonly outputs?: OutputDeclarations;
-  readonly gate?: WorkflowModelStepGate;
-  readonly sourceLocation?: WorkflowSourceLocation;
-}
-
-export interface WorkflowModelRunStep extends WorkflowModelStepBase {
-  readonly kind: 'run';
-  readonly command: WorkflowModelRunCommand;
-  readonly env?: Readonly<Record<string, string>>;
-  readonly templates?: {
-    readonly command?: WorkflowFieldTemplate;
-    readonly name?: WorkflowFieldTemplate;
-    readonly env?: WorkflowEnvTemplates;
-  };
-}
-
-export interface WorkflowModelAgentStep extends WorkflowModelStepBase {
-  readonly kind: 'agent';
-  readonly harness?: Harness;
-  readonly model?: string;
-  readonly provider?: string;
-  readonly thinking?: AgentThinking;
-  readonly tools?: readonly string[];
-  readonly integrations?: readonly WorkflowModelStepIntegration[];
-  readonly prompt: string;
-  readonly templates?: {
-    readonly prompt?: WorkflowFieldTemplate;
-    readonly model?: WorkflowFieldTemplate;
-    readonly provider?: WorkflowFieldTemplate;
-    readonly name?: WorkflowFieldTemplate;
-  };
-}
-
-export interface WorkflowModelStepIntegration {
-  readonly connection?: string;
-  readonly include: readonly string[];
-  readonly exclude?: readonly string[];
-  readonly allowWrite: boolean;
-}
-
-export interface WorkflowSourceLocation {
-  readonly startLine: number;
-  readonly endLine: number;
-}
-
-export type WorkflowStepSourceLocationMap = ReadonlyMap<
-  string,
-  ReadonlyMap<number, WorkflowSourceLocation>
->;
-
-export interface WorkflowModelRunCommand {
-  readonly kind: 'shell';
-  readonly value: string;
-}
-
-export interface WorkflowModelStepGate {
-  readonly success?: WorkflowExpression;
-  readonly onFailure?: WorkflowModelStepFailureAction;
-}
-
-export interface WorkflowModelStepFailureAction {
-  readonly restartFrom: string;
-  readonly feedback?: string;
-  readonly feedbackTemplate?: WorkflowFieldTemplate;
-}
-
-export interface WorkflowModelDependency {
-  readonly from: string;
-  readonly to: string;
-}
+export type * from '@shipfox/api-definitions-dto';

package/src/core/integrations.ts

@@ -0,0 +1,39 @@
+import {
+  type IntegrationsModuleClient,
+  integrationsInterModuleContract,
+} from '@shipfox/api-integration-core-dto';
+
+export type DefinitionsSourceControl = {
+  resolveRepository: IntegrationsModuleClient['resolveSourceRepository'];
+  listFiles: IntegrationsModuleClient['listSourceFiles'];
+  fetchFile: IntegrationsModuleClient['fetchSourceFile'];
+};
+
+export function createDefinitionsSourceControl(
+  integrations: IntegrationsModuleClient,
+): DefinitionsSourceControl {
+  return {
+    resolveRepository: integrations.resolveSourceRepository,
+    listFiles: integrations.listSourceFiles,
+    fetchFile: integrations.fetchSourceFile,
+  };
+}
+
+export async function loadIntegrationValidationContext(
+  integrations: IntegrationsModuleClient,
+  workspaceId: string,
+  defaultConnectionId: string,
+) {
+  const context = await integrations.getAgentToolsContext({workspaceId, defaultConnectionId});
+  return {
+    agentToolSelectionCatalogs: new Map(
+      context.selectionCatalogs.map(({provider, selectors}) => [provider, {selectors}]),
+    ),
+    workspaceConnectionSnapshot: new Map(
+      context.workspaceConnections.map(({slug, ...connection}) => [slug, connection]),
+    ),
+    defaultConnectionSlug: context.defaultConnection?.slug,
+  };
+}
+
+export {integrationsInterModuleContract};

package/src/core/sync-definitions.test.ts

@@ -1,10 +1,6 @@
-import {
-  IntegrationConnectionInactiveError,
-  IntegrationConnectionNotFoundError,
-  IntegrationConnectionWorkspaceMismatchError,
-  IntegrationProviderError,
-  type IntegrationSourceControlService,
-} from '@shipfox/api-integration-core';
+import type {IntegrationSourceControlService} from '@shipfox/api-integration-core';
+import {integrationsInterModuleContract} from '@shipfox/api-integration-core-dto';
+import {createInterModuleKnownError} from '@shipfox/inter-module';
 import {LOWERCASE_SHA256_HEX_RE} from '@shipfox/regex';
 import type {IntegrationValidationContext} from './entities/integration-context.js';
 import {DefinitionSyncPermanentError} from './errors.js';
@@ -349,13 +345,15 @@ describe('classifySyncFailure', () => {
     ['malformed-provider-response', false, 'provider-malformed-response'],
     ['content-too-large', false, 'content-too-large'],
     ['too-many-files', false, 'too-many-files'],
-  ])('maps IntegrationProviderError(%s) to retryable=%s code=%s', (reason, retryable, code) => {
-    const result = classifySyncFailure(
-      // biome-ignore lint/suspicious/noExplicitAny: enumerated reason
-      new IntegrationProviderError(reason as any, 'boom'),
+  ])('maps provider failures (%s) to retryable=%s code=%s', (reason, retryable, code) => {
+    const error = createInterModuleKnownError(
+      integrationsInterModuleContract.methods.resolveSourceRepository,
+      'provider-failure',
+      {reason},
     );
+    const result = classifySyncFailure(error);
 
-    expect(result).toEqual({code, message: 'boom', retryable});
+    expect(result).toEqual({code, message: error.message, retryable});
   });
 
   it('classifies DefinitionSyncPermanentError as non-retryable', () => {
@@ -367,11 +365,15 @@ describe('classifySyncFailure', () => {
   });
 
   it.each([
-    () => new IntegrationConnectionNotFoundError('connection-1'),
-    () => new IntegrationConnectionInactiveError('connection-1'),
-    () => new IntegrationConnectionWorkspaceMismatchError('connection-1'),
-  ])('classifies connection lifecycle errors as non-retryable connection-unavailable', (build) => {
-    const error = build();
+    'connection-not-found',
+    'connection-inactive',
+    'connection-workspace-mismatch',
+  ] as const)('classifies %s as non-retryable connection-unavailable', (code) => {
+    const error = createInterModuleKnownError(
+      integrationsInterModuleContract.methods.resolveSourceRepository,
+      code,
+      {connectionId: '00000000-0000-0000-0000-000000000000'},
+    );
 
     const result = classifySyncFailure(error);
 

package/src/core/sync-definitions.ts

@@ -1,18 +1,16 @@
 import {createHash} from 'node:crypto';
 import {
-  IntegrationConnectionInactiveError,
-  IntegrationConnectionNotFoundError,
-  IntegrationConnectionWorkspaceMismatchError,
-  IntegrationProviderError,
-  type IntegrationSourceControlService,
+  integrationsInterModuleContract,
   MAX_REPOSITORY_FILE_BYTES,
-} from '@shipfox/api-integration-core';
+} from '@shipfox/api-integration-core-dto';
+import {isInterModuleKnownError} from '@shipfox/inter-module';
 import {boundedMap} from '@shipfox/node-module';
 import type {IntegrationValidationContext} from './entities/integration-context.js';
 import type {DefinitionSyncErrorCode} from './entities/sync-state.js';
 import type {WorkflowDefinitionPayload} from './entities/workflow-definition.js';
 import {DefinitionParseError, DefinitionSyncPermanentError} from './errors.js';
 import {hasAgentStepIntegrations} from './has-agent-step-integrations.js';
+import type {DefinitionsSourceControl} from './integrations.js';
 import {parseDefinition} from './parse-definition.js';
 
 export const WORKFLOW_PREFIX = '.shipfox/workflows/';
@@ -24,7 +22,7 @@ export interface SyncSourceContext {
   workspaceId: string;
   sourceConnectionId: string;
   sourceExternalRepositoryId: string;
-  sourceControl: IntegrationSourceControlService;
+  sourceControl: DefinitionsSourceControl;
 }
 
 export interface ResolvedSyncSource {
@@ -173,19 +171,27 @@ export function classifySyncFailure(error: unknown): SyncFailureClassification {
   if (error instanceof DefinitionSyncPermanentError) {
     return {code: error.code, message: error.message, retryable: false};
   }
-  if (
-    error instanceof IntegrationConnectionNotFoundError ||
-    error instanceof IntegrationConnectionInactiveError ||
-    error instanceof IntegrationConnectionWorkspaceMismatchError
-  ) {
-    return {code: 'connection-unavailable', message: error.message, retryable: false};
-  }
-  if (error instanceof IntegrationProviderError) {
-    return {
-      code: providerErrorCode(error.reason),
-      message: error.message,
-      retryable: isProviderReasonRetryable(error.reason),
-    };
+  const methods = [
+    integrationsInterModuleContract.methods.resolveSourceRepository,
+    integrationsInterModuleContract.methods.listSourceFiles,
+    integrationsInterModuleContract.methods.fetchSourceFile,
+  ] as const;
+  for (const method of methods) {
+    if (!isInterModuleKnownError(method, error)) continue;
+    if (
+      error.code === 'connection-not-found' ||
+      error.code === 'connection-inactive' ||
+      error.code === 'connection-workspace-mismatch'
+    ) {
+      return {code: 'connection-unavailable', message: error.message, retryable: false};
+    }
+    if (error.code === 'provider-failure') {
+      return {
+        code: providerErrorCode(error.details.reason),
+        message: error.message,
+        retryable: isProviderReasonRetryable(error.details.reason),
+      };
+    }
   }
   return {
     code: 'unknown',

package/src/core/workflow-model/constants.ts

@@ -1 +1 @@
-export const DEFAULT_RUN_TIMEOUT_MS = 30 * 24 * 60 * 60 * 1000;
+export {DEFAULT_RUN_TIMEOUT_MS} from '@shipfox/api-definitions-dto';

package/src/core/workflow-model/normalize-job-checkout.ts

@@ -1,10 +1,7 @@
+import {DEFAULT_JOB_CHECKOUT, type WorkflowModelJobCheckout} from '@shipfox/api-definitions-dto';
 import type {WorkflowDocumentJobCheckout} from '@shipfox/workflow-document';
-import type {WorkflowModelJobCheckout} from '../entities/workflow-model.js';
 
-export const DEFAULT_JOB_CHECKOUT: WorkflowModelJobCheckout = {
-  permissions: {contents: 'read'},
-  persistCredentials: true,
-};
+export {DEFAULT_JOB_CHECKOUT};
 
 export function normalizeJobCheckout(
   checkout: WorkflowDocumentJobCheckout | undefined,

package/src/core/workflow-model/normalize-job-success.ts

@@ -1,8 +1,9 @@
+import {DEFAULT_JOB_SUCCESS} from '@shipfox/api-definitions-dto';
 import type {ExpressionTypeEnvironment} from '@shipfox/expression';
 import type {WorkflowModelValidationIssue} from './invalid-workflow-model-error.js';
 import {validatePredicateExpression} from './validate-predicate-expression.js';
 
-export const DEFAULT_JOB_SUCCESS = "!executions.exists(e, e.status == 'failed')";
+export {DEFAULT_JOB_SUCCESS};
 
 export function normalizeJobSuccess(params: {
   source: string | undefined;

package/src/db/definitions.test.ts

@@ -1,15 +1,19 @@
 import {DEFINITION_RESOLVED} from '@shipfox/api-definitions-dto';
 import {
   BATCH_SIZE,
+  countPendingOutboxRows as countPendingOutboxRowsFromRegistry,
+  createOutboxRegistry,
   type DrainedEvent,
-  drainAll,
-  markDispatched,
+  drainAll as drainFromRegistry,
+  type ModulePublisher,
+  markDispatched as markDispatchedFromRegistry,
+  type OutboxDispatchClaim,
   type OutboxDispatchFailure,
-  pruneDispatchedOutboxRows,
-  recordDispatchFailure,
-  registerPublisher,
-  renewDispatchClaim,
-  resetPublishers,
+  type PruneDispatchedOutboxRowsOptions,
+  pruneDispatchedOutboxRows as pruneFromRegistry,
+  recordDispatchFailure as recordFailureFromRegistry,
+  registerPublisher as registerInRegistry,
+  renewDispatchClaim as renewFromRegistry,
 } from '@shipfox/node-module';
 import {sql} from 'drizzle-orm';
 import type {WorkflowDefinitionPayload} from '#core/entities/workflow-definition.js';
@@ -27,6 +31,44 @@ import {workflowDefinitions} from './schema/definitions.js';
 import {definitionsOutbox} from './schema/outbox.js';
 
 const MS_PER_DAY = 24 * 60 * 60 * 1_000;
+let outboxRegistry = createOutboxRegistry();
+
+function resetPublishers(): void {
+  outboxRegistry = createOutboxRegistry();
+}
+
+function registerPublisher(publisher: ModulePublisher): void {
+  registerInRegistry(outboxRegistry, publisher);
+}
+
+function drainAll(options?: {partition?: {workerIndex: number; workerCount: number}}) {
+  return drainFromRegistry(outboxRegistry, options);
+}
+
+function countPendingOutboxRows() {
+  return countPendingOutboxRowsFromRegistry(outboxRegistry);
+}
+
+function markDispatched(source: string, claims: string[] | OutboxDispatchClaim[]) {
+  return markDispatchedFromRegistry(outboxRegistry, source, claims);
+}
+
+function renewDispatchClaim(source: string, claim: OutboxDispatchClaim) {
+  return renewFromRegistry(outboxRegistry, source, claim);
+}
+
+function recordDispatchFailure(
+  source: string,
+  id: string,
+  failure: OutboxDispatchFailure,
+  claimExpiresAt?: Date,
+) {
+  return recordFailureFromRegistry(outboxRegistry, source, id, failure, claimExpiresAt);
+}
+
+function pruneDispatchedOutboxRows(options: PruneDispatchedOutboxRowsOptions) {
+  return pruneFromRegistry(outboxRegistry, options);
+}
 
 function definitionFields(name = 'Test Workflow'): WorkflowDefinitionPayload {
   const document = {
@@ -740,6 +782,25 @@ describe('definition queries', () => {
         .where(sql`${definitionsOutbox.payload}->>'projectId' = ${projectId}`);
     });
 
+    test('countPendingOutboxRows counts pending rows but excludes dispatched and dead-lettered rows', async () => {
+      await insertOutboxRow({projectId, marker: 'pending'});
+      await insertOutboxRow({projectId, marker: 'dispatched', dispatchedAt: new Date()});
+      await insertOutboxRow({projectId, marker: 'dead-lettered', deadLetteredAt: new Date()});
+
+      const pendingRows = await countPendingOutboxRows();
+
+      expect(pendingRows).toBe(1);
+    });
+
+    test('countPendingOutboxRows sums pending rows across every registered publisher', async () => {
+      registerPublisher({name: 'definitions-second', table: definitionsOutbox, db: () => db()});
+      await insertOutboxRow({projectId, marker: 'pending'});
+
+      const pendingRows = await countPendingOutboxRows();
+
+      expect(pendingRows).toBe(2);
+    });
+
     test('drainAll returns undispatched outbox events', async () => {
       await upsertDefinition({
         projectId,

package/src/index.ts

@@ -5,12 +5,8 @@ import {
   type DefinitionsEventMap,
   definitionsEventSchemas,
 } from '@shipfox/api-definitions-dto';
-import type {
-  AgentToolSelectionCatalogs,
-  GetIntegrationConnectionByIdFn,
-  IntegrationSourceControlService,
-  LoadWorkspaceConnectionSnapshot,
-} from '@shipfox/api-integration-core';
+import type {IntegrationsModuleClient} from '@shipfox/api-integration-core-dto';
+import type {ProjectsModuleClient} from '@shipfox/api-projects-dto';
 import {
   PROJECT_SOURCE_BOUND,
   PROJECT_SOURCE_COMMIT_OBSERVED,
@@ -18,8 +14,10 @@ import {
 } from '@shipfox/api-projects-dto';
 import {type ShipfoxModule, subscriberFactory} from '@shipfox/node-module';
 import {logger} from '@shipfox/node-opentelemetry';
+import {createDefinitionsSourceControl} from '#core/integrations.js';
 import {db, definitionsOutbox, migrationsPath} from '#db/index.js';
 import {createDefinitionRoutes} from '#presentation/index.js';
+import {createDefinitionsInterModulePresentation} from '#presentation/inter-module.js';
 import {
   onProjectSourceBound,
   onProjectSourceCommitObserved,
@@ -42,7 +40,6 @@ export {
   normalizeWorkflowDocument,
 } from '#core/index.js';
 export {db, definitionsOutbox, getDefinitionById, migrationsPath} from '#db/index.js';
-export {routes} from '#presentation/index.js';
 
 const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const workflowsPath = resolve(packageRoot, 'dist/temporal/workflows/index.js');
@@ -50,37 +47,20 @@ const workflowsPath = resolve(packageRoot, 'dist/temporal/workflows/index.js');
 const subscriber = subscriberFactory<DefinitionsEventMap & ProjectsEventMap>();
 
 export interface CreateDefinitionsModuleOptions {
-  sourceControl: IntegrationSourceControlService;
-  agentToolSelectionCatalogs?: AgentToolSelectionCatalogs | undefined;
-  loadWorkspaceConnectionSnapshot?: LoadWorkspaceConnectionSnapshot | undefined;
-  getIntegrationConnectionById?: GetIntegrationConnectionByIdFn | undefined;
+  projects: ProjectsModuleClient;
+  integrations: IntegrationsModuleClient;
 }
 
 export function createDefinitionsModule({
-  sourceControl,
-  agentToolSelectionCatalogs,
-  loadWorkspaceConnectionSnapshot,
-  getIntegrationConnectionById,
+  projects,
+  integrations,
 }: CreateDefinitionsModuleOptions): ShipfoxModule {
-  const integrationValidation =
-    agentToolSelectionCatalogs === undefined ||
-    loadWorkspaceConnectionSnapshot === undefined ||
-    getIntegrationConnectionById === undefined
-      ? undefined
-      : {
-          agentToolSelectionCatalogs,
-          loadWorkspaceConnectionSnapshot,
-          getIntegrationConnectionById,
-        };
+  const sourceControl = createDefinitionsSourceControl(integrations);
 
   return {
     name: 'definitions',
     database: {db, migrationsPath},
-    routes: createDefinitionRoutes({
-      agentToolSelectionCatalogs,
-      loadWorkspaceConnectionSnapshot,
-      getIntegrationConnectionById,
-    }),
+    routes: createDefinitionRoutes({projects, integrations}),
     publishers: [
       {name: 'definitions', table: definitionsOutbox, db, eventSchemas: definitionsEventSchemas},
     ],
@@ -96,9 +76,10 @@ export function createDefinitionsModule({
       {
         taskQueue: DEFINITIONS_TASK_QUEUE,
         workflowsPath,
-        activities: () => createDefinitionSyncActivities(sourceControl, integrationValidation),
+        activities: () => createDefinitionSyncActivities(sourceControl, integrations),
         workflows: [],
       },
     ],
+    interModulePresentations: [createDefinitionsInterModulePresentation()],
   };
 }

package/src/presentation/index.ts

@@ -1 +1 @@
-export {createDefinitionRoutes, definitionRoutes as routes} from './routes/index.js';
+export {createDefinitionRoutes} from './routes/index.js';

package/src/presentation/inter-module.ts

@@ -0,0 +1,25 @@
+import {createWorkflowModelSnapshot} from '@shipfox/api-definitions-dto';
+import {definitionsInterModuleContract} from '@shipfox/api-definitions-dto/inter-module';
+import {defineInterModulePresentation, type InterModulePresentation} from '@shipfox/inter-module';
+import {getDefinitionById} from '#db/definitions.js';
+
+export function createDefinitionsInterModulePresentation(): InterModulePresentation<
+  typeof definitionsInterModuleContract
+> {
+  return defineInterModulePresentation(definitionsInterModuleContract, {
+    getDefinitionForWorkflowRun: async ({definitionId}) => {
+      const definition = await getDefinitionById(definitionId);
+      if (!definition) return {definition: null};
+
+      return {
+        definition: {
+          id: definition.id,
+          projectId: definition.projectId,
+          name: definition.name,
+          model: createWorkflowModelSnapshot(definition.model),
+          sourceSnapshot: definition.sourceSnapshot,
+        },
+      };
+    },
+  });
+}