@pattern-stack/codegen 0.10.0 → 0.11.0

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

@@ -1,5 +1,5 @@
 /**
- * Typed errors + shared boundary helpers for the sync subsystem.
+ * Typed errors + shared boundary helpers for the integration subsystem.
  *
  * Classes (not bare Error) so consumers can `instanceof` them in catch
  * blocks and exception filters can map them to HTTP codes.
@@ -9,7 +9,7 @@
 
 /**
  * Thrown by the Drizzle cursor-store / run-recorder backends AND by the
- * orchestrator entry point when `SYNC_MULTI_TENANT` is enabled but the
+ * orchestrator entry point when `INTEGRATION_MULTI_TENANT` is enabled but the
  * caller did not supply a non-null `tenantId`. Strict enforcement at the
  * boundary — explicit `null` still throws.
  *
@@ -24,7 +24,7 @@ export class MissingTenantIdError extends Error {
   override readonly name = 'MissingTenantIdError';
   constructor(operation: string) {
     super(
-      `Missing tenantId for sync operation '${operation}'. SyncModule is ` +
+      `Missing tenantId for integration operation '${operation}'. IntegrationModule is ` +
         `configured with multiTenant: true — every call must include a ` +
         `non-null tenantId. Either pass the tenantId or disable multi-` +
         `tenancy on the module.`,

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

@@ -1,5 +1,5 @@
 /**
- * Sync subsystem — field-diff protocol (port)
+ * Integration subsystem — field-diff protocol (port)
  *
  * `IFieldDiffer<T>` is the pluggable differ seam. The default implementation
  * (`DeepEqualDiffer`, ships in SYNC-5) walks every field except an ignore
@@ -17,7 +17,7 @@ import { z } from 'zod';
 // ============================================================================
 
 /**
- * Structured per-field change. Enforced shape for `sync_run_items.changed_fields`.
+ * Structured per-field change. Enforced shape for `integration_run_items.changed_fields`.
  *
  * `created` items set `from: null, to: <value>` for every non-null field.
  * `deleted` items set `from: <value>, to: null`.

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

@@ -1,9 +1,9 @@
 /**
- * Sync subsystem — loopback-fingerprint protocol (port)
+ * Integration subsystem — loopback-fingerprint protocol (port)
  *
  * Optional port. When the local system writes to an upstream provider via an
  * outbound path, the same change typically echoes back on the next inbound
- * poll/CDC/webhook. A fingerprint store lets `ExecuteSyncUseCase` skip
+ * poll/CDC/webhook. A fingerprint store lets `ExecuteIntegrationUseCase` skip
  * records it already wrote, avoiding a diff-noop round trip and a spurious
  * audit row.
  *

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

@@ -1,5 +1,5 @@
 /**
- * Sync subsystem — change-source middleware protocol (#226-1)
+ * Integration subsystem — change-source middleware protocol (#226-1)
  *
  * `ChangeMiddleware<T>` lets consumers compose cross-cutting concerns
  * (loopback suppression, redaction, throttling) onto an `IChangeSource<T>`
@@ -11,7 +11,7 @@
  *
  *   type ChangeMiddleware<T> =
  *     (next: ChangeIterator<T>) =>
- *       (subscription: SyncSubscriptionView, cursor: unknown | null) =>
+ *       (subscription: IntegrationSubscriptionView, cursor: unknown | null) =>
  *         AsyncIterable<Change<T>>;
  *
  * The middleware wraps the *next* iterator factory rather than the
@@ -26,13 +26,13 @@
  * Loopback shipping as middleware (#226-5) is the canonical example —
  * `createLoopbackMiddleware(store)` filters echoes of local writes
  * before they reach the orchestrator's diff stage, replacing the prior
- * `@Optional() SYNC_LOOPBACK_FINGERPRINT_STORE` orchestrator branch.
+ * `@Optional() INTEGRATION_LOOPBACK_FINGERPRINT_STORE` orchestrator branch.
  */
 
 import type {
   Change,
-  SyncSubscriptionView,
-} from './sync-change-source.protocol';
+  IntegrationSubscriptionView,
+} from './integration-change-source.protocol';
 
 // ============================================================================
 // ChangeIterator — the inner shape middleware wraps
@@ -44,7 +44,7 @@ import type {
  * `IChangeSource<T>` instance method binds 1:1 to this signature.
  */
 export type ChangeIterator<T> = (
-  subscription: SyncSubscriptionView,
+  subscription: IntegrationSubscriptionView,
   cursor: unknown | null,
 ) => AsyncIterable<Change<T>>;
 

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

@@ -1,23 +1,23 @@
 /**
- * DrizzleSyncRunRecorder — Drizzle-backed `ISyncRunRecorder` (SYNC-4).
+ * DrizzleIntegrationRunRecorder — Drizzle-backed `IIntegrationRunRecorder` (SYNC-4).
  *
  * Generic write path only — extracted from the source app's
- * `SyncRunRecorderService`, minus CRM-specific convenience methods. Those
+ * `IntegrationRunRecorderService`, minus CRM-specific convenience methods. Those
  * stay consumer-owned; the subsystem ships the substrate.
  *
  * ## Responsibilities
  *
- *   - `startRun`     — INSERT sync_runs row in status='running', returns id.
+ *   - `startRun`     — INSERT integration_runs row in status='running', returns id.
  *   - `recordItem`   — validates `changedFields` via `FieldDiffSchema.parse`
  *                      BEFORE the INSERT; a malformed shape throws before
  *                      any DB call fires. Enforces the ADR-0003 contract at
  *                      the write boundary.
- *   - `completeRun`  — UPDATE sync_runs with terminal status, counts,
+ *   - `completeRun`  — UPDATE integration_runs with terminal status, counts,
  *                      cursor_after, duration_ms, completed_at.
  *
  * ## Multi-tenancy
  *
- * When `SYNC_MULTI_TENANT` is true (SYNC-6):
+ * When `INTEGRATION_MULTI_TENANT` is true (SYNC-6):
  *   - `startRun` and `recordItem` require non-null `tenantId` on input.
  *     Enforcement goes through the shared `assertTenantId` helper so the
  *     error message shape matches the orchestrator entry point + the
@@ -33,23 +33,23 @@ import type { DrizzleClient } from '../../types/drizzle';
 import { DRIZZLE } from '../../constants/tokens';
 import type {
   CompleteRunInput,
-  ISyncRunRecorder,
+  IIntegrationRunRecorder,
   RecordItemInput,
   StartRunInput,
-  SyncRunSummary,
-} from './sync-run-recorder.protocol';
-import { syncRuns, syncRunItems, syncSubscriptions } from './sync-audit.schema';
-import { FieldDiffSchema } from './sync-field-diff.protocol';
-import { SYNC_MULTI_TENANT } from './sync.tokens';
-import { assertTenantId } from './sync-errors';
+  IntegrationRunSummary,
+} from './integration-run-recorder.protocol';
+import { integrationRuns, integrationRunItems, integrationSubscriptions } from './integration-audit.schema';
+import { FieldDiffSchema } from './integration-field-diff.protocol';
+import { INTEGRATION_MULTI_TENANT } from './integration.tokens';
+import { assertTenantId } from './integration-errors';
 
 @Injectable()
-export class DrizzleSyncRunRecorder implements ISyncRunRecorder {
+export class DrizzleIntegrationRunRecorder implements IIntegrationRunRecorder {
   private readonly multiTenant: boolean;
 
   constructor(
     @Inject(DRIZZLE) private readonly db: DrizzleClient,
-    @Optional() @Inject(SYNC_MULTI_TENANT) multiTenant?: boolean,
+    @Optional() @Inject(INTEGRATION_MULTI_TENANT) multiTenant?: boolean,
   ) {
     this.multiTenant = multiTenant ?? false;
   }
@@ -61,7 +61,7 @@ export class DrizzleSyncRunRecorder implements ISyncRunRecorder {
     });
 
     const rows = await this.db
-      .insert(syncRuns)
+      .insert(integrationRuns)
       .values({
         subscriptionId: input.subscriptionId,
         direction: input.direction,
@@ -70,14 +70,14 @@ export class DrizzleSyncRunRecorder implements ISyncRunRecorder {
         cursorBefore: input.cursorBefore ?? null,
         tenantId: input.tenantId ?? null,
       })
-      .returning({ id: syncRuns.id });
+      .returning({ id: integrationRuns.id });
 
     const id = rows[0]?.id;
     if (!id) {
       // Drizzle's insert().returning() contract: at least one row is
       // returned for every successful INSERT. A missing id would indicate
       // a driver misbehavior; throw loudly rather than return bogus data.
-      throw new Error('DrizzleSyncRunRecorder: INSERT RETURNING produced no id');
+      throw new Error('DrizzleIntegrationRunRecorder: INSERT RETURNING produced no id');
     }
     return { id };
   }
@@ -93,8 +93,8 @@ export class DrizzleSyncRunRecorder implements ISyncRunRecorder {
     // the validation failure, not a DB constraint error.
     FieldDiffSchema.parse(input.changedFields);
 
-    await this.db.insert(syncRunItems).values({
-      syncRunId: input.syncRunId,
+    await this.db.insert(integrationRunItems).values({
+      integrationRunId: input.integrationRunId,
       entityType: input.entityType,
       externalId: input.externalId,
       localId: input.localId ?? null,
@@ -111,21 +111,21 @@ export class DrizzleSyncRunRecorder implements ISyncRunRecorder {
     limit: number,
     subscriptionId?: string,
     tenantId?: string | null,
-  ): Promise<SyncRunSummary[]> {
+  ): Promise<IntegrationRunSummary[]> {
     assertTenantId(tenantId, {
       multiTenant: this.multiTenant,
       operation: 'listRecent',
     });
 
-    // JOIN against sync_subscriptions to resolve `integration_id` per run.
-    // `sync_runs.subscription_id` is a non-null FK so INNER JOIN is correct;
+    // JOIN against integration_subscriptions to resolve `connection_id` per run.
+    // `integration_runs.subscription_id` is a non-null FK so INNER JOIN is correct;
     // there should be no orphaned runs.
     const conditions: SQL[] = [];
     if (subscriptionId !== undefined) {
-      conditions.push(eq(syncRuns.subscriptionId, subscriptionId));
+      conditions.push(eq(integrationRuns.subscriptionId, subscriptionId));
     }
     if (this.multiTenant) {
-      conditions.push(eq(syncRuns.tenantId, tenantId as string));
+      conditions.push(eq(integrationRuns.tenantId, tenantId as string));
     }
     const where =
       conditions.length === 0
@@ -136,28 +136,28 @@ export class DrizzleSyncRunRecorder implements ISyncRunRecorder {
 
     const rows = await this.db
       .select({
-        id: syncRuns.id,
-        subscriptionId: syncRuns.subscriptionId,
-        integrationId: syncSubscriptions.integrationId,
-        status: syncRuns.status,
-        startedAt: syncRuns.startedAt,
-        completedAt: syncRuns.completedAt,
-        recordsProcessed: syncRuns.recordsProcessed,
-        tenantId: syncRuns.tenantId,
+        id: integrationRuns.id,
+        subscriptionId: integrationRuns.subscriptionId,
+        connectionId: integrationSubscriptions.connectionId,
+        status: integrationRuns.status,
+        startedAt: integrationRuns.startedAt,
+        completedAt: integrationRuns.completedAt,
+        recordsProcessed: integrationRuns.recordsProcessed,
+        tenantId: integrationRuns.tenantId,
       })
-      .from(syncRuns)
+      .from(integrationRuns)
       .innerJoin(
-        syncSubscriptions,
-        eq(syncRuns.subscriptionId, syncSubscriptions.id),
+        integrationSubscriptions,
+        eq(integrationRuns.subscriptionId, integrationSubscriptions.id),
       )
       .where(where)
-      .orderBy(desc(syncRuns.startedAt))
+      .orderBy(desc(integrationRuns.startedAt))
       .limit(limit);
 
     return rows.map((row) => ({
       id: row.id,
       subscriptionId: row.subscriptionId,
-      integrationId: row.integrationId,
+      connectionId: row.connectionId,
       status: row.status,
       startedAt: row.startedAt,
       completedAt: row.completedAt,
@@ -168,7 +168,7 @@ export class DrizzleSyncRunRecorder implements ISyncRunRecorder {
 
   async completeRun(runId: string, input: CompleteRunInput): Promise<void> {
     await this.db
-      .update(syncRuns)
+      .update(integrationRuns)
       .set({
         status: input.status,
         recordsFound: input.recordsFound,
@@ -178,6 +178,6 @@ export class DrizzleSyncRunRecorder implements ISyncRunRecorder {
         error: input.error ?? null,
         completedAt: new Date(),
       })
-      .where(eq(syncRuns.id, runId));
+      .where(eq(integrationRuns.id, runId));
   }
 }

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,