@pattern-stack/codegen 0.10.1 → 0.11.0

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

@@ -1,8 +1,8 @@
 /**
- * Sync subsystem — change-source protocol (port)
+ * Integration subsystem — change-source protocol (port)
  *
- * `IChangeSource<T>` is the hexagonal port every sync adapter implements.
- * Use cases inject this interface via `SYNC_CHANGE_SOURCE` token. They never
+ * `IChangeSource<T>` is the hexagonal port every integration adapter implements.
+ * Use cases inject this interface via `INTEGRATION_CHANGE_SOURCE` token. They never
  * depend on a specific backend implementation.
  *
  * Three detection modes (poll / cdc / webhook) converge on this single port
@@ -26,7 +26,7 @@
 // ============================================================================
 
 /**
- * Provenance of a change record. Maps 1:1 to `sync_runs.action` so run logs
+ * Provenance of a change record. Maps 1:1 to `integration_runs.action` so run logs
  * self-identify.
  */
 export type ChangeSource = 'poll' | 'cdc' | 'webhook';
@@ -65,13 +65,13 @@ export interface Change<T> {
 // ============================================================================
 
 /**
- * Minimal structural view of a sync-subscription row the port needs.
+ * Minimal structural view of a integration-subscription row the port needs.
  *
- * The consumer owns the concrete `sync_subscriptions` table (schema lands in
+ * The consumer owns the concrete `integration_subscriptions` table (schema lands in
  * SYNC-1). This interface captures only the fields the port itself reads, so
  * adapters can be typed without depending on the consumer's ORM row type.
  */
-export interface SyncSubscriptionView {
+export interface IntegrationSubscriptionView {
   /** Primary key — addresses the cursor in `ICursorStore`. */
   readonly id: string;
   /** Canonical entity domain, e.g. `'opportunity'`, `'contact'`. */
@@ -85,7 +85,7 @@ export interface SyncSubscriptionView {
 // ============================================================================
 
 /**
- * The one port every sync adapter implements. Mode-specific concerns
+ * The one port every integration adapter implements. Mode-specific concerns
  * (scheduling, rate-limiting, ack contracts, credential refresh) stay in the
  * strategy class that implements this interface — this seam is deliberately
  * minimal.
@@ -108,7 +108,7 @@ export interface IChangeSource<T> {
    * it internally. `null` means "first run, no cursor yet."
    */
   listChanges(
-    subscription: SyncSubscriptionView,
+    subscription: IntegrationSubscriptionView,
     cursor: unknown | null,
   ): AsyncIterable<Change<T>>;
 }

package/runtime/subsystems/{sync/sync-cursor-store.drizzle-backend.ts → integration/integration-cursor-store.drizzle-backend.ts}

@@ -1,22 +1,22 @@
 /**
  * PostgresCursorStore — Drizzle-backed `ICursorStore` (SYNC-4).
  *
- * Reads/writes `sync_subscriptions.cursor` directly — no service
+ * Reads/writes `integration_subscriptions.cursor` directly — no service
  * composition. Consumers that want a service layer around subscriptions
  * wire it themselves; the port's contract is just cursor persistence.
  *
  * ## What `put` stamps
  *
- * `put` writes three columns in one statement: `cursor`, `last_sync_at`,
+ * `put` writes three columns in one statement: `cursor`, `last_integration_at`,
  * and `updated_at`. Rationale: SYNC-1's scheduling index
- * `(enabled, last_sync_at)` is useless if `last_sync_at` doesn't advance
+ * `(enabled, last_integration_at)` is useless if `last_integration_at` doesn't advance
  * with every cursor put. Every real consumer needs this stamped, so
  * bundling it here avoids every consumer wrapping the port in a service
  * layer just to stamp a timestamp.
  *
  * ## Multi-tenancy
  *
- * When `SYNC_MULTI_TENANT` is true (SYNC-6):
+ * When `INTEGRATION_MULTI_TENANT` is true (SYNC-6):
  *   - every read/write is scoped by `AND tenant_id = $tenantId`
  *   - a null/missing `tenantId` throws `MissingTenantIdError` via the
  *     shared `assertTenantId` helper (one message shape across the
@@ -33,10 +33,10 @@ import { DRIZZLE } from '../../constants/tokens';
 import type {
   CursorSnapshot,
   ICursorStore,
-} from './sync-cursor-store.protocol';
-import { syncSubscriptions } from './sync-audit.schema';
-import { SYNC_MULTI_TENANT } from './sync.tokens';
-import { assertTenantId } from './sync-errors';
+} from './integration-cursor-store.protocol';
+import { integrationSubscriptions } from './integration-audit.schema';
+import { INTEGRATION_MULTI_TENANT } from './integration.tokens';
+import { assertTenantId } from './integration-errors';
 
 @Injectable()
 export class PostgresCursorStore implements ICursorStore {
@@ -44,7 +44,7 @@ export class PostgresCursorStore implements ICursorStore {
 
   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;
   }
@@ -56,8 +56,8 @@ export class PostgresCursorStore implements ICursorStore {
     const where = this.buildWhere(subscriptionId, tenantId, 'cursor.get');
 
     const rows = await this.db
-      .select({ cursor: syncSubscriptions.cursor })
-      .from(syncSubscriptions)
+      .select({ cursor: integrationSubscriptions.cursor })
+      .from(integrationSubscriptions)
       .where(where)
       .limit(1);
 
@@ -73,10 +73,10 @@ export class PostgresCursorStore implements ICursorStore {
     const where = this.buildWhere(subscriptionId, tenantId, 'cursor.put');
 
     await this.db
-      .update(syncSubscriptions)
+      .update(integrationSubscriptions)
       .set({
         cursor,
-        lastSyncAt: new Date(),
+        lastIntegrationAt: new Date(),
         updatedAt: new Date(),
       })
       .where(where);
@@ -89,33 +89,33 @@ export class PostgresCursorStore implements ICursorStore {
     });
 
     const where = this.multiTenant
-      ? eq(syncSubscriptions.tenantId, tenantId as string)
+      ? eq(integrationSubscriptions.tenantId, tenantId as string)
       : undefined;
 
     const rows = await this.db
       .select({
-        id: syncSubscriptions.id,
-        integrationId: syncSubscriptions.integrationId,
-        adapter: syncSubscriptions.adapter,
-        domain: syncSubscriptions.domain,
-        externalRef: syncSubscriptions.externalRef,
-        cursor: syncSubscriptions.cursor,
-        lastSyncAt: syncSubscriptions.lastSyncAt,
-        updatedAt: syncSubscriptions.updatedAt,
-        tenantId: syncSubscriptions.tenantId,
+        id: integrationSubscriptions.id,
+        connectionId: integrationSubscriptions.connectionId,
+        adapter: integrationSubscriptions.adapter,
+        domain: integrationSubscriptions.domain,
+        externalRef: integrationSubscriptions.externalRef,
+        cursor: integrationSubscriptions.cursor,
+        lastIntegrationAt: integrationSubscriptions.lastIntegrationAt,
+        updatedAt: integrationSubscriptions.updatedAt,
+        tenantId: integrationSubscriptions.tenantId,
       })
-      .from(syncSubscriptions)
+      .from(integrationSubscriptions)
       .where(where)
-      .orderBy(desc(syncSubscriptions.updatedAt));
+      .orderBy(desc(integrationSubscriptions.updatedAt));
 
     return rows.map((row) => ({
       subscriptionId: row.id,
-      integrationId: row.integrationId,
+      connectionId: row.connectionId,
       adapter: row.adapter,
       domain: row.domain,
       externalRef: row.externalRef,
       cursor: row.cursor ?? null,
-      lastSyncAt: row.lastSyncAt,
+      lastIntegrationAt: row.lastIntegrationAt,
       updatedAt: row.updatedAt,
       tenantId: row.tenantId,
     }));
@@ -137,10 +137,10 @@ export class PostgresCursorStore implements ICursorStore {
     });
     if (this.multiTenant) {
       return and(
-        eq(syncSubscriptions.id, subscriptionId),
-        eq(syncSubscriptions.tenantId, tenantId as string),
+        eq(integrationSubscriptions.id, subscriptionId),
+        eq(integrationSubscriptions.tenantId, tenantId as string),
       );
     }
-    return eq(syncSubscriptions.id, subscriptionId);
+    return eq(integrationSubscriptions.id, subscriptionId);
   }
 }

package/runtime/subsystems/{sync/sync-cursor-store.memory-backend.ts → integration/integration-cursor-store.memory-backend.ts}

@@ -1,7 +1,7 @@
 /**
  * MemoryCursorStore — in-memory backend for `ICursorStore` (SYNC-3).
  *
- * Test double that lets consumers exercise `ExecuteSyncUseCase` (SYNC-5) and
+ * Test double that lets consumers exercise `ExecuteIntegrationUseCase` (SYNC-5) and
  * other cursor-consuming code paths without Postgres. Mirrors the role of
  * `MemoryEventBus` and `MemoryJobStore`: plain keyed state, tests take a
  * direct reference for `beforeEach` resets.
@@ -23,15 +23,15 @@
  *
  * Not shipped in the upstream consumer; this is a subsystem-first addition for the
  * test surface. Consumed by:
- *   - SYNC-5 unit tests (`ExecuteSyncUseCase` against synthetic sources)
- *   - SYNC-6 module tests (`SyncModule.forRoot({ backend: 'memory' })`)
+ *   - SYNC-5 unit tests (`ExecuteIntegrationUseCase` against synthetic sources)
+ *   - SYNC-6 module tests (`IntegrationModule.forRoot({ backend: 'memory' })`)
  */
 import { Injectable } from '@nestjs/common';
 import type {
   CursorSnapshot,
   ICursorStore,
-} from './sync-cursor-store.protocol';
-import type { MemorySyncSubscription } from './sync-run-recorder.memory-backend';
+} from './integration-cursor-store.protocol';
+import type { MemoryIntegrationSubscription } from './integration-run-recorder.memory-backend';
 
 @Injectable()
 export class MemoryCursorStore implements ICursorStore {
@@ -44,13 +44,13 @@ export class MemoryCursorStore implements ICursorStore {
   /**
    * Seedable subscription metadata for `listAll` — the memory backend
    * stores only `subscriptionId → cursor` in its write path, so the
-   * snapshot shape (`integrationId`, `adapter`, `domain`, `externalRef`,
+   * snapshot shape (`connectionId`, `adapter`, `domain`, `externalRef`,
    * timestamps) has no natural source without test seeding. Tests populate
    * this map; unseeded entries get empty-string metadata and `new Date(0)`
    * timestamps so the shape stays stable. Production paths go through the
    * Drizzle backend.
    */
-  readonly subscriptions: Map<string, MemorySyncSubscription> = new Map();
+  readonly subscriptions: Map<string, MemoryIntegrationSubscription> = new Map();
 
   async get(
     subscriptionId: string,
@@ -80,12 +80,12 @@ export class MemoryCursorStore implements ICursorStore {
       const meta = this.subscriptions.get(subscriptionId);
       snapshots.push({
         subscriptionId,
-        integrationId: meta?.integrationId ?? '',
+        connectionId: meta?.connectionId ?? '',
         adapter: meta?.adapter ?? '',
         domain: meta?.domain ?? '',
         externalRef: meta?.externalRef ?? null,
         cursor: cursor ?? null,
-        lastSyncAt: meta?.lastSyncAt ?? null,
+        lastIntegrationAt: meta?.lastIntegrationAt ?? null,
         updatedAt: meta?.updatedAt ?? new Date(0),
         tenantId: null,
       });

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

@@ -1,5 +1,5 @@
 /**
- * Sync subsystem — cursor-store protocol (port)
+ * Integration subsystem — cursor-store protocol (port)
  *
  * Subscription-addressed cursor persistence. The subscription row IS the
  * cursor owner — addressable by id, scoped by
@@ -7,11 +7,11 @@
  *
  * Cursor shape is opaque at this seam; strategies type it internally
  * (polling: `{ systemModstamp }`, CDC: `{ replayId }`, webhook: `{ ts }`).
- * The Drizzle backend stores this as `sync_subscriptions.cursor` jsonb.
+ * The Drizzle backend stores this as `integration_subscriptions.cursor` jsonb.
  *
  * ## Multi-tenancy (SYNC-4)
  *
- * Both methods accept an optional `tenantId`. When `SYNC_MULTI_TENANT` is
+ * Both methods accept an optional `tenantId`. When `INTEGRATION_MULTI_TENANT` is
  * enabled (SYNC-6), the Drizzle backend MUST scope every read/write by
  * `tenant_id`, and a `null`/missing value throws `MissingTenantIdError` at
  * the module boundary. When the flag is off, `tenantId` is ignored.
@@ -26,23 +26,23 @@
  * through input shapes, not through wrapper layers.
  */
 /**
- * Denormalized snapshot of one `sync_subscriptions` row for the OBS-5
+ * Denormalized snapshot of one `integration_subscriptions` row for the OBS-5
  * observability composer (epic #195). `cursor` is opaque (the port's
  * contract); the rest is subscription metadata needed to label the snapshot
  * in a dashboard/API surface.
  *
- * The Drizzle backend reads this directly from `sync_subscriptions`. Memory
+ * The Drizzle backend reads this directly from `integration_subscriptions`. Memory
  * backends derive it from the seedable `subscriptions` side-map — tests
  * that want meaningful snapshots must seed first.
  */
 export interface CursorSnapshot {
   readonly subscriptionId: string;
-  readonly integrationId: string;
+  readonly connectionId: string;
   readonly adapter: string;
   readonly domain: string;
   readonly externalRef: string | null;
   readonly cursor: unknown | null;
-  readonly lastSyncAt: Date | null;
+  readonly lastIntegrationAt: Date | null;
   readonly updatedAt: Date;
   readonly tenantId: string | null;
 }
@@ -51,7 +51,7 @@ export interface ICursorStore {
   /**
    * Return the last persisted cursor for `subscriptionId`, or `null`.
    *
-   * @param tenantId  required when `SYNC_MULTI_TENANT` is on (backend
+   * @param tenantId  required when `INTEGRATION_MULTI_TENANT` is on (backend
    *                  scopes the SELECT by tenant); ignored otherwise.
    */
   get(subscriptionId: string, tenantId?: string | null): Promise<unknown | null>;
@@ -59,12 +59,12 @@ export interface ICursorStore {
   /**
    * Persist `cursor` for `subscriptionId`. Overwrites.
    *
-   * The Drizzle backend also stamps `last_sync_at` + `updated_at` on the
-   * same row so the scheduling index `(enabled, last_sync_at)` stays
+   * The Drizzle backend also stamps `last_integration_at` + `updated_at` on the
+   * same row so the scheduling index `(enabled, last_integration_at)` stays
    * accurate without consumers wrapping the port. The memory backend
    * ignores timestamps.
    *
-   * @param tenantId  required when `SYNC_MULTI_TENANT` is on (backend
+   * @param tenantId  required when `INTEGRATION_MULTI_TENANT` is on (backend
    *                  scopes the UPDATE by tenant); ignored otherwise.
    */
   put(
@@ -74,11 +74,11 @@ export interface ICursorStore {
   ): Promise<void>;
 
   /**
-   * Return one `CursorSnapshot` per `sync_subscriptions` row, ordered by
+   * Return one `CursorSnapshot` per `integration_subscriptions` row, ordered by
    * `updated_at DESC`. Consumed by the OBS-5 observability composer to
    * surface current cursor state per subscription.
    *
-   * @param tenantId  required by Drizzle backend when `SYNC_MULTI_TENANT`
+   * @param tenantId  required by Drizzle backend when `INTEGRATION_MULTI_TENANT`
    *                  is on (throws `MissingTenantIdError` otherwise); memory
    *                  backend accepts but ignores.
    */

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));
   }
 }