@pattern-stack/codegen 0.10.1 → 0.11.0

package/runtime/subsystems/{sync/sync-run-recorder.memory-backend.ts → integration/integration-run-recorder.memory-backend.ts}

@@ -1,7 +1,7 @@
 /**
- * MemoryRunRecorder — in-memory backend for `ISyncRunRecorder` (SYNC-6).
+ * MemoryRunRecorder — in-memory backend for `IIntegrationRunRecorder` (SYNC-6).
  *
- * Test double so `SyncModule.forRoot({ backend: 'memory' })` is genuinely
+ * Test double so `IntegrationModule.forRoot({ backend: 'memory' })` is genuinely
  * end-to-end runnable without Postgres. Mirrors the role of
  * `MemoryCursorStore`: plain keyed state, `clear()` helper for
  * `beforeEach` resets, public inspection surface so tests can assert on
@@ -27,34 +27,34 @@
 import { Injectable } from '@nestjs/common';
 import type {
   CompleteRunInput,
-  ISyncRunRecorder,
+  IIntegrationRunRecorder,
   RecordItemInput,
   StartRunInput,
-  SyncRunSummary,
-} from './sync-run-recorder.protocol';
-import { FieldDiffSchema } from './sync-field-diff.protocol';
+  IntegrationRunSummary,
+} from './integration-run-recorder.protocol';
+import { FieldDiffSchema } from './integration-field-diff.protocol';
 
 /**
  * Optional per-subscription metadata a test can seed on the memory backend
- * so `listRecent` can surface `integrationId`. The memory recorder's write
+ * so `listRecent` can surface `connectionId`. The memory recorder's write
  * path never persists subscription rows (it only stores runs + items), so
- * `listRecent` has no way to derive `integrationId` on its own. Tests that
+ * `listRecent` has no way to derive `connectionId` on its own. Tests that
  * care about the field should populate `subscriptions` before calling
  * `listRecent`; calls that don't seed get an empty string and a stable
  * shape (see `listRecent` below).
  */
-export interface MemorySyncSubscription {
-  integrationId: string;
+export interface MemoryIntegrationSubscription {
+  connectionId: string;
   adapter: string;
   domain: string;
   externalRef: string | null;
-  lastSyncAt?: Date | null;
+  lastIntegrationAt?: Date | null;
   updatedAt: Date;
 }
 
 /**
  * Concrete run row as held in memory. Shape mirrors the interesting
- * columns on `sync_runs` so assertions read like DB queries.
+ * columns on `integration_runs` so assertions read like DB queries.
  */
 export interface MemoryRunRecord {
   id: string;
@@ -74,7 +74,7 @@ export interface MemoryRunRecord {
 }
 
 @Injectable()
-export class MemoryRunRecorder implements ISyncRunRecorder {
+export class MemoryRunRecorder implements IIntegrationRunRecorder {
   /**
    * All started runs keyed by id. Public so tests can inspect lifecycle
    * transitions without poking through recording methods.
@@ -82,20 +82,20 @@ export class MemoryRunRecorder implements ISyncRunRecorder {
   readonly runs: Map<string, MemoryRunRecord> = new Map();
 
   /**
-   * Items keyed by `sync_run_id`, array order matches insertion order —
-   * mirrors the timeline the `(sync_run_id, created_at)` index produces
+   * Items keyed by `integration_run_id`, array order matches insertion order —
+   * mirrors the timeline the `(integration_run_id, created_at)` index produces
    * in Postgres.
    */
   readonly items: Map<string, RecordItemInput[]> = new Map();
 
   /**
    * Seedable subscription metadata — tests populate this to make
-   * `listRecent` return meaningful `integrationId` values. The memory
+   * `listRecent` return meaningful `connectionId` values. The memory
    * backend doesn't track subscriptions on its own (only runs + items), so
    * this map is the intentional extension point: tests write entries for
    * the subscription ids they use, production code never touches it.
    */
-  readonly subscriptions: Map<string, MemorySyncSubscription> = new Map();
+  readonly subscriptions: Map<string, MemoryIntegrationSubscription> = new Map();
 
   async startRun(input: StartRunInput): Promise<{ id: string }> {
     const id = crypto.randomUUID();
@@ -123,10 +123,10 @@ export class MemoryRunRecorder implements ISyncRunRecorder {
     // Same ADR-0003 contract as the Drizzle backend.
     FieldDiffSchema.parse(input.changedFields);
 
-    const bucket = this.items.get(input.syncRunId);
+    const bucket = this.items.get(input.integrationRunId);
     if (!bucket) {
       throw new Error(
-        `MemoryRunRecorder.recordItem: no run started for id '${input.syncRunId}'. ` +
+        `MemoryRunRecorder.recordItem: no run started for id '${input.integrationRunId}'. ` +
           `Call startRun(...) first.`,
       );
     }
@@ -153,7 +153,7 @@ export class MemoryRunRecorder implements ISyncRunRecorder {
     limit: number,
     subscriptionId?: string,
     _tenantId?: string | null,
-  ): Promise<SyncRunSummary[]> {
+  ): Promise<IntegrationRunSummary[]> {
     // Memory backend accepts tenantId for contract symmetry but does not
     // filter on it — state is process-local and cross-tenant isolation is
     // not meaningful here (matches MemoryCursorStore behavior).
@@ -168,11 +168,11 @@ export class MemoryRunRecorder implements ISyncRunRecorder {
       .map((r) => ({
         id: r.id,
         subscriptionId: r.subscriptionId,
-        // integrationId is only knowable if the test seeded subscriptions
+        // connectionId is only knowable if the test seeded subscriptions
         // metadata; empty string otherwise. The Drizzle backend resolves
         // it via JOIN, which is the production path.
-        integrationId:
-          this.subscriptions.get(r.subscriptionId)?.integrationId ?? '',
+        connectionId:
+          this.subscriptions.get(r.subscriptionId)?.connectionId ?? '',
         status: r.status,
         startedAt: r.startedAt,
         completedAt: r.completedAt,

package/runtime/subsystems/{sync/sync-run-recorder.protocol.ts → integration/integration-run-recorder.protocol.ts}

@@ -1,12 +1,12 @@
 /**
- * Sync subsystem — run-recorder protocol (port)
+ * Integration subsystem — run-recorder protocol (port)
  *
- * `ISyncRunRecorder` is the write side of the audit log. `ExecuteSyncUseCase`
+ * `IIntegrationRunRecorder` is the write side of the audit log. `ExecuteIntegrationUseCase`
  * (SYNC-5) calls `startRun` at the top of the loop, `recordItem` for each
  * processed change, and `completeRun` in a `finally` block so a run always
  * reaches a terminal status.
  *
- * The Drizzle backend (SYNC-4) persists against `sync_runs` / `sync_run_items`
+ * The Drizzle backend (SYNC-4) persists against `integration_runs` / `integration_run_items`
  * from the SYNC-1 schema. Tests use lightweight in-memory fakes — no
  * dedicated memory backend ships; the surface is small enough that inline
  * fakes keep the intent local to each spec.
@@ -17,13 +17,13 @@
  * orchestrator before reaching the recorder, so the recorder's input is
  * always a `FieldDiff`.
  */
-import type { FieldDiff } from './sync-field-diff.protocol';
+import type { FieldDiff } from './integration-field-diff.protocol';
 
 // ============================================================================
 // Lifecycle — inputs
 // ============================================================================
 
-/** Args for `startRun`. Mirrors the non-nullable columns on `sync_runs`. */
+/** Args for `startRun`. Mirrors the non-nullable columns on `integration_runs`. */
 export interface StartRunInput {
   readonly subscriptionId: string;
   readonly direction: 'inbound' | 'outbound';
@@ -31,16 +31,16 @@ export interface StartRunInput {
   /** Cursor snapshot at run start, or `null` if this is the first run. */
   readonly cursorBefore: unknown | null;
   /**
-   * Tenant id when `SYNC_MULTI_TENANT` is enabled. The recorder's own
+   * Tenant id when `INTEGRATION_MULTI_TENANT` is enabled. The recorder's own
    * boundary rule (SYNC-6) enforces non-null when the flag is on;
-   * orchestrator passes it through from `ExecuteSyncInput.tenantId`.
+   * orchestrator passes it through from `ExecuteIntegrationInput.tenantId`.
    */
   readonly tenantId?: string | null;
 }
 
-/** Args for `recordItem`. Mirrors the non-nullable columns on `sync_run_items`. */
+/** Args for `recordItem`. Mirrors the non-nullable columns on `integration_run_items`. */
 export interface RecordItemInput {
-  readonly syncRunId: string;
+  readonly integrationRunId: string;
   readonly entityType: string;
   readonly externalId: string;
   readonly localId?: string | null;
@@ -71,24 +71,24 @@ export interface CompleteRunInput {
 // ============================================================================
 
 /**
- * Denormalized view of one `sync_runs` row, JOINed against
- * `sync_subscriptions` to surface `integrationId` in a single read. Consumed
+ * Denormalized view of one `integration_runs` row, JOINed against
+ * `integration_subscriptions` to surface `connectionId` in a single read. Consumed
  * by the OBS-5 observability composer (epic #195).
  *
- * `recordsProcessed` is the denormalized column on `sync_runs` — it does NOT
- * count `sync_run_items` rows. A correlated subquery per run would be
+ * `recordsProcessed` is the denormalized column on `integration_runs` — it does NOT
+ * count `integration_run_items` rows. A correlated subquery per run would be
  * required for a true item count; deferred as a follow-up if needed.
  *
- * Memory backends can't know `integrationId` without subscription metadata
+ * Memory backends can't know `connectionId` without subscription metadata
  * — see each memory backend for the seedable `subscriptions` side-map that
  * tests populate. When metadata is missing, memory backends emit an empty
  * string so the shape stays stable (documented in the memory backend).
  */
-export interface SyncRunSummary {
+export interface IntegrationRunSummary {
   readonly id: string;
   readonly subscriptionId: string;
   /** Resolved by Drizzle via JOIN; empty string from memory if not seeded. */
-  readonly integrationId: string;
+  readonly connectionId: string;
   readonly status: 'running' | 'success' | 'no_changes' | 'failed';
   readonly startedAt: Date;
   readonly completedAt: Date | null;
@@ -97,14 +97,14 @@ export interface SyncRunSummary {
 }
 
 // ============================================================================
-// ISyncRunRecorder
+// IIntegrationRunRecorder
 // ============================================================================
 
-export interface ISyncRunRecorder {
-  /** Opens a new `sync_runs` row in `status = 'running'`. Returns the run id. */
+export interface IIntegrationRunRecorder {
+  /** Opens a new `integration_runs` row in `status = 'running'`. Returns the run id. */
   startRun(input: StartRunInput): Promise<{ id: string }>;
 
-  /** Appends one `sync_run_items` row. Throws if `changedFields` is malformed. */
+  /** Appends one `integration_run_items` row. Throws if `changedFields` is malformed. */
   recordItem(input: RecordItemInput): Promise<void>;
 
   /**
@@ -115,16 +115,16 @@ export interface ISyncRunRecorder {
   completeRun(runId: string, input: CompleteRunInput): Promise<void>;
 
   /**
-   * Recent `sync_runs` rows ordered by `started_at DESC`, capped at `limit`.
+   * Recent `integration_runs` rows ordered by `started_at DESC`, capped at `limit`.
    *
-   * Filter is `subscriptionId` — the natural FK on `sync_runs`. An
-   * integration-wide view requires filtering on `sync_subscriptions.integration_id`
+   * Filter is `subscriptionId` — the natural FK on `integration_runs`. An
+   * integration-wide view requires filtering on `integration_subscriptions.connection_id`
    * through the JOIN and is deferred as a follow-up (epic #195 OBS-4 spec).
    *
    * @param limit           hard cap on rows returned (no implicit default)
    * @param subscriptionId  optional FK filter; omit for cross-subscription view
    * @param tenantId        required by Drizzle backend when
-   *                        `SYNC_MULTI_TENANT` is on (throws
+   *                        `INTEGRATION_MULTI_TENANT` is on (throws
    *                        `MissingTenantIdError` otherwise); memory backend
    *                        accepts but ignores
    */
@@ -132,5 +132,5 @@ export interface ISyncRunRecorder {
     limit: number,
     subscriptionId?: string,
     tenantId?: string | null,
-  ): Promise<SyncRunSummary[]>;
+  ): Promise<IntegrationRunSummary[]>;
 }

package/runtime/subsystems/{sync/sync-sink.protocol.ts → integration/integration-sink.protocol.ts}

@@ -1,5 +1,5 @@
 /**
- * Sync subsystem — sync-sink protocol (port)
+ * Integration subsystem — integration-sink protocol (port)
  *
  * Write surface for the generic orchestrator. One per canonical entity type.
  *
@@ -13,7 +13,7 @@
  * Implementations compose the entity's service + (when the entity has EAV)
  * `FieldValueService` inside a single transaction. ADR-13-revised.
  */
-export interface ISyncSink<TCanonical> {
+export interface IIntegrationSink<TCanonical> {
   /**
    * Canonical-shaped view of local state, or `null` when no local row exists.
    * Called once per change to source the diff's "before" side.
@@ -32,11 +32,11 @@ export interface ISyncSink<TCanonical> {
    *   - tolerate re-entry (same record twice in a window = no-op)
    *
    * Returns the local row id and the canonical projection of the saved row
-   * (so the orchestrator can record it on `sync_run_items.local_id`).
+   * (so the orchestrator can record it on `integration_run_items.local_id`).
    *
    * `provider` is the adapter domain string (e.g. `'salesforce-crm'`,
    * `'hubspot-crm'`) persisted on the DB row. Passed from
-   * `ExecuteSyncInput.provider`.
+   * `ExecuteIntegrationInput.provider`.
    */
   upsertByExternalId(
     userId: string,

package/runtime/subsystems/{sync/sync.module.ts → integration/integration.module.ts}

@@ -1,31 +1,31 @@
 /**
- * SyncModule — `DynamicModule.forRoot({ backend, multiTenant? })` factory
- * wiring the sync subsystem's substrate (SYNC-6, ADR-008 subsystem pattern).
+ * IntegrationModule — `DynamicModule.forRoot({ backend, multiTenant? })` factory
+ * wiring the integration subsystem's substrate (SYNC-6, ADR-008 subsystem pattern).
  *
  * ## What this module provides
  *
- *   - `SYNC_CURSOR_STORE`    — Drizzle or Memory cursor store
- *   - `SYNC_RUN_RECORDER`    — Drizzle or Memory run recorder
- *   - `SYNC_FIELD_DIFFER`    — default `DeepEqualDiffer`
- *   - `SYNC_MULTI_TENANT`    — resolved boolean flag (defaults to false)
- *   - `SYNC_MODULE_OPTIONS`  — the options object itself, for backends
+ *   - `INTEGRATION_CURSOR_STORE`    — Drizzle or Memory cursor store
+ *   - `INTEGRATION_RUN_RECORDER`    — Drizzle or Memory run recorder
+ *   - `INTEGRATION_FIELD_DIFFER`    — default `DeepEqualDiffer`
+ *   - `INTEGRATION_MULTI_TENANT`    — resolved boolean flag (defaults to false)
+ *   - `INTEGRATION_MODULE_OPTIONS`  — the options object itself, for backends
  *     that need to inspect config at construction time
  *
  * ## What this module does NOT provide
  *
- *   - `SYNC_CHANGE_SOURCE` — per-provider per-entity; consumer binds in
- *     their feature module (e.g. `OpportunitySyncModule` provides a
+ *   - `INTEGRATION_CHANGE_SOURCE` — per-provider per-entity; consumer binds in
+ *     their feature module (e.g. `OpportunityIntegrationModule` provides a
  *     `SalesforceOpportunityChangeSource`). Loopback suppression — when
  *     needed — is composed into the primitive's middleware chain via
  *     `createLoopbackMiddleware(store)` (#226-5 / ADR-033); the
  *     orchestrator no longer accepts a fingerprint store directly.
- *   - `SYNC_SINK` — per canonical entity; consumer binds in their feature
+ *   - `INTEGRATION_SINK` — per canonical entity; consumer binds in their feature
  *     module.
- *   - `ExecuteSyncUseCase` — registered by the feature module alongside
+ *   - `ExecuteIntegrationUseCase` — registered by the feature module alongside
  *     its source + sink bindings. Providing the orchestrator here would
- *     force Nest to resolve SYNC_CHANGE_SOURCE + SYNC_SINK at module
+ *     force Nest to resolve INTEGRATION_CHANGE_SOURCE + INTEGRATION_SINK at module
  *     compile time, which fails when the feature module hasn't been
- *     imported yet. Consumers register `ExecuteSyncUseCase` in the same
+ *     imported yet. Consumers register `ExecuteIntegrationUseCase` in the same
  *     `providers` array as their source + sink so resolution is local
  *     to where all three are bound.
  *
@@ -38,7 +38,7 @@
  * ```ts
  * // AppModule — single source of truth for backend + multi-tenancy.
  * @Module({
- *   imports: [SyncModule.forRoot({ backend: 'drizzle' })],
+ *   imports: [IntegrationModule.forRoot({ backend: 'drizzle' })],
  * })
  * export class AppModule {}
  *
@@ -46,36 +46,36 @@
  * // orchestrator for free.
  * @Module({
  *   providers: [
- *     { provide: SYNC_CHANGE_SOURCE, useClass: SalesforceOpportunitySource },
- *     { provide: SYNC_SINK,          useClass: OpportunitySyncSink },
- *     ExecuteSyncUseCase,
+ *     { provide: INTEGRATION_CHANGE_SOURCE, useClass: SalesforceOpportunitySource },
+ *     { provide: INTEGRATION_SINK,          useClass: OpportunityIntegrationSink },
+ *     ExecuteIntegrationUseCase,
  *   ],
  * })
- * export class OpportunitySyncModule {
+ * export class OpportunityIntegrationModule {
  *   constructor(
- *     private readonly execute: ExecuteSyncUseCase<CanonicalOpportunity>,
+ *     private readonly execute: ExecuteIntegrationUseCase<CanonicalOpportunity>,
  *   ) {}
  * }
  * ```
  *
  * `global: true` means feature modules do not need to re-import
- * `SyncModule` — the substrate tokens are available project-wide.
+ * `IntegrationModule` — the substrate tokens are available project-wide.
  */
 import { Module, type DynamicModule, type Provider } from '@nestjs/common';
 import {
-  SYNC_CURSOR_STORE,
-  SYNC_FIELD_DIFFER,
-  SYNC_MODULE_OPTIONS,
-  SYNC_MULTI_TENANT,
-  SYNC_RUN_RECORDER,
-} from './sync.tokens';
-import { MemoryCursorStore } from './sync-cursor-store.memory-backend';
-import { MemoryRunRecorder } from './sync-run-recorder.memory-backend';
-import { PostgresCursorStore } from './sync-cursor-store.drizzle-backend';
-import { DrizzleSyncRunRecorder } from './sync-run-recorder.drizzle-backend';
+  INTEGRATION_CURSOR_STORE,
+  INTEGRATION_FIELD_DIFFER,
+  INTEGRATION_MODULE_OPTIONS,
+  INTEGRATION_MULTI_TENANT,
+  INTEGRATION_RUN_RECORDER,
+} from './integration.tokens';
+import { MemoryCursorStore } from './integration-cursor-store.memory-backend';
+import { MemoryRunRecorder } from './integration-run-recorder.memory-backend';
+import { PostgresCursorStore } from './integration-cursor-store.drizzle-backend';
+import { DrizzleIntegrationRunRecorder } from './integration-run-recorder.drizzle-backend';
 import { DeepEqualDiffer } from './deep-equal.differ';
 
-export interface SyncModuleOptions {
+export interface IntegrationModuleOptions {
   /**
    * Backend selection. `drizzle` wires the Postgres cursor store +
    * run-log recorder; `memory` wires in-memory doubles suitable for
@@ -103,16 +103,16 @@ export interface SyncModuleOptions {
 }
 
 @Module({})
-export class SyncModule {
-  static forRoot(options: SyncModuleOptions): DynamicModule {
+export class IntegrationModule {
+  static forRoot(options: IntegrationModuleOptions): DynamicModule {
     const multiTenant = options.multiTenant ?? false;
 
     const sharedProviders: Provider[] = [
-      { provide: SYNC_MODULE_OPTIONS, useValue: options },
-      { provide: SYNC_MULTI_TENANT, useValue: multiTenant },
+      { provide: INTEGRATION_MODULE_OPTIONS, useValue: options },
+      { provide: INTEGRATION_MULTI_TENANT, useValue: multiTenant },
       // Default differ — consumers can override by binding a different
-      // `IFieldDiffer<T>` to `SYNC_FIELD_DIFFER` in their feature module.
-      { provide: SYNC_FIELD_DIFFER, useValue: new DeepEqualDiffer() },
+      // `IFieldDiffer<T>` to `INTEGRATION_FIELD_DIFFER` in their feature module.
+      { provide: INTEGRATION_FIELD_DIFFER, useValue: new DeepEqualDiffer() },
     ];
 
     const backendProviders: Provider[] =
@@ -123,33 +123,33 @@ export class SyncModule {
             // direct assertions. Matches JOB-4 / MemoryJobStore shape.
             { provide: MemoryCursorStore, useValue: new MemoryCursorStore() },
             {
-              provide: SYNC_CURSOR_STORE,
+              provide: INTEGRATION_CURSOR_STORE,
               useExisting: MemoryCursorStore,
             },
             { provide: MemoryRunRecorder, useValue: new MemoryRunRecorder() },
             {
-              provide: SYNC_RUN_RECORDER,
+              provide: INTEGRATION_RUN_RECORDER,
               useExisting: MemoryRunRecorder,
             },
           ]
         : [
             // Drizzle backends — injected with DRIZZLE (provided by the
-            // consumer's DrizzleModule) + the SYNC_MULTI_TENANT flag
+            // consumer's DrizzleModule) + the INTEGRATION_MULTI_TENANT flag
             // we bound above.
-            { provide: SYNC_CURSOR_STORE, useClass: PostgresCursorStore },
-            { provide: SYNC_RUN_RECORDER, useClass: DrizzleSyncRunRecorder },
+            { provide: INTEGRATION_CURSOR_STORE, useClass: PostgresCursorStore },
+            { provide: INTEGRATION_RUN_RECORDER, useClass: DrizzleIntegrationRunRecorder },
           ];
 
     return {
-      module: SyncModule,
+      module: IntegrationModule,
       global: true,
       providers: [...sharedProviders, ...backendProviders],
       exports: [
-        SYNC_MODULE_OPTIONS,
-        SYNC_MULTI_TENANT,
-        SYNC_FIELD_DIFFER,
-        SYNC_CURSOR_STORE,
-        SYNC_RUN_RECORDER,
+        INTEGRATION_MODULE_OPTIONS,
+        INTEGRATION_MULTI_TENANT,
+        INTEGRATION_FIELD_DIFFER,
+        INTEGRATION_CURSOR_STORE,
+        INTEGRATION_RUN_RECORDER,
       ],
     };
   }

package/runtime/subsystems/integration/integration.tokens.ts

@@ -0,0 +1,49 @@
+/**
+ * Integration subsystem — DI tokens
+ *
+ * String constants (not Symbols) so they match by value across import
+ * boundaries — same convention as the events subsystem (`EVENT_BUS`). The
+ * jobs subsystem uses Symbols for its analogous tokens; events and integration
+ * stay internally consistent with strings.
+ *
+ * Usage in use cases:
+ * ```ts
+ * constructor(
+ *   @Inject(INTEGRATION_CHANGE_SOURCE) private readonly source: IChangeSource<CanonicalOpportunity>,
+ *   @Inject(INTEGRATION_CURSOR_STORE)  private readonly cursors: ICursorStore,
+ *   @Inject(INTEGRATION_FIELD_DIFFER)  private readonly differ: IFieldDiffer<CanonicalOpportunity>,
+ *   @Inject(INTEGRATION_SINK)          private readonly sink: IIntegrationSink<CanonicalOpportunity>,
+ *   @Inject(INTEGRATION_RUN_RECORDER)  private readonly recorder: IIntegrationRunRecorder,
+ * ) {}
+ * ```
+ *
+ * Concrete bindings are registered by `IntegrationModule.forRoot(...)` (SYNC-6).
+ */
+
+export const INTEGRATION_CHANGE_SOURCE = 'INTEGRATION_CHANGE_SOURCE' as const;
+export const INTEGRATION_CURSOR_STORE = 'INTEGRATION_CURSOR_STORE' as const;
+export const INTEGRATION_FIELD_DIFFER = 'INTEGRATION_FIELD_DIFFER' as const;
+export const INTEGRATION_SINK = 'INTEGRATION_SINK' as const;
+
+/**
+ * Run-recorder token (SYNC-5). Backed by `IIntegrationRunRecorder`. Drizzle impl
+ * lands in SYNC-4; tests provide inline fakes.
+ */
+export const INTEGRATION_RUN_RECORDER = 'INTEGRATION_RUN_RECORDER' as const;
+
+/**
+ * Injection token for the resolved `IntegrationModuleOptions` object (SYNC-6).
+ *
+ * Backends that need to observe module configuration (e.g. `multiTenant`
+ * flag, pool filters) inject via this token. Provided automatically by
+ * `IntegrationModule.forRoot(...)` / `IntegrationModule.forRootAsync(...)`.
+ */
+export const INTEGRATION_MODULE_OPTIONS = 'INTEGRATION_MODULE_OPTIONS' as const;
+
+/**
+ * Injection token for the resolved multi-tenancy flag (SYNC-6).
+ *
+ * Provided by `IntegrationModule.forRoot(...)` as `options.multiTenant ?? false`.
+ * Consumed by `ExecuteIntegrationUseCase` to enforce the tenantId-is-required rule.
+ */
+export const INTEGRATION_MULTI_TENANT = 'INTEGRATION_MULTI_TENANT' as const;

package/runtime/subsystems/{sync → integration}/loopback.middleware.ts

@@ -1,7 +1,7 @@
 /**
- * Sync subsystem — loopback `ChangeMiddleware` factory (#226-5, ADR-033).
+ * Integration subsystem — loopback `ChangeMiddleware` factory (#226-5, ADR-033).
  *
- * Replaces the prior orchestrator-side `@Optional() SYNC_LOOPBACK_FINGERPRINT_STORE`
+ * Replaces the prior orchestrator-side `@Optional() INTEGRATION_LOOPBACK_FINGERPRINT_STORE`
  * branch. Consumers that need to suppress echoes of their own outbound
  * writes compose `createLoopbackMiddleware(store)` into a primitive's
  * middleware chain — typically alongside `PollChangeSource<T>` — instead
@@ -28,12 +28,12 @@
  * their store or layer a counting middleware alongside this one.
  */
 
-import type { Change } from './sync-change-source.protocol';
+import type { Change } from './integration-change-source.protocol';
 import type {
   ChangeIterator,
   ChangeMiddleware,
-} from './sync-middleware.protocol';
-import type { ILoopbackFingerprintStore } from './sync-loopback.protocol';
+} from './integration-middleware.protocol';
+import type { ILoopbackFingerprintStore } from './integration-loopback.protocol';
 
 /**
  * Build a `ChangeMiddleware<T>` that suppresses changes whose fingerprint

package/runtime/subsystems/{sync → integration}/poll-change-source.ts

@@ -1,5 +1,5 @@
 /**
- * Sync subsystem — `PollChangeSource<T>` primitive (#226-3, ADR-033).
+ * Integration subsystem — `PollChangeSource<T>` primitive (#226-3, ADR-033).
  *
  * Generic poll-mode `IChangeSource<T>` implementation parameterized by a
  * parsed `DetectionConfig` (poll mode) and a consumer-supplied
@@ -36,12 +36,12 @@ import type {
   Change,
   ChangeSource,
   IChangeSource,
-  SyncSubscriptionView,
-} from './sync-change-source.protocol';
+  IntegrationSubscriptionView,
+} from './integration-change-source.protocol';
 import type {
   ChangeIterator,
   ChangeMiddleware,
-} from './sync-middleware.protocol';
+} from './integration-middleware.protocol';
 
 // ============================================================================
 // Cursor + adapter callback shapes
@@ -60,7 +60,7 @@ export type PollCursor = unknown;
  * NOT here on purpose.
  */
 export interface PollFetchContext {
-  readonly subscription: SyncSubscriptionView;
+  readonly subscription: IntegrationSubscriptionView;
   readonly cursor: PollCursor | null;
   readonly filters: readonly ResolvedFilter[];
 }
@@ -174,14 +174,14 @@ export class PollChangeSource<T> implements IChangeSource<T> {
   }
 
   listChanges(
-    subscription: SyncSubscriptionView,
+    subscription: IntegrationSubscriptionView,
     cursor: unknown | null,
   ): AsyncIterable<Change<T>> {
     return this.composed(subscription, cursor);
   }
 
   private async *fetch(
-    subscription: SyncSubscriptionView,
+    subscription: IntegrationSubscriptionView,
     cursor: unknown | null,
   ): AsyncIterable<Change<T>> {
     const ctx: PollFetchContext = {

package/runtime/subsystems/{sync → integration}/webhook-change-source.ts

@@ -1,5 +1,5 @@
 /**
- * Sync subsystem — `WebhookChangeSource<T>` primitive (#226-4, ADR-033).
+ * Integration subsystem — `WebhookChangeSource<T>` primitive (#226-4, ADR-033).
  *
  * Generic webhook-mode `IChangeSource<T>` implementation parameterized by a
  * parsed `DetectionConfig` (webhook mode) and a consumer-supplied
@@ -40,12 +40,12 @@ import type { DetectionConfig } from './detection-config.schema';
 import type {
   Change,
   IChangeSource,
-  SyncSubscriptionView,
-} from './sync-change-source.protocol';
+  IntegrationSubscriptionView,
+} from './integration-change-source.protocol';
 import type {
   ChangeIterator,
   ChangeMiddleware,
-} from './sync-middleware.protocol';
+} from './integration-middleware.protocol';
 
 // ============================================================================
 // Cursor + queue callback shapes
@@ -65,7 +65,7 @@ export type WebhookCursor = unknown;
  * `userId` / `tenantId`.
  */
 export interface WebhookFetchContext {
-  readonly subscription: SyncSubscriptionView;
+  readonly subscription: IntegrationSubscriptionView;
   readonly cursor: WebhookCursor | null;
 }
 
@@ -162,14 +162,14 @@ export class WebhookChangeSource<T> implements IChangeSource<T> {
   }
 
   listChanges(
-    subscription: SyncSubscriptionView,
+    subscription: IntegrationSubscriptionView,
     cursor: unknown | null,
   ): AsyncIterable<Change<T>> {
     return this.composed(subscription, cursor);
   }
 
   private async *fetch(
-    subscription: SyncSubscriptionView,
+    subscription: IntegrationSubscriptionView,
     cursor: unknown | null,
   ): AsyncIterable<Change<T>> {
     const ctx: WebhookFetchContext = {

package/runtime/subsystems/observability/index.ts

@@ -39,7 +39,7 @@ export type {
   CorrelationTimeline,
   CorrelationTimelineEntry,
   StatusHistogram,
-  SyncRunSummary,
+  IntegrationRunSummary,
   CursorSnapshot,
 } from './observability.protocol';