@pattern-stack/codegen 0.10.1 → 0.12.0

package/dist/src/cli/index.js

@@ -12,8 +12,8 @@ var __decorateClass = (decorators, target, key, kind) => {
 var __decorateParam = (index2, decorator) => (target, key) => decorator(target, key, index2);
 
 // src/cli/index.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { join as join10 } from "path";
+import { readFileSync as readFileSync9 } from "fs";
+import { join as join13 } from "path";
 import { Builtins, Cli, Command as Command13 } from "clipanion";
 
 // src/cli/noun-module.ts
@@ -1081,7 +1081,7 @@ import { parse as parseYaml } from "yaml";
 // src/schema/entity-definition.schema.ts
 import { z as z3 } from "zod";
 
-// runtime/subsystems/sync/sync-field-diff.protocol.ts
+// runtime/subsystems/integration/integration-field-diff.protocol.ts
 import { z } from "zod";
 var FieldDiffValueSchema = z.object({
   from: z.unknown(),
@@ -1089,7 +1089,7 @@ var FieldDiffValueSchema = z.object({
 });
 var FieldDiffSchema = z.record(z.string(), FieldDiffValueSchema);
 
-// runtime/subsystems/sync/detection-config.schema.ts
+// runtime/subsystems/integration/detection-config.schema.ts
 import { z as z2 } from "zod";
 var FieldMappingSchema = z2.object({
   source: z2.string().min(1),
@@ -1147,21 +1147,21 @@ var DetectionConfigSchema = z2.discriminatedUnion("mode", [
   WebhookModeSchema
 ]);
 
-// runtime/subsystems/sync/sync.tokens.ts
-var SYNC_CHANGE_SOURCE = "SYNC_CHANGE_SOURCE";
-var SYNC_CURSOR_STORE = "SYNC_CURSOR_STORE";
-var SYNC_FIELD_DIFFER = "SYNC_FIELD_DIFFER";
-var SYNC_SINK = "SYNC_SINK";
-var SYNC_RUN_RECORDER = "SYNC_RUN_RECORDER";
-var SYNC_MODULE_OPTIONS = "SYNC_MODULE_OPTIONS";
-var SYNC_MULTI_TENANT = "SYNC_MULTI_TENANT";
+// runtime/subsystems/integration/integration.tokens.ts
+var INTEGRATION_CHANGE_SOURCE = "INTEGRATION_CHANGE_SOURCE";
+var INTEGRATION_CURSOR_STORE = "INTEGRATION_CURSOR_STORE";
+var INTEGRATION_FIELD_DIFFER = "INTEGRATION_FIELD_DIFFER";
+var INTEGRATION_SINK = "INTEGRATION_SINK";
+var INTEGRATION_RUN_RECORDER = "INTEGRATION_RUN_RECORDER";
+var INTEGRATION_MODULE_OPTIONS = "INTEGRATION_MODULE_OPTIONS";
+var INTEGRATION_MULTI_TENANT = "INTEGRATION_MULTI_TENANT";
 
-// runtime/subsystems/sync/sync-errors.ts
+// runtime/subsystems/integration/integration-errors.ts
 var MissingTenantIdError = class extends Error {
   name = "MissingTenantIdError";
   constructor(operation) {
     super(
-      `Missing tenantId for sync operation '${operation}'. SyncModule is configured with multiTenant: true \u2014 every call must include a non-null tenantId. Either pass the tenantId or disable multi-tenancy on the module.`
+      `Missing tenantId for integration operation '${operation}'. IntegrationModule is configured with multiTenant: true \u2014 every call must include a non-null tenantId. Either pass the tenantId or disable multi-tenancy on the module.`
     );
   }
 };
@@ -1172,7 +1172,7 @@ function assertTenantId(tenantId, options) {
   }
 }
 
-// runtime/subsystems/sync/sync-audit.schema.ts
+// runtime/subsystems/integration/integration-audit.schema.ts
 import {
   pgEnum,
   pgTable,
@@ -1185,39 +1185,39 @@ import {
   index,
   uniqueIndex
 } from "drizzle-orm/pg-core";
-var syncRunDirectionEnum = pgEnum("sync_run_direction", [
+var integrationRunDirectionEnum = pgEnum("integration_run_direction", [
   "inbound",
   "outbound"
 ]);
-var syncRunActionEnum = pgEnum("sync_run_action", [
+var integrationRunActionEnum = pgEnum("integration_run_action", [
   "poll",
   "cdc",
   "webhook",
   "manual",
   "writeback"
 ]);
-var syncRunStatusEnum = pgEnum("sync_run_status", [
+var integrationRunStatusEnum = pgEnum("integration_run_status", [
   "running",
   "success",
   "no_changes",
   "failed"
 ]);
-var syncRunItemOperationEnum = pgEnum("sync_run_item_operation", [
+var integrationRunItemOperationEnum = pgEnum("integration_run_item_operation", [
   "created",
   "updated",
   "deleted",
   "noop"
 ]);
-var syncRunItemStatusEnum = pgEnum("sync_run_item_status", [
+var integrationRunItemStatusEnum = pgEnum("integration_run_item_status", [
   "success",
   "failed",
   "skipped"
 ]);
-var syncSubscriptions = pgTable(
-  "sync_subscriptions",
+var 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"),
@@ -1232,8 +1232,8 @@ var syncSubscriptions = pgTable(
      * successful run advances it.
      */
     cursor: jsonb("cursor").$type(),
-    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()
@@ -1242,31 +1242,31 @@ var 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)
   })
 );
-var syncRuns = pgTable(
-  "sync_runs",
+var 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"),
+    subscriptionId: uuid("subscription_id").notNull().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(),
@@ -1275,31 +1275,31 @@ var syncRuns = pgTable(
     error: text("error"),
     startedAt: timestamp("started_at", { withTimezone: true }).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
     )
   })
 );
-var syncRunItems = pgTable(
-  "sync_run_items",
+var integrationRunItems = pgTable(
+  "integration_run_items",
   {
     id: uuid("id").primaryKey().defaultRandom(),
-    syncRunId: uuid("sync_run_id").notNull().references(() => syncRuns.id, { onDelete: "cascade" }),
+    integrationRunId: uuid("integration_run_id").notNull().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.
@@ -1313,23 +1313,23 @@ var syncRunItems = pgTable(
     title: text("title"),
     error: text("error"),
     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)
   })
 );
 
-// runtime/subsystems/sync/sync-cursor-store.memory-backend.ts
+// runtime/subsystems/integration/integration-cursor-store.memory-backend.ts
 import { Injectable } from "@nestjs/common";
 var MemoryCursorStore = class {
   /**
@@ -1340,7 +1340,7 @@ var MemoryCursorStore = class {
   /**
    * 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
@@ -1360,12 +1360,12 @@ var MemoryCursorStore = class {
       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 ?? /* @__PURE__ */ new Date(0),
         tenantId: null
       });
@@ -1384,7 +1384,7 @@ MemoryCursorStore = __decorateClass([
   Injectable()
 ], MemoryCursorStore);
 
-// runtime/subsystems/sync/sync-run-recorder.memory-backend.ts
+// runtime/subsystems/integration/integration-run-recorder.memory-backend.ts
 import { Injectable as Injectable2 } from "@nestjs/common";
 var MemoryRunRecorder = class {
   /**
@@ -1393,14 +1393,14 @@ var MemoryRunRecorder = class {
    */
   runs = /* @__PURE__ */ 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.
    */
   items = /* @__PURE__ */ 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.
@@ -1429,10 +1429,10 @@ var MemoryRunRecorder = class {
   }
   async recordItem(input) {
     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}'. Call startRun(...) first.`
+        `MemoryRunRecorder.recordItem: no run started for id '${input.integrationRunId}'. Call startRun(...) first.`
       );
     }
     bucket.push(input);
@@ -1458,10 +1458,10 @@ var MemoryRunRecorder = class {
     return filtered.sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime()).slice(0, limit).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,
@@ -1489,7 +1489,7 @@ MemoryRunRecorder = __decorateClass([
   Injectable2()
 ], MemoryRunRecorder);
 
-// runtime/subsystems/sync/deep-equal.differ.ts
+// runtime/subsystems/integration/deep-equal.differ.ts
 import { Injectable as Injectable3 } from "@nestjs/common";
 var DEFAULT_IGNORE_FIELDS = /* @__PURE__ */ new Set([
   "id",
@@ -1588,9 +1588,9 @@ function deepEqualObject(a, b) {
   return true;
 }
 
-// runtime/subsystems/sync/execute-sync.use-case.ts
+// runtime/subsystems/integration/execute-integration.use-case.ts
 import { Inject, Injectable as Injectable4, Logger, Optional } from "@nestjs/common";
-var ExecuteSyncUseCase = class {
+var ExecuteIntegrationUseCase = class {
   constructor(source, cursors, differ, sink, recorder, multiTenant = false) {
     this.source = source;
     this.cursors = cursors;
@@ -1605,7 +1605,7 @@ var ExecuteSyncUseCase = class {
   sink;
   recorder;
   multiTenant;
-  logger = new Logger(ExecuteSyncUseCase.name);
+  logger = new Logger(ExecuteIntegrationUseCase.name);
   async execute(input) {
     assertTenantId(input.tenantId, {
       multiTenant: this.multiTenant,
@@ -1640,10 +1640,10 @@ var ExecuteSyncUseCase = class {
           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",
@@ -1666,7 +1666,7 @@ var ExecuteSyncUseCase = class {
       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}`
       );
     }
     if (cursorAdvanced && latestCursor !== null && latestCursor !== void 0) {
@@ -1711,7 +1711,7 @@ var ExecuteSyncUseCase = class {
         change.externalId
       );
       await this.recorder.recordItem({
-        syncRunId: runId,
+        integrationRunId: runId,
         entityType: input.subscription.domain,
         externalId: change.externalId,
         localId: result?.id ?? null,
@@ -1734,7 +1734,7 @@ var ExecuteSyncUseCase = class {
     if (diff === "noop") {
       if (!this.sink.reprojectsOnNoop) {
         await this.recorder.recordItem({
-          syncRunId: runId,
+          integrationRunId: runId,
           entityType: input.subscription.domain,
           externalId: change.externalId,
           localId: null,
@@ -1751,7 +1751,7 @@ var ExecuteSyncUseCase = class {
         input.provider
       );
       await this.recorder.recordItem({
-        syncRunId: runId,
+        integrationRunId: runId,
         entityType: input.subscription.domain,
         externalId: change.externalId,
         localId: noopLocalId,
@@ -1768,7 +1768,7 @@ var ExecuteSyncUseCase = class {
       input.provider
     );
     await this.recorder.recordItem({
-      syncRunId: runId,
+      integrationRunId: runId,
       entityType: input.subscription.domain,
       externalId: change.externalId,
       localId,
@@ -1779,25 +1779,25 @@ var ExecuteSyncUseCase = class {
     });
   }
 };
-ExecuteSyncUseCase = __decorateClass([
+ExecuteIntegrationUseCase = __decorateClass([
   Injectable4(),
-  __decorateParam(0, Inject(SYNC_CHANGE_SOURCE)),
-  __decorateParam(1, Inject(SYNC_CURSOR_STORE)),
-  __decorateParam(2, Inject(SYNC_FIELD_DIFFER)),
-  __decorateParam(3, Inject(SYNC_SINK)),
-  __decorateParam(4, Inject(SYNC_RUN_RECORDER)),
+  __decorateParam(0, Inject(INTEGRATION_CHANGE_SOURCE)),
+  __decorateParam(1, Inject(INTEGRATION_CURSOR_STORE)),
+  __decorateParam(2, Inject(INTEGRATION_FIELD_DIFFER)),
+  __decorateParam(3, Inject(INTEGRATION_SINK)),
+  __decorateParam(4, Inject(INTEGRATION_RUN_RECORDER)),
   __decorateParam(5, Optional()),
-  __decorateParam(5, Inject(SYNC_MULTI_TENANT))
-], ExecuteSyncUseCase);
+  __decorateParam(5, Inject(INTEGRATION_MULTI_TENANT))
+], ExecuteIntegrationUseCase);
 
-// runtime/subsystems/sync/sync-cursor-store.drizzle-backend.ts
+// runtime/subsystems/integration/integration-cursor-store.drizzle-backend.ts
 import { Inject as Inject2, Injectable as Injectable5, Optional as Optional2 } from "@nestjs/common";
 import { and, desc, eq } from "drizzle-orm";
 
 // runtime/constants/tokens.ts
 var DRIZZLE = "DRIZZLE";
 
-// runtime/subsystems/sync/sync-cursor-store.drizzle-backend.ts
+// runtime/subsystems/integration/integration-cursor-store.drizzle-backend.ts
 var PostgresCursorStore = class {
   constructor(db, multiTenant) {
     this.db = db;
@@ -1807,15 +1807,15 @@ var PostgresCursorStore = class {
   multiTenant;
   async get(subscriptionId, tenantId) {
     const where = this.buildWhere(subscriptionId, tenantId, "cursor.get");
-    const rows = await this.db.select({ cursor: syncSubscriptions.cursor }).from(syncSubscriptions).where(where).limit(1);
+    const rows = await this.db.select({ cursor: integrationSubscriptions.cursor }).from(integrationSubscriptions).where(where).limit(1);
     if (rows.length === 0) return null;
     return rows[0]?.cursor ?? null;
   }
   async put(subscriptionId, cursor, tenantId) {
     const where = this.buildWhere(subscriptionId, tenantId, "cursor.put");
-    await this.db.update(syncSubscriptions).set({
+    await this.db.update(integrationSubscriptions).set({
       cursor,
-      lastSyncAt: /* @__PURE__ */ new Date(),
+      lastIntegrationAt: /* @__PURE__ */ new Date(),
       updatedAt: /* @__PURE__ */ new Date()
     }).where(where);
   }
@@ -1824,26 +1824,26 @@ var PostgresCursorStore = class {
       multiTenant: this.multiTenant,
       operation: "cursor.listAll"
     });
-    const where = this.multiTenant ? eq(syncSubscriptions.tenantId, tenantId) : void 0;
+    const where = this.multiTenant ? eq(integrationSubscriptions.tenantId, tenantId) : void 0;
     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
-    }).from(syncSubscriptions).where(where).orderBy(desc(syncSubscriptions.updatedAt));
+      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(integrationSubscriptions).where(where).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
     }));
@@ -1860,24 +1860,24 @@ var PostgresCursorStore = class {
     });
     if (this.multiTenant) {
       return and(
-        eq(syncSubscriptions.id, subscriptionId),
-        eq(syncSubscriptions.tenantId, tenantId)
+        eq(integrationSubscriptions.id, subscriptionId),
+        eq(integrationSubscriptions.tenantId, tenantId)
       );
     }
-    return eq(syncSubscriptions.id, subscriptionId);
+    return eq(integrationSubscriptions.id, subscriptionId);
   }
 };
 PostgresCursorStore = __decorateClass([
   Injectable5(),
   __decorateParam(0, Inject2(DRIZZLE)),
   __decorateParam(1, Optional2()),
-  __decorateParam(1, Inject2(SYNC_MULTI_TENANT))
+  __decorateParam(1, Inject2(INTEGRATION_MULTI_TENANT))
 ], PostgresCursorStore);
 
-// runtime/subsystems/sync/sync-run-recorder.drizzle-backend.ts
+// runtime/subsystems/integration/integration-run-recorder.drizzle-backend.ts
 import { Inject as Inject3, Injectable as Injectable6, Optional as Optional3 } from "@nestjs/common";
 import { and as and2, desc as desc2, eq as eq2 } from "drizzle-orm";
-var DrizzleSyncRunRecorder = class {
+var DrizzleIntegrationRunRecorder = class {
   constructor(db, multiTenant) {
     this.db = db;
     this.multiTenant = multiTenant ?? false;
@@ -1889,17 +1889,17 @@ var DrizzleSyncRunRecorder = class {
       multiTenant: this.multiTenant,
       operation: "startRun"
     });
-    const rows = await this.db.insert(syncRuns).values({
+    const rows = await this.db.insert(integrationRuns).values({
       subscriptionId: input.subscriptionId,
       direction: input.direction,
       action: input.action,
       status: "running",
       cursorBefore: input.cursorBefore ?? null,
       tenantId: input.tenantId ?? null
-    }).returning({ id: syncRuns.id });
+    }).returning({ id: integrationRuns.id });
     const id = rows[0]?.id;
     if (!id) {
-      throw new Error("DrizzleSyncRunRecorder: INSERT RETURNING produced no id");
+      throw new Error("DrizzleIntegrationRunRecorder: INSERT RETURNING produced no id");
     }
     return { id };
   }
@@ -1909,8 +1909,8 @@ var DrizzleSyncRunRecorder = class {
       operation: "recordItem"
     });
     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,
@@ -1929,29 +1929,29 @@ var DrizzleSyncRunRecorder = class {
     });
     const conditions = [];
     if (subscriptionId !== void 0) {
-      conditions.push(eq2(syncRuns.subscriptionId, subscriptionId));
+      conditions.push(eq2(integrationRuns.subscriptionId, subscriptionId));
     }
     if (this.multiTenant) {
-      conditions.push(eq2(syncRuns.tenantId, tenantId));
+      conditions.push(eq2(integrationRuns.tenantId, tenantId));
     }
     const where = conditions.length === 0 ? void 0 : conditions.length === 1 ? conditions[0] : and2(...conditions);
     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
-    }).from(syncRuns).innerJoin(
-      syncSubscriptions,
-      eq2(syncRuns.subscriptionId, syncSubscriptions.id)
-    ).where(where).orderBy(desc2(syncRuns.startedAt)).limit(limit);
+      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(integrationRuns).innerJoin(
+      integrationSubscriptions,
+      eq2(integrationRuns.subscriptionId, integrationSubscriptions.id)
+    ).where(where).orderBy(desc2(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,
@@ -1960,7 +1960,7 @@ var DrizzleSyncRunRecorder = class {
     }));
   }
   async completeRun(runId, input) {
-    await this.db.update(syncRuns).set({
+    await this.db.update(integrationRuns).set({
       status: input.status,
       recordsFound: input.recordsFound,
       recordsProcessed: input.recordsProcessed,
@@ -1968,27 +1968,27 @@ var DrizzleSyncRunRecorder = class {
       durationMs: input.durationMs,
       error: input.error ?? null,
       completedAt: /* @__PURE__ */ new Date()
-    }).where(eq2(syncRuns.id, runId));
+    }).where(eq2(integrationRuns.id, runId));
   }
 };
-DrizzleSyncRunRecorder = __decorateClass([
+DrizzleIntegrationRunRecorder = __decorateClass([
   Injectable6(),
   __decorateParam(0, Inject3(DRIZZLE)),
   __decorateParam(1, Optional3()),
-  __decorateParam(1, Inject3(SYNC_MULTI_TENANT))
-], DrizzleSyncRunRecorder);
+  __decorateParam(1, Inject3(INTEGRATION_MULTI_TENANT))
+], DrizzleIntegrationRunRecorder);
 
-// runtime/subsystems/sync/sync.module.ts
+// runtime/subsystems/integration/integration.module.ts
 import { Module } from "@nestjs/common";
-var SyncModule = class {
+var IntegrationModule = class {
   static forRoot(options) {
     const multiTenant = options.multiTenant ?? false;
     const sharedProviders = [
-      { provide: SYNC_MODULE_OPTIONS, useValue: options },
-      { provide: SYNC_MULTI_TENANT, useValue: multiTenant },
+      { provide: INTEGRATION_MODULE_OPTIONS, useValue: options },
+      { provide: INTEGRATION_MULTI_TENANT, useValue: multiTenant },
       // Default differ — consumers can override by binding a different
-      // `IFieldDiffer<T>` to `SYNC_FIELD_DIFFER` in their feature module.
-      { provide: SYNC_FIELD_DIFFER, useValue: new DeepEqualDiffer() }
+      // `IFieldDiffer<T>` to `INTEGRATION_FIELD_DIFFER` in their feature module.
+      { provide: INTEGRATION_FIELD_DIFFER, useValue: new DeepEqualDiffer() }
     ];
     const backendProviders = options.backend === "memory" ? [
       // Wired as singletons via `useValue` so tests can pull
@@ -1996,38 +1996,38 @@ var SyncModule = class {
       // direct assertions. Matches JOB-4 / MemoryJobStore shape.
       { provide: MemoryCursorStore, useValue: new MemoryCursorStore() },
       {
-        provide: SYNC_CURSOR_STORE,
+        provide: INTEGRATION_CURSOR_STORE,
         useExisting: MemoryCursorStore
       },
       { provide: MemoryRunRecorder, useValue: new MemoryRunRecorder() },
       {
-        provide: SYNC_RUN_RECORDER,
+        provide: INTEGRATION_RUN_RECORDER,
         useExisting: MemoryRunRecorder
       }
     ] : [
       // Drizzle backends — injected with DRIZZLE (provided by the
-      // consumer's DrizzleModule) + the SYNC_MULTI_TENANT flag
+      // consumer's DrizzleModule) + the INTEGRATION_MULTI_TENANT flag
       // we bound above.
-      { provide: SYNC_CURSOR_STORE, useClass: PostgresCursorStore },
-      { provide: SYNC_RUN_RECORDER, useClass: DrizzleSyncRunRecorder }
+      { provide: INTEGRATION_CURSOR_STORE, useClass: PostgresCursorStore },
+      { provide: INTEGRATION_RUN_RECORDER, useClass: DrizzleIntegrationRunRecorder }
     ];
     return {
-      module: SyncModule,
+      module: IntegrationModule,
       global: true,
       providers: [...sharedProviders, ...backendProviders],
       exports: [
-        SYNC_MODULE_OPTIONS,
-        SYNC_MULTI_TENANT,
-        SYNC_FIELD_DIFFER,
-        SYNC_CURSOR_STORE,
-        SYNC_RUN_RECORDER
+        INTEGRATION_MODULE_OPTIONS,
+        INTEGRATION_MULTI_TENANT,
+        INTEGRATION_FIELD_DIFFER,
+        INTEGRATION_CURSOR_STORE,
+        INTEGRATION_RUN_RECORDER
       ]
     };
   }
 };
-SyncModule = __decorateClass([
+IntegrationModule = __decorateClass([
   Module({})
-], SyncModule);
+], IntegrationModule);
 
 // src/schema/entity-definition.schema.ts
 var FieldTypeSchema = z3.enum([
@@ -2335,21 +2335,21 @@ var AnyQueryDeclarationSchema = z3.union([
   SearchQueryDeclarationSchema,
   QueryDeclarationSchema
 ]);
-var SyncDirectionSchema = z3.enum([
+var IntegrationDirectionSchema = z3.enum([
   "inbound",
   "outbound",
   "bidirectional"
 ]);
-var ProviderSyncSchema = z3.object({
+var ProviderIntegrationSchema = z3.object({
   remote_entity: z3.string(),
-  direction: SyncDirectionSchema,
+  direction: IntegrationDirectionSchema,
   cdc: z3.boolean().optional().default(false),
   field_mapping: z3.record(z3.string(), z3.string()).optional(),
   read_only_fields: z3.array(z3.string()).optional()
 });
-var SyncConfigSchema = z3.object({
+var IntegrationConfigSchema = z3.object({
   electric: z3.boolean().optional().default(false),
-  providers: z3.record(z3.string(), ProviderSyncSchema).optional()
+  providers: z3.record(z3.string(), ProviderIntegrationSchema).optional()
 });
 var EventDeclarationSchema = z3.object({
   name: z3.string().regex(/^[a-z][a-z0-9_]*$/, "Event name must be snake_case"),
@@ -2449,22 +2449,52 @@ var EntityDefinitionSchema = z3.object({
   // v2: Declarative query generation (ADR-005)
   // Generates repository + service + use case methods from declarations
   queries: z3.array(AnyQueryDeclarationSchema).optional(),
-  // v2: Integration sync configuration (CODEGEN-EVOLUTION-PLAN Phase 2)
-  // Electric SQL + provider sync (Salesforce, HubSpot, etc.)
-  sync: SyncConfigSchema.optional(),
+  // v2: Integration integration configuration (CODEGEN-EVOLUTION-PLAN Phase 2)
+  // Electric SQL + provider integration (Salesforce, HubSpot, etc.)
+  integration: IntegrationConfigSchema.optional(),
   // ADR-033.1: Provider-keyed change-source detection.
   //
   // Map of provider name → DetectionConfig. Single-provider entities use
   // a one-key map; multi-provider entities list each provider as a
   // separate key. Each value is an independent `DetectionConfig` (its
   // own mode/cursor/mapping/filters) sourced from the canonical schema
-  // in `runtime/subsystems/sync` so this validator and the runtime
+  // in `runtime/subsystems/integration` so this validator and the runtime
   // parser stay in lockstep.
   //
   // Within-file cross-check (ADR-033.1 §6): every key here must also
-  // appear in `sync.providers` — see the superRefine on
+  // appear in `integration.providers` — see the superRefine on
   // `EntityDefinitionSchema` below.
   detection: z3.record(z3.string(), DetectionConfigSchema).optional(),
+  // RFC-0001 §1/§8: the integration *surface* this entity belongs to
+  // (e.g. 'calendar', 'mail', 'crm'). Surfaces span provider contexts
+  // (ADR-0006) — one Google OAuth feeds calendar+mail+transcript. The union
+  // of `surface:` values across all entity YAML is the closed set that a
+  // provider's `surfaces:` must be a subset of (cross-checked in
+  // src/parser/validate-providers.ts). Optional: entities without an
+  // integration surface omit it. The surface-package *emission* convention
+  // is Track C (#329); this field is only the declarative input both tracks
+  // read.
+  surface: z3.string().optional(),
+  // Bounded-context declaration (ADR-0004) — "which bounded context this
+  // entity belongs to". This is the DURABLE decision; it is a plain
+  // bounded-context slug, NOT a folder knob. Different features consume it:
+  //
+  //   - #403 (this PR, the FIRST consumer): drives the generated code's
+  //     module output folder. clean-lite-ps nests the entity's module under
+  //     `<modules>/<context>/<entity>/` so same-context entities group
+  //     together; untagged entities stay flat (`<modules>/<entity>/`).
+  //   - ADR-0004 (deferred): a later `naming: prefix | schema` knob reads
+  //     this SAME field to drive the Postgres physical layout —
+  //     `prefix` → `pgTable('<context>__<table>')`, then the flip to
+  //     `schema` → `pgSchema('<context>').table('<table>')`. NOT wired here;
+  //     #403 makes no table/column/schema changes.
+  //
+  // Sibling to `surface:` and orthogonal to it (ADR-0006): context = model
+  // cohesion (which domain), surface = vendor composition (which integration).
+  context: z3.string().regex(
+    /^[a-z][a-z0-9_]*$/,
+    "context must be lowercase snake_case (e.g. 'integration')"
+  ).optional(),
   // v2: Domain event declarations (CODEGEN-EVOLUTION-PLAN Phase 2)
   // Generates typed event classes, handlers, and queue registration
   events: z3.array(EventDeclarationSchema).optional(),
@@ -2483,7 +2513,18 @@ var EntityDefinitionSchema = z3.object({
   ).optional(),
   // v2: Analytics / semantic layer configuration
   // Cube.js measure packs, custom cube name, and metric definitions
-  analytics: AnalyticsBlockSchema.optional()
+  analytics: AnalyticsBlockSchema.optional(),
+  // Composite (multi-column) unique indexes (#356). Single-column uniqueness
+  // is `unique: true` on the field itself; this declares constraints that
+  // span 2+ columns, e.g. UNIQUE (conversation_id, sequence). Emitted as a
+  // `uniqueIndex(...).on(...)` entry in the generated entity's pgTable
+  // extra-config callback. `name` defaults to <table>_<col1>_<col2>_uniq.
+  unique_indexes: z3.array(
+    z3.object({
+      fields: z3.array(z3.string()).min(2, "unique_indexes entries span 2+ columns \u2014 use `unique: true` on the field for single-column uniqueness"),
+      name: z3.string().optional()
+    }).strict()
+  ).optional()
 }).strict().refine(
   (data) => !data.eav_value_table || typeof data.eav_definition_table === "string",
   {
@@ -2492,13 +2533,13 @@ var EntityDefinitionSchema = z3.object({
   }
 ).superRefine((entity, ctx) => {
   if (!entity.detection) return;
-  const declared = new Set(Object.keys(entity.sync?.providers ?? {}));
+  const declared = new Set(Object.keys(entity.integration?.providers ?? {}));
   for (const provider of Object.keys(entity.detection)) {
     if (!declared.has(provider)) {
       ctx.addIssue({
         code: "custom",
         path: ["detection", provider],
-        message: `Provider '${provider}' used in detection: but not declared in sync.providers. Known providers: ${[...declared].join(", ")}`
+        message: `Provider '${provider}' used in detection: but not declared in integration.providers. Known providers: ${[...declared].join(", ")}`
       });
     }
   }
@@ -2910,6 +2951,60 @@ var JunctionDefinitionSchema = z6.object({
   }
 );
 
+// src/schema/provider-definition.schema.ts
+import { z as z7 } from "zod";
+var IMPORT_REF_RE = /^[^#\s]+#[A-Za-z_$][A-Za-z0-9_$]*$/;
+var ImportRefSchema = z7.string().regex(
+  IMPORT_REF_RE,
+  "must be an 'import-path#Export' reference (e.g. '@app/foo/bar.strategy#BarStrategy')"
+);
+function parseImportRef(ref) {
+  const hash = ref.indexOf("#");
+  return { path: ref.slice(0, hash), exportName: ref.slice(hash + 1) };
+}
+var AuthTypeSchema = z7.enum(["oauth2", "api-key", "app-password"]);
+var AuthSchema = z7.object({
+  type: AuthTypeSchema,
+  // Class implementing the auth subsystem's strategy contract (ADR-031).
+  // Pre-flight verified against a real export at codegen time.
+  strategy: ImportRefSchema,
+  // Required (and non-empty) iff type === 'oauth2'; see refine below.
+  scopes: z7.array(z7.string()).optional()
+}).strict().refine(
+  (a) => a.type !== "oauth2" || a.scopes !== void 0 && a.scopes.length > 0,
+  {
+    message: "auth.scopes is required and must be non-empty when auth.type is 'oauth2'",
+    path: ["scopes"]
+  }
+);
+var ClientSchema = z7.object({
+  // API client class. Pre-flight verified against a real export.
+  class: ImportRefSchema,
+  base_url: z7.string().url("client.base_url must be an absolute URL")
+}).strict();
+var ProviderDefinitionSchema = z7.object({
+  // Provider id — the canonical string used as detection: keys, audit rows,
+  // subscription rows. kebab/lower; unique across definitions/providers/
+  // (uniqueness is a cross-file check in validate-providers.ts).
+  slug: z7.string().regex(
+    /^[a-z][a-z0-9-]*$/,
+    "slug must be kebab-case lower (e.g. 'google', 'hubspot')"
+  ),
+  display_name: z7.string().optional(),
+  auth: AuthSchema,
+  client: ClientSchema,
+  // Surfaces this provider serves (ADR-0006: surfaces span contexts — one
+  // Google OAuth feeds calendar+mail+transcript). Each must reference a real
+  // `surface:` declared on some entity; that cross-check is in
+  // validate-providers.ts. Non-empty enforced here.
+  surfaces: z7.array(z7.string()).min(1, "surfaces must list at least one surface"),
+  // Optional auth lifecycle hints consumed by provider-module emission (D2).
+  // `refresh_behavior` is left as a free string in D1 — its domain firms up
+  // when D2 consumes it; carrying it now keeps the YAML lossless.
+  token_lifetime: z7.number().int().positive().optional(),
+  refresh_behavior: z7.string().optional()
+}).strict();
+
 // src/utils/yaml-loader.ts
 function loadEntityFromYaml(filePath) {
   if (!existsSync6(filePath)) {
@@ -2963,6 +3058,19 @@ function formatZodErrors(error) {
     return `${err.message} ${location}`;
   });
 }
+function loadEntitiesFromYaml(filePaths) {
+  const successes = [];
+  const failures = [];
+  for (const filePath of filePaths) {
+    const result = loadEntityFromYaml(filePath);
+    if (result.success) {
+      successes.push(result);
+    } else {
+      failures.push(result);
+    }
+  }
+  return { successes, failures };
+}
 function loadRelationshipFromYaml(filePath) {
   if (!existsSync6(filePath)) {
     return {
@@ -3098,6 +3206,64 @@ function loadJunctionFromYaml(filePath) {
     filePath
   };
 }
+function loadProviderFromYaml(filePath) {
+  if (!existsSync6(filePath)) {
+    return {
+      success: false,
+      error: `File not found: ${filePath}`,
+      filePath
+    };
+  }
+  let content;
+  try {
+    content = readFileSync4(filePath, "utf-8");
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to read file: ${filePath}`,
+      details: [err instanceof Error ? err.message : String(err)],
+      filePath
+    };
+  }
+  let parsed;
+  try {
+    parsed = parseYaml(content);
+  } catch (err) {
+    return {
+      success: false,
+      error: `Invalid YAML syntax in ${filePath}`,
+      details: [err instanceof Error ? err.message : String(err)],
+      filePath
+    };
+  }
+  const result = ProviderDefinitionSchema.safeParse(parsed);
+  if (!result.success) {
+    return {
+      success: false,
+      error: `Validation failed for ${filePath}`,
+      details: formatZodErrors(result.error),
+      filePath
+    };
+  }
+  return {
+    success: true,
+    definition: result.data,
+    filePath
+  };
+}
+function loadProvidersFromYaml(filePaths) {
+  const successes = [];
+  const failures = [];
+  for (const filePath of filePaths) {
+    const result = loadProviderFromYaml(filePath);
+    if (result.success) {
+      successes.push(result);
+    } else {
+      failures.push(result);
+    }
+  }
+  return { successes, failures };
+}
 function detectYamlType(filePath) {
   if (!existsSync6(filePath)) return "unknown";
   try {
@@ -3182,14 +3348,14 @@ function transformToEntity(result) {
       entity.relationships.set(name, relationship);
     }
   }
-  if (definition.sync) {
-    const syncDef = definition.sync;
-    const parsedSync = {
-      electric: syncDef.electric ?? false
+  if (definition.integration) {
+    const integrationDef = definition.integration;
+    const parsedIntegration = {
+      electric: integrationDef.electric ?? false
     };
-    if (syncDef.providers) {
-      parsedSync.providers = {};
-      for (const [providerName, providerDef] of Object.entries(syncDef.providers)) {
+    if (integrationDef.providers) {
+      parsedIntegration.providers = {};
+      for (const [providerName, providerDef] of Object.entries(integrationDef.providers)) {
         const parsedProvider = {
           remoteEntity: providerDef.remote_entity,
           direction: providerDef.direction,
@@ -3201,10 +3367,10 @@ function transformToEntity(result) {
         if (providerDef.read_only_fields) {
           parsedProvider.readOnlyFields = providerDef.read_only_fields;
         }
-        parsedSync.providers[providerName] = parsedProvider;
+        parsedIntegration.providers[providerName] = parsedProvider;
       }
     }
-    entity.sync = parsedSync;
+    entity.integration = parsedIntegration;
   }
   if (definition.events) {
     entity.events = definition.events.map((ev) => ({
@@ -3477,6 +3643,160 @@ function resolveRelationshipReferences(relationshipDefs, entities) {
   return issues;
 }
 
+// src/parser/validate-providers.ts
+import { existsSync as existsSync7, readFileSync as readFileSync5, statSync as statSync3 } from "fs";
+import { isAbsolute, join as join8, resolve as resolve3 } from "path";
+import ts from "typescript";
+function collectEntitySurfaces(entities) {
+  const surfaces = /* @__PURE__ */ new Set();
+  for (const e of entities) {
+    if (e.surface) surfaces.add(e.surface);
+  }
+  return surfaces;
+}
+function resolveImportRef(ref, opts) {
+  const { path: path34, exportName } = parseImportRef(ref);
+  const file = resolveModuleFile(path34, opts);
+  if (!file) {
+    return { status: "module-not-found", resolvedFrom: opts.sourceRoot };
+  }
+  const content = readFileSync5(file, "utf-8");
+  const { names: names2, hasWildcard } = collectExportedNames(file, content);
+  if (names2.has(exportName) || hasWildcard) {
+    return { status: "ok", file };
+  }
+  return { status: "export-not-found", file };
+}
+function resolveModuleFile(importPath, opts) {
+  let base = null;
+  for (const [alias, target] of Object.entries(opts.aliases ?? {})) {
+    if (importPath === alias || importPath.startsWith(`${alias}/`)) {
+      const rest = importPath.slice(alias.length);
+      base = join8(target, rest);
+      break;
+    }
+  }
+  if (base === null) {
+    base = isAbsolute(importPath) ? importPath : resolve3(opts.sourceRoot, importPath);
+  }
+  const candidates = [
+    base,
+    `${base}.ts`,
+    `${base}.tsx`,
+    join8(base, "index.ts"),
+    join8(base, "index.tsx")
+  ];
+  for (const c of candidates) {
+    if (existsSync7(c) && statSync3(c).isFile()) return c;
+  }
+  return null;
+}
+function collectExportedNames(fileName, content) {
+  const sf = ts.createSourceFile(
+    fileName,
+    content,
+    ts.ScriptTarget.Latest,
+    /* setParentNodes */
+    true
+  );
+  const names2 = /* @__PURE__ */ new Set();
+  let hasWildcard = false;
+  const hasExportModifier = (node) => ts.canHaveModifiers(node) && (ts.getModifiers(node)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false);
+  sf.forEachChild((node) => {
+    if (hasExportModifier(node)) {
+      if ((ts.isClassDeclaration(node) || ts.isFunctionDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isModuleDeclaration(node)) && node.name && ts.isIdentifier(node.name)) {
+        names2.add(node.name.text);
+      } else if (ts.isVariableStatement(node)) {
+        for (const decl of node.declarationList.declarations) {
+          if (ts.isIdentifier(decl.name)) names2.add(decl.name.text);
+        }
+      }
+    }
+    if (ts.isExportDeclaration(node)) {
+      if (!node.exportClause) {
+        hasWildcard = true;
+      } else if (ts.isNamedExports(node.exportClause)) {
+        for (const el of node.exportClause.elements) names2.add(el.name.text);
+      } else if (ts.isNamespaceExport(node.exportClause)) {
+        names2.add(node.exportClause.name.text);
+      }
+    }
+  });
+  return { names: names2, hasWildcard };
+}
+function validateProviders(providers, opts) {
+  const issues = [];
+  const knownSurfaces = new Set(opts.entitySurfaces);
+  const slugToFiles = /* @__PURE__ */ new Map();
+  for (const p of providers) {
+    const files = slugToFiles.get(p.definition.slug) ?? [];
+    files.push(p.filePath);
+    slugToFiles.set(p.definition.slug, files);
+  }
+  for (const [slug, files] of slugToFiles) {
+    if (files.length > 1) {
+      for (const file of files) {
+        const others = files.filter((f) => f !== file);
+        issues.push({
+          severity: "error",
+          type: "provider_duplicate_slug",
+          message: `provider slug '${slug}' is declared more than once (also in: ${others.join(", ")})`,
+          path: file
+        });
+      }
+    }
+  }
+  for (const { definition, filePath } of providers) {
+    const { slug } = definition;
+    for (const surface of definition.surfaces) {
+      if (!knownSurfaces.has(surface)) {
+        const known = [...knownSurfaces].sort().join(", ") || "(none declared)";
+        issues.push({
+          severity: "error",
+          type: "provider_unknown_surface",
+          message: `provider ${slug}: surface '${surface}' is not declared by any entity (known surfaces: ${known})`,
+          path: filePath
+        });
+      }
+    }
+    if (!opts.skipImportCheck) {
+      if (!opts.sourceRoot) {
+        throw new Error(
+          "validateProviders: sourceRoot is required for the import pre-flight check (or set skipImportCheck: true)"
+        );
+      }
+      const resolveOpts = {
+        sourceRoot: opts.sourceRoot,
+        aliases: opts.aliases
+      };
+      const refs = [
+        { field: "auth.strategy", ref: definition.auth.strategy },
+        { field: "client.class", ref: definition.client.class }
+      ];
+      for (const { field, ref } of refs) {
+        const result = resolveImportRef(ref, resolveOpts);
+        if (result.status === "module-not-found") {
+          issues.push({
+            severity: "error",
+            type: "provider_import_unresolved",
+            message: `provider ${slug}: ${field} '${ref}' not found \u2014 module could not be resolved from ${result.resolvedFrom}`,
+            path: filePath
+          });
+        } else if (result.status === "export-not-found") {
+          const { exportName } = parseImportRef(ref);
+          issues.push({
+            severity: "error",
+            type: "provider_import_unresolved",
+            message: `provider ${slug}: ${field} '${ref}' not found \u2014 export '${exportName}' is missing from ${result.file}`,
+            path: filePath
+          });
+        }
+      }
+    }
+  }
+  return issues;
+}
+
 // src/analyzer/graph-builder.ts
 function inferCardinality(type) {
   switch (type) {
@@ -3833,8 +4153,8 @@ function checkConsistency(graph) {
     if (entity.queries !== void 0) {
       issues.push(...checkQueryFieldReferences(entity));
     }
-    if (entity.sync !== void 0) {
-      issues.push(...checkSyncFieldMappingReferences(entity));
+    if (entity.integration !== void 0) {
+      issues.push(...checkIntegrationFieldMappingReferences(entity));
       issues.push(...checkExternalIdTrackingCollision(entity));
     }
   }
@@ -4070,19 +4390,19 @@ function checkQueryFieldReferences(entity) {
   }
   return issues;
 }
-function checkSyncFieldMappingReferences(entity) {
+function checkIntegrationFieldMappingReferences(entity) {
   const issues = [];
   const availableFields = getAvailableFieldNames(entity);
   const availableSet = new Set(availableFields);
-  for (const [providerName, provider] of Object.entries(entity.sync?.providers ?? {})) {
+  for (const [providerName, provider] of Object.entries(entity.integration?.providers ?? {})) {
     for (const fieldName of Object.keys(provider.fieldMapping ?? {})) {
       if (!availableSet.has(fieldName)) {
         issues.push({
           severity: "warning",
-          type: "unknown_sync_field_mapping",
+          type: "unknown_integration_field_mapping",
           entity: entity.name,
           field: fieldName,
-          message: `Sync field mapping references unknown field "${fieldName}" for provider "${providerName}" in entity "${entity.name}"`
+          message: `Integration field mapping references unknown field "${fieldName}" for provider "${providerName}" in entity "${entity.name}"`
         });
       }
     }
@@ -4090,10 +4410,10 @@ function checkSyncFieldMappingReferences(entity) {
       if (!availableSet.has(fieldName)) {
         issues.push({
           severity: "warning",
-          type: "unknown_sync_field_mapping",
+          type: "unknown_integration_field_mapping",
           entity: entity.name,
           field: fieldName,
-          message: `Sync field mapping references unknown field "${fieldName}" for provider "${providerName}" in entity "${entity.name}"`
+          message: `Integration field mapping references unknown field "${fieldName}" for provider "${providerName}" in entity "${entity.name}"`
         });
       }
     }
@@ -4104,14 +4424,14 @@ function checkExternalIdTrackingCollision(entity) {
   const issues = [];
   const hasExternalIdTracking = entity.behaviors.includes("external_id_tracking");
   if (!hasExternalIdTracking) return issues;
-  for (const [providerName, provider] of Object.entries(entity.sync?.providers ?? {})) {
+  for (const [providerName, provider] of Object.entries(entity.integration?.providers ?? {})) {
     if (provider.fieldMapping && "external_id" in provider.fieldMapping) {
       issues.push({
         severity: "warning",
         type: "external_id_tracking_collision",
         entity: entity.name,
         field: "external_id",
-        message: `Entity "${entity.name}" has external_id_tracking behavior and also maps "external_id" in sync field_mapping for provider "${providerName}". The behavior-added field may collide with the mapped field.`
+        message: `Entity "${entity.name}" has external_id_tracking behavior and also maps "external_id" in integration field_mapping for provider "${providerName}". The behavior-added field may collide with the mapped field.`
       });
     }
   }
@@ -4290,28 +4610,28 @@ function createSuggestion(path34) {
 
 // src/analyzer/manifest.ts
 import { createHash } from "crypto";
-import { readFileSync as readFileSync5, writeFileSync, existsSync as existsSync7, mkdirSync, readdirSync as readdirSync6, statSync as statSync3 } from "fs";
-import { join as join8 } from "path";
+import { readFileSync as readFileSync6, writeFileSync, existsSync as existsSync8, mkdirSync, readdirSync as readdirSync6, statSync as statSync4 } from "fs";
+import { join as join9 } from "path";
 var MANIFEST_FILE = "manifest.json";
 var MANIFEST_VERSION = 1;
 function getManifestDir() {
   return process.env.CODEGEN_MANIFEST_DIR || ".codegen";
 }
 function getManifestPaths(projectRoot) {
-  const dir = join8(projectRoot, getManifestDir());
-  const file = join8(dir, MANIFEST_FILE);
+  const dir = join9(projectRoot, getManifestDir());
+  const file = join9(dir, MANIFEST_FILE);
   return { dir, file };
 }
 async function computeEntityFilesHash(entitiesDir) {
-  if (!existsSync7(entitiesDir)) {
+  if (!existsSync8(entitiesDir)) {
     return createHash("sha256").update("").digest("hex");
   }
   const yamlFiles = [];
   function walkDir(dir) {
     const entries = readdirSync6(dir);
     for (const entry of entries) {
-      const fullPath = join8(dir, entry);
-      const stat = statSync3(fullPath);
+      const fullPath = join9(dir, entry);
+      const stat = statSync4(fullPath);
       if (stat.isDirectory()) {
         walkDir(fullPath);
       } else if (stat.isFile() && (entry.endsWith(".yaml") || entry.endsWith(".yml"))) {
@@ -4323,7 +4643,7 @@ async function computeEntityFilesHash(entitiesDir) {
   yamlFiles.sort();
   const hash = createHash("sha256");
   for (const file of yamlFiles) {
-    const content = readFileSync5(file, "utf-8");
+    const content = readFileSync6(file, "utf-8");
     hash.update(file);
     hash.update(content);
   }
@@ -4331,11 +4651,11 @@ async function computeEntityFilesHash(entitiesDir) {
 }
 function readManifest(projectRoot) {
   const { file } = getManifestPaths(projectRoot);
-  if (!existsSync7(file)) {
+  if (!existsSync8(file)) {
     return null;
   }
   try {
-    const content = readFileSync5(file, "utf-8");
+    const content = readFileSync6(file, "utf-8");
     const manifest = JSON.parse(content);
     if (manifest.version !== MANIFEST_VERSION) {
       return null;
@@ -4347,7 +4667,7 @@ function readManifest(projectRoot) {
 }
 function writeManifest(projectRoot, manifest) {
   const { dir, file } = getManifestPaths(projectRoot);
-  if (!existsSync7(dir)) {
+  if (!existsSync8(dir)) {
     mkdirSync(dir, { recursive: true });
   }
   const content = JSON.stringify(manifest, null, 2);
@@ -5442,8 +5762,8 @@ var BasePattern = definePattern({
 });
 
 // src/patterns/library/junction.pattern.ts
-import { z as z7 } from "zod";
-var JunctionPatternConfigSchema = z7.object({}).strict();
+import { z as z8 } from "zod";
+var JunctionPatternConfigSchema = z8.object({}).strict();
 var JunctionPattern = definePattern({
   name: "Junction",
   description: "Explicit many-to-many junction with role + temporal + sourcing metadata",
@@ -5489,30 +5809,30 @@ var MetadataPattern = definePattern({
   description: "History-tracked metadata rows \u2014 entity-id + type scoped lookups"
 });
 
-// src/patterns/library/synced.pattern.ts
-var SyncedPattern = definePattern({
-  name: "Synced",
+// src/patterns/library/integrated.pattern.ts
+var IntegratedPattern = definePattern({
+  name: "Integrated",
   extends: ["Base"],
-  repositoryClass: "SyncedEntityRepository",
-  serviceClass: "SyncedEntityService",
-  repositoryImport: "@shared/base-classes/synced-entity-repository",
-  serviceImport: "@shared/base-classes/synced-entity-service",
+  repositoryClass: "IntegratedEntityRepository",
+  serviceClass: "IntegratedEntityService",
+  repositoryImport: "@shared/base-classes/integrated-entity-repository",
+  serviceImport: "@shared/base-classes/integrated-entity-service",
   repositoryInheritedMethods: [
     "findById, findByIds, list, count, exists, create, update, delete, upsertMany",
     "findByExternalId, findManyByExternalIds, findAllByUserId, findVisibleByUserId",
-    "syncUpsertOne, findByExternalIdProjected, softDeleteByExternalId, syncUpsert"
+    "integrationUpsertOne, findByExternalIdProjected, softDeleteByExternalId, integrationUpsert"
   ],
   serviceInheritedMethods: [
     "findById, findByIds, list, count, exists, create, update, delete",
     "findByExternalId, findAllByUserId, findVisibleByUserId"
   ],
   impliedBehaviors: ["external_id_tracking"],
-  description: "External CRM/system sync columns and syncUpsert methods"
+  description: "External CRM/system integration columns and integrationUpsert methods"
 });
 
 // src/patterns/library/index.ts
 registerLibraryPattern(BasePattern);
-registerLibraryPattern(SyncedPattern);
+registerLibraryPattern(IntegratedPattern);
 registerLibraryPattern(ActivityPattern);
 registerLibraryPattern(KnowledgePattern);
 registerLibraryPattern(MetadataPattern);
@@ -5572,9 +5892,9 @@ function validateEntities(entitiesDir) {
 
 // src/cli/shared/hygen.ts
 import { execSync } from "child_process";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 function defaultTemplateRoot() {
-  return join9(import.meta.dirname, "..", "..", "..", "templates");
+  return join10(import.meta.dirname, "..", "..", "..", "templates");
 }
 function quoteArg(a) {
   if (a === "" || /[\s"'$`\\]/.test(a)) {
@@ -5698,7 +6018,9 @@ function collectEntities(entitiesDir) {
     const def = result.definition;
     entities.push({
       name: def.entity.name,
-      plural: def.entity.plural
+      plural: def.entity.plural,
+      // #403: top-level `context:` nests the module folder; undefined → flat.
+      context: def.context
     });
   }
   entities.sort((a, b) => a.name.localeCompare(b.name));
@@ -5754,11 +6076,12 @@ function entityFilePaths(info, architecture, backendSrc) {
   const pluralKebab = toKebabCase(plural);
   if (architecture === "clean-lite-ps") {
     const prefix = backendSrc && backendSrc !== "." ? `${backendSrc}/` : "";
+    const ctxSeg = info.context ? `${info.context}/` : "";
     return {
-      moduleFile: `${prefix}modules/${plural}/${plural}.module.ts`,
+      moduleFile: `${prefix}modules/${ctxSeg}${plural}/${plural}.module.ts`,
       moduleClass: `${toPascalCase(plural)}Module`,
       // Drizzle entity schema lives alongside the entity file in clean-lite-ps.
-      schemaFile: `${prefix}modules/${plural}/${name}.entity.ts`
+      schemaFile: `${prefix}modules/${ctxSeg}${plural}/${name}.entity.ts`
     };
   }
   return {
@@ -5879,22 +6202,22 @@ var HEADER2 = `// AUTO-GENERATED by @pattern-stack/codegen. Do not edit.
 function collectScopeableNames(entitiesDir) {
   if (!fs3.existsSync(entitiesDir)) return [];
   const files = findYamlFiles(entitiesDir);
-  const names = [];
+  const names2 = [];
   for (const file of files) {
     const result = loadEntityFromYaml(file);
     if (!result.success) continue;
     if (result.definition.entity.scopeable === true) {
-      names.push(result.definition.entity.name);
+      names2.push(result.definition.entity.name);
     }
   }
-  names.sort((a, b) => a.localeCompare(b));
-  return names;
+  names2.sort((a, b) => a.localeCompare(b));
+  return names2;
 }
-function buildScopeEntityTypeContent(names) {
-  if (names.length === 0) {
+function buildScopeEntityTypeContent(names2) {
+  if (names2.length === 0) {
     return HEADER2 + "\nexport type ScopeEntityType = never;\n\nexport const SCOPE_ENTITY_TYPES = [] as const;\n";
   }
-  const quoted = names.map((n) => `'${n}'`);
+  const quoted = names2.map((n) => `'${n}'`);
   const unionLiteral = quoted.join(" | ");
   const tupleLiteral = quoted.join(", ");
   return HEADER2 + `
@@ -5953,8 +6276,8 @@ var SUBSYSTEMS = [
     defaultBackend: "local"
   },
   {
-    name: "sync",
-    description: "External-system sync engine (IChangeSource<T> + orchestrator + audit log)",
+    name: "integration",
+    description: "External-system integration engine (IChangeSource<T> + orchestrator + audit log)",
     backends: ["drizzle", "memory"],
     defaultBackend: "drizzle"
   },
@@ -5977,7 +6300,7 @@ var SUBSYSTEMS = [
   {
     // OBS-7 / ADR-025. Combiner subsystem — no schema, no worker, no
     // generated/ dir. `ObservabilityModule` composes sibling read ports
-    // (events/jobs/bridge/sync) via @Optional() DI. The `combiner`
+    // (events/jobs/bridge/integration) via @Optional() DI. The `combiner`
     // pseudo-backend is parallel to `openapi-config`'s `config-only`.
     name: "observability",
     description: "Observability combiner \u2014 composes sibling read ports via @Optional() DI (ADR-025)",
@@ -5999,14 +6322,14 @@ var SUBSYSTEMS = [
   {
     // #287. Auth-integrations starter (PR #290) — vendored from
     // `examples/auth-integrations/`, NOT from `runtime/subsystems/`.
-    // Bundles a canonical `integration` entity yaml + the three
-    // integration-store-port adapters + the `IntegrationsService`
+    // Bundles a canonical `connection` entity yaml + the three
+    // connection-store-port adapters + the `ConnectionsService`
     // facade. Single-backend (drizzle); the runtime adapters call
-    // directly into the codegen-emitted `IntegrationService` from the
+    // directly into the codegen-emitted `ConnectionService` from the
     // entity layer. Detection: presence of
-    // `<sharedRoot>/integrations/integrations-auth.module.ts`.
+    // `<vendorRoot>/connections/connections-auth.module.ts`.
     name: "auth-integrations",
-    description: "Vendored integrations entity + adapters (consumes auth subsystem)",
+    description: "Vendored connection entity + adapters (consumes auth subsystem)",
     backends: ["drizzle"],
     defaultBackend: "drizzle"
   }
@@ -6017,7 +6340,7 @@ var SUBSYSTEM_MODULE_FILE = {
   jobs: "jobs-domain.module.ts",
   cache: "cache.module.ts",
   storage: "storage.module.ts",
-  sync: "sync.module.ts",
+  integration: "integration.module.ts",
   bridge: "bridge.module.ts",
   observability: "observability.module.ts",
   auth: "auth.module.ts"
@@ -6099,11 +6422,8 @@ async function detectSubsystemStatesImpl(ctx) {
     const pathsAny = ctx.config?.paths;
     const modulesConfigured = pathsAny?.modules_dir;
     const vendorRoot = typeof modulesConfigured === "string" && modulesConfigured.length > 0 ? path6.resolve(ctx.cwd, modulesConfigured) : path6.resolve(ctx.cwd, backendSrc, "modules");
-    const sharedConfigured = pathsAny?.shared;
-    const sharedRoot = typeof sharedConfigured === "string" && sharedConfigured.length > 0 ? path6.resolve(ctx.cwd, sharedConfigured) : path6.resolve(ctx.cwd, backendSrc, "shared");
     const candidates = [
-      path6.join(vendorRoot, "integrations", "integrations-auth.module.ts"),
-      path6.join(sharedRoot, "integrations", "integrations-auth.module.ts")
+      path6.join(vendorRoot, "connections", "connections-auth.module.ts")
     ];
     for (const moduleFile of candidates) {
       if (fs4.existsSync(moduleFile)) {
@@ -6217,24 +6537,24 @@ var COMPOSERS = {
       ]
     };
   },
-  sync: ({ subsystemsRel, cfg }) => {
+  integration: ({ subsystemsRel, cfg }) => {
     const backend = cfg?.backend ?? "drizzle";
     const multiTenant = Boolean(cfg?.multi_tenant);
     return {
       imports: [
-        `import { SyncModule } from '${subsystemsRel}/sync/sync.module';`
+        `import { IntegrationModule } from '${subsystemsRel}/integration/integration.module';`
       ],
       calls: [
-        `	SyncModule.forRoot(${quoteOpts({ backend, multiTenant })}),`
+        `	IntegrationModule.forRoot(${quoteOpts({ backend, multiTenant })}),`
       ]
     };
   }
 };
-var COMPOSABLE_ORDER = ["events", "jobs", "bridge", "sync"];
+var COMPOSABLE_ORDER = ["events", "jobs", "bridge", "integration"];
 var HEADER3 = `// AUTO-GENERATED by @pattern-stack/codegen. DO NOT EDIT.
 // Subsystem composition barrel \u2014 reflects \`subsystems.install\` in
 // codegen.config.yaml and the per-subsystem option blocks
-// (\`events:\`, \`jobs:\`, \`bridge:\`, \`sync:\`).
+// (\`events:\`, \`jobs:\`, \`bridge:\`, \`integration:\`).
 //
 // Wire into AppModule once:
 //
@@ -6308,7 +6628,7 @@ async function regenerateSubsystemBarrel(opts) {
 // src/cli/shared/bridge-registry-generator.ts
 import fs6 from "fs";
 import path9 from "path";
-import ts from "typescript";
+import ts2 from "typescript";
 var HEADER4 = `// AUTO-GENERATED by @pattern-stack/codegen. Do not edit.
 // Run \`codegen entity new --all\` to refresh.
 `;
@@ -6384,34 +6704,34 @@ function findHandlerFiles(dir) {
 function extractTriggersFromSourceFile(sourceFile, filePath) {
   const triggers = [];
   function visit(node) {
-    if (ts.isClassDeclaration(node)) {
-      const modifiers = ts.canHaveDecorators(node) ? ts.getDecorators(node) ?? [] : [];
+    if (ts2.isClassDeclaration(node)) {
+      const modifiers = ts2.canHaveDecorators(node) ? ts2.getDecorators(node) ?? [] : [];
       for (const decorator of modifiers) {
         const call = decorator.expression;
-        if (!ts.isCallExpression(call)) continue;
-        if (!ts.isIdentifier(call.expression)) continue;
+        if (!ts2.isCallExpression(call)) continue;
+        if (!ts2.isIdentifier(call.expression)) continue;
         if (call.expression.text !== "JobHandler") continue;
         const [typeArg, metaArg] = call.arguments;
-        if (!typeArg || !ts.isStringLiteralLike(typeArg)) continue;
-        if (!metaArg || !ts.isObjectLiteralExpression(metaArg)) continue;
+        if (!typeArg || !ts2.isStringLiteralLike(typeArg)) continue;
+        if (!metaArg || !ts2.isObjectLiteralExpression(metaArg)) continue;
         const jobType = typeArg.text;
         const triggersProp = metaArg.properties.find(
-          (p) => ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === "triggers"
+          (p) => ts2.isPropertyAssignment(p) && ts2.isIdentifier(p.name) && p.name.text === "triggers"
         );
         if (!triggersProp) continue;
-        if (!ts.isArrayLiteralExpression(triggersProp.initializer)) continue;
+        if (!ts2.isArrayLiteralExpression(triggersProp.initializer)) continue;
         triggersProp.initializer.elements.forEach((el, index2) => {
-          if (!ts.isObjectLiteralExpression(el)) return;
+          if (!ts2.isObjectLiteralExpression(el)) return;
           const eventProp = el.properties.find(
-            (p) => ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === "event"
+            (p) => ts2.isPropertyAssignment(p) && ts2.isIdentifier(p.name) && p.name.text === "event"
           );
           const mapProp = el.properties.find(
-            (p) => ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === "map"
+            (p) => ts2.isPropertyAssignment(p) && ts2.isIdentifier(p.name) && p.name.text === "map"
           );
           const whenProp = el.properties.find(
-            (p) => ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === "when"
+            (p) => ts2.isPropertyAssignment(p) && ts2.isIdentifier(p.name) && p.name.text === "when"
           );
-          if (!eventProp || !ts.isStringLiteralLike(eventProp.initializer)) return;
+          if (!eventProp || !ts2.isStringLiteralLike(eventProp.initializer)) return;
           if (!mapProp) return;
           const { line } = sourceFile.getLineAndCharacterOfPosition(el.getStart(sourceFile));
           triggers.push({
@@ -6426,7 +6746,7 @@ function extractTriggersFromSourceFile(sourceFile, filePath) {
         });
       }
     }
-    ts.forEachChild(node, visit);
+    ts2.forEachChild(node, visit);
   }
   visit(sourceFile);
   return triggers;
@@ -6436,13 +6756,13 @@ function scanHandlerFiles(handlersDir) {
   const out = [];
   for (const filePath of files) {
     const text2 = fs6.readFileSync(filePath, "utf8");
-    const sourceFile = ts.createSourceFile(
+    const sourceFile = ts2.createSourceFile(
       filePath,
       text2,
-      ts.ScriptTarget.Latest,
+      ts2.ScriptTarget.Latest,
       /* setParentNodes */
       true,
-      ts.ScriptKind.TS
+      ts2.ScriptKind.TS
     );
     out.push(...extractTriggersFromSourceFile(sourceFile, filePath));
   }
@@ -6741,8 +7061,8 @@ function emitTypeImports(imports) {
   }
   const out = [];
   for (const specifier of [...grouped.keys()].sort()) {
-    const names = [...grouped.get(specifier)].sort();
-    out.push(`import type { ${names.join(", ")} } from '${specifier}';`);
+    const names2 = [...grouped.get(specifier)].sort();
+    out.push(`import type { ${names2.join(", ")} } from '${specifier}';`);
   }
   return out;
 }
@@ -6755,8 +7075,8 @@ function emitValueImports(imports) {
   }
   const out = [];
   for (const specifier of [...grouped.keys()].sort()) {
-    const names = [...grouped.get(specifier)].sort();
-    out.push(`import { ${names.join(", ")} } from '${specifier}';`);
+    const names2 = [...grouped.get(specifier)].sort();
+    out.push(`import { ${names2.join(", ")} } from '${specifier}';`);
   }
   return out;
 }
@@ -6788,13 +7108,13 @@ function buildTokensTs(pattern) {
   lines.push("");
   for (const i of emitTypeImports(typeImports)) lines.push(i);
   lines.push("");
-  for (const { names } of registries) {
-    lines.push(`export const ${names.tokenConst} = Symbol('${names.tokenConst}');`);
+  for (const { names: names2 } of registries) {
+    lines.push(`export const ${names2.tokenConst} = Symbol('${names2.tokenConst}');`);
   }
   lines.push("");
-  for (const { reg, names } of registries) {
+  for (const { reg, names: names2 } of registries) {
     lines.push(
-      `export type ${names.mapType} = Map<${reg.keyType}, ${reg.valueType}>;`
+      `export type ${names2.mapType} = Map<${reg.keyType}, ${reg.valueType}>;`
     );
   }
   lines.push("");
@@ -6808,8 +7128,8 @@ function buildProvidersTs(pattern) {
       providerImports.push({ specifier: e.providerImport, name: e.provider });
     }
   }
-  const tokenValueImports = registries.map(({ names }) => names.tokenConst);
-  const mapTypeImports = registries.map(({ names }) => names.mapType);
+  const tokenValueImports = registries.map(({ names: names2 }) => names2.tokenConst);
+  const mapTypeImports = registries.map(({ names: names2 }) => names2.mapType);
   const typeImports = [];
   for (const { reg } of registries) {
     typeImports.push({ specifier: reg.keyTypeImport, name: reg.keyType });
@@ -6834,24 +7154,24 @@ function buildProvidersTs(pattern) {
     `export function build${pascal}RegistryProviders(opts?: ${optsType}): Provider[] {`
   );
   lines.push("	return [");
-  for (const { reg, names } of registries) {
+  for (const { reg, names: names2 } of registries) {
     const factoryArgs = reg.entries.map((e, i) => `${camelArg(e.provider, i)}: ${e.provider}`).join(", ");
     lines.push("		{");
-    lines.push(`			provide: ${names.tokenConst},`);
+    lines.push(`			provide: ${names2.tokenConst},`);
     lines.push(`			useFactory: (${factoryArgs}) => {`);
-    lines.push(`				const base: ${names.mapType} = new Map<${reg.keyType}, ${reg.valueType}>([`);
+    lines.push(`				const base: ${names2.mapType} = new Map<${reg.keyType}, ${reg.valueType}>([`);
     for (const [i, e] of reg.entries.entries()) {
       lines.push(
         `					['${e.key}' as ${reg.keyType}, ${camelArg(e.provider, i)}],`
       );
     }
     lines.push("				]);");
-    lines.push(`				if (opts?.${names.overrideField}) {`);
-    lines.push(`					for (const [k, v] of Object.entries(opts.${names.overrideField})) {`);
+    lines.push(`				if (opts?.${names2.overrideField}) {`);
+    lines.push(`					for (const [k, v] of Object.entries(opts.${names2.overrideField})) {`);
     lines.push(`						if (v !== undefined) base.set(k as ${reg.keyType}, v as ${reg.valueType});`);
     lines.push("					}");
     lines.push("				}");
-    lines.push(`				return base as ${names.mapType};`);
+    lines.push(`				return base as ${names2.mapType};`);
     lines.push("			},");
     const injectList = reg.entries.map((e) => e.provider).join(", ");
     lines.push(`			inject: [${injectList}],`);
@@ -6881,8 +7201,8 @@ function buildDispatcherTs(pattern) {
       providerImports.push({ specifier: e.providerImport, name: e.provider });
     }
   }
-  const tokenValues = registries.map(({ names }) => names.tokenConst);
-  const mapTypes = registries.map(({ names }) => names.mapType);
+  const tokenValues = registries.map(({ names: names2 }) => names2.tokenConst);
+  const mapTypes = registries.map(({ names: names2 }) => names2.mapType);
   const lines = [];
   lines.push(HEADER5.trimEnd());
   lines.push("");
@@ -6900,21 +7220,21 @@ function buildDispatcherTs(pattern) {
   lines.push("@Injectable()");
   lines.push(`export class ${className} {`);
   lines.push("	constructor(");
-  for (const { names } of registries) {
-    const fieldName = names.method === "select" ? "registry" : `${camelFromMethod(names.method)}Registry`;
+  for (const { names: names2 } of registries) {
+    const fieldName = names2.method === "select" ? "registry" : `${camelFromMethod(names2.method)}Registry`;
     lines.push(
-      `		@Inject(${names.tokenConst}) protected readonly ${fieldName}: ${names.mapType},`
+      `		@Inject(${names2.tokenConst}) protected readonly ${fieldName}: ${names2.mapType},`
     );
   }
   lines.push("	) {}");
   lines.push("");
-  for (const { reg, names } of registries) {
-    const fieldName = names.method === "select" ? "registry" : `${camelFromMethod(names.method)}Registry`;
+  for (const { reg, names: names2 } of registries) {
+    const fieldName = names2.method === "select" ? "registry" : `${camelFromMethod(names2.method)}Registry`;
     for (const e of reg.entries) {
-      lines.push(`	${names.method}(key: '${e.key}'): ${e.provider};`);
+      lines.push(`	${names2.method}(key: '${e.key}'): ${e.provider};`);
     }
-    lines.push(`	${names.method}(key: ${reg.keyType}): ${reg.valueType};`);
-    lines.push(`	${names.method}(key: ${reg.keyType}): ${reg.valueType} {`);
+    lines.push(`	${names2.method}(key: ${reg.keyType}): ${reg.valueType};`);
+    lines.push(`	${names2.method}(key: ${reg.keyType}): ${reg.valueType} {`);
     lines.push(`		const entry = this.${fieldName}.get(key);`);
     lines.push(
       `		if (!entry) throw new ${errorClass}(\`Unknown ${reg.keyType}: \${String(key)}\`);`
@@ -6956,7 +7276,7 @@ function buildModuleTs(pattern) {
     typeImports.push({ specifier: reg.keyTypeImport, name: reg.keyType });
     typeImports.push({ specifier: reg.valueTypeImport, name: reg.valueType });
   }
-  const tokenValues = registries.map(({ names }) => names.tokenConst);
+  const tokenValues = registries.map(({ names: names2 }) => names2.tokenConst);
   const lines = [];
   lines.push(HEADER5.trimEnd());
   lines.push("");
@@ -6967,9 +7287,9 @@ function buildModuleTs(pattern) {
   lines.push(`import { ${tokenValues.sort().join(", ")} } from './tokens.js';`);
   lines.push("");
   lines.push(`export interface ${optsType} {`);
-  for (const { reg, names } of registries) {
+  for (const { reg, names: names2 } of registries) {
     lines.push(
-      `	${names.overrideField}?: Partial<Record<${reg.keyType}, ${reg.valueType}>>;`
+      `	${names2.overrideField}?: Partial<Record<${reg.keyType}, ${reg.valueType}>>;`
     );
   }
   lines.push("}");
@@ -7083,7 +7403,7 @@ import fs8 from "fs";
 import path11 from "path";
 
 // src/parser/load-events.ts
-import { basename as basename2, resolve as resolve3 } from "path";
+import { basename as basename2, resolve as resolve4 } from "path";
 function loadErrorToIssue2(error) {
   const issues = [];
   issues.push({
@@ -7113,7 +7433,7 @@ function stripYamlExt(file) {
 function loadEvents(eventsDir, entityNames) {
   const events = [];
   const issues = [];
-  const resolvedDir = resolve3(eventsDir);
+  const resolvedDir = resolve4(eventsDir);
   let files;
   try {
     files = findYamlFiles(resolvedDir);
@@ -7755,6 +8075,564 @@ function validateEntityEmits(entities, events) {
   return issues;
 }
 
+// src/cli/shared/provider-module-generator.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync2, readFileSync as readFileSync7, statSync as statSync5, writeFileSync as writeFileSync2 } from "fs";
+import { dirname, isAbsolute as isAbsolute2, join as join11, resolve as resolve5 } from "path";
+function providerPascalCase(slug) {
+  return slug.split("-").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function providerConstantCase(slug) {
+  return slug.replace(/-/g, "_").toUpperCase();
+}
+function providerModuleBanner(sourceYaml) {
+  return `// @generated by @pattern-stack/codegen from ${sourceYaml} \u2014 DO NOT EDIT.
+// Hand edits are overwritten on re-emit. Regenerate with \`bun run codegen\`. To change this provider, edit its \`definitions/providers/*.yaml\`.`;
+}
+function generateProviderModule(def, sourceYaml) {
+  const { slug } = def;
+  const Pascal = providerPascalCase(slug);
+  const CONST = providerConstantCase(slug);
+  const strategy = parseImportRef(def.auth.strategy);
+  const client = parseImportRef(def.client.class);
+  const strategyToken = `${CONST}_AUTH_STRATEGY`;
+  const clientToken = `${CONST}_CLIENT`;
+  const surfaces = def.surfaces.join(", ");
+  const title = def.display_name ? `${def.display_name} (\`${slug}\`)` : `\`${slug}\``;
+  return `${providerModuleBanner(sourceYaml)}
+/**
+ * Provider module for ${title}.
+ *
+ * Surfaces: ${surfaces}.
+ *
+ * Wires the declared auth strategy and API client under the provider-specific
+ * DI tokens \`${strategyToken}\` and \`${clientToken}\`. Per the auth subsystem
+ * contract, strategies are registered under provider-specific tokens rather
+ * than a single \`AUTH_STRATEGY\`. Registry aggregation (RFC-0001 \xA73) is
+ * emitted by a later codegen step.
+ */
+import { Module } from '@nestjs/common';
+import { ${strategy.exportName} } from '${strategy.path}';
+import { ${client.exportName} } from '${client.path}';
+
+/** DI token for the \`${slug}\` provider's auth strategy. */
+export const ${strategyToken} = Symbol('${strategyToken}');
+/** DI token for the \`${slug}\` provider's API client. */
+export const ${clientToken} = Symbol('${clientToken}');
+
+@Module({
+  providers: [
+    ${strategy.exportName},
+    ${client.exportName},
+    { provide: ${strategyToken}, useExisting: ${strategy.exportName} },
+    { provide: ${clientToken}, useExisting: ${client.exportName} },
+  ],
+  exports: [
+    ${strategy.exportName},
+    ${client.exportName},
+    ${strategyToken},
+    ${clientToken},
+  ],
+})
+export class ${Pascal}ProviderModule {}
+`;
+}
+function resolveTsconfigAliases(consumerRoot) {
+  const tsconfigPath = join11(consumerRoot, "tsconfig.json");
+  if (!existsSync9(tsconfigPath)) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(stripJsonComments(readFileSync7(tsconfigPath, "utf-8")));
+  } catch {
+    return null;
+  }
+  const compilerOptions = parsed.compilerOptions ?? {};
+  const baseUrl = compilerOptions.baseUrl ?? ".";
+  const sourceRoot = isAbsolute2(baseUrl) ? baseUrl : resolve5(consumerRoot, baseUrl);
+  const aliases = {};
+  for (const [pattern, targets] of Object.entries(compilerOptions.paths ?? {})) {
+    if (!Array.isArray(targets) || targets.length === 0) continue;
+    const aliasKey = pattern.replace(/\/\*$/, "");
+    const target = targets[0].replace(/\/\*$/, "");
+    aliases[aliasKey] = isAbsolute2(target) ? target : resolve5(sourceRoot, target);
+  }
+  return { sourceRoot, aliases };
+}
+function stripJsonComments(input) {
+  return input.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
+}
+function generateProviderModules(opts) {
+  const base = {
+    providersDir: opts.providersDir,
+    skipped: false,
+    written: [],
+    loadFailures: [],
+    issues: []
+  };
+  if (!existsSync9(opts.providersDir) || !statSync5(opts.providersDir).isDirectory()) {
+    return { ...base, skipped: true };
+  }
+  const files = findYamlFiles(opts.providersDir);
+  if (files.length === 0) return { ...base, skipped: true };
+  const { successes, failures } = loadProvidersFromYaml(files);
+  const loaded = successes.map((s) => ({
+    definition: s.definition,
+    filePath: s.filePath
+  }));
+  const issues = failures.map((f) => ({
+    severity: "error",
+    type: "provider_load_failed",
+    message: `${f.error}${f.details?.length ? ` \u2014 ${f.details.join("; ")}` : ""}`,
+    path: f.filePath
+  }));
+  issues.push(
+    ...validateProviders(loaded, {
+      entitySurfaces: opts.entitySurfaces,
+      sourceRoot: opts.sourceRoot,
+      aliases: opts.aliases,
+      skipImportCheck: opts.skipImportCheck
+    })
+  );
+  if (issues.some((i) => i.severity === "error")) {
+    return { ...base, loadFailures: failures, issues };
+  }
+  const written = [];
+  for (const { definition, filePath } of loaded) {
+    const sourceYaml = relativeSource(filePath);
+    const content = generateProviderModule(definition, sourceYaml);
+    const outPath = join11(
+      opts.outputRoot,
+      definition.slug,
+      `${definition.slug}.provider.module.ts`
+    );
+    if (!opts.dryRun) {
+      writeIfChanged(outPath, content);
+    }
+    written.push(outPath);
+  }
+  return { ...base, written, loadFailures: failures, issues };
+}
+function writeIfChanged(outPath, content) {
+  if (existsSync9(outPath) && readFileSync7(outPath, "utf-8") === content) return;
+  mkdirSync2(dirname(outPath), { recursive: true });
+  writeFileSync2(outPath, content);
+}
+function relativeSource(filePath) {
+  const marker = "definitions/providers/";
+  const idx = filePath.lastIndexOf(marker);
+  if (idx !== -1) return filePath.slice(idx);
+  const slash = filePath.lastIndexOf("/");
+  return slash === -1 ? filePath : `definitions/providers/${filePath.slice(slash + 1)}`;
+}
+
+// src/cli/shared/adapter-emission-generator.ts
+import {
+  existsSync as existsSync10,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync8,
+  statSync as statSync6,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { dirname as dirname2, join as join12 } from "path";
+var SURFACE_REGISTRY = {
+  crm: {
+    packageName: "@pattern-stack/codegen-crm",
+    portType: "CrmPort",
+    capabilitiesType: "CrmCapabilities",
+    noCapsConst: "NO_CRM_CAPABILITIES",
+    l2Ports: [
+      {
+        prop: "fields",
+        type: "IFieldDefinitionReader",
+        method: "list",
+        params: "(_integrationId, _entity)",
+        capFlag: "fieldDefinitions"
+      },
+      {
+        prop: "picklists",
+        type: "IPicklistReader",
+        method: "values",
+        params: "(_integrationId, _entity, _fieldId)",
+        capFlag: "picklists"
+      },
+      {
+        prop: "associations",
+        type: "IAssociationReader",
+        method: "list",
+        params: "(_integrationId, _fromEntity, _fromId, _toEntity)",
+        capFlag: "associations"
+      }
+    ]
+  },
+  // Interaction surfaces (#416) are incremental-read with no L2 sub-ports — the
+  // port composes L1 (auth + sources) + a capabilities descriptor whose only
+  // field is `entities`; reads go through the change-source registry. So
+  // `l2Ports: []` and the scaffold emits no L2 readers/stubs/capability flags.
+  calendar: {
+    packageName: "@pattern-stack/codegen-calendar",
+    portType: "CalendarPort",
+    capabilitiesType: "CalendarCapabilities",
+    noCapsConst: "NO_CALENDAR_CAPABILITIES",
+    l2Ports: []
+  },
+  mail: {
+    packageName: "@pattern-stack/codegen-mail",
+    portType: "MailPort",
+    capabilitiesType: "MailCapabilities",
+    noCapsConst: "NO_MAIL_CAPABILITIES",
+    l2Ports: []
+  },
+  transcript: {
+    packageName: "@pattern-stack/codegen-transcript",
+    portType: "TranscriptPort",
+    capabilitiesType: "TranscriptCapabilities",
+    noCapsConst: "NO_TRANSCRIPT_CAPABILITIES",
+    l2Ports: []
+  }
+};
+var SCAFFOLD_SENTINEL = "// <CODEGEN-SCAFFOLD-V1>";
+function generatedBanner(sourceDesc) {
+  return `// @generated by @pattern-stack/codegen from ${sourceDesc} \u2014 DO NOT EDIT.
+// Hand edits are overwritten on re-emit. Regenerate with \`bun run codegen\`.`;
+}
+function collectEntitiesBySurface(entities) {
+  const bySurface = /* @__PURE__ */ new Map();
+  for (const e of entities) {
+    if (!e.surface) continue;
+    const list = bySurface.get(e.surface) ?? [];
+    list.push(e.entity.name);
+    bySurface.set(e.surface, list);
+  }
+  for (const [surface, list] of bySurface) {
+    bySurface.set(surface, [...list].sort());
+  }
+  return bySurface;
+}
+function names(providerSlug, surface) {
+  const providerPascal = providerPascalCase(providerSlug);
+  const providerConst = providerConstantCase(providerSlug);
+  const surfacePascal = providerPascalCase(surface);
+  const surfaceConst = providerConstantCase(surface);
+  return {
+    providerPascal,
+    providerConst,
+    surfacePascal,
+    surfaceConst,
+    adapterClass: `${providerPascal}${surfacePascal}Adapter`,
+    adapterModuleClass: `${providerPascal}${surfacePascal}AdapterModule`,
+    providerModuleClass: `${providerPascal}ProviderModule`,
+    aggregatorClass: `${surfacePascal}AdaptersModule`,
+    strategyToken: `${providerConst}_AUTH_STRATEGY`,
+    clientToken: `${providerConst}_CLIENT`,
+    contributionsToken: `${surfaceConst}_ADAPTER_CONTRIBUTIONS`,
+    entitySourcesToken: `${surfaceConst}_ENTITY_SOURCES`
+  };
+}
+function generateAdapterScaffold(def, surface, entities) {
+  const spec = SURFACE_REGISTRY[surface];
+  if (!spec) throw new Error(`no surface package for '${surface}'`);
+  const n = names(def.slug, surface);
+  const client = parseImportRef(def.client.class);
+  const entitiesLiteral = entities.length ? `[${entities.map((e) => `'${e}'`).join(", ")}]` : "[]";
+  const surfaceTypeImports = [
+    spec.portType,
+    ...spec.l2Ports.map((p) => p.type),
+    spec.capabilitiesType
+  ].map((t) => `  ${t},`).join("\n");
+  const capabilityBody = [
+    `    ...${spec.noCapsConst},`,
+    ...spec.l2Ports.map((p) => `    ${p.capFlag}: true,`),
+    `    entities: ${entitiesLiteral},`
+  ].join("\n");
+  const l2Members = spec.l2Ports.map(
+    (p) => `  /** L2 \u2014 fill in the provider-specific implementation. */
+  readonly ${p.prop}: ${p.type} = {
+    ${p.method}: async ${p.params} => {
+      throw new Error('not implemented: ${n.adapterClass}.${p.prop}.${p.method}');
+    },
+  };`
+  ).join("\n\n");
+  const l2Section = l2Members ? `
+${l2Members}
+` : "";
+  return `${SCAFFOLD_SENTINEL}
+// Scaffolded once by @pattern-stack/codegen, then author-owned. Re-running
+// codegen detects the sentinel above and SKIPS this file \u2014 your edits are safe.
+// Source: definitions/providers/${def.slug}.yaml (surface: ${surface}).
+import { Inject, Injectable } from '@nestjs/common';
+import type {
+${surfaceTypeImports}
+} from '${spec.packageName}';
+import { ${spec.noCapsConst} } from '${spec.packageName}';
+import type {
+  IAuthStrategy,
+  IChangeSource,
+  IEntityChangeSourceRegistry,
+} from '@pattern-stack/codegen/subsystems';
+import type { ${client.exportName} } from '${client.path}';
+import { ${n.strategyToken}, ${n.clientToken} } from '../../../providers/${def.slug}/${def.slug}.provider.module';
+import { ${n.entitySourcesToken} } from '../../${surface}-adapters.tokens';
+
+@Injectable()
+export class ${n.adapterClass} implements ${spec.portType} {
+  /** Declared capabilities. \`entities\` derives from \`surface: ${surface}\` entity YAML. */
+  readonly capabilities: ${spec.capabilitiesType} = {
+${capabilityBody}
+  };
+
+  constructor(
+    @Inject(${n.strategyToken}) readonly auth: IAuthStrategy,
+    @Inject(${n.clientToken}) private readonly client: ${client.exportName},
+    @Inject(${n.entitySourcesToken}) readonly sources: IEntityChangeSourceRegistry,
+  ) {}
+${l2Section}
+  /**
+   * Per-entity change sources this adapter contributes to the ${surface}
+   * registry (ADR-033 \`buildChangeSource\`), keyed by entity name. The
+   * surface aggregator folds these into the \`IEntityChangeSourceRegistry\`
+   * bound under \`${n.entitySourcesToken}\`. Author-owned \u2014 populate one entry
+   * per entity in \`capabilities.entities\`.
+   */
+  readonly changeSources: Record<string, IChangeSource<unknown>> = {};
+
+  // surface-only methods (optional on ${spec.portType}): add here
+}
+`;
+}
+function generateAdapterModule(def, surface) {
+  const n = names(def.slug, surface);
+  return `${generatedBanner(`definitions/providers/${def.slug}.yaml (surface: ${surface})`)}
+import { Module } from '@nestjs/common';
+import { ${n.providerModuleClass} } from '../../../providers/${def.slug}/${def.slug}.provider.module';
+import { ${n.adapterClass} } from './${def.slug}-${surface}.adapter';
+
+@Module({
+  imports: [${n.providerModuleClass}],
+  providers: [${n.adapterClass}],
+  exports: [${n.adapterClass}],
+})
+export class ${n.adapterModuleClass} {}
+`;
+}
+function generateAdaptersBarrel(surface, providerSlugs) {
+  const lines = [...providerSlugs].sort().map((slug) => {
+    const n = names(slug, surface);
+    return `export { ${n.adapterModuleClass} } from './${slug}/${slug}-${surface}.adapter.module';`;
+  }).join("\n");
+  return `${generatedBanner(`definitions/providers/*.yaml (surface: ${surface})`)}
+${lines}
+`;
+}
+function generateSurfaceTokens(surface) {
+  const n = names("__placeholder__", surface);
+  return `${generatedBanner(`surface: ${surface}`)}
+import type { IChangeSource } from '@pattern-stack/codegen/subsystems';
+
+/** The assembled list of every ${surface} adapter's contribution. */
+export const ${n.contributionsToken} = Symbol.for('@app/integrations/${surface}.adapter-contributions');
+
+/** Resolved registry token \u2014 resolves to a C7 IEntityChangeSourceRegistry. */
+export const ${n.entitySourcesToken} = Symbol.for('@app/integrations/${surface}.entity-sources');
+
+/** One provider-adapter's contribution to the surface registry. */
+export interface AdapterContribution {
+  /** Provider slug. */
+  provider: string;
+  /** Entities this provider serves on this surface \u2192 their change sources. */
+  sources: Record<string, IChangeSource<unknown>>;
+}
+`;
+}
+function generateSurfaceAggregator(surface, providerSlugs) {
+  const n = names("__placeholder__", surface);
+  const slugs = [...providerSlugs].sort();
+  const per = slugs.map((slug) => names(slug, surface));
+  const moduleClasses = per.map((p) => p.adapterModuleClass);
+  const moduleImport = `import {
+  ${moduleClasses.join(",\n  ")},
+} from './adapters';`;
+  const adapterImports = slugs.map((slug) => {
+    const p = names(slug, surface);
+    return `import { ${p.adapterClass} } from './adapters/${slug}/${slug}-${surface}.adapter';`;
+  }).join("\n");
+  const contributionEntries = slugs.map((slug) => {
+    const p = names(slug, surface);
+    return `        { provider: '${slug}', sources: ${lowerFirst(p.adapterClass)}.changeSources },`;
+  }).join("\n");
+  const injectParams = slugs.map((slug) => {
+    const p = names(slug, surface);
+    return `${lowerFirst(p.adapterClass)}: ${p.adapterClass}`;
+  }).join(", ");
+  const injectTokens = per.map((p) => p.adapterClass).join(", ");
+  return `${generatedBanner(`surface: ${surface}`)}
+import { Module } from '@nestjs/common';
+import {
+  MemoryEntityChangeSourceRegistry,
+  type IChangeSource,
+  type IEntityChangeSourceRegistry,
+} from '@pattern-stack/codegen/subsystems';
+${moduleImport}
+${adapterImports}
+import {
+  ${n.contributionsToken},
+  ${n.entitySourcesToken},
+  type AdapterContribution,
+} from './${surface}-adapters.tokens';
+
+/**
+ * Fold every adapter contribution into one entity-keyed registry. Each entity
+ * resolves to exactly one change source; two providers serving the same entity
+ * is an ambiguous-source boot error.
+ */
+function provide${n.surfacePascal}EntitySources(
+  contribs: AdapterContribution[],
+): IEntityChangeSourceRegistry {
+  const merged = new Map<string, IChangeSource<unknown>>();
+  const owner = new Map<string, string>();
+  for (const contrib of contribs ?? []) {
+    for (const [entity, source] of Object.entries(contrib.sources)) {
+      const prior = owner.get(entity);
+      if (prior !== undefined) {
+        throw new Error(
+          \`entity '\${entity}' is served by both '\${prior}' and '\${contrib.provider}' \u2014 ambiguous change source\`,
+        );
+      }
+      owner.set(entity, contrib.provider);
+      merged.set(entity, source);
+    }
+  }
+  return new MemoryEntityChangeSourceRegistry(merged);
+}
+
+@Module({
+  imports: [${moduleClasses.join(", ")}],
+  providers: [
+    {
+      provide: ${n.contributionsToken},
+      useFactory: (${injectParams}): AdapterContribution[] => [
+${contributionEntries}
+      ],
+      inject: [${injectTokens}],
+    },
+    {
+      provide: ${n.entitySourcesToken},
+      useFactory: (contributions: AdapterContribution[]) =>
+        provide${n.surfacePascal}EntitySources(contributions),
+      inject: [${n.contributionsToken}],
+    },
+  ],
+  exports: [${n.entitySourcesToken}, ${n.contributionsToken}],
+})
+export class ${n.aggregatorClass} {}
+`;
+}
+function lowerFirst(s) {
+  return s.length ? s[0].toLowerCase() + s.slice(1) : s;
+}
+function generateTypedView(surface, providerSlugs, entities) {
+  const surfacePascal = providerPascalCase(surface);
+  const slugs = [...providerSlugs].sort();
+  const ents = [...entities].sort();
+  const providerUnion = slugs.length ? slugs.map((s) => `'${s}'`).join(" | ") : "never";
+  const entityUnion = ents.length ? ents.map((e) => `'${e}'`).join(" | ") : "never";
+  const mapEntries = slugs.map((s) => `  ${jsKey(s)}: ${surfacePascal}Entity;`).join("\n");
+  return `${generatedBanner(`surface: ${surface}`)}
+/**
+ * Per-consumer typed view for the \`${surface}\` surface. Surface-scoped unions
+ * + a (provider, entity) validity map for compile-time-checked consumer
+ * use-cases. Replaces ADR-033.2's per-entity provider tuples (RFC-0001 \xA75/\xA78).
+ */
+
+/** Providers whose \`surfaces[]\` include \`${surface}\`. */
+export type ${surfacePascal}Provider = ${providerUnion};
+
+/** Entities declared with \`surface: ${surface}\`. */
+export type ${surfacePascal}Entity = ${entityUnion};
+
+/** Valid entities per provider on this surface. */
+export interface ${surfacePascal}ProviderEntities {
+${mapEntries || "  // no providers serve this surface yet"}
+}
+`;
+}
+function jsKey(key) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : `'${key}'`;
+}
+function emitAdapters(opts) {
+  const result = {
+    written: [],
+    scaffoldsWritten: [],
+    scaffoldsSkipped: [],
+    skippedSurfaces: []
+  };
+  const entitiesBySurface = collectEntitiesBySurface(opts.entities);
+  const bySurface = /* @__PURE__ */ new Map();
+  for (const { definition } of opts.providers) {
+    for (const surface of definition.surfaces) {
+      if (!SURFACE_REGISTRY[surface]) {
+        result.skippedSurfaces.push({
+          provider: definition.slug,
+          surface,
+          reason: `no surface package for '${surface}' yet \u2014 add codegen-${surface} (Track C) to emit its adapters`
+        });
+        continue;
+      }
+      const list = bySurface.get(surface) ?? [];
+      list.push(definition.slug);
+      bySurface.set(surface, list);
+    }
+  }
+  const defBySlug = new Map(opts.providers.map((p) => [p.definition.slug, p.definition]));
+  for (const [surface, slugs] of bySurface) {
+    const surfaceDir = join12(opts.outputRoot, surface);
+    const adaptersDir = join12(surfaceDir, "adapters");
+    for (const slug of slugs) {
+      const def = defBySlug.get(slug);
+      const providerDir = join12(adaptersDir, slug);
+      const scaffoldPath = join12(providerDir, `${slug}-${surface}.adapter.ts`);
+      const modulePath = join12(providerDir, `${slug}-${surface}.adapter.module.ts`);
+      if (existsSync10(scaffoldPath)) {
+        result.scaffoldsSkipped.push(scaffoldPath);
+      } else {
+        const content = generateAdapterScaffold(
+          def,
+          surface,
+          entitiesBySurface.get(surface) ?? []
+        );
+        if (!opts.dryRun) writeFile(scaffoldPath, content);
+        result.scaffoldsWritten.push(scaffoldPath);
+      }
+      const moduleContent = generateAdapterModule(def, surface);
+      if (!opts.dryRun) writeIfChanged2(modulePath, moduleContent);
+      result.written.push(modulePath);
+    }
+    const barrelPath = join12(adaptersDir, "index.ts");
+    const tokensPath = join12(surfaceDir, `${surface}-adapters.tokens.ts`);
+    const aggregatorPath = join12(surfaceDir, `${surface}-adapters.module.ts`);
+    const typedViewPath = join12(surfaceDir, "types.generated.ts");
+    const files = [
+      [barrelPath, generateAdaptersBarrel(surface, slugs)],
+      [tokensPath, generateSurfaceTokens(surface)],
+      [aggregatorPath, generateSurfaceAggregator(surface, slugs)],
+      [typedViewPath, generateTypedView(surface, slugs, entitiesBySurface.get(surface) ?? [])]
+    ];
+    for (const [path34, content] of files) {
+      if (!opts.dryRun) writeIfChanged2(path34, content);
+      result.written.push(path34);
+    }
+  }
+  return result;
+}
+function writeFile(outPath, content) {
+  mkdirSync3(dirname2(outPath), { recursive: true });
+  writeFileSync3(outPath, content);
+}
+function writeIfChanged2(outPath, content) {
+  if (existsSync10(outPath) && statSync6(outPath).isFile() && readFileSync8(outPath, "utf-8") === content) {
+    return;
+  }
+  writeFile(outPath, content);
+}
+
 // src/cli/shared/events-path.ts
 import path12 from "path";
 var FALLBACK = "events";
@@ -8264,6 +9142,92 @@ var EntityNewCommand = class extends Command2 {
         }
       }
     }
+    let providerResult = null;
+    try {
+      const providersDir = ctx.config?.paths?.providers != null ? path13.resolve(
+        ctx.cwd,
+        ctx.config.paths.providers
+      ) : path13.resolve(ctx.cwd, "definitions/providers");
+      const providerOutputRoot = path13.resolve(
+        ctx.cwd,
+        backendSrcForHandlers,
+        "integrations/providers"
+      );
+      const entitySurfaces = fs9.existsSync(entitiesDir) ? collectEntitySurfaces(
+        loadEntitiesFromYaml(findYamlFiles(entitiesDir)).successes.map(
+          (s) => s.definition
+        )
+      ) : /* @__PURE__ */ new Set();
+      const tsAliases = resolveTsconfigAliases(ctx.cwd);
+      providerResult = generateProviderModules({
+        providersDir,
+        outputRoot: providerOutputRoot,
+        entitySurfaces,
+        sourceRoot: tsAliases?.sourceRoot,
+        aliases: tsAliases?.aliases,
+        skipImportCheck: tsAliases === null
+      });
+      if (!providerResult.skipped && !isJsonMode()) {
+        for (const issue of providerResult.issues) {
+          printError(`provider codegen: ${issue.message}`);
+        }
+        if (providerResult.issues.length === 0) {
+          printInfo(
+            `provider modules regenerated (${providerResult.written.length}) \u2192 ${providerOutputRoot}`
+          );
+        }
+      }
+      if (providerResult.issues.some((i) => i.severity === "error") && !this.continueOnError) {
+        return 1;
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (!isJsonMode()) {
+        printWarning(`provider codegen failed \u2014 ${msg}`);
+      }
+    }
+    try {
+      if (providerResult && !providerResult.skipped && providerResult.issues.length === 0) {
+        const providersDir = providerResult.providersDir;
+        const adapterOutputRoot = path13.resolve(
+          ctx.cwd,
+          backendSrcForHandlers,
+          "integrations"
+        );
+        const entityDefs = fs9.existsSync(entitiesDir) ? loadEntitiesFromYaml(findYamlFiles(entitiesDir)).successes.map(
+          (s) => s.definition
+        ) : [];
+        const loadedProviders = loadProvidersFromYaml(
+          findYamlFiles(providersDir)
+        ).successes.map((s) => ({
+          definition: s.definition,
+          filePath: s.filePath
+        }));
+        const adapterResult = emitAdapters({
+          providers: loadedProviders,
+          entities: entityDefs,
+          outputRoot: adapterOutputRoot
+        });
+        if (!isJsonMode()) {
+          if (adapterResult.written.length || adapterResult.scaffoldsWritten.length) {
+            printInfo(
+              `adapter codegen: ${adapterResult.scaffoldsWritten.length} scaffold(s) + ${adapterResult.written.length} @generated \u2192 ${adapterOutputRoot}`
+            );
+          }
+          for (const s of adapterResult.scaffoldsSkipped) {
+            printInfo(`skipped scaffold ${s} (author-owned)`);
+          }
+          for (const s of adapterResult.skippedSurfaces) {
+            printWarning(`adapter codegen: ${s.reason} (provider ${s.provider})`);
+          }
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (!isJsonMode()) {
+        printWarning(`adapter codegen failed \u2014 ${msg}`);
+      }
+    }
     if (isJsonMode()) {
       printJson({
         command: "entity new",
@@ -8627,22 +9591,22 @@ function localsToHygenArgs2(locals) {
   ];
 }
 
-// src/cli/shared/sync-scaffold-locals.ts
+// src/cli/shared/integration-scaffold-locals.ts
 import path16 from "path";
-function resolveSyncScaffoldLocals(input) {
+function resolveIntegrationScaffoldLocals(input) {
   const { cwd, config } = input;
   void input.fileExists;
-  const syncBlock = config?.sync ?? {};
+  const integrationBlock = config?.integration ?? {};
   const subsystemsRoot = resolveSubsystemsRootFromConfig(cwd, config);
   const configPath = path16.resolve(cwd, "codegen.config.yaml");
   const schemaPath = path16.resolve(
     subsystemsRoot,
-    "sync",
-    "sync-audit.schema.ts"
+    "integration",
+    "integration-audit.schema.ts"
   );
   return {
     appName: path16.basename(cwd),
-    multiTenant: normaliseMultiTenant3(syncBlock.multi_tenant),
+    multiTenant: normaliseMultiTenant3(integrationBlock.multi_tenant),
     configPath,
     schemaPath
   };
@@ -8781,19 +9745,16 @@ function localsToHygenArgs6(locals) {
 // src/cli/shared/auth-integrations-scaffold-locals.ts
 import path20 from "path";
 var FALLBACK_BACKEND_SRC4 = "src";
-var SHARED_DIR_NAME = "shared";
 var DEFAULT_MODULES_DIR = "modules";
 var DEFAULT_DEFINITIONS_DIR = "definitions/entities";
 function resolveAuthIntegrationsScaffoldLocals(input) {
   const { cwd, config } = input;
   const backendSrc = typeof config?.paths?.backend_src === "string" && config.paths.backend_src.length > 0 ? config.paths.backend_src : FALLBACK_BACKEND_SRC4;
   const pathsAny = config?.paths;
-  const sharedConfigured = pathsAny?.shared;
-  const sharedRoot = typeof sharedConfigured === "string" && sharedConfigured.length > 0 ? path20.resolve(cwd, sharedConfigured) : path20.resolve(cwd, backendSrc, SHARED_DIR_NAME);
   const modulesConfigured = pathsAny?.modules_dir;
   const vendorRoot = typeof modulesConfigured === "string" && modulesConfigured.length > 0 ? path20.resolve(cwd, modulesConfigured) : path20.resolve(cwd, backendSrc, DEFAULT_MODULES_DIR);
   const entitiesConfigured = typeof pathsAny?.entities === "string" && pathsAny.entities.length > 0 ? pathsAny.entities : typeof pathsAny?.entities_dir === "string" && pathsAny.entities_dir.length > 0 ? pathsAny.entities_dir : null;
-  const definitionsPath = entitiesConfigured !== null ? path20.resolve(cwd, entitiesConfigured, "integration.yaml") : path20.resolve(cwd, DEFAULT_DEFINITIONS_DIR, "integration.yaml");
+  const definitionsPath = entitiesConfigured !== null ? path20.resolve(cwd, entitiesConfigured, "connection.yaml") : path20.resolve(cwd, DEFAULT_DEFINITIONS_DIR, "connection.yaml");
   const appModulePath = path20.resolve(cwd, backendSrc, "app.module.ts");
   let authModuleRegistered = false;
   const appModuleSource = input.readFile(appModulePath);
@@ -8803,7 +9764,6 @@ function resolveAuthIntegrationsScaffoldLocals(input) {
   return {
     appName: path20.basename(cwd),
     appModulePath,
-    sharedRoot,
     vendorRoot,
     definitionsPath,
     authModuleRegistered
@@ -9002,7 +9962,7 @@ function backendFileFilter(backend, subsystemName) {
     if (subsystemName === "events" && file === "domain-events.schema.ts") {
       return false;
     }
-    if (subsystemName === "sync" && file === "sync-audit.schema.ts") {
+    if (subsystemName === "integration" && file === "integration-audit.schema.ts") {
       return false;
     }
     if (subsystemName === "auth" && file === "auth-oauth-state.schema.ts") {
@@ -9126,7 +10086,7 @@ var SubsystemInstallCommand = class extends Command3 {
       json: isJsonMode(),
       forceConfig: this.forceConfig
     }) : null;
-    const syncScaffold = desc3.name === "sync" ? runSyncScaffold(ctx.cwd, ctx.config, {
+    const integrationScaffold = desc3.name === "integration" ? runIntegrationScaffold(ctx.cwd, ctx.config, {
       dryRun: this.dryRun,
       json: isJsonMode(),
       forceConfig: this.forceConfig
@@ -9158,9 +10118,9 @@ var SubsystemInstallCommand = class extends Command3 {
       );
       return 1;
     }
-    if (syncScaffold?.configBlockOutcome === "parse-error") {
+    if (integrationScaffold?.configBlockOutcome === "parse-error") {
       printError(
-        "codegen.config.yaml is not valid YAML: refusing to inject sync config block. Fix the YAML and re-run."
+        "codegen.config.yaml is not valid YAML: refusing to inject integration config block. Fix the YAML and re-run."
       );
       return 1;
     }
@@ -9198,7 +10158,7 @@ var SubsystemInstallCommand = class extends Command3 {
         },
         ...jobsScaffold ? { scaffold: jobsScaffold } : {},
         ...eventsScaffold ? { scaffold: eventsScaffold } : {},
-        ...syncScaffold ? { scaffold: syncScaffold } : {},
+        ...integrationScaffold ? { scaffold: integrationScaffold } : {},
         ...bridgeScaffold ? { scaffold: bridgeScaffold } : {},
         ...observabilityScaffold ? { scaffold: observabilityScaffold } : {},
         ...authScaffold ? { scaffold: authScaffold } : {}
@@ -9226,11 +10186,11 @@ var SubsystemInstallCommand = class extends Command3 {
           console.log(`  ${theme.muted(icons.arrow)} ${path22.relative(ctx.cwd, p) || p}`);
         }
       }
-      if (syncScaffold?.planned?.length) {
+      if (integrationScaffold?.planned?.length) {
         printInfo(
-          `Sync scaffold \u2014 ${syncScaffold.planned.length} template targets`
+          `Integration scaffold \u2014 ${integrationScaffold.planned.length} template targets`
         );
-        for (const p of syncScaffold.planned) {
+        for (const p of integrationScaffold.planned) {
           console.log(`  ${theme.muted(icons.arrow)} ${path22.relative(ctx.cwd, p) || p}`);
         }
       }
@@ -9289,14 +10249,14 @@ var SubsystemInstallCommand = class extends Command3 {
         );
       }
     }
-    if (syncScaffold) {
-      if (syncScaffold.ok) {
+    if (integrationScaffold) {
+      if (integrationScaffold.ok) {
         printSuccess(
-          `sync scaffold applied (config block, schema)`
+          `integration scaffold applied (config block, schema)`
         );
       } else {
         printWarning(
-          `sync scaffold (Hygen) failed \u2014 runtime files were written; re-run after fixing: ${syncScaffold.error ?? "unknown error"}`
+          `integration scaffold (Hygen) failed \u2014 runtime files were written; re-run after fixing: ${integrationScaffold.error ?? "unknown error"}`
         );
       }
     }
@@ -9343,7 +10303,7 @@ var SubsystemInstallCommand = class extends Command3 {
     }
     if (desc3.name === "observability") {
       printInfo(
-        "Register `ObservabilityModule.forRoot()` AFTER Events/Jobs/Bridge/Sync in app.module.ts"
+        "Register `ObservabilityModule.forRoot()` AFTER Events/Jobs/Bridge/Integration in app.module.ts"
       );
     } else if (desc3.name === "auth") {
       printInfo("auth subsystem installed.");
@@ -9357,9 +10317,9 @@ var SubsystemInstallCommand = class extends Command3 {
         `Register ${capitalize(desc3.name)}Module.forRoot({ backend: '${backend}' }) in your app.module.ts`
       );
     }
-    if (desc3.name === "sync") {
+    if (desc3.name === "integration") {
       printInfo(
-        `Per-entity: register ExecuteSyncUseCase + your IChangeSource/ISyncSink bindings in a feature module (see SyncModule docstring).`
+        `Per-entity: register ExecuteIntegrationUseCase + your IChangeSource/IIntegrationSink bindings in a feature module (see IntegrationModule docstring).`
       );
     }
     return 0;
@@ -9372,7 +10332,7 @@ var SubsystemInstallCommand = class extends Command3 {
    * `codegen project init`. This method just invokes the
    * `subsystem/openapi-config` Hygen action to inject the `openapi:`
    * block into `codegen.config.yaml`, honoring the same `--force-config`
-   * semantics as jobs/events/sync/bridge.
+   * semantics as jobs/events/integration/bridge.
    */
   async executeOpenApiConfig(ctx) {
     const configPath = path22.join(ctx.cwd, "codegen.config.yaml");
@@ -9435,9 +10395,9 @@ var SubsystemInstallCommand = class extends Command3 {
    *
    * Source is `examples/auth-integrations/`, NOT `runtime/subsystems/`,
    * so this method short-circuits the `copyRuntime` flow. It vendors the
-   * adapters tree + the canonical `integration.yaml`, then invokes the
+   * adapters tree + the canonical `connection.yaml`, then invokes the
    * `subsystem auth-integrations` Hygen action to append the
-   * `IntegrationsAuthModule` TODO to `app.module.ts`.
+   * `ConnectionsAuthModule` TODO to `app.module.ts`.
    *
    * Idempotent: pre-existing files are skipped unless `--force` is set.
    */
@@ -9485,7 +10445,7 @@ var SubsystemInstallCommand = class extends Command3 {
     }
     if (this.dryRun) {
       printInfo(
-        `Dry run \u2014 auth-integrations would vendor adapters + integration.yaml + append TODO`
+        `Dry run \u2014 auth-integrations would vendor adapters + connection.yaml + append TODO`
       );
       for (const p of scaffold.planned) {
         console.log(
@@ -9501,14 +10461,14 @@ var SubsystemInstallCommand = class extends Command3 {
     );
     if (scaffold.authModuleRegistered === false) {
       printWarning(
-        "AuthModule.forRoot(...) not detected in app.module.ts. Run `cdp subsystem install auth` first \u2014 IntegrationsAuthModule requires ENCRYPTION_KEY from it."
+        "AuthModule.forRoot(...) not detected in app.module.ts. Run `cdp subsystem install auth` first \u2014 ConnectionsAuthModule requires ENCRYPTION_KEY from it."
       );
     }
     printInfo("auth-integrations starter vendored.");
     printInfo("Next steps:");
-    printInfo("  1. Run `cdp entity new integration` to scaffold the codegen layer (apps/api/src/modules/integrations/integration.service) the adapters import.");
+    printInfo("  1. Run `cdp entity new connection` to scaffold the codegen layer (apps/api/src/modules/connections/connection.service) the adapters import.");
     printInfo("  2. Ensure AuthModule.forRoot(...) is registered in AppModule (run `cdp subsystem install auth` if not).");
-    printInfo("  3. Wire IntegrationsAuthModule into AppModule (see TODO appended to app.module.ts).");
+    printInfo("  3. Wire ConnectionsAuthModule into AppModule (see TODO appended to app.module.ts).");
     return 0;
   }
 };
@@ -9689,8 +10649,8 @@ function runEventsScaffold(cwd, config, opts) {
   }
   return { ok: true, planned, configBlockOutcome };
 }
-function runSyncScaffold(cwd, config, opts) {
-  const locals = resolveSyncScaffoldLocals({
+function runIntegrationScaffold(cwd, config, opts) {
+  const locals = resolveIntegrationScaffoldLocals({
     cwd,
     config,
     fileExists: (p) => fs11.existsSync(p)
@@ -9701,7 +10661,7 @@ function runSyncScaffold(cwd, config, opts) {
   ];
   const configBlockOutcome = planConfigBlockAction(
     locals.configPath,
-    "sync",
+    "integration",
     opts.forceConfig
   );
   if (configBlockOutcome === "parse-error") {
@@ -9712,7 +10672,7 @@ function runSyncScaffold(cwd, config, opts) {
   }
   const result = invokeHygen({
     generator: "subsystem",
-    action: "sync",
+    action: "integration",
     cwd,
     args: localsToHygenArgs3(locals),
     // Suppress Hygen stdout in JSON mode so it doesn't corrupt the JSON output.
@@ -9728,9 +10688,9 @@ function runSyncScaffold(cwd, config, opts) {
   }
   const configResult = runConfigBlockAction({
     cwd,
-    actionFolder: "sync-config",
+    actionFolder: "integration-config",
     configPath: locals.configPath,
-    subsystem: "sync",
+    subsystem: "integration",
     outcome: configBlockOutcome,
     json: opts.json
   });
@@ -9981,18 +10941,18 @@ function runAuthIntegrationsScaffold(cwd, config, opts) {
       error: `auth-integrations starter source missing: ${examplesRoot}`
     };
   }
-  const adaptersSrc = path22.join(examplesRoot, "runtime", "integrations");
-  const adaptersDest = path22.join(locals.vendorRoot, "integrations");
-  const integrationYamlSrc = path22.join(
+  const adaptersSrc = path22.join(examplesRoot, "runtime", "connections");
+  const adaptersDest = path22.join(locals.vendorRoot, "connections");
+  const connectionYamlSrc = path22.join(
     examplesRoot,
     "definitions",
     "entities",
-    "integration.yaml"
+    "connection.yaml"
   );
-  const integrationYamlDest = locals.definitionsPath;
+  const connectionYamlDest = locals.definitionsPath;
   const planned = [
     adaptersDest,
-    integrationYamlDest,
+    connectionYamlDest,
     locals.appModulePath
   ];
   if (opts.dryRun) {
@@ -10012,18 +10972,18 @@ function runAuthIntegrationsScaffold(cwd, config, opts) {
   let yamlWritten = false;
   let yamlSkipped = false;
   try {
-    if (fs11.existsSync(integrationYamlDest) && !opts.force) {
+    if (fs11.existsSync(connectionYamlDest) && !opts.force) {
       yamlSkipped = true;
-    } else if (fs11.existsSync(integrationYamlSrc)) {
-      fs11.mkdirSync(path22.dirname(integrationYamlDest), { recursive: true });
-      fs11.copyFileSync(integrationYamlSrc, integrationYamlDest);
+    } else if (fs11.existsSync(connectionYamlSrc)) {
+      fs11.mkdirSync(path22.dirname(connectionYamlDest), { recursive: true });
+      fs11.copyFileSync(connectionYamlSrc, connectionYamlDest);
       yamlWritten = true;
     }
   } catch (err) {
     return {
       ok: false,
       planned,
-      error: `failed to vendor integration.yaml: ${err instanceof Error ? err.message : String(err)}`,
+      error: `failed to vendor connection.yaml: ${err instanceof Error ? err.message : String(err)}`,
       authModuleRegistered: locals.authModuleRegistered
     };
   }
@@ -10039,16 +10999,16 @@ function runAuthIntegrationsScaffold(cwd, config, opts) {
       ok: false,
       planned,
       error: result.stderr?.trim() || "hygen exited non-zero",
-      written: adapterCopy.written.concat(yamlWritten ? [integrationYamlDest] : []),
-      skipped: adapterCopy.skipped.concat(yamlSkipped ? [integrationYamlDest] : []),
+      written: adapterCopy.written.concat(yamlWritten ? [connectionYamlDest] : []),
+      skipped: adapterCopy.skipped.concat(yamlSkipped ? [connectionYamlDest] : []),
       authModuleRegistered: locals.authModuleRegistered
     };
   }
   return {
     ok: true,
     planned,
-    written: adapterCopy.written.concat(yamlWritten ? [integrationYamlDest] : []),
-    skipped: adapterCopy.skipped.concat(yamlSkipped ? [integrationYamlDest] : []),
+    written: adapterCopy.written.concat(yamlWritten ? [connectionYamlDest] : []),
+    skipped: adapterCopy.skipped.concat(yamlSkipped ? [connectionYamlDest] : []),
     authModuleRegistered: locals.authModuleRegistered
   };
 }
@@ -10151,7 +11111,7 @@ var SubsystemRemoveCommand = class extends Command3 {
         "auth-integrations is vendored under <modules>/integrations/ alongside the codegen-emitted entity layer \u2014 not auto-removable here."
       );
       printInfo(
-        "To uninstall: remove the integrations/ directory and the IntegrationsAuthModule registration from app.module.ts by hand."
+        "To uninstall: remove the integrations/ directory and the ConnectionsAuthModule registration from app.module.ts by hand."
       );
       return 1;
     }
@@ -10270,11 +11230,11 @@ var VENDORED_RUNTIME_FILES = [
   // Ambient tenant scope — imported by base-repository.ts (scopePredicate)
   { runtime: "base-classes/tenant-context.ts", target: "src/shared/base-classes/tenant-context.ts" },
   { runtime: "base-classes/base-service.ts", target: "src/shared/base-classes/base-service.ts" },
-  { runtime: "base-classes/synced-entity-repository.ts", target: "src/shared/base-classes/synced-entity-repository.ts" },
-  { runtime: "base-classes/synced-entity-service.ts", target: "src/shared/base-classes/synced-entity-service.ts" },
-  // Inbound-sync write surface (#374) — deps of synced/junction repos
-  { runtime: "base-classes/sync-upsert-config.ts", target: "src/shared/base-classes/sync-upsert-config.ts" },
-  { runtime: "base-classes/junction-sync-repository.ts", target: "src/shared/base-classes/junction-sync-repository.ts" },
+  { runtime: "base-classes/integrated-entity-repository.ts", target: "src/shared/base-classes/integrated-entity-repository.ts" },
+  { runtime: "base-classes/integrated-entity-service.ts", target: "src/shared/base-classes/integrated-entity-service.ts" },
+  // Inbound-integration write surface (#374) — deps of integrated/junction repos
+  { runtime: "base-classes/integration-upsert-config.ts", target: "src/shared/base-classes/integration-upsert-config.ts" },
+  { runtime: "base-classes/junction-integration-repository.ts", target: "src/shared/base-classes/junction-integration-repository.ts" },
   { runtime: "base-classes/activity-entity-repository.ts", target: "src/shared/base-classes/activity-entity-repository.ts" },
   { runtime: "base-classes/activity-entity-service.ts", target: "src/shared/base-classes/activity-entity-service.ts" },
   { runtime: "base-classes/metadata-entity-repository.ts", target: "src/shared/base-classes/metadata-entity-repository.ts" },
@@ -10539,7 +11499,7 @@ function exampleEntityYaml() {
 #
 # entity:
 #   name: account
-#   pattern: Synced       # Base | Synced | Activity | Metadata | Knowledge (or app-defined)
+#   pattern: Integrated   # Base | Integrated | Activity | Metadata | Knowledge (or app-defined)
 #
 # fields:
 #   name:
@@ -10587,7 +11547,7 @@ var REQUIRED_ALIASES = {
   "@modules/*": ["./src/modules/*"],
   "@generated/*": ["./src/generated/*"]
 };
-function stripJsonComments(raw) {
+function stripJsonComments2(raw) {
   let out = "";
   let i = 0;
   let inString = false;
@@ -10635,7 +11595,7 @@ var REQUIRED_COMPILER_OPTIONS = {
 function mergeTsconfig(raw) {
   let parsed;
   try {
-    parsed = JSON.parse(stripJsonComments(raw));
+    parsed = JSON.parse(stripJsonComments2(raw));
   } catch (err) {
     return {
       content: raw,
@@ -11105,8 +12065,8 @@ function ensureMainSwaggerBlock(sourceFile, opts) {
       /^import\s+\{\s*([^}]+)\s*\}\s+from\s+['"]([^'"]+)['"]\s*;?\s*$/
     );
     if (match) {
-      const names = match[1].split(",").map((s) => s.trim()).filter(Boolean);
-      ensureImport(sourceFile, match[2], names);
+      const names2 = match[1].split(",").map((s) => s.trim()).filter(Boolean);
+      ensureImport(sourceFile, match[2], names2);
     } else {
       sourceFile.insertStatements(0, importLine);
     }
@@ -12112,10 +13072,10 @@ var ProjectInitCommand = class extends Command7 {
 };
 function askConfirm(question) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve4) => {
+  return new Promise((resolve6) => {
     rl.question(`${question} [Y/n] `, (answer) => {
       rl.close();
-      resolve4(answer.trim().toLowerCase() !== "n");
+      resolve6(answer.trim().toLowerCase() !== "n");
     });
   });
 }
@@ -13722,7 +14682,7 @@ var junction_default = junctionNoun;
 // src/cli/commands/events.ts
 import fs20 from "fs";
 import path32 from "path";
-import ts2 from "typescript";
+import ts3 from "typescript";
 import { Command as Command11, Option as Option11 } from "clipanion";
 function scanSourceFileForConsumers(sourceFile, filePath, eventType) {
   const tier2 = [];
@@ -13736,13 +14696,13 @@ function scanSourceFileForConsumers(sourceFile, filePath, eventType) {
   }
   function checkImport(node) {
     const moduleSpec = node.moduleSpecifier;
-    if (ts2.isStringLiteral(moduleSpec) && moduleSpec.text.includes("subsystems/bridge")) {
+    if (ts3.isStringLiteral(moduleSpec) && moduleSpec.text.includes("subsystems/bridge")) {
       hasEventFlowImport = true;
     }
     const clause = node.importClause;
     if (!clause) return;
     const named = clause.namedBindings;
-    if (named && ts2.isNamedImports(named)) {
+    if (named && ts3.isNamedImports(named)) {
       for (const el of named.elements) {
         const name = el.name.text;
         if (name === "EventFlowService" || name === "EVENT_FLOW") {
@@ -13752,11 +14712,11 @@ function scanSourceFileForConsumers(sourceFile, filePath, eventType) {
     }
   }
   function checkCall(node) {
-    if (!ts2.isPropertyAccessExpression(node.expression)) return;
+    if (!ts3.isPropertyAccessExpression(node.expression)) return;
     const methodName = node.expression.name.text;
     if (methodName !== "publishAndStart" && methodName !== "subscribe") return;
     const firstArg = node.arguments[0];
-    if (!firstArg || !ts2.isStringLiteralLike(firstArg)) return;
+    if (!firstArg || !ts3.isStringLiteralLike(firstArg)) return;
     if (firstArg.text !== eventType) return;
     const receiverText = node.expression.expression.getText(sourceFile);
     if (methodName === "publishAndStart") {
@@ -13777,24 +14737,24 @@ function scanSourceFileForConsumers(sourceFile, filePath, eventType) {
   function findEnclosingClassName(node) {
     let cur = node.parent;
     while (cur) {
-      if (ts2.isClassDeclaration(cur) && cur.name) return cur.name.text;
-      if (ts2.isClassExpression(cur) && cur.name) return cur.name.text;
+      if (ts3.isClassDeclaration(cur) && cur.name) return cur.name.text;
+      if (ts3.isClassExpression(cur) && cur.name) return cur.name.text;
       cur = cur.parent;
     }
     return null;
   }
   function checkDecoratorOn(member) {
-    const decorators = ts2.canHaveDecorators(member) ? ts2.getDecorators(member) ?? [] : [];
+    const decorators = ts3.canHaveDecorators(member) ? ts3.getDecorators(member) ?? [] : [];
     for (const decorator of decorators) {
       const call = decorator.expression;
-      if (!ts2.isCallExpression(call)) continue;
-      if (!ts2.isIdentifier(call.expression)) continue;
+      if (!ts3.isCallExpression(call)) continue;
+      if (!ts3.isIdentifier(call.expression)) continue;
       if (call.expression.text !== "OnEvent") continue;
       const firstArg = call.arguments[0];
-      if (!firstArg || !ts2.isStringLiteralLike(firstArg)) continue;
+      if (!firstArg || !ts3.isStringLiteralLike(firstArg)) continue;
       if (firstArg.text !== eventType) continue;
       const className = findEnclosingClassName(member) ?? "<anonymous>";
-      const memberName = ts2.isIdentifier(member.name) ? member.name.text : member.name.getText(sourceFile);
+      const memberName = ts3.isIdentifier(member.name) ? member.name.text : member.name.getText(sourceFile);
       tier1.push({
         kind: "on-event",
         siteLabel: `${className}.${memberName} @OnEvent('${eventType}')`,
@@ -13804,12 +14764,12 @@ function scanSourceFileForConsumers(sourceFile, filePath, eventType) {
     }
   }
   function visit(node) {
-    if (ts2.isImportDeclaration(node)) checkImport(node);
-    if (ts2.isCallExpression(node)) checkCall(node);
-    if (ts2.isMethodDeclaration(node) || ts2.isPropertyDeclaration(node)) {
+    if (ts3.isImportDeclaration(node)) checkImport(node);
+    if (ts3.isCallExpression(node)) checkCall(node);
+    if (ts3.isMethodDeclaration(node) || ts3.isPropertyDeclaration(node)) {
       checkDecoratorOn(node);
     }
-    ts2.forEachChild(node, visit);
+    ts3.forEachChild(node, visit);
   }
   visit(sourceFile);
   return { tier2, tier1, hasEventFlowImport };
@@ -13821,12 +14781,12 @@ function scanDirectoryForConsumers(rootDir, eventType) {
   let hasEventFlowImport = false;
   for (const filePath of files) {
     const text2 = fs20.readFileSync(filePath, "utf8");
-    const sourceFile = ts2.createSourceFile(
+    const sourceFile = ts3.createSourceFile(
       filePath,
       text2,
-      ts2.ScriptTarget.Latest,
+      ts3.ScriptTarget.Latest,
       true,
-      ts2.ScriptKind.TS
+      ts3.ScriptKind.TS
     );
     const result = scanSourceFileForConsumers(sourceFile, filePath, eventType);
     tier2.push(...result.tier2);
@@ -14240,12 +15200,12 @@ async function summary9(ctx) {
     await reloadRegistry(ctx);
   } catch {
   }
-  const names = getOrchestrationPatternNames();
+  const names2 = getOrchestrationPatternNames();
   return {
     title: "orchestration",
     body: [
-      `patterns: ${names.length}`,
-      ...names.length > 0 ? [`  ${names.join(", ")}`] : []
+      `patterns: ${names2.length}`,
+      ...names2.length > 0 ? [`  ${names2.join(", ")}`] : []
     ]
   };
 }
@@ -14294,8 +15254,8 @@ var update_default = UpdateShortcut;
 // src/cli/index.ts
 function readVersion() {
   try {
-    const pkgPath = join10(import.meta.dirname, "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
+    const pkgPath = join13(import.meta.dirname, "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
     return typeof pkg.version === "string" ? pkg.version : "0.0.0";
   } catch {
     return "0.0.0";