@pattern-stack/codegen 0.10.0 → 0.11.0

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

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.
    */