@pattern-stack/codegen 0.10.1 → 0.12.0

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

@@ -1,31 +1,31 @@
 /**
- * SyncModule — `DynamicModule.forRoot({ backend, multiTenant? })` factory
- * wiring the sync subsystem's substrate (SYNC-6, ADR-008 subsystem pattern).
+ * IntegrationModule — `DynamicModule.forRoot({ backend, multiTenant? })` factory
+ * wiring the integration subsystem's substrate (SYNC-6, ADR-008 subsystem pattern).
  *
  * ## What this module provides
  *
- *   - `SYNC_CURSOR_STORE`    — Drizzle or Memory cursor store
- *   - `SYNC_RUN_RECORDER`    — Drizzle or Memory run recorder
- *   - `SYNC_FIELD_DIFFER`    — default `DeepEqualDiffer`
- *   - `SYNC_MULTI_TENANT`    — resolved boolean flag (defaults to false)
- *   - `SYNC_MODULE_OPTIONS`  — the options object itself, for backends
+ *   - `INTEGRATION_CURSOR_STORE`    — Drizzle or Memory cursor store
+ *   - `INTEGRATION_RUN_RECORDER`    — Drizzle or Memory run recorder
+ *   - `INTEGRATION_FIELD_DIFFER`    — default `DeepEqualDiffer`
+ *   - `INTEGRATION_MULTI_TENANT`    — resolved boolean flag (defaults to false)
+ *   - `INTEGRATION_MODULE_OPTIONS`  — the options object itself, for backends
  *     that need to inspect config at construction time
  *
  * ## What this module does NOT provide
  *
- *   - `SYNC_CHANGE_SOURCE` — per-provider per-entity; consumer binds in
- *     their feature module (e.g. `OpportunitySyncModule` provides a
+ *   - `INTEGRATION_CHANGE_SOURCE` — per-provider per-entity; consumer binds in
+ *     their feature module (e.g. `OpportunityIntegrationModule` provides a
  *     `SalesforceOpportunityChangeSource`). Loopback suppression — when
  *     needed — is composed into the primitive's middleware chain via
  *     `createLoopbackMiddleware(store)` (#226-5 / ADR-033); the
  *     orchestrator no longer accepts a fingerprint store directly.
- *   - `SYNC_SINK` — per canonical entity; consumer binds in their feature
+ *   - `INTEGRATION_SINK` — per canonical entity; consumer binds in their feature
  *     module.
- *   - `ExecuteSyncUseCase` — registered by the feature module alongside
+ *   - `ExecuteIntegrationUseCase` — registered by the feature module alongside
  *     its source + sink bindings. Providing the orchestrator here would
- *     force Nest to resolve SYNC_CHANGE_SOURCE + SYNC_SINK at module
+ *     force Nest to resolve INTEGRATION_CHANGE_SOURCE + INTEGRATION_SINK at module
  *     compile time, which fails when the feature module hasn't been
- *     imported yet. Consumers register `ExecuteSyncUseCase` in the same
+ *     imported yet. Consumers register `ExecuteIntegrationUseCase` in the same
  *     `providers` array as their source + sink so resolution is local
  *     to where all three are bound.
  *
@@ -38,7 +38,7 @@
  * ```ts
  * // AppModule — single source of truth for backend + multi-tenancy.
  * @Module({
- *   imports: [SyncModule.forRoot({ backend: 'drizzle' })],
+ *   imports: [IntegrationModule.forRoot({ backend: 'drizzle' })],
  * })
  * export class AppModule {}
  *
@@ -46,36 +46,36 @@
  * // orchestrator for free.
  * @Module({
  *   providers: [
- *     { provide: SYNC_CHANGE_SOURCE, useClass: SalesforceOpportunitySource },
- *     { provide: SYNC_SINK,          useClass: OpportunitySyncSink },
- *     ExecuteSyncUseCase,
+ *     { provide: INTEGRATION_CHANGE_SOURCE, useClass: SalesforceOpportunitySource },
+ *     { provide: INTEGRATION_SINK,          useClass: OpportunityIntegrationSink },
+ *     ExecuteIntegrationUseCase,
  *   ],
  * })
- * export class OpportunitySyncModule {
+ * export class OpportunityIntegrationModule {
  *   constructor(
- *     private readonly execute: ExecuteSyncUseCase<CanonicalOpportunity>,
+ *     private readonly execute: ExecuteIntegrationUseCase<CanonicalOpportunity>,
  *   ) {}
  * }
  * ```
  *
  * `global: true` means feature modules do not need to re-import
- * `SyncModule` — the substrate tokens are available project-wide.
+ * `IntegrationModule` — the substrate tokens are available project-wide.
  */
 import { Module, type DynamicModule, type Provider } from '@nestjs/common';
 import {
-  SYNC_CURSOR_STORE,
-  SYNC_FIELD_DIFFER,
-  SYNC_MODULE_OPTIONS,
-  SYNC_MULTI_TENANT,
-  SYNC_RUN_RECORDER,
-} from './sync.tokens';
-import { MemoryCursorStore } from './sync-cursor-store.memory-backend';
-import { MemoryRunRecorder } from './sync-run-recorder.memory-backend';
-import { PostgresCursorStore } from './sync-cursor-store.drizzle-backend';
-import { DrizzleSyncRunRecorder } from './sync-run-recorder.drizzle-backend';
+  INTEGRATION_CURSOR_STORE,
+  INTEGRATION_FIELD_DIFFER,
+  INTEGRATION_MODULE_OPTIONS,
+  INTEGRATION_MULTI_TENANT,
+  INTEGRATION_RUN_RECORDER,
+} from './integration.tokens';
+import { MemoryCursorStore } from './integration-cursor-store.memory-backend';
+import { MemoryRunRecorder } from './integration-run-recorder.memory-backend';
+import { PostgresCursorStore } from './integration-cursor-store.drizzle-backend';
+import { DrizzleIntegrationRunRecorder } from './integration-run-recorder.drizzle-backend';
 import { DeepEqualDiffer } from './deep-equal.differ';
 
-export interface SyncModuleOptions {
+export interface IntegrationModuleOptions {
   /**
    * Backend selection. `drizzle` wires the Postgres cursor store +
    * run-log recorder; `memory` wires in-memory doubles suitable for
@@ -103,16 +103,16 @@ export interface SyncModuleOptions {
 }
 
 @Module({})
-export class SyncModule {
-  static forRoot(options: SyncModuleOptions): DynamicModule {
+export class IntegrationModule {
+  static forRoot(options: IntegrationModuleOptions): DynamicModule {
     const multiTenant = options.multiTenant ?? false;
 
     const sharedProviders: Provider[] = [
-      { 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: Provider[] =
@@ -123,33 +123,33 @@ export class SyncModule {
             // 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,
       ],
     };
   }

package/runtime/subsystems/integration/integration.tokens.ts

@@ -0,0 +1,63 @@
+/**
+ * Integration subsystem — DI tokens
+ *
+ * String constants (not Symbols) so they match by value across import
+ * boundaries — same convention as the events subsystem (`EVENT_BUS`). The
+ * jobs subsystem uses Symbols for its analogous tokens; events and integration
+ * stay internally consistent with strings.
+ *
+ * Usage in use cases:
+ * ```ts
+ * constructor(
+ *   @Inject(INTEGRATION_CHANGE_SOURCE) private readonly source: IChangeSource<CanonicalOpportunity>,
+ *   @Inject(INTEGRATION_CURSOR_STORE)  private readonly cursors: ICursorStore,
+ *   @Inject(INTEGRATION_FIELD_DIFFER)  private readonly differ: IFieldDiffer<CanonicalOpportunity>,
+ *   @Inject(INTEGRATION_SINK)          private readonly sink: IIntegrationSink<CanonicalOpportunity>,
+ *   @Inject(INTEGRATION_RUN_RECORDER)  private readonly recorder: IIntegrationRunRecorder,
+ * ) {}
+ * ```
+ *
+ * Concrete bindings are registered by `IntegrationModule.forRoot(...)` (SYNC-6).
+ */
+
+export const INTEGRATION_CHANGE_SOURCE = 'INTEGRATION_CHANGE_SOURCE' as const;
+export const INTEGRATION_CURSOR_STORE = 'INTEGRATION_CURSOR_STORE' as const;
+export const INTEGRATION_FIELD_DIFFER = 'INTEGRATION_FIELD_DIFFER' as const;
+export const INTEGRATION_SINK = 'INTEGRATION_SINK' as const;
+
+/**
+ * Run-recorder token (SYNC-5). Backed by `IIntegrationRunRecorder`. Drizzle impl
+ * lands in SYNC-4; tests provide inline fakes.
+ */
+export const INTEGRATION_RUN_RECORDER = 'INTEGRATION_RUN_RECORDER' as const;
+
+/**
+ * Injection token for the resolved `IntegrationModuleOptions` object (SYNC-6).
+ *
+ * Backends that need to observe module configuration (e.g. `multiTenant`
+ * flag, pool filters) inject via this token. Provided automatically by
+ * `IntegrationModule.forRoot(...)` / `IntegrationModule.forRootAsync(...)`.
+ */
+export const INTEGRATION_MODULE_OPTIONS = 'INTEGRATION_MODULE_OPTIONS' as const;
+
+/**
+ * Injection token for the resolved multi-tenancy flag (SYNC-6).
+ *
+ * Provided by `IntegrationModule.forRoot(...)` as `options.multiTenant ?? false`.
+ * Consumed by `ExecuteIntegrationUseCase` to enforce the tenantId-is-required rule.
+ */
+export const INTEGRATION_MULTI_TENANT = 'INTEGRATION_MULTI_TENANT' as const;
+
+/**
+ * Injection token for the entity-keyed `IEntityChangeSourceRegistry` (C7,
+ * #336). Bound to the codegen-emitted aggregator that folds per-provider
+ * adapter contributions into one registry (RFC-0001 §3, emitted by Track D
+ * D3/D4).
+ *
+ * A string constant, not `Symbol.for(...)`, to match this subsystem's token
+ * convention (see file header). The originating issue's code block proposed a
+ * `Symbol.for('@pattern-stack/codegen.entity-change-source-registry')` key,
+ * predating the sync→integration consolidation onto string tokens; kept as a
+ * string here for internal consistency with the other INTEGRATION_* tokens.
+ */
+export const ENTITY_CHANGE_SOURCE_REGISTRY = 'ENTITY_CHANGE_SOURCE_REGISTRY' as const;

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

@@ -1,7 +1,7 @@
 /**
- * Sync subsystem — loopback `ChangeMiddleware` factory (#226-5, ADR-033).
+ * Integration subsystem — loopback `ChangeMiddleware` factory (#226-5, ADR-033).
  *
- * Replaces the prior orchestrator-side `@Optional() SYNC_LOOPBACK_FINGERPRINT_STORE`
+ * Replaces the prior orchestrator-side `@Optional() INTEGRATION_LOOPBACK_FINGERPRINT_STORE`
  * branch. Consumers that need to suppress echoes of their own outbound
  * writes compose `createLoopbackMiddleware(store)` into a primitive's
  * middleware chain — typically alongside `PollChangeSource<T>` — instead
@@ -28,12 +28,12 @@
  * their store or layer a counting middleware alongside this one.
  */
 
-import type { Change } from './sync-change-source.protocol';
+import type { Change } from './integration-change-source.protocol';
 import type {
   ChangeIterator,
   ChangeMiddleware,
-} from './sync-middleware.protocol';
-import type { ILoopbackFingerprintStore } from './sync-loopback.protocol';
+} from './integration-middleware.protocol';
+import type { ILoopbackFingerprintStore } from './integration-loopback.protocol';
 
 /**
  * Build a `ChangeMiddleware<T>` that suppresses changes whose fingerprint

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

@@ -1,5 +1,5 @@
 /**
- * Sync subsystem — `PollChangeSource<T>` primitive (#226-3, ADR-033).
+ * Integration subsystem — `PollChangeSource<T>` primitive (#226-3, ADR-033).
  *
  * Generic poll-mode `IChangeSource<T>` implementation parameterized by a
  * parsed `DetectionConfig` (poll mode) and a consumer-supplied
@@ -36,12 +36,12 @@ import type {
   Change,
   ChangeSource,
   IChangeSource,
-  SyncSubscriptionView,
-} from './sync-change-source.protocol';
+  IntegrationSubscriptionView,
+} from './integration-change-source.protocol';
 import type {
   ChangeIterator,
   ChangeMiddleware,
-} from './sync-middleware.protocol';
+} from './integration-middleware.protocol';
 
 // ============================================================================
 // Cursor + adapter callback shapes
@@ -60,7 +60,7 @@ export type PollCursor = unknown;
  * NOT here on purpose.
  */
 export interface PollFetchContext {
-  readonly subscription: SyncSubscriptionView;
+  readonly subscription: IntegrationSubscriptionView;
   readonly cursor: PollCursor | null;
   readonly filters: readonly ResolvedFilter[];
 }
@@ -174,14 +174,14 @@ export class PollChangeSource<T> implements IChangeSource<T> {
   }
 
   listChanges(
-    subscription: SyncSubscriptionView,
+    subscription: IntegrationSubscriptionView,
     cursor: unknown | null,
   ): AsyncIterable<Change<T>> {
     return this.composed(subscription, cursor);
   }
 
   private async *fetch(
-    subscription: SyncSubscriptionView,
+    subscription: IntegrationSubscriptionView,
     cursor: unknown | null,
   ): AsyncIterable<Change<T>> {
     const ctx: PollFetchContext = {

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

@@ -1,5 +1,5 @@
 /**
- * Sync subsystem — `WebhookChangeSource<T>` primitive (#226-4, ADR-033).
+ * Integration subsystem — `WebhookChangeSource<T>` primitive (#226-4, ADR-033).
  *
  * Generic webhook-mode `IChangeSource<T>` implementation parameterized by a
  * parsed `DetectionConfig` (webhook mode) and a consumer-supplied
@@ -40,12 +40,12 @@ import type { DetectionConfig } from './detection-config.schema';
 import type {
   Change,
   IChangeSource,
-  SyncSubscriptionView,
-} from './sync-change-source.protocol';
+  IntegrationSubscriptionView,
+} from './integration-change-source.protocol';
 import type {
   ChangeIterator,
   ChangeMiddleware,
-} from './sync-middleware.protocol';
+} from './integration-middleware.protocol';
 
 // ============================================================================
 // Cursor + queue callback shapes
@@ -65,7 +65,7 @@ export type WebhookCursor = unknown;
  * `userId` / `tenantId`.
  */
 export interface WebhookFetchContext {
-  readonly subscription: SyncSubscriptionView;
+  readonly subscription: IntegrationSubscriptionView;
   readonly cursor: WebhookCursor | null;
 }
 
@@ -162,14 +162,14 @@ export class WebhookChangeSource<T> implements IChangeSource<T> {
   }
 
   listChanges(
-    subscription: SyncSubscriptionView,
+    subscription: IntegrationSubscriptionView,
     cursor: unknown | null,
   ): AsyncIterable<Change<T>> {
     return this.composed(subscription, cursor);
   }
 
   private async *fetch(
-    subscription: SyncSubscriptionView,
+    subscription: IntegrationSubscriptionView,
     cursor: unknown | null,
   ): AsyncIterable<Change<T>> {
     const ctx: WebhookFetchContext = {

package/runtime/subsystems/observability/index.ts

@@ -39,7 +39,7 @@ export type {
   CorrelationTimeline,
   CorrelationTimelineEntry,
   StatusHistogram,
-  SyncRunSummary,
+  IntegrationRunSummary,
   CursorSnapshot,
 } from './observability.protocol';
 

package/runtime/subsystems/observability/observability.module.ts

@@ -1,7 +1,7 @@
 /**
  * ObservabilityModule — combiner subsystem (ADR-025, OBS-5, OBS-6).
  *
- * Composes the jobs, bridge, and sync read ports into a single
+ * Composes the jobs, bridge, and integration read ports into a single
  * `IObservability` facade. Owned by no sibling subsystem; it consumes
  * their tokens via DI, which the consumer app wires by registering the
  * sibling modules in the right order (like BridgeModule — the named
@@ -14,7 +14,7 @@
  *     EventsModule.forRoot({ backend: 'drizzle' }),
  *     JobsDomainModule.forRoot({ backend: 'drizzle' }),
  *     BridgeModule.forRoot({ backend: 'drizzle' }),
- *     SyncModule.forRoot({ backend: 'drizzle' }),
+ *     IntegrationModule.forRoot({ backend: 'drizzle' }),
  *     ObservabilityModule.forRoot({
  *       reporters: {
  *         bridgeMetrics: {

package/runtime/subsystems/observability/observability.protocol.ts

@@ -5,7 +5,7 @@
  * Every method:
  *   - Accepts an optional `tenantId`, passed VERBATIM to the owning sibling
  *     port. Observability never re-implements tenant filtering — that is
- *     the owning subsystem's job (jobs / bridge / sync). See
+ *     the owning subsystem's job (jobs / bridge / integration). See
  *     `.claude/skills/observability/SKILL.md` §3.
  *       - `undefined` — "not provided"; sibling default semantics apply.
  *       - `null`      — explicit cross-tenant match (sibling-specific).
@@ -32,8 +32,8 @@ import type {
   ListEventsQuery,
 } from '../events/event-read.protocol';
 import type { StatusHistogram } from '../bridge/bridge.protocol';
-import type { SyncRunSummary } from '../sync/sync-run-recorder.protocol';
-import type { CursorSnapshot } from '../sync/sync-cursor-store.protocol';
+import type { IntegrationRunSummary } from '../integration/integration-run-recorder.protocol';
+import type { CursorSnapshot } from '../integration/integration-cursor-store.protocol';
 
 /**
  * One chronological entry in a correlation timeline (OBS-LIST-1). Either a
@@ -98,22 +98,22 @@ export interface IObservability {
   ): Promise<StatusHistogram>;
 
   /**
-   * Recent `sync_runs` (optionally filtered by subscription). Delegates to
-   * `ISyncRunRecorder.listRecent`.
+   * Recent `integration_runs` (optionally filtered by subscription). Delegates to
+   * `IIntegrationRunRecorder.listRecent`.
    *
-   * Empty array when the sync subsystem is not installed.
+   * Empty array when the integration subsystem is not installed.
    */
-  getRecentSyncRuns(
+  getRecentIntegrationRuns(
     limit: number,
     subscriptionId?: string,
     tenantId?: string | null,
-  ): Promise<SyncRunSummary[]>;
+  ): Promise<IntegrationRunSummary[]>;
 
   /**
-   * Cursor state per enabled `sync_subscriptions` row. Delegates to
+   * Cursor state per enabled `integration_subscriptions` row. Delegates to
    * `ICursorStore.listAll`.
    *
-   * Empty array when the sync subsystem is not installed.
+   * Empty array when the integration subsystem is not installed.
    */
   getCursors(tenantId?: string | null): Promise<CursorSnapshot[]>;
 
@@ -163,6 +163,6 @@ export type {
   EventPage,
   ListEventsQuery,
   StatusHistogram,
-  SyncRunSummary,
+  IntegrationRunSummary,
   CursorSnapshot,
 };

package/runtime/subsystems/observability/observability.service.ts

@@ -2,7 +2,7 @@
  * ObservabilityService — `IObservability` combiner implementation
  * (ADR-025, OBS-5).
  *
- * Composes read methods across the jobs, bridge, and sync subsystems via
+ * Composes read methods across the jobs, bridge, and integration subsystems via
  * DI. Owns no state, no schema, no SQL. Every method is a one-line
  * delegation to the sibling port that already encodes the semantics.
  *
@@ -50,15 +50,15 @@ import type {
 import { BRIDGE_DELIVERY_REPO } from '../bridge/bridge.tokens';
 import type { IJobBridge, StatusHistogram } from '../bridge/bridge.protocol';
 
-import { SYNC_CURSOR_STORE, SYNC_RUN_RECORDER } from '../sync/sync.tokens';
+import { INTEGRATION_CURSOR_STORE, INTEGRATION_RUN_RECORDER } from '../integration/integration.tokens';
 import type {
-  ISyncRunRecorder,
-  SyncRunSummary,
-} from '../sync/sync-run-recorder.protocol';
+  IIntegrationRunRecorder,
+  IntegrationRunSummary,
+} from '../integration/integration-run-recorder.protocol';
 import type {
   CursorSnapshot,
   ICursorStore,
-} from '../sync/sync-cursor-store.protocol';
+} from '../integration/integration-cursor-store.protocol';
 
 import type {
   CorrelationTimeline,
@@ -106,10 +106,10 @@ export class ObservabilityService implements IObservability {
     @Inject(BRIDGE_DELIVERY_REPO)
     private readonly bridge?: IJobBridge,
     @Optional()
-    @Inject(SYNC_RUN_RECORDER)
-    private readonly syncRuns?: ISyncRunRecorder,
+    @Inject(INTEGRATION_RUN_RECORDER)
+    private readonly integrationRuns?: IIntegrationRunRecorder,
     @Optional()
-    @Inject(SYNC_CURSOR_STORE)
+    @Inject(INTEGRATION_CURSOR_STORE)
     private readonly cursors?: ICursorStore,
     @Optional()
     @Inject(EVENT_READ_PORT)
@@ -137,13 +137,13 @@ export class ObservabilityService implements IObservability {
     return this.bridge.getStatusHistogram(windowHours, tenantId);
   }
 
-  async getRecentSyncRuns(
+  async getRecentIntegrationRuns(
     limit: number,
     subscriptionId?: string,
     tenantId?: string | null,
-  ): Promise<SyncRunSummary[]> {
-    if (!this.syncRuns) return [];
-    return this.syncRuns.listRecent(limit, subscriptionId, tenantId);
+  ): Promise<IntegrationRunSummary[]> {
+    if (!this.integrationRuns) return [];
+    return this.integrationRuns.listRecent(limit, subscriptionId, tenantId);
   }
 
   async getCursors(tenantId?: string | null): Promise<CursorSnapshot[]> {

package/runtime/subsystems/observability/observability.tokens.ts

@@ -1,7 +1,7 @@
 /**
  * Observability combiner subsystem — DI tokens (ADR-025, OBS-5).
  *
- * String constants (not Symbols), matching the events / bridge / sync
+ * String constants (not Symbols), matching the events / bridge / integration
  * convention. The jobs subsystem uses Symbols for its analogous tokens;
  * observability stays internally consistent with its sibling combiner
  * (bridge) because the two are structurally paired (ADR-025).

package/src/patterns/library/index.ts

@@ -1,7 +1,7 @@
 /**
  * Library pattern bootstrap — imports every shipped pattern and registers
  * it with the shared library registry. Side-effect-only module: importing
- * this barrel is what pre-registers `Base`, `Synced`, `Activity`,
+ * this barrel is what pre-registers `Base`, `Integrated`, `Activity`,
  * `Knowledge`, and `Metadata`.
  *
  * Adding a new library pattern is two edits: create the `*.pattern.ts`
@@ -14,10 +14,10 @@ import { BasePattern } from './base.pattern.js';
 import { JunctionPattern } from './junction.pattern.js';
 import { KnowledgePattern } from './knowledge.pattern.js';
 import { MetadataPattern } from './metadata.pattern.js';
-import { SyncedPattern } from './synced.pattern.js';
+import { IntegratedPattern } from './integrated.pattern.js';
 
 registerLibraryPattern(BasePattern);
-registerLibraryPattern(SyncedPattern);
+registerLibraryPattern(IntegratedPattern);
 registerLibraryPattern(ActivityPattern);
 registerLibraryPattern(KnowledgePattern);
 registerLibraryPattern(MetadataPattern);
@@ -29,7 +29,7 @@ export {
 	JunctionPattern,
 	KnowledgePattern,
 	MetadataPattern,
-	SyncedPattern,
+	IntegratedPattern,
 };
 export {
 	BaseJunctionFields,

package/src/patterns/library/{synced.pattern.ts → integrated.pattern.ts}

@@ -1,35 +1,35 @@
 /**
- * SyncedPattern — adds external-system sync columns and methods.
+ * IntegratedPattern — adds external-system integration columns and methods.
  *
- * Replaces the legacy `family: synced` entry in
+ * Replaces the legacy `family: integrated` entry in
  * `templates/entity/new/clean-lite-ps/prompt-extension.js`. Class names,
  * import paths, and inherited-method comment lines are preserved verbatim
  * so PATTERN-5's template swap produces byte-identical output for
- * pre-existing `family: synced` fixtures.
+ * pre-existing `family: integrated` fixtures.
  *
  * Implies `external_id_tracking` — the behavior that contributes the
  * `external_id`, `provider`, and `provider_metadata` columns to the table.
- * An entity declaring `pattern: Synced` need not re-declare the behavior.
+ * An entity declaring `pattern: Integrated` need not re-declare the behavior.
  */
 
 import { definePattern } from '../pattern-definition.js';
 
-export const SyncedPattern = definePattern({
-	name: 'Synced',
+export const 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',
 });

package/src/patterns/library/junction.pattern.ts

@@ -2,7 +2,7 @@
  * JunctionPattern — top-level discriminator for explicit many-to-many
  * junction YAML files.
  *
- * Unlike `Activity` / `Synced` / `Metadata` (which attach to an entity via
+ * Unlike `Activity` / `Integrated` / `Metadata` (which attach to an entity via
  * `pattern:` / `patterns:`), `Junction` IS the top-level YAML shape — a
  * junction file's discriminator is `pattern: Junction`, not `entity:`.
  * It therefore does not declare `repositoryClass` / `serviceClass`: the

package/src/patterns/pattern-definition.ts

@@ -52,7 +52,7 @@ export type PatternKind = 'domain' | 'orchestration';
  * store these and look them up by `name`.
  */
 export interface PatternDefinition<TConfig = unknown> {
-	/** Unique name used in YAML — e.g. `pattern: Synced` */
+	/** Unique name used in YAML — e.g. `pattern: Integrated` */
 	name: string;
 
 	/**
@@ -65,7 +65,7 @@ export interface PatternDefinition<TConfig = unknown> {
 
 	/**
 	 * Built-in patterns this extends, by name. Phase 1 supports single-depth
-	 * chains only — a pattern may `extends: ['Synced']` but the transitive
+	 * chains only — a pattern may `extends: ['Integrated']` but the transitive
 	 * chain is not yet resolved. Multi-depth inheritance is deferred until
 	 * a real consumer asks.
 	 */
@@ -79,7 +79,7 @@ export interface PatternDefinition<TConfig = unknown> {
 	/**
 	 * Fully-qualified TypeScript path alias the consumer's tsconfig resolves.
 	 * Library patterns use the consumer-installed runtime base class path
-	 * (e.g. `@shared/base-classes/synced-entity-repository`); app patterns
+	 * (e.g. `@shared/base-classes/integrated-entity-repository`); app patterns
 	 * use whatever alias the consumer has configured (e.g. `@/patterns/...`).
 	 */
 	repositoryImport?: string;