@pattern-stack/codegen 0.16.1 → 0.17.1

package/dist/{chunk-24WXSC3C.js → chunk-JA7GJDNI.js}

@@ -1,15 +1,15 @@
-import {
-  MemoryRunRecorder
-} from "./chunk-EO2QPOKH.js";
-import {
-  PostgresCursorStore
-} from "./chunk-XWBK3XJK.js";
 import {
   MemoryCursorStore
 } from "./chunk-AHV4GDYM.js";
 import {
   DrizzleIntegrationRunRecorder
 } from "./chunk-YK5JEVLX.js";
+import {
+  MemoryRunRecorder
+} from "./chunk-EO2QPOKH.js";
+import {
+  PostgresCursorStore
+} from "./chunk-XWBK3XJK.js";
 import {
   INTEGRATION_CURSOR_STORE,
   INTEGRATION_FIELD_DIFFER,
@@ -19,7 +19,7 @@ import {
 } from "./chunk-S7C6TIIF.js";
 import {
   DeepEqualDiffer
-} from "./chunk-36U5UGIO.js";
+} from "./chunk-JEINYUJH.js";
 import {
   __decorateClass
 } from "./chunk-2E224ZSN.js";
@@ -34,7 +34,13 @@ var IntegrationModule = class {
       { provide: INTEGRATION_MULTI_TENANT, useValue: multiTenant },
       // Default differ — consumers can override by binding a different
       // `IFieldDiffer<T>` to `INTEGRATION_FIELD_DIFFER` in their feature module.
-      { provide: INTEGRATION_FIELD_DIFFER, useValue: new DeepEqualDiffer() }
+      // DIFFER-UNIGNORE: `options.differ` (ignore/unignore) is threaded here so
+      // a consumer can declare a default-ignored column (e.g. `deletedAt`) as
+      // domain data for their entities without binding a bespoke differ.
+      {
+        provide: INTEGRATION_FIELD_DIFFER,
+        useValue: new DeepEqualDiffer(options.differ ?? {})
+      }
     ];
     const backendProviders = options.backend === "memory" ? [
       // Wired as singletons via `useValue` so tests can pull
@@ -78,4 +84,4 @@ IntegrationModule = __decorateClass([
 export {
   IntegrationModule
 };
-//# sourceMappingURL=chunk-24WXSC3C.js.map
+//# sourceMappingURL=chunk-JA7GJDNI.js.map

package/dist/chunk-JA7GJDNI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/integration/integration.module.ts"],"sourcesContent":["/**\n * IntegrationModule — `DynamicModule.forRoot({ backend, multiTenant? })` factory\n * wiring the integration subsystem's substrate (SYNC-6, ADR-008 subsystem pattern).\n *\n * ## What this module provides\n *\n *   - `INTEGRATION_CURSOR_STORE`    — Drizzle or Memory cursor store\n *   - `INTEGRATION_RUN_RECORDER`    — Drizzle or Memory run recorder\n *   - `INTEGRATION_FIELD_DIFFER`    — default `DeepEqualDiffer`\n *   - `INTEGRATION_MULTI_TENANT`    — resolved boolean flag (defaults to false)\n *   - `INTEGRATION_MODULE_OPTIONS`  — the options object itself, for backends\n *     that need to inspect config at construction time\n *\n * ## What this module does NOT provide\n *\n *   - `INTEGRATION_CHANGE_SOURCE` — per-provider per-entity; consumer binds in\n *     their feature module (e.g. `OpportunityIntegrationModule` provides a\n *     `SalesforceOpportunityChangeSource`). Loopback suppression — when\n *     needed — is composed into the primitive's middleware chain via\n *     `createLoopbackMiddleware(store)` (#226-5 / ADR-033); the\n *     orchestrator no longer accepts a fingerprint store directly.\n *   - `INTEGRATION_SINK` — per canonical entity; consumer binds in their feature\n *     module.\n *   - `ExecuteIntegrationUseCase` — registered by the feature module alongside\n *     its source + sink bindings. Providing the orchestrator here would\n *     force Nest to resolve INTEGRATION_CHANGE_SOURCE + INTEGRATION_SINK at module\n *     compile time, which fails when the feature module hasn't been\n *     imported yet. Consumers register `ExecuteIntegrationUseCase` in the same\n *     `providers` array as their source + sink so resolution is local\n *     to where all three are bound.\n *\n * Same shape as `EventsModule.forRoot` — the module wires the bus; you\n * bring your own handlers. Here: the module wires the substrate; you\n * bring your own source + sink.\n *\n * ## Usage\n *\n * ```ts\n * // AppModule — single source of truth for backend + multi-tenancy.\n * @Module({\n *   imports: [IntegrationModule.forRoot({ backend: 'drizzle' })],\n * })\n * export class AppModule {}\n *\n * // Per-entity feature module — binds source + sink, gets the\n * // orchestrator for free.\n * @Module({\n *   providers: [\n *     { provide: INTEGRATION_CHANGE_SOURCE, useClass: SalesforceOpportunitySource },\n *     { provide: INTEGRATION_SINK,          useClass: OpportunityIntegrationSink },\n *     ExecuteIntegrationUseCase,\n *   ],\n * })\n * export class OpportunityIntegrationModule {\n *   constructor(\n *     private readonly execute: ExecuteIntegrationUseCase<CanonicalOpportunity>,\n *   ) {}\n * }\n * ```\n *\n * `global: true` means feature modules do not need to re-import\n * `IntegrationModule` — the substrate tokens are available project-wide.\n */\nimport { Module, type DynamicModule, type Provider } from '@nestjs/common';\nimport {\n  INTEGRATION_CURSOR_STORE,\n  INTEGRATION_FIELD_DIFFER,\n  INTEGRATION_MODULE_OPTIONS,\n  INTEGRATION_MULTI_TENANT,\n  INTEGRATION_RUN_RECORDER,\n} from './integration.tokens';\nimport { MemoryCursorStore } from './integration-cursor-store.memory-backend';\nimport { MemoryRunRecorder } from './integration-run-recorder.memory-backend';\nimport { PostgresCursorStore } from './integration-cursor-store.drizzle-backend';\nimport { DrizzleIntegrationRunRecorder } from './integration-run-recorder.drizzle-backend';\nimport { DeepEqualDiffer, type DeepEqualDifferOptions } from './deep-equal.differ';\n\nexport interface IntegrationModuleOptions {\n  /**\n   * Backend selection. `drizzle` wires the Postgres cursor store +\n   * run-log recorder; `memory` wires in-memory doubles suitable for\n   * tests + local dev.\n   */\n  backend: 'drizzle' | 'memory';\n\n  /**\n   * Multi-tenancy opt-in (SYNC-6).\n   *\n   * When `true`, every call to the orchestrator + both Drizzle backends\n   * must supply a non-null `tenantId`; missing values throw\n   * `MissingTenantIdError`. Defense-in-depth: the orchestrator rejects\n   * at entry (no dangling `status=running` rows) AND the Drizzle\n   * backends reject at their write boundary (belt-and-braces for any\n   * path that bypasses the orchestrator). Both sites use the shared\n   * `assertTenantId` helper so error messages match.\n   *\n   * Memory backends accept `tenantId` unconditionally — their state is\n   * process-local; cross-tenant isolation there is not meaningful.\n   *\n   * Defaults to `false`.\n   */\n  multiTenant?: boolean;\n\n  /**\n   * Default-differ configuration (DIFFER-UNIGNORE, 0.17.1). Threaded into the\n   * `DeepEqualDiffer` bound to `INTEGRATION_FIELD_DIFFER`. Omit for the\n   * historical behaviour (the default ignore list, unchanged).\n   *\n   * Mirrors `DeepEqualDifferOptions`:\n   *   - `ignore`   — extra field names to ignore (merged with the defaults).\n   *   - `unignore` — default-ignored field names to RE-include as domain data\n   *     (e.g. `['deletedAt']` for an entity whose `deletedAt` is a\n   *     vendor-observed retraction tombstone, not row metadata — swe-brain\n   *     ADR-0008 §1). Subtracted after the merge, so it wins.\n   *\n   * A feature module that binds its own `IFieldDiffer<T>` to\n   * `INTEGRATION_FIELD_DIFFER` overrides this entirely (per-entity escape hatch\n   * unchanged).\n   */\n  differ?: DeepEqualDifferOptions;\n}\n\n@Module({})\nexport class IntegrationModule {\n  static forRoot(options: IntegrationModuleOptions): DynamicModule {\n    const multiTenant = options.multiTenant ?? false;\n\n    const sharedProviders: Provider[] = [\n      { provide: INTEGRATION_MODULE_OPTIONS, useValue: options },\n      { provide: INTEGRATION_MULTI_TENANT, useValue: multiTenant },\n      // Default differ — consumers can override by binding a different\n      // `IFieldDiffer<T>` to `INTEGRATION_FIELD_DIFFER` in their feature module.\n      // DIFFER-UNIGNORE: `options.differ` (ignore/unignore) is threaded here so\n      // a consumer can declare a default-ignored column (e.g. `deletedAt`) as\n      // domain data for their entities without binding a bespoke differ.\n      {\n        provide: INTEGRATION_FIELD_DIFFER,\n        useValue: new DeepEqualDiffer(options.differ ?? {}),\n      },\n    ];\n\n    const backendProviders: Provider[] =\n      options.backend === 'memory'\n        ? [\n            // Wired as singletons via `useValue` so tests can pull\n            // them out via `moduleRef.get(MemoryCursorStore)` for\n            // direct assertions. Matches JOB-4 / MemoryJobStore shape.\n            { provide: MemoryCursorStore, useValue: new MemoryCursorStore() },\n            {\n              provide: INTEGRATION_CURSOR_STORE,\n              useExisting: MemoryCursorStore,\n            },\n            { provide: MemoryRunRecorder, useValue: new MemoryRunRecorder() },\n            {\n              provide: INTEGRATION_RUN_RECORDER,\n              useExisting: MemoryRunRecorder,\n            },\n          ]\n        : [\n            // Drizzle backends — injected with DRIZZLE (provided by the\n            // consumer's DrizzleModule) + the INTEGRATION_MULTI_TENANT flag\n            // we bound above.\n            { provide: INTEGRATION_CURSOR_STORE, useClass: PostgresCursorStore },\n            { provide: INTEGRATION_RUN_RECORDER, useClass: DrizzleIntegrationRunRecorder },\n          ];\n\n    return {\n      module: IntegrationModule,\n      global: true,\n      providers: [...sharedProviders, ...backendProviders],\n      exports: [\n        INTEGRATION_MODULE_OPTIONS,\n        INTEGRATION_MULTI_TENANT,\n        INTEGRATION_FIELD_DIFFER,\n        INTEGRATION_CURSOR_STORE,\n        INTEGRATION_RUN_RECORDER,\n      ],\n    };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA+DA,SAAS,cAAiD;AA4DnD,IAAM,oBAAN,MAAwB;AAAA,EAC7B,OAAO,QAAQ,SAAkD;AAC/D,UAAM,cAAc,QAAQ,eAAe;AAE3C,UAAM,kBAA8B;AAAA,MAClC,EAAE,SAAS,4BAA4B,UAAU,QAAQ;AAAA,MACzD,EAAE,SAAS,0BAA0B,UAAU,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAM3D;AAAA,QACE,SAAS;AAAA,QACT,UAAU,IAAI,gBAAgB,QAAQ,UAAU,CAAC,CAAC;AAAA,MACpD;AAAA,IACF;AAEA,UAAM,mBACJ,QAAQ,YAAY,WAChB;AAAA;AAAA;AAAA;AAAA,MAIE,EAAE,SAAS,mBAAmB,UAAU,IAAI,kBAAkB,EAAE;AAAA,MAChE;AAAA,QACE,SAAS;AAAA,QACT,aAAa;AAAA,MACf;AAAA,MACA,EAAE,SAAS,mBAAmB,UAAU,IAAI,kBAAkB,EAAE;AAAA,MAChE;AAAA,QACE,SAAS;AAAA,QACT,aAAa;AAAA,MACf;AAAA,IACF,IACA;AAAA;AAAA;AAAA;AAAA,MAIE,EAAE,SAAS,0BAA0B,UAAU,oBAAoB;AAAA,MACnE,EAAE,SAAS,0BAA0B,UAAU,8BAA8B;AAAA,IAC/E;AAEN,WAAO;AAAA,MACL,QAAQ;AAAA,MACR,QAAQ;AAAA,MACR,WAAW,CAAC,GAAG,iBAAiB,GAAG,gBAAgB;AAAA,MACnD,SAAS;AAAA,QACP;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAxDa,oBAAN;AAAA,EADN,OAAO,CAAC,CAAC;AAAA,GACG;","names":[]}

package/dist/{chunk-36U5UGIO.js → chunk-JEINYUJH.js}

@@ -21,11 +21,14 @@ var DEFAULT_IGNORE_FIELDS = /* @__PURE__ */ new Set([
 var DeepEqualDiffer = class {
   ignore;
   constructor(opts = {}) {
-    if (opts.ignore && opts.ignore.length > 0) {
-      this.ignore = /* @__PURE__ */ new Set([...DEFAULT_IGNORE_FIELDS, ...opts.ignore]);
-    } else {
-      this.ignore = DEFAULT_IGNORE_FIELDS;
+    const merged = new Set(DEFAULT_IGNORE_FIELDS);
+    if (opts.ignore) {
+      for (const field of opts.ignore) merged.add(field);
+    }
+    if (opts.unignore) {
+      for (const field of opts.unignore) merged.delete(field);
     }
+    this.ignore = merged;
   }
   diff(existing, incoming, providerChangedFields) {
     if (existing === null) {
@@ -104,4 +107,4 @@ function deepEqualObject(a, b) {
 export {
   DeepEqualDiffer
 };
-//# sourceMappingURL=chunk-36U5UGIO.js.map
+//# sourceMappingURL=chunk-JEINYUJH.js.map

package/dist/chunk-JEINYUJH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/integration/deep-equal.differ.ts"],"sourcesContent":["/**\n * DeepEqualDiffer — default `IFieldDiffer<T>` for the integration subsystem (SYNC-5).\n *\n * Walks every field of `incoming` against `existing`, emitting a structured\n * per-field diff (`{ from, to }`) for every field whose value changed.\n * Returns `'noop'` when the record is unchanged.\n *\n * Design decisions (extracted from the upstream consumer + HS-9 findings):\n *\n * 1. **Ignore list** — row metadata that sinks/services stamp unconditionally\n *    so upstream cannot reasonably disagree:\n *      `id`, `createdAt`, `updatedAt`, `deletedAt`, `type`,\n *      `lastModifiedAt`, `fields`, `providerMetadata`\n *    (`fields` is the EAV bag — it's diffed by the sink's EAV dual-write\n *    path, not at the canonical-record layer.) Consumers augment the list via\n *    `options.ignore` and — when a default is domain data for their entity —\n *    REMOVE a default via `options.unignore` (e.g. an entity whose\n *    `deletedAt` is a vendor-observed retraction tombstone, not row metadata;\n *    see `DeepEqualDifferOptions.unignore`).\n *\n * 2. **`providerChangedFields` hint (CDC)** — when present, restricts the\n *    comparison to the hinted field set. The hint is advisory; fields in\n *    the ignore list are still filtered out even when hinted. Provider\n *    hints are field-NAME-level; they don't override the ignore rules.\n *\n * 3. **Date → ISO string** — `Date` instances are normalized to\n *    `toISOString()` before comparison. Sinks return `Date` from the DB\n *    driver; adapters typically deliver strings. Direct `===` would\n *    always say \"changed.\"\n *\n * 4. **Decimal-string vs number** — Postgres `numeric` columns return as\n *    strings through Drizzle; adapters deliver numbers. When one side is a\n *    number and the other is a numeric string that parses to the same\n *    number, they're equal. The normalizer does NOT coerce non-numeric\n *    strings, and it preserves zero-vs-null distinction.\n *\n * 5. **null-existing path** — `diff(null, incoming)` produces a full\n *    created-shape diff (`{from: null, to: <value>}` for every non-ignored\n *    field). Orchestrator sees this and records `operation: 'created'`.\n */\nimport { Injectable } from '@nestjs/common';\nimport type {\n  DiffResult,\n  FieldDiff,\n  IFieldDiffer,\n} from './integration-field-diff.protocol';\n\n/**\n * Default ignore list. Keep in integration with consumer canonical-record shapes —\n * adding a row-metadata field here means no integration will ever mark it changed.\n *\n * Includes the columns contributed by the `external_id_tracking` behavior\n * (`external_id`/`externalId`, `provider`, `provider_metadata`/`providerMetadata`).\n * These are integration-tracking metadata, not domain attributes: they ride on the\n * canonical record but must never register as a field change (the external id\n * is the record's identity, not a mutable value). Listed in both snake_case\n * and camelCase so the differ ignores them regardless of the consumer's\n * canonical projection casing.\n */\nconst DEFAULT_IGNORE_FIELDS: ReadonlySet<string> = new Set([\n  'id',\n  'createdAt',\n  'updatedAt',\n  'deletedAt',\n  'type',\n  'lastModifiedAt',\n  'fields',\n  'external_id',\n  'externalId',\n  'provider',\n  'provider_metadata',\n  'providerMetadata',\n]);\n\nexport interface DeepEqualDifferOptions {\n  /**\n   * Extra field names to ignore in addition to the defaults. Consumers can\n   * pass `['integration_version']` etc. to augment the base list; values here are\n   * merged (not replaced) with `DEFAULT_IGNORE_FIELDS`.\n   */\n  readonly ignore?: readonly string[];\n\n  /**\n   * Field names to REMOVE from the default ignore list — the inverse of\n   * `ignore`. Use this to declare that a normally-metadata column is in fact\n   * DOMAIN DATA for this entity and must register as a field change.\n   *\n   * The canonical case (swe-brain ADR-0008 §1, the gap this knob closes):\n   * `deletedAt` is in `DEFAULT_IGNORE_FIELDS` because most sinks stamp it as\n   * row metadata sinks own unconditionally. But an entity with\n   * `softDelete: false` and a domain-owned `deleted_at` carries the\n   * vendor-observed retraction tombstone ON the canonical record (a Slack\n   * `message_deleted` → `deletedAt`). Without un-ignoring it, the tombstone\n   * overlay diffs to `'noop'`, the upsert is skipped, and `deleted_at` never\n   * lands. `unignore: ['deletedAt']` makes the differ treat it as domain data.\n   *\n   * Applied AFTER `ignore` is merged, so `unignore` wins on a field listed in\n   * both. Subtracting a field not in the (merged) ignore set is a harmless\n   * no-op. Does not touch `DEFAULT_IGNORE_FIELDS` for any other instance.\n   */\n  readonly unignore?: readonly string[];\n}\n\n@Injectable()\nexport class DeepEqualDiffer<T extends Record<string, unknown>>\n  implements IFieldDiffer<T>\n{\n  private readonly ignore: ReadonlySet<string>;\n\n  constructor(opts: DeepEqualDifferOptions = {}) {\n    const merged = new Set<string>(DEFAULT_IGNORE_FIELDS);\n    if (opts.ignore) {\n      for (const field of opts.ignore) merged.add(field);\n    }\n    // `unignore` is subtracted last so it wins over a field that also appears\n    // in `ignore` or the defaults — \"this column is domain data here.\"\n    if (opts.unignore) {\n      for (const field of opts.unignore) merged.delete(field);\n    }\n    this.ignore = merged;\n  }\n\n  diff(\n    existing: T | null,\n    incoming: T,\n    providerChangedFields?: string[],\n  ): DiffResult {\n    // Created-shape: every non-ignored field becomes `{from: null, to}`.\n    if (existing === null) {\n      const out: FieldDiff = {};\n      for (const key of Object.keys(incoming)) {\n        if (this.ignore.has(key)) continue;\n        const value = (incoming as Record<string, unknown>)[key];\n        // Skip fields that are themselves null/undefined — a created record\n        // doesn't need to declare \"this field is null now\" for every\n        // untouched column.\n        if (value === null || value === undefined) continue;\n        out[key] = { from: null, to: value };\n      }\n      return Object.keys(out).length === 0 ? 'noop' : out;\n    }\n\n    // Field set to compare. `providerChangedFields` narrows to a hint set;\n    // ignored fields are filtered out regardless of hint.\n    const candidates = new Set<string>();\n    if (providerChangedFields && providerChangedFields.length > 0) {\n      for (const key of providerChangedFields) {\n        if (!this.ignore.has(key)) candidates.add(key);\n      }\n    } else {\n      for (const key of Object.keys(incoming)) {\n        if (!this.ignore.has(key)) candidates.add(key);\n      }\n      // Also include keys that exist on existing but not on incoming —\n      // e.g. a field that was cleared. This would otherwise be missed when\n      // incoming carries an undefined column we drop from the iteration.\n      for (const key of Object.keys(existing)) {\n        if (this.ignore.has(key)) continue;\n        if (!(key in (incoming as Record<string, unknown>))) continue;\n        candidates.add(key);\n      }\n    }\n\n    const out: FieldDiff = {};\n    for (const key of candidates) {\n      const before = (existing as Record<string, unknown>)[key];\n      const after = (incoming as Record<string, unknown>)[key];\n      if (!isEqual(before, after)) {\n        out[key] = { from: before ?? null, to: after ?? null };\n      }\n    }\n\n    return Object.keys(out).length === 0 ? 'noop' : out;\n  }\n}\n\n// ─── equality helpers ───────────────────────────────────────────────────────\n\n/**\n * Field-level equality with the canonical-integration normalizations:\n *   - Date → toISOString (adapters deliver strings)\n *   - numeric-string vs number → numeric equality when both parse\n *   - deep equality for plain objects/arrays (single-level is enough for\n *     canonical records; nested records travel as jsonb columns where the\n *     sink already owns the comparison)\n */\nfunction isEqual(a: unknown, b: unknown): boolean {\n  if (a === b) return true;\n\n  const na = normalize(a);\n  const nb = normalize(b);\n  if (na === nb) return true;\n\n  // After normalization: both may still be non-primitive objects.\n  if (\n    typeof na === 'object' &&\n    typeof nb === 'object' &&\n    na !== null &&\n    nb !== null\n  ) {\n    return deepEqualObject(na as Record<string, unknown>, nb as Record<string, unknown>);\n  }\n\n  // Numeric string ↔ number: when one side is a number and the other is a\n  // string that parses to the same finite number.\n  const numericEqual = maybeNumericEqual(na, nb) || maybeNumericEqual(nb, na);\n  return numericEqual;\n}\n\nfunction normalize(value: unknown): unknown {\n  if (value instanceof Date) return value.toISOString();\n  return value;\n}\n\nfunction maybeNumericEqual(a: unknown, b: unknown): boolean {\n  // a is string-shape, b is number — parse a and compare. Only when the\n  // string looks numeric AND the parse round-trips (no silent NaN pass-\n  // through on non-numeric strings).\n  if (typeof a !== 'string' || typeof b !== 'number') return false;\n  if (a.trim() === '') return false;\n  const parsed = Number(a);\n  if (!Number.isFinite(parsed)) return false;\n  return parsed === b;\n}\n\nfunction deepEqualObject(\n  a: Record<string, unknown>,\n  b: Record<string, unknown>,\n): boolean {\n  if (Array.isArray(a) !== Array.isArray(b)) return false;\n  const aKeys = Object.keys(a);\n  const bKeys = Object.keys(b);\n  if (aKeys.length !== bKeys.length) return false;\n  for (const key of aKeys) {\n    if (!(key in b)) return false;\n    if (!isEqual(a[key], b[key])) return false;\n  }\n  return true;\n}\n"],"mappings":"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","names":["out"]}

package/dist/{chunk-BOPZWRJK.js → chunk-JYBFPNBJ.js}

@@ -11,26 +11,26 @@ var ActivityEntityService = class extends BaseService {
     return this.repository.findByDateRange(start, end);
   }
   /**
-   * Find all activities for a specific user.
+   * Find all activities for a specific user (actor / owner scoping).
    */
   findByUser(userId) {
     return this.repository.findByUserId(userId);
   }
   /**
-   * Find all activities for a specific opportunity.
+   * Find all activities for a specific subject (config-driven FK column).
    */
-  findByOpportunity(opportunityId) {
-    return this.repository.findByOpportunityId(opportunityId);
+  findBySubject(subjectId) {
+    return this.repository.findBySubjectId(subjectId);
   }
   /**
-   * Find the most recent activities for an opportunity.
+   * Find the most recent activities for a subject.
    */
-  findRecent(opportunityId, limit) {
-    return this.repository.findRecentByOpportunityId(opportunityId, limit);
+  findRecent(subjectId, limit) {
+    return this.repository.findRecentBySubjectId(subjectId, limit);
   }
 };
 
 export {
   ActivityEntityService
 };
-//# sourceMappingURL=chunk-BOPZWRJK.js.map
+//# sourceMappingURL=chunk-JYBFPNBJ.js.map

package/dist/chunk-JYBFPNBJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/base-classes/activity-entity-service.ts"],"sourcesContent":["/**\n * ActivityEntityService<TRepo, TEntity>\n *\n * Family-specific base service for activity / interaction entities. Delegates\n * to an activity repository that provides date-range, actor (`user_id`), and\n * config-driven subject queries. The subject FK column is resolved inside the\n * repository from its `patternConfig` (ADR-031 §4) — the service is\n * subject-name-agnostic. See ACTIVITY-SUBJECT-1.\n */\nimport { BaseService, type IBaseRepository } from './base-service';\n\nexport interface IActivityEntityRepository<TEntity> extends IBaseRepository<TEntity> {\n  findByDateRange(start: Date, end: Date): Promise<TEntity[]>;\n  findByUserId(userId: string): Promise<TEntity[]>;\n  findBySubjectId(subjectId: string): Promise<TEntity[]>;\n  findRecentBySubjectId(subjectId: string, limit?: number): Promise<TEntity[]>;\n}\n\nexport abstract class ActivityEntityService<\n  TRepo extends IActivityEntityRepository<TEntity>,\n  TEntity,\n> extends BaseService<TRepo, TEntity> {\n  /**\n   * Find activities within a date range (inclusive).\n   */\n  findByDateRange(start: Date, end: Date): Promise<TEntity[]> {\n    return this.repository.findByDateRange(start, end);\n  }\n\n  /**\n   * Find all activities for a specific user (actor / owner scoping).\n   */\n  findByUser(userId: string): Promise<TEntity[]> {\n    return this.repository.findByUserId(userId);\n  }\n\n  /**\n   * Find all activities for a specific subject (config-driven FK column).\n   */\n  findBySubject(subjectId: string): Promise<TEntity[]> {\n    return this.repository.findBySubjectId(subjectId);\n  }\n\n  /**\n   * Find the most recent activities for a subject.\n   */\n  findRecent(subjectId: string, limit?: number): Promise<TEntity[]> {\n    return this.repository.findRecentBySubjectId(subjectId, limit);\n  }\n}\n"],"mappings":";;;;;AAkBO,IAAe,wBAAf,cAGG,YAA4B;AAAA;AAAA;AAAA;AAAA,EAIpC,gBAAgB,OAAa,KAA+B;AAC1D,WAAO,KAAK,WAAW,gBAAgB,OAAO,GAAG;AAAA,EACnD;AAAA;AAAA;AAAA;AAAA,EAKA,WAAW,QAAoC;AAC7C,WAAO,KAAK,WAAW,aAAa,MAAM;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA,EAKA,cAAc,WAAuC;AACnD,WAAO,KAAK,WAAW,gBAAgB,SAAS;AAAA,EAClD;AAAA;AAAA;AAAA;AAAA,EAKA,WAAW,WAAmB,OAAoC;AAChE,WAAO,KAAK,WAAW,sBAAsB,WAAW,KAAK;AAAA,EAC/D;AACF;","names":[]}

package/dist/{chunk-K2I6XIK5.js → chunk-KSTZIULO.js}

@@ -1,9 +1,9 @@
-import {
-  assertTenantId
-} from "./chunk-6DWFJNIK.js";
 import {
   bridgeDelivery
 } from "./chunk-2TVVBC53.js";
+import {
+  assertTenantId
+} from "./chunk-6DWFJNIK.js";
 import {
   BRIDGE_MULTI_TENANT
 } from "./chunk-4LH67P4U.js";
@@ -119,4 +119,4 @@ DrizzleBridgeDeliveryRepo = __decorateClass([
 export {
   DrizzleBridgeDeliveryRepo
 };
-//# sourceMappingURL=chunk-K2I6XIK5.js.map
+//# sourceMappingURL=chunk-KSTZIULO.js.map

package/dist/chunk-MKWQKKK7.js

@@ -0,0 +1,72 @@
+import {
+  BaseRepository
+} from "./chunk-J6KZS54B.js";
+
+// runtime/base-classes/activity-entity-repository.ts
+import { eq, between, desc } from "drizzle-orm";
+var toCamel = (snake) => snake.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+var ActivityEntityRepository = class extends BaseRepository {
+  /**
+   * Per-entity Activity config. The template emits this from `config:
+   * { Activity: {...} }`; entities that only use date-range / user scoping omit
+   * it (and must not call the subject finders).
+   */
+  patternConfig;
+  /**
+   * camelCase key for the recency-ordering column. Defaults to `occurredAt`
+   * (column `occurred_at`); override via `patternConfig.occurredAt`.
+   */
+  get occurredAtColumn() {
+    const snake = this.patternConfig?.occurredAt ?? "occurred_at";
+    return toCamel(snake);
+  }
+  /**
+   * camelCase key for the subject FK column, resolved from `patternConfig`:
+   * `subjectColumn` (explicit) → `<subject>_id` (derived). Throws when neither
+   * is configured — the subject finders are unusable without it, and a clear
+   * error beats a silent `undefined` column index.
+   */
+  get subjectColumn() {
+    const explicit = this.patternConfig?.subjectColumn;
+    if (explicit) return toCamel(explicit);
+    const subject = this.patternConfig?.subject;
+    if (subject) return toCamel(`${subject}_id`);
+    throw new Error(
+      "ActivityEntityRepository: subject finders require a subject column. Set `config: { Activity: { subject: '<entity>' } }` (\u2192 <entity>_id) or `config: { Activity: { subjectColumn: '<column>' } }` on the entity YAML."
+    );
+  }
+  /**
+   * Find activities within a date range (inclusive), by the recency column.
+   */
+  async findByDateRange(start, end) {
+    const rows = await this.baseQuery().where(between(this.table[this.occurredAtColumn], start, end));
+    return rows;
+  }
+  /**
+   * Find all activities for a specific user (actor / owner scoping).
+   */
+  async findByUserId(userId) {
+    const rows = await this.baseQuery().where(eq(this.table["userId"], userId));
+    return rows;
+  }
+  /**
+   * Find all activities for a specific subject (config-driven FK column).
+   */
+  async findBySubjectId(subjectId) {
+    const rows = await this.baseQuery().where(eq(this.table[this.subjectColumn], subjectId));
+    return rows;
+  }
+  /**
+   * Find the most recent activities for a subject, ordered by the recency
+   * column descending.
+   */
+  async findRecentBySubjectId(subjectId, limit = 10) {
+    const rows = await this.baseQuery().where(eq(this.table[this.subjectColumn], subjectId)).orderBy(desc(this.table[this.occurredAtColumn])).limit(limit);
+    return rows;
+  }
+};
+
+export {
+  ActivityEntityRepository
+};
+//# sourceMappingURL=chunk-MKWQKKK7.js.map

package/dist/chunk-MKWQKKK7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/base-classes/activity-entity-repository.ts"],"sourcesContent":["/**\n * ActivityEntityRepository<TEntity>\n *\n * Family-specific base for activity / interaction entities (emails, calls,\n * meetings, messages, transcripts). Adds date-range queries, actor (`user_id`)\n * scoping, recency ordering, and **config-driven subject scoping** — the\n * subject FK column is resolved from the concrete repo's `patternConfig`\n * (ADR-031 §4) rather than hardcoded, so the same base serves a CRM\n * `opportunity`-scoped activity and a swe-brain `person`-scoped interaction.\n *\n * Concrete repos extend this and declare their table + behaviors, and (when\n * they use the subject finders) a `patternConfig` carrying `subject` /\n * `subjectColumn` / `occurredAt`. The template emits that property from the\n * entity's `config: { Activity: {...} }` block. See ACTIVITY-SUBJECT-1.\n */\nimport { eq, between, desc } from 'drizzle-orm';\nimport { BaseRepository } from './base-repository';\n\n/**\n * Per-entity Activity config (matches `ActivityPatternConfigSchema` in\n * `src/patterns/library/activity.pattern.ts`). Carried on the concrete repo as\n * `patternConfig` and read here to resolve column names at runtime.\n */\nexport interface ActivityPatternConfig {\n  /** Subject entity name → derives the FK column `<subject>_id`. */\n  subject?: string;\n  /** Explicit snake_case FK column, when it does not follow `<subject>_id`. */\n  subjectColumn?: string;\n  /** snake_case recency-ordering column; defaults to `occurred_at`. */\n  occurredAt?: string;\n}\n\nconst toCamel = (snake: string): string =>\n  snake.replace(/_([a-z0-9])/g, (_, c: string) => c.toUpperCase());\n\nexport abstract class ActivityEntityRepository<TEntity> extends BaseRepository<TEntity> {\n  /**\n   * Per-entity Activity config. The template emits this from `config:\n   * { Activity: {...} }`; entities that only use date-range / user scoping omit\n   * it (and must not call the subject finders).\n   */\n  protected readonly patternConfig?: ActivityPatternConfig;\n\n  /**\n   * camelCase key for the recency-ordering column. Defaults to `occurredAt`\n   * (column `occurred_at`); override via `patternConfig.occurredAt`.\n   */\n  protected get occurredAtColumn(): string {\n    const snake = this.patternConfig?.occurredAt ?? 'occurred_at';\n    return toCamel(snake);\n  }\n\n  /**\n   * camelCase key for the subject FK column, resolved from `patternConfig`:\n   * `subjectColumn` (explicit) → `<subject>_id` (derived). Throws when neither\n   * is configured — the subject finders are unusable without it, and a clear\n   * error beats a silent `undefined` column index.\n   */\n  protected get subjectColumn(): string {\n    const explicit = this.patternConfig?.subjectColumn;\n    if (explicit) return toCamel(explicit);\n    const subject = this.patternConfig?.subject;\n    if (subject) return toCamel(`${subject}_id`);\n    throw new Error(\n      'ActivityEntityRepository: subject finders require a subject column. ' +\n        \"Set `config: { Activity: { subject: '<entity>' } }` (→ <entity>_id) \" +\n        \"or `config: { Activity: { subjectColumn: '<column>' } }` on the entity YAML.\",\n    );\n  }\n\n  /**\n   * Find activities within a date range (inclusive), by the recency column.\n   */\n  async findByDateRange(start: Date, end: Date): Promise<TEntity[]> {\n    const rows = await this.baseQuery()\n      .where(between(this.table[this.occurredAtColumn], start, end));\n    return rows as TEntity[];\n  }\n\n  /**\n   * Find all activities for a specific user (actor / owner scoping).\n   */\n  async findByUserId(userId: string): Promise<TEntity[]> {\n    const rows = await this.baseQuery()\n      .where(eq(this.table['userId'], userId));\n    return rows as TEntity[];\n  }\n\n  /**\n   * Find all activities for a specific subject (config-driven FK column).\n   */\n  async findBySubjectId(subjectId: string): Promise<TEntity[]> {\n    const rows = await this.baseQuery()\n      .where(eq(this.table[this.subjectColumn], subjectId));\n    return rows as TEntity[];\n  }\n\n  /**\n   * Find the most recent activities for a subject, ordered by the recency\n   * column descending.\n   */\n  async findRecentBySubjectId(subjectId: string, limit = 10): Promise<TEntity[]> {\n    const rows = await this.baseQuery()\n      .where(eq(this.table[this.subjectColumn], subjectId))\n      .orderBy(desc(this.table[this.occurredAtColumn]))\n      .limit(limit);\n    return rows as TEntity[];\n  }\n}\n"],"mappings":";;;;;AAeA,SAAS,IAAI,SAAS,YAAY;AAiBlC,IAAM,UAAU,CAAC,UACf,MAAM,QAAQ,gBAAgB,CAAC,GAAG,MAAc,EAAE,YAAY,CAAC;AAE1D,IAAe,2BAAf,cAAyD,eAAwB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMnE;AAAA;AAAA;AAAA;AAAA;AAAA,EAMnB,IAAc,mBAA2B;AACvC,UAAM,QAAQ,KAAK,eAAe,cAAc;AAChD,WAAO,QAAQ,KAAK;AAAA,EACtB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,IAAc,gBAAwB;AACpC,UAAM,WAAW,KAAK,eAAe;AACrC,QAAI,SAAU,QAAO,QAAQ,QAAQ;AACrC,UAAM,UAAU,KAAK,eAAe;AACpC,QAAI,QAAS,QAAO,QAAQ,GAAG,OAAO,KAAK;AAC3C,UAAM,IAAI;AAAA,MACR;AAAA,IAGF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,gBAAgB,OAAa,KAA+B;AAChE,UAAM,OAAO,MAAM,KAAK,UAAU,EAC/B,MAAM,QAAQ,KAAK,MAAM,KAAK,gBAAgB,GAAG,OAAO,GAAG,CAAC;AAC/D,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,aAAa,QAAoC;AACrD,UAAM,OAAO,MAAM,KAAK,UAAU,EAC/B,MAAM,GAAG,KAAK,MAAM,QAAQ,GAAG,MAAM,CAAC;AACzC,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,gBAAgB,WAAuC;AAC3D,UAAM,OAAO,MAAM,KAAK,UAAU,EAC/B,MAAM,GAAG,KAAK,MAAM,KAAK,aAAa,GAAG,SAAS,CAAC;AACtD,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,sBAAsB,WAAmB,QAAQ,IAAwB;AAC7E,UAAM,OAAO,MAAM,KAAK,UAAU,EAC/B,MAAM,GAAG,KAAK,MAAM,KAAK,aAAa,GAAG,SAAS,CAAC,EACnD,QAAQ,KAAK,KAAK,MAAM,KAAK,gBAAgB,CAAC,CAAC,EAC/C,MAAM,KAAK;AACd,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/{chunk-CRBVI4GE.js → chunk-PSDVGPQR.js}

@@ -9,22 +9,22 @@ import {
 } from "./chunk-EDKJU5BO.js";
 import {
   DrizzleBridgeDeliveryRepo
-} from "./chunk-K2I6XIK5.js";
+} from "./chunk-KSTZIULO.js";
 import {
   MemoryBridgeDeliveryRepo
 } from "./chunk-4DOJBQTP.js";
 import {
   BridgeOutboxDrainHook
-} from "./chunk-DLG62MQY.js";
+} from "./chunk-SFQRETXJ.js";
 import {
   BridgeDeliveryHandler
-} from "./chunk-NXNVTXKG.js";
+} from "./chunk-SGSWVNNB.js";
 import {
   BridgeReservedPoolsNotPolledError
 } from "./chunk-NXXDZ6ZF.js";
 import {
   JOB_WORKER_MODULE_OPTIONS
-} from "./chunk-AYC2HEAL.js";
+} from "./chunk-HPS554L4.js";
 import {
   BRIDGE_DELIVERY_REPO,
   BRIDGE_MODULE_OPTIONS,
@@ -119,4 +119,4 @@ BridgeModule = __decorateClass([
 export {
   BridgeModule
 };
-//# sourceMappingURL=chunk-CRBVI4GE.js.map
+//# sourceMappingURL=chunk-PSDVGPQR.js.map

package/dist/{chunk-DLG62MQY.js → chunk-SFQRETXJ.js}

@@ -1,22 +1,22 @@
 import {
   BRIDGE_DELIVERY_JOB_TYPE
-} from "./chunk-NXNVTXKG.js";
+} from "./chunk-SGSWVNNB.js";
 import {
   bridgeDelivery
 } from "./chunk-2TVVBC53.js";
-import {
-  jobRuns
-} from "./chunk-OKXZ63IA.js";
 import {
   JOBS_LISTEN_NOTIFY
 } from "./chunk-ZPL74UQN.js";
 import {
-  BRIDGE_REGISTRY
-} from "./chunk-4LH67P4U.js";
+  jobRuns
+} from "./chunk-OKXZ63IA.js";
 import {
   JOBS_WAKE_CHANNEL,
   pgNotify
 } from "./chunk-MYQIQ27N.js";
+import {
+  BRIDGE_REGISTRY
+} from "./chunk-4LH67P4U.js";
 import {
   __decorateClass,
   __decorateParam
@@ -151,4 +151,4 @@ BridgeOutboxDrainHook = __decorateClass([
 export {
   BridgeOutboxDrainHook
 };
-//# sourceMappingURL=chunk-DLG62MQY.js.map
+//# sourceMappingURL=chunk-SFQRETXJ.js.map

package/dist/{chunk-NXNVTXKG.js → chunk-SGSWVNNB.js}

@@ -1,13 +1,13 @@
 import {
   assertTenantId
 } from "./chunk-6DWFJNIK.js";
-import {
-  JobHandler,
-  JobHandlerBase
-} from "./chunk-CO6LUM72.js";
 import {
   JOB_ORCHESTRATOR
 } from "./chunk-ZPL74UQN.js";
+import {
+  JobHandler,
+  JobHandlerBase
+} from "./chunk-7P5ODGLA.js";
 import {
   BRIDGE_DELIVERY_REPO,
   BRIDGE_MULTI_TENANT,
@@ -118,4 +118,4 @@ export {
   BRIDGE_DELIVERY_JOB_TYPE,
   BridgeDeliveryHandler
 };
-//# sourceMappingURL=chunk-NXNVTXKG.js.map
+//# sourceMappingURL=chunk-SGSWVNNB.js.map

package/dist/{chunk-5LXOJGO2.js → chunk-VNBC3VXM.js}

@@ -1,19 +1,19 @@
+import {
+  MissingTenantIdError
+} from "./chunk-T4BIIU5E.js";
 import {
   clampLimit,
   decodeKeysetCursor,
   encodeKeysetCursor,
   toJobRunSummary
 } from "./chunk-L3LZWWSX.js";
-import {
-  jobRuns
-} from "./chunk-OKXZ63IA.js";
 import {
   JOBS_MULTI_TENANT,
   JOB_ORCHESTRATOR
 } from "./chunk-ZPL74UQN.js";
 import {
-  MissingTenantIdError
-} from "./chunk-T4BIIU5E.js";
+  jobRuns
+} from "./chunk-OKXZ63IA.js";
 import {
   DRIZZLE
 } from "./chunk-U64T4YZE.js";
@@ -198,4 +198,4 @@ DrizzleJobRunService = __decorateClass([
 export {
   DrizzleJobRunService
 };
-//# sourceMappingURL=chunk-5LXOJGO2.js.map
+//# sourceMappingURL=chunk-VNBC3VXM.js.map

package/dist/{job-orchestrator.protocol-DubMVbm9.d.ts → job-orchestrator.protocol-ZuJ3ow-O.d.ts}

@@ -36,12 +36,31 @@ interface RetryPolicy {
     baseMs: number;
     nonRetryableErrors?: string[];
 }
+/**
+ * Concurrency lane key (JOB-FN-KEY, 0.16.2).
+ *
+ * Two authoring forms, both honored end-to-end (the typed function form was
+ * previously dropped to `null` at registration — see `upsertJobRows` — so
+ * `collisionMode` silently never engaged):
+ *
+ *   - **`string`** — a `{{field}}` template evaluated against the start
+ *     payload by `evaluateKeyTemplate` (single-key substitution, no dotted
+ *     paths). Persisted verbatim to `job.concurrency_key_template`.
+ *   - **`(input) => string`** — an arbitrary function of the input. Persisted
+ *     as the `FN_KEY_SENTINEL` marker so the definition-hash gate stays stable
+ *     and the collision path engages; `start()` re-resolves the live function
+ *     from `JOB_HANDLER_REGISTRY` and evaluates it against the payload.
+ *
+ * Both forms produce a per-lane key; same key + in-flight incumbent ⇒
+ * `collisionMode` ('queue' | 'reject' | 'replace') decides.
+ */
+type JobKeySelector<TInput> = string | ((input: TInput) => string);
 interface ConcurrencyPolicy<TInput> {
-    key: (input: TInput) => string;
+    key: JobKeySelector<TInput>;
     collisionMode: 'queue' | 'reject' | 'replace';
 }
 interface DedupePolicy<TInput> {
-    key: (input: TInput) => string;
+    key: JobKeySelector<TInput>;
     windowMs: number;
 }
 /**
@@ -165,6 +184,61 @@ declare namespace HandlerRegistry {
     /** Lookup by job type, or `undefined` if no `@JobHandler` is registered. */
     function get(type: string): HandlerRegistryEntry | undefined;
 }
+/**
+ * Sentinel persisted to `job.concurrency_key_template` / `dedupe_key_template`
+ * when the authored `key` is a function rather than a `{{field}}` template.
+ *
+ * Why a sentinel (not `null`): the collision/dedupe paths in both backends gate
+ * on `definition.concurrencyKeyTemplate != null`. A function key persisted as
+ * `null` (the pre-0.16.2 bug) left those columns empty, so `collisionMode` /
+ * the dedupe window never engaged — the job ran with NO key. A stable sentinel
+ * keeps the column non-null (path engages) AND keeps the definition-hash gate
+ * (`upsertJobRows`' `IS DISTINCT FROM` clause) stable across boots, since the
+ * function identity itself can't be hashed. `start()` detects the sentinel and
+ * re-resolves the live function from `JOB_HANDLER_REGISTRY`.
+ *
+ * Chosen as an angle-bracketed token so it can never collide with a real
+ * `{{field}}` template (which never contains a literal `<`).
+ */
+declare const FN_KEY_SENTINEL = "<fn>";
+/**
+ * Registration-time projection: collapse an authored `JobKeySelector` to the
+ * string stored in the `job` definition row. A string template is stored
+ * verbatim; a function is stored as `FN_KEY_SENTINEL`; absence stays `null`.
+ */
+declare function keySelectorToTemplate(key: JobKeySelector<unknown> | undefined): string | null;
+/** Which meta policy a key belongs to — selects the live fn at `start()`. */
+type KeyKind = 'concurrency' | 'dedupe';
+/**
+ * `start()`-time resolution shared by every backend. Turns the persisted
+ * template column into the concrete per-run key for the given payload.
+ *
+ *   - `template == null` → `null` (no key; caller skips the collision/dedupe path).
+ *   - `template === FN_KEY_SENTINEL` → look the live `@JobHandler` meta up in
+ *     `JOB_HANDLER_REGISTRY`, pull `meta[kind].key`, and invoke it against the
+ *     payload. The registry is the runtime source of truth (the worker already
+ *     resolves handler classes the same way), so the function survives the DB
+ *     round-trip even though it can't be persisted.
+ *   - otherwise → a `{{field}}` template, evaluated via the injected
+ *     `evaluateTemplate` (each backend passes its own copy to avoid a runtime
+ *     import cycle).
+ *
+ * Throws `JobKeyFunctionUnavailableError` if the sentinel is present but no
+ * live function can be found (e.g. the registry was reset, or a function key
+ * was persisted by a newer build and read by an older one). Failing loud beats
+ * silently degrading to no-key — the exact regression this fix exists to kill.
+ */
+declare function resolveJobKey(kind: KeyKind, type: string, template: string | null, payload: Record<string, unknown>, evaluateTemplate: (template: string, payload: Record<string, unknown>) => string): string | null;
+/**
+ * Raised when a `${FN_KEY_SENTINEL}` template is read but the live function
+ * key is missing from `JOB_HANDLER_REGISTRY`. Kept here (not in `jobs-errors`)
+ * so `job-handler.base` stays import-cycle-free.
+ */
+declare class JobKeyFunctionUnavailableError extends Error {
+    readonly jobType: string;
+    readonly kind: KeyKind;
+    constructor(jobType: string, kind: KeyKind);
+}
 
 /**
  * Public return type for orchestrator reads. Re-exported as `JobRun` so
@@ -310,4 +384,4 @@ interface IJobOrchestrator {
     }>;
 }
 
-export { type CancelOptions as C, type DedupePolicy as D, HandlerRegistry as H, type IJobOrchestrator as I, JOB_HANDLER_METADATA_KEY as J, ParentClosePolicy as P, type RetryPolicy as R, type ScopeRef as S, type ConcurrencyPolicy as a, type HandlerRegistryEntry as b, JOB_HANDLER_REGISTRY as c, type JobContext as d, JobHandler as e, JobHandlerBase as f, type JobHandlerMeta as g, type JobPoolDef as h, type JobRun as i, type JobUpsertEntry as j, type SpawnChildOptions as k, type StartOptions as l, type StepOptions as m, type JobTrigger as n };
+export { type CancelOptions as C, type DedupePolicy as D, FN_KEY_SENTINEL as F, HandlerRegistry as H, type IJobOrchestrator as I, JOB_HANDLER_METADATA_KEY as J, type KeyKind as K, ParentClosePolicy as P, type RetryPolicy as R, type ScopeRef as S, type ConcurrencyPolicy as a, type HandlerRegistryEntry as b, JOB_HANDLER_REGISTRY as c, type JobContext as d, JobHandler as e, JobHandlerBase as f, type JobHandlerMeta as g, type JobPoolDef as h, type JobRun as i, type JobUpsertEntry as j, type SpawnChildOptions as k, type StartOptions as l, type StepOptions as m, JobKeyFunctionUnavailableError as n, type JobKeySelector as o, type JobTrigger as p, keySelectorToTemplate as q, resolveJobKey as r };

package/dist/runtime/base-classes/activity-entity-repository.d.ts

@@ -4,23 +4,55 @@ import 'drizzle-orm';
 import '../types/drizzle.js';
 import 'drizzle-orm/node-postgres';
 
+/**
+ * Per-entity Activity config (matches `ActivityPatternConfigSchema` in
+ * `src/patterns/library/activity.pattern.ts`). Carried on the concrete repo as
+ * `patternConfig` and read here to resolve column names at runtime.
+ */
+interface ActivityPatternConfig {
+    /** Subject entity name → derives the FK column `<subject>_id`. */
+    subject?: string;
+    /** Explicit snake_case FK column, when it does not follow `<subject>_id`. */
+    subjectColumn?: string;
+    /** snake_case recency-ordering column; defaults to `occurred_at`. */
+    occurredAt?: string;
+}
 declare abstract class ActivityEntityRepository<TEntity> extends BaseRepository<TEntity> {
     /**
-     * Find activities within a date range (inclusive).
+     * Per-entity Activity config. The template emits this from `config:
+     * { Activity: {...} }`; entities that only use date-range / user scoping omit
+     * it (and must not call the subject finders).
+     */
+    protected readonly patternConfig?: ActivityPatternConfig;
+    /**
+     * camelCase key for the recency-ordering column. Defaults to `occurredAt`
+     * (column `occurred_at`); override via `patternConfig.occurredAt`.
+     */
+    protected get occurredAtColumn(): string;
+    /**
+     * camelCase key for the subject FK column, resolved from `patternConfig`:
+     * `subjectColumn` (explicit) → `<subject>_id` (derived). Throws when neither
+     * is configured — the subject finders are unusable without it, and a clear
+     * error beats a silent `undefined` column index.
+     */
+    protected get subjectColumn(): string;
+    /**
+     * Find activities within a date range (inclusive), by the recency column.
      */
     findByDateRange(start: Date, end: Date): Promise<TEntity[]>;
     /**
-     * Find all activities for a specific user.
+     * Find all activities for a specific user (actor / owner scoping).
      */
     findByUserId(userId: string): Promise<TEntity[]>;
     /**
-     * Find all activities for a specific opportunity.
+     * Find all activities for a specific subject (config-driven FK column).
      */
-    findByOpportunityId(opportunityId: string): Promise<TEntity[]>;
+    findBySubjectId(subjectId: string): Promise<TEntity[]>;
     /**
-     * Find the most recent activities for an opportunity, ordered by occurredAt desc.
+     * Find the most recent activities for a subject, ordered by the recency
+     * column descending.
      */
-    findRecentByOpportunityId(opportunityId: string, limit?: number): Promise<TEntity[]>;
+    findRecentBySubjectId(subjectId: string, limit?: number): Promise<TEntity[]>;
 }
 
-export { ActivityEntityRepository };
+export { ActivityEntityRepository, type ActivityPatternConfig };

package/dist/runtime/base-classes/activity-entity-repository.js

@@ -1,6 +1,6 @@
 import {
   ActivityEntityRepository
-} from "../../chunk-XCEI7NUH.js";
+} from "../../chunk-MKWQKKK7.js";
 import "../../chunk-J6KZS54B.js";
 import "../../chunk-ZUKFQL6E.js";
 import "../../chunk-2E224ZSN.js";

package/dist/runtime/base-classes/activity-entity-service.d.ts

@@ -6,16 +6,18 @@ import 'drizzle-orm/node-postgres';
 /**
  * ActivityEntityService<TRepo, TEntity>
  *
- * Family-specific base service for activity entities.
- * Delegates to an activity repository that provides date-range,
- * user, and opportunity queries.
+ * Family-specific base service for activity / interaction entities. Delegates
+ * to an activity repository that provides date-range, actor (`user_id`), and
+ * config-driven subject queries. The subject FK column is resolved inside the
+ * repository from its `patternConfig` (ADR-031 §4) — the service is
+ * subject-name-agnostic. See ACTIVITY-SUBJECT-1.
  */
 
 interface IActivityEntityRepository<TEntity> extends IBaseRepository<TEntity> {
     findByDateRange(start: Date, end: Date): Promise<TEntity[]>;
     findByUserId(userId: string): Promise<TEntity[]>;
-    findByOpportunityId(opportunityId: string): Promise<TEntity[]>;
-    findRecentByOpportunityId(opportunityId: string, limit?: number): Promise<TEntity[]>;
+    findBySubjectId(subjectId: string): Promise<TEntity[]>;
+    findRecentBySubjectId(subjectId: string, limit?: number): Promise<TEntity[]>;
 }
 declare abstract class ActivityEntityService<TRepo extends IActivityEntityRepository<TEntity>, TEntity> extends BaseService<TRepo, TEntity> {
     /**
@@ -23,17 +25,17 @@ declare abstract class ActivityEntityService<TRepo extends IActivityEntityReposi
      */
     findByDateRange(start: Date, end: Date): Promise<TEntity[]>;
     /**
-     * Find all activities for a specific user.
+     * Find all activities for a specific user (actor / owner scoping).
      */
     findByUser(userId: string): Promise<TEntity[]>;
     /**
-     * Find all activities for a specific opportunity.
+     * Find all activities for a specific subject (config-driven FK column).
      */
-    findByOpportunity(opportunityId: string): Promise<TEntity[]>;
+    findBySubject(subjectId: string): Promise<TEntity[]>;
     /**
-     * Find the most recent activities for an opportunity.
+     * Find the most recent activities for a subject.
      */
-    findRecent(opportunityId: string, limit?: number): Promise<TEntity[]>;
+    findRecent(subjectId: string, limit?: number): Promise<TEntity[]>;
 }
 
 export { ActivityEntityService, type IActivityEntityRepository };

package/dist/runtime/base-classes/activity-entity-service.js

@@ -1,6 +1,6 @@
 import {
   ActivityEntityService
-} from "../../chunk-BOPZWRJK.js";
+} from "../../chunk-JYBFPNBJ.js";
 import "../../chunk-W72PRNJY.js";
 import "../../chunk-KYR3B3OW.js";
 import "../../chunk-2E224ZSN.js";