@pattern-stack/codegen 0.10.1 → 0.11.0

package/runtime/subsystems/{sync/execute-sync.use-case.ts → integration/execute-integration.use-case.ts}

@@ -1,12 +1,12 @@
 /**
- * ExecuteSyncUseCase — the generic sync orchestrator (SYNC-5).
+ * ExecuteIntegrationUseCase — the generic integration orchestrator (SYNC-5).
  *
  * One class. Reused across every `(provider, detection-mode, canonical-entity)`
  * tuple. Parameterized over `T` so canonical records stay typed end-to-end.
  *
  * Flow per run:
  *
- *   1. `recorder.startRun(...)` — opens a `sync_runs` row in 'running'.
+ *   1. `recorder.startRun(...)` — opens a `integration_runs` row in 'running'.
  *   2. for each change yielded by `source.listChanges(subscription, cursorBefore)`:
  *        a. differ.diff(existing, incoming) → 'noop' short-circuits to
  *           a noop audit row (no sink write).
@@ -33,7 +33,7 @@
  * ## Generics
  *
  * - `T` = canonical record shape from the adapter side. Same `T` flows
- *   through `IChangeSource<T>`, `IFieldDiffer<T>`, `ISyncSink<T>`.
+ *   through `IChangeSource<T>`, `IFieldDiffer<T>`, `IIntegrationSink<T>`.
  *
  * ## No CRM bleed
  *
@@ -41,30 +41,30 @@
  * is strictly provider-agnostic:
  *   - `entityType` is `string` throughout; no `'opportunity' | 'account' | ...`
  *     narrowing leaks into the use case
- *   - the upstream consumer's `SyncRunRecorderService` class injection replaced with the
- *     `ISyncRunRecorder` protocol (backend lands in SYNC-4)
+ *   - the upstream consumer's `IntegrationRunRecorderService` class injection replaced with the
+ *     `IIntegrationRunRecorder` protocol (backend lands in SYNC-4)
  */
 import { Inject, Injectable, Logger, Optional } from '@nestjs/common';
-import type { IChangeSource, Change } from './sync-change-source.protocol';
-import type { ICursorStore } from './sync-cursor-store.protocol';
-import type { IFieldDiffer, FieldDiff } from './sync-field-diff.protocol';
-import type { ISyncSink } from './sync-sink.protocol';
-import type { ISyncRunRecorder } from './sync-run-recorder.protocol';
-import { assertTenantId } from './sync-errors';
+import type { IChangeSource, Change } from './integration-change-source.protocol';
+import type { ICursorStore } from './integration-cursor-store.protocol';
+import type { IFieldDiffer, FieldDiff } from './integration-field-diff.protocol';
+import type { IIntegrationSink } from './integration-sink.protocol';
+import type { IIntegrationRunRecorder } from './integration-run-recorder.protocol';
+import { assertTenantId } from './integration-errors';
 import {
-  SYNC_CHANGE_SOURCE,
-  SYNC_CURSOR_STORE,
-  SYNC_FIELD_DIFFER,
-  SYNC_MULTI_TENANT,
-  SYNC_RUN_RECORDER,
-  SYNC_SINK,
-} from './sync.tokens';
+  INTEGRATION_CHANGE_SOURCE,
+  INTEGRATION_CURSOR_STORE,
+  INTEGRATION_FIELD_DIFFER,
+  INTEGRATION_MULTI_TENANT,
+  INTEGRATION_RUN_RECORDER,
+  INTEGRATION_SINK,
+} from './integration.tokens';
 
 // ============================================================================
 // Inputs + result
 // ============================================================================
 
-export interface ExecuteSyncInput<T> {
+export interface ExecuteIntegrationInput<T> {
   /** The subscription whose cursor/identity frames this run. */
   readonly subscription: {
     readonly id: string;
@@ -77,19 +77,19 @@ export interface ExecuteSyncInput<T> {
   readonly provider: string;
   /** Run direction — almost always `'inbound'`. Reserved for writeback. */
   readonly direction: 'inbound' | 'outbound';
-  /** Detection mode — maps 1:1 to `sync_runs.action`. */
+  /** Detection mode — maps 1:1 to `integration_runs.action`. */
   readonly action: 'poll' | 'cdc' | 'webhook' | 'manual' | 'writeback';
   /** Multi-tenant deployments pass the tenant id through. */
   readonly tenantId?: string | null;
   /**
    * Optional override — inject a specific change source for this run when
    * the DI-bound source is not the one to use (e.g. manual backfill with
-   * a custom cursor). Defaults to the DI-resolved `SYNC_CHANGE_SOURCE`.
+   * a custom cursor). Defaults to the DI-resolved `INTEGRATION_CHANGE_SOURCE`.
    */
   readonly sourceOverride?: IChangeSource<T>;
 }
 
-export interface ExecuteSyncResult {
+export interface ExecuteIntegrationResult {
   readonly runId: string;
   readonly status: 'success' | 'no_changes' | 'failed';
   readonly recordsFound: number;
@@ -102,25 +102,25 @@ export interface ExecuteSyncResult {
 }
 
 // ============================================================================
-// ExecuteSyncUseCase
+// ExecuteIntegrationUseCase
 // ============================================================================
 
 @Injectable()
-export class ExecuteSyncUseCase<T extends Record<string, unknown>> {
-  private readonly logger = new Logger(ExecuteSyncUseCase.name);
+export class ExecuteIntegrationUseCase<T extends Record<string, unknown>> {
+  private readonly logger = new Logger(ExecuteIntegrationUseCase.name);
 
   constructor(
-    @Inject(SYNC_CHANGE_SOURCE) private readonly source: IChangeSource<T>,
-    @Inject(SYNC_CURSOR_STORE) private readonly cursors: ICursorStore,
-    @Inject(SYNC_FIELD_DIFFER) private readonly differ: IFieldDiffer<T>,
-    @Inject(SYNC_SINK) private readonly sink: ISyncSink<T>,
-    @Inject(SYNC_RUN_RECORDER) private readonly recorder: ISyncRunRecorder,
+    @Inject(INTEGRATION_CHANGE_SOURCE) private readonly source: IChangeSource<T>,
+    @Inject(INTEGRATION_CURSOR_STORE) private readonly cursors: ICursorStore,
+    @Inject(INTEGRATION_FIELD_DIFFER) private readonly differ: IFieldDiffer<T>,
+    @Inject(INTEGRATION_SINK) private readonly sink: IIntegrationSink<T>,
+    @Inject(INTEGRATION_RUN_RECORDER) private readonly recorder: IIntegrationRunRecorder,
     @Optional()
-    @Inject(SYNC_MULTI_TENANT)
+    @Inject(INTEGRATION_MULTI_TENANT)
     private readonly multiTenant: boolean = false,
   ) {}
 
-  async execute(input: ExecuteSyncInput<T>): Promise<ExecuteSyncResult> {
+  async execute(input: ExecuteIntegrationInput<T>): Promise<ExecuteIntegrationResult> {
     // Defense-in-depth tenancy guard — fire BEFORE startRun so a rejected
     // input never leaves a dangling `status=running` row. Backends also
     // enforce (SYNC-4), but failing fast at the orchestrator boundary is
@@ -163,10 +163,10 @@ export class ExecuteSyncUseCase<T extends Record<string, unknown>> {
           recordsFailed++;
           const message = err instanceof Error ? err.message : String(err);
           this.logger.warn(
-            `sync item failed: subscription=${input.subscription.id} externalId=${change.externalId}: ${message}`,
+            `integration item failed: subscription=${input.subscription.id} externalId=${change.externalId}: ${message}`,
           );
           await this.recorder.recordItem({
-            syncRunId: runId,
+            integrationRunId: runId,
             entityType: input.subscription.domain,
             externalId: change.externalId,
             operation: change.operation === 'deleted' ? 'deleted' : 'updated',
@@ -197,7 +197,7 @@ export class ExecuteSyncUseCase<T extends Record<string, unknown>> {
       status = 'failed';
       runError = err instanceof Error ? err.message : String(err);
       this.logger.error(
-        `sync source failed: subscription=${input.subscription.id}: ${runError}`,
+        `integration source failed: subscription=${input.subscription.id}: ${runError}`,
       );
     }
 
@@ -244,7 +244,7 @@ export class ExecuteSyncUseCase<T extends Record<string, unknown>> {
 
   private async processChange(
     runId: string,
-    input: ExecuteSyncInput<T>,
+    input: ExecuteIntegrationInput<T>,
     change: Change<T>,
   ): Promise<void> {
     // Deletion branch — no diff, no upsert; soft-delete via sink.
@@ -254,7 +254,7 @@ export class ExecuteSyncUseCase<T extends Record<string, unknown>> {
         change.externalId,
       );
       await this.recorder.recordItem({
-        syncRunId: runId,
+        integrationRunId: runId,
         entityType: input.subscription.domain,
         externalId: change.externalId,
         localId: result?.id ?? null,
@@ -285,7 +285,7 @@ export class ExecuteSyncUseCase<T extends Record<string, unknown>> {
       // returned by the upsert. Sinks without the flag keep today's behavior.
       if (!this.sink.reprojectsOnNoop) {
         await this.recorder.recordItem({
-          syncRunId: runId,
+          integrationRunId: runId,
           entityType: input.subscription.domain,
           externalId: change.externalId,
           localId: null,
@@ -303,7 +303,7 @@ export class ExecuteSyncUseCase<T extends Record<string, unknown>> {
         input.provider,
       );
       await this.recorder.recordItem({
-        syncRunId: runId,
+        integrationRunId: runId,
         entityType: input.subscription.domain,
         externalId: change.externalId,
         localId: noopLocalId,
@@ -322,7 +322,7 @@ export class ExecuteSyncUseCase<T extends Record<string, unknown>> {
     );
 
     await this.recorder.recordItem({
-      syncRunId: runId,
+      integrationRunId: runId,
       entityType: input.subscription.domain,
       externalId: change.externalId,
       localId,

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

@@ -1,13 +1,13 @@
 /**
- * Sync subsystem — public API
+ * Integration subsystem — public API
  *
  * Slices landed so far:
  *   - SYNC-2 — protocols + DI tokens (#134)
  *   - SYNC-1 — Drizzle audit-table schemas (#148)
  *   - SYNC-3 — MemoryCursorStore (#149)
- *   - SYNC-5 — ExecuteSyncUseCase + DeepEqualDiffer + recorder/loopback protocols (#150)
+ *   - SYNC-5 — ExecuteIntegrationUseCase + DeepEqualDiffer + recorder/loopback protocols (#150)
  *   - SYNC-4 — Drizzle backends (#151)
- *   - SYNC-6 — SyncModule + MemoryRunRecorder + multi-tenancy opt-in (this slice)
+ *   - SYNC-6 — IntegrationModule + MemoryRunRecorder + multi-tenancy opt-in (this slice)
  *
  * Scaffold templates (SYNC-7) and docs/skills (SYNC-8) land in their own
  * PRs. See epic #60.
@@ -18,31 +18,31 @@ export type {
   Change,
   ChangeSource,
   IChangeSource,
-  SyncSubscriptionView,
-} from './sync-change-source.protocol';
+  IntegrationSubscriptionView,
+} from './integration-change-source.protocol';
 export type {
   CursorSnapshot,
   ICursorStore,
-} from './sync-cursor-store.protocol';
+} from './integration-cursor-store.protocol';
 export type {
   DiffResult,
   FieldDiff,
   FieldDiffValue,
   IFieldDiffer,
-} from './sync-field-diff.protocol';
+} from './integration-field-diff.protocol';
 export {
   FieldDiffSchema,
   FieldDiffValueSchema,
-} from './sync-field-diff.protocol';
-export type { ISyncSink } from './sync-sink.protocol';
+} from './integration-field-diff.protocol';
+export type { IIntegrationSink } from './integration-sink.protocol';
 export type {
   CompleteRunInput,
-  ISyncRunRecorder,
+  IIntegrationRunRecorder,
   RecordItemInput,
   StartRunInput,
-  SyncRunSummary,
-} from './sync-run-recorder.protocol';
-export type { ILoopbackFingerprintStore } from './sync-loopback.protocol';
+  IntegrationRunSummary,
+} from './integration-run-recorder.protocol';
+export type { ILoopbackFingerprintStore } from './integration-loopback.protocol';
 
 // DetectionConfig (#226-1) — Zod schema + inferred types; canonical source
 // of filter/mapping shape consumed by primitives + codegen YAML validator
@@ -68,10 +68,10 @@ export type {
   ChangeIterator,
   ChangeMiddleware,
   ComposeChangeMiddleware,
-} from './sync-middleware.protocol';
+} from './integration-middleware.protocol';
 
 // Loopback middleware factory (#226-5) — replaces the orchestrator's prior
-// `@Optional() SYNC_LOOPBACK_FINGERPRINT_STORE` branch. Consumers compose
+// `@Optional() INTEGRATION_LOOPBACK_FINGERPRINT_STORE` branch. Consumers compose
 // `createLoopbackMiddleware(store)` into their primitive's middleware chain.
 export { createLoopbackMiddleware } from './loopback.middleware';
 
@@ -100,42 +100,42 @@ export { buildChangeSource } from './build-change-source';
 
 // Tokens
 export {
-  SYNC_CHANGE_SOURCE,
-  SYNC_CURSOR_STORE,
-  SYNC_FIELD_DIFFER,
-  SYNC_MODULE_OPTIONS,
-  SYNC_MULTI_TENANT,
-  SYNC_RUN_RECORDER,
-  SYNC_SINK,
-} from './sync.tokens';
+  INTEGRATION_CHANGE_SOURCE,
+  INTEGRATION_CURSOR_STORE,
+  INTEGRATION_FIELD_DIFFER,
+  INTEGRATION_MODULE_OPTIONS,
+  INTEGRATION_MULTI_TENANT,
+  INTEGRATION_RUN_RECORDER,
+  INTEGRATION_SINK,
+} from './integration.tokens';
 
 // Errors + shared guards
-export { MissingTenantIdError, assertTenantId } from './sync-errors';
+export { MissingTenantIdError, assertTenantId } from './integration-errors';
 
 // Audit schemas (SYNC-1) — Drizzle pgTable declarations + row types + enums
 export {
-  syncSubscriptions,
-  syncRuns,
-  syncRunItems,
-  syncRunDirectionEnum,
-  syncRunActionEnum,
-  syncRunStatusEnum,
-  syncRunItemOperationEnum,
-  syncRunItemStatusEnum,
-} from './sync-audit.schema';
+  integrationSubscriptions,
+  integrationRuns,
+  integrationRunItems,
+  integrationRunDirectionEnum,
+  integrationRunActionEnum,
+  integrationRunStatusEnum,
+  integrationRunItemOperationEnum,
+  integrationRunItemStatusEnum,
+} from './integration-audit.schema';
 export type {
-  SyncSubscriptionRow,
-  SyncRunRow,
-  SyncRunItemRow,
-} from './sync-audit.schema';
+  IntegrationSubscriptionRow,
+  IntegrationRunRow,
+  IntegrationRunItemRow,
+} from './integration-audit.schema';
 
 // Memory backends (SYNC-3, SYNC-6) — test doubles
-export { MemoryCursorStore } from './sync-cursor-store.memory-backend';
+export { MemoryCursorStore } from './integration-cursor-store.memory-backend';
 export {
   MemoryRunRecorder,
   type MemoryRunRecord,
-  type MemorySyncSubscription,
-} from './sync-run-recorder.memory-backend';
+  type MemoryIntegrationSubscription,
+} from './integration-run-recorder.memory-backend';
 
 // Runtime (SYNC-5) — orchestrator + default differ
 export {
@@ -143,14 +143,14 @@ export {
   type DeepEqualDifferOptions,
 } from './deep-equal.differ';
 export {
-  ExecuteSyncUseCase,
-  type ExecuteSyncInput,
-  type ExecuteSyncResult,
-} from './execute-sync.use-case';
+  ExecuteIntegrationUseCase,
+  type ExecuteIntegrationInput,
+  type ExecuteIntegrationResult,
+} from './execute-integration.use-case';
 
 // Drizzle backends (SYNC-4)
-export { PostgresCursorStore } from './sync-cursor-store.drizzle-backend';
-export { DrizzleSyncRunRecorder } from './sync-run-recorder.drizzle-backend';
+export { PostgresCursorStore } from './integration-cursor-store.drizzle-backend';
+export { DrizzleIntegrationRunRecorder } from './integration-run-recorder.drizzle-backend';
 
 // Module (SYNC-6)
-export { SyncModule, type SyncModuleOptions } from './sync.module';
+export { IntegrationModule, type IntegrationModuleOptions } from './integration.module';

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

@@ -1,23 +1,23 @@
 /**
- * Drizzle schema for the sync subsystem audit/observability tables (SYNC-1).
+ * Drizzle schema for the integration subsystem audit/observability tables (SYNC-1).
  *
- * Three tables model end-to-end sync observability, keyed by the single port
- * every sync adapter implements (`IChangeSource<T>` from SYNC-2):
+ * Three tables model end-to-end integration observability, keyed by the single port
+ * every integration adapter implements (`IChangeSource<T>` from SYNC-2):
  *
- *   - `sync_subscriptions` — owns the cursor per
- *       `(integration_id, adapter, domain, external_ref)` tuple. Addressed
+ *   - `integration_subscriptions` — owns the cursor per
+ *       `(connection_id, adapter, domain, external_ref)` tuple. Addressed
  *       by id by `ICursorStore` (SYNC-3/SYNC-4).
- *   - `sync_runs`          — per-run audit log: start/complete, status,
+ *   - `integration_runs`          — per-run audit log: start/complete, status,
  *       cursor before/after, counts, direction (inbound|outbound),
  *       action (poll|cdc|webhook|manual|writeback).
- *   - `sync_run_items`     — per-record change log with structured
+ *   - `integration_run_items`     — per-record change log with structured
  *       `changed_fields` jsonb enforced by the Zod `FieldDiffSchema`
  *       contract (ADR-0003; protocol lives in SYNC-2's
- *       sync-field-diff.protocol.ts).
+ *       integration-field-diff.protocol.ts).
  *
  * Design calls (vs. issue #126 open questions):
  *
- *   - `sync_subscriptions` ships in the subsystem (not consumer-owned).
+ *   - `integration_subscriptions` ships in the subsystem (not consumer-owned).
  *     Rationale: SYNC-4's `PostgresCursorStore` needs to read/write this
  *     table directly; making it consumer-owned would require consumers to
  *     hand-wire a shape the backend already knows. The row is addressable
@@ -26,13 +26,13 @@
  *     owned while remaining consumer-queryable.
  *
  *   - `tenant_id` is always emitted on the three tables as nullable text.
- *     The `SYNC_MULTI_TENANT` DI flag (SYNC-6) is what enforces the
+ *     The `INTEGRATION_MULTI_TENANT` DI flag (SYNC-6) is what enforces the
  *     non-null + cross-tenant-isolation contract at the service/orchestrator
  *     boundary. This mirrors JOB-1/JOB-8's final shape — runtime guard, not
  *     a scaffold-time conditional column. Keeps the schema file uniform
  *     across single-tenant and multi-tenant deployments.
  *
- *   - `changed_fields` on `sync_run_items` is typed via the Zod-inferred
+ *   - `changed_fields` on `integration_run_items` is typed via the Zod-inferred
  *     `FieldDiff` shape from SYNC-2 (`{ [fieldName]: { from, to } }`). The
  *     recorder service (SYNC-5) validates every write against
  *     `FieldDiffSchema.parse` so consumers can rely on the shape.
@@ -51,28 +51,28 @@ import {
 } from 'drizzle-orm/pg-core';
 import type { InferSelectModel } from 'drizzle-orm';
 
-import type { FieldDiff } from './sync-field-diff.protocol';
+import type { FieldDiff } from './integration-field-diff.protocol';
 
 // ─── Enums ──────────────────────────────────────────────────────────────────
 
 /**
- * Direction of a sync run relative to local state.
+ * Direction of a integration run relative to local state.
  *
  *   - `inbound`  — external → local (the common case: SFDC poll → local DB).
  *   - `outbound` — local → external (writeback; deferred per epic but the
  *     column shape is reserved so future writeback runs share the audit log).
  */
-export const syncRunDirectionEnum = pgEnum('sync_run_direction', [
+export const integrationRunDirectionEnum = pgEnum('integration_run_direction', [
   'inbound',
   'outbound',
 ]);
 
 /**
  * How the run detected upstream changes. Maps 1:1 to the `Change.source`
- * provenance on inbound runs; `manual` captures operator-triggered re-syncs
+ * provenance on inbound runs; `manual` captures operator-triggered re-integrations
  * and `writeback` captures outbound runs.
  */
-export const syncRunActionEnum = pgEnum('sync_run_action', [
+export const integrationRunActionEnum = pgEnum('integration_run_action', [
   'poll',
   'cdc',
   'webhook',
@@ -81,7 +81,7 @@ export const syncRunActionEnum = pgEnum('sync_run_action', [
 ]);
 
 /**
- * Lifecycle status of a sync run.
+ * Lifecycle status of a integration run.
  *
  *   - `running`     — in-flight; recorder has started but not completed.
  *   - `success`     — completed with at least one change processed.
@@ -89,7 +89,7 @@ export const syncRunActionEnum = pgEnum('sync_run_action', [
  *   - `failed`      — errored before completion; `error` column carries the
  *     message. `records_processed` may be non-zero (partial progress).
  */
-export const syncRunStatusEnum = pgEnum('sync_run_status', [
+export const integrationRunStatusEnum = pgEnum('integration_run_status', [
   'running',
   'success',
   'no_changes',
@@ -100,7 +100,7 @@ export const syncRunStatusEnum = pgEnum('sync_run_status', [
  * Operation applied per record. Mirrors `Change<T>.operation` from SYNC-2,
  * plus the recorder's own `'noop'` for changes that matched existing state.
  */
-export const syncRunItemOperationEnum = pgEnum('sync_run_item_operation', [
+export const integrationRunItemOperationEnum = pgEnum('integration_run_item_operation', [
   'created',
   'updated',
   'deleted',
@@ -113,18 +113,18 @@ export const syncRunItemOperationEnum = pgEnum('sync_run_item_operation', [
  * epic), which record the external_id but intentionally do not touch local
  * state.
  */
-export const syncRunItemStatusEnum = pgEnum('sync_run_item_status', [
+export const integrationRunItemStatusEnum = pgEnum('integration_run_item_status', [
   'success',
   'failed',
   'skipped',
 ]);
 
-// ─── sync_subscriptions ─────────────────────────────────────────────────────
+// ─── integration_subscriptions ─────────────────────────────────────────────────────
 
 /**
  * One cursor owner per (integration, adapter, domain, external_ref).
  *
- *   - `integration_id` — opaque id of the connected account/instance. E.g.
+ *   - `connection_id` — opaque id of the connected account/instance. E.g.
  *     the SFDC org id for polling strategies, the GitHub installation id
  *     for webhook strategies.
  *   - `adapter`        — short adapter label, e.g. `'salesforce'`, `'hubspot'`.
@@ -138,11 +138,11 @@ export const syncRunItemStatusEnum = pgEnum('sync_run_item_status', [
  * `{ systemModstamp }`, cdc: `{ replayId }`, webhook: `{ ts }`). Overwritten
  * by `ICursorStore.put(id, cursor)`.
  */
-export const syncSubscriptions = pgTable(
-  'sync_subscriptions',
+export const integrationSubscriptions = pgTable(
+  'integration_subscriptions',
   {
     id: uuid('id').primaryKey().defaultRandom(),
-    integrationId: text('integration_id').notNull(),
+    connectionId: text('connection_id').notNull(),
     adapter: text('adapter').notNull(),
     domain: text('domain').notNull(),
     externalRef: text('external_ref'),
@@ -157,8 +157,8 @@ export const syncSubscriptions = pgTable(
      * successful run advances it.
      */
     cursor: jsonb('cursor').$type<unknown>(),
-    lastSyncAt: timestamp('last_sync_at', { withTimezone: true }),
-    /** Runtime-enforced when `SYNC_MULTI_TENANT` is true; see SYNC-6. */
+    lastIntegrationAt: timestamp('last_integration_at', { withTimezone: true }),
+    /** Runtime-enforced when `INTEGRATION_MULTI_TENANT` is true; see SYNC-6. */
     tenantId: text('tenant_id'),
     createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
     updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
@@ -167,30 +167,30 @@ export const syncSubscriptions = pgTable(
     /**
      * Composite uniqueness per the epic shape. `external_ref` is nullable;
      * Postgres treats NULLs as distinct in a UNIQUE constraint, which means
-     * two rows with the same `(integration_id, adapter, domain)` and NULL
+     * two rows with the same `(connection_id, adapter, domain)` and NULL
      * external_ref are allowed. That's intentional — a subscription with
      * NULL external_ref covers the full domain, and duplicates there would
      * be a consumer-layer modeling issue, not a schema concern.
      */
-    uqSyncSubscriptionTuple: uniqueIndex('uq_sync_subscriptions_tuple').on(
-      t.integrationId,
+    uqIntegrationSubscriptionTuple: uniqueIndex('uq_integration_subscriptions_tuple').on(
+      t.connectionId,
       t.adapter,
       t.domain,
       t.externalRef,
     ),
     /** Scheduling query: list enabled subscriptions ordered by staleness. */
-    idxSyncSubscriptionsEnabledLastSync: index(
-      'idx_sync_subscriptions_enabled_last_sync',
-    ).on(t.enabled, t.lastSyncAt),
+    idxIntegrationSubscriptionsEnabledLastIntegration: index(
+      'idx_integration_subscriptions_enabled_last_integration',
+    ).on(t.enabled, t.lastIntegrationAt),
   }),
 );
 
-export type SyncSubscriptionRow = InferSelectModel<typeof syncSubscriptions>;
+export type IntegrationSubscriptionRow = InferSelectModel<typeof integrationSubscriptions>;
 
-// ─── sync_runs ──────────────────────────────────────────────────────────────
+// ─── integration_runs ──────────────────────────────────────────────────────────────
 
 /**
- * One row per invocation of `ExecuteSyncUseCase`. `started_at` is set when
+ * One row per invocation of `ExecuteIntegrationUseCase`. `started_at` is set when
  * the recorder opens the run; `completed_at`, `status`, `records_*`,
  * `cursor_after`, and `duration_ms` are filled on completion.
  *
@@ -199,16 +199,16 @@ export type SyncSubscriptionRow = InferSelectModel<typeof syncSubscriptions>;
  * about exactly what window was scanned without cross-referencing another
  * table.
  */
-export const syncRuns = pgTable(
-  'sync_runs',
+export const integrationRuns = pgTable(
+  'integration_runs',
   {
     id: uuid('id').primaryKey().defaultRandom(),
     subscriptionId: uuid('subscription_id')
       .notNull()
-      .references(() => syncSubscriptions.id, { onDelete: 'cascade' }),
-    direction: syncRunDirectionEnum('direction').notNull(),
-    action: syncRunActionEnum('action').notNull(),
-    status: syncRunStatusEnum('status').notNull().default('running'),
+      .references(() => integrationSubscriptions.id, { onDelete: 'cascade' }),
+    direction: integrationRunDirectionEnum('direction').notNull(),
+    action: integrationRunActionEnum('action').notNull(),
+    status: integrationRunStatusEnum('status').notNull().default('running'),
     recordsFound: integer('records_found').notNull().default(0),
     recordsProcessed: integer('records_processed').notNull().default(0),
     cursorBefore: jsonb('cursor_before').$type<unknown>(),
@@ -219,25 +219,25 @@ export const syncRuns = pgTable(
       .notNull()
       .defaultNow(),
     completedAt: timestamp('completed_at', { withTimezone: true }),
-    /** Runtime-enforced when `SYNC_MULTI_TENANT` is true; see SYNC-6. */
+    /** Runtime-enforced when `INTEGRATION_MULTI_TENANT` is true; see SYNC-6. */
     tenantId: text('tenant_id'),
   },
   (t) => ({
     /** Timeline read: "most recent runs for this subscription". */
-    idxSyncRunsSubscriptionStartedAt: index(
-      'idx_sync_runs_subscription_started_at',
+    idxIntegrationRunsSubscriptionStartedAt: index(
+      'idx_integration_runs_subscription_started_at',
     ).on(t.subscriptionId, t.startedAt),
     /** Stale-run sweeper: "runs that started > N minutes ago and are still running". */
-    idxSyncRunsStatusStartedAt: index('idx_sync_runs_status_started_at').on(
+    idxIntegrationRunsStatusStartedAt: index('idx_integration_runs_status_started_at').on(
       t.status,
       t.startedAt,
     ),
   }),
 );
 
-export type SyncRunRow = InferSelectModel<typeof syncRuns>;
+export type IntegrationRunRow = InferSelectModel<typeof integrationRuns>;
 
-// ─── sync_run_items ─────────────────────────────────────────────────────────
+// ─── integration_run_items ─────────────────────────────────────────────────────────
 
 /**
  * One row per upstream change processed within a run. Captures the canonical
@@ -254,18 +254,18 @@ export type SyncRunRow = InferSelectModel<typeof syncRuns>;
  * `"Pinnacle opportunity"`) so run-log UIs don't need to re-hydrate the
  * canonical record.
  */
-export const syncRunItems = pgTable(
-  'sync_run_items',
+export const integrationRunItems = pgTable(
+  'integration_run_items',
   {
     id: uuid('id').primaryKey().defaultRandom(),
-    syncRunId: uuid('sync_run_id')
+    integrationRunId: uuid('integration_run_id')
       .notNull()
-      .references(() => syncRuns.id, { onDelete: 'cascade' }),
+      .references(() => integrationRuns.id, { onDelete: 'cascade' }),
     entityType: text('entity_type').notNull(),
     externalId: text('external_id').notNull(),
     localId: text('local_id'),
-    operation: syncRunItemOperationEnum('operation').notNull(),
-    status: syncRunItemStatusEnum('status').notNull(),
+    operation: integrationRunItemOperationEnum('operation').notNull(),
+    status: integrationRunItemStatusEnum('status').notNull(),
     /**
      * Structured per-field diff — ADR-0003 shape enforced by
      * `FieldDiffSchema.parse` at the recorder service layer.
@@ -281,20 +281,20 @@ export const syncRunItems = pgTable(
     createdAt: timestamp('created_at', { withTimezone: true })
       .notNull()
       .defaultNow(),
-    /** Runtime-enforced when `SYNC_MULTI_TENANT` is true; see SYNC-6. */
+    /** Runtime-enforced when `INTEGRATION_MULTI_TENANT` is true; see SYNC-6. */
     tenantId: text('tenant_id'),
   },
   (t) => ({
     /** Ordered timeline within a run. */
-    idxSyncRunItemsRunCreatedAt: index('idx_sync_run_items_run_created_at').on(
-      t.syncRunId,
+    idxIntegrationRunItemsRunCreatedAt: index('idx_integration_run_items_run_created_at').on(
+      t.integrationRunId,
       t.createdAt,
     ),
-    /** Per-record history: "every sync that touched opportunity/$extId". */
-    idxSyncRunItemsEntityExternal: index(
-      'idx_sync_run_items_entity_external',
+    /** Per-record history: "every integration that touched opportunity/$extId". */
+    idxIntegrationRunItemsEntityExternal: index(
+      'idx_integration_run_items_entity_external',
     ).on(t.entityType, t.externalId),
   }),
 );
 
-export type SyncRunItemRow = InferSelectModel<typeof syncRunItems>;
+export type IntegrationRunItemRow = InferSelectModel<typeof integrationRunItems>;