@pattern-stack/codegen 0.8.1 → 0.9.0

package/runtime/subsystems/jobs/jobs-domain.module.ts

@@ -24,10 +24,17 @@ import {
 import { DrizzleJobOrchestrator } from './job-orchestrator.drizzle-backend';
 import { DrizzleJobRunService } from './job-run-service.drizzle-backend';
 import { DrizzleJobStepService } from './job-step-service.drizzle-backend';
+import { BullMQJobOrchestrator } from './job-orchestrator.bullmq-backend';
 import { MemoryJobOrchestrator } from './job-orchestrator.memory-backend';
 import { MemoryJobRunService } from './job-run-service.memory-backend';
 import { MemoryJobStepService } from './job-step-service.memory-backend';
 import { MemoryJobStore } from './memory-job-store';
+import {
+  BULLMQ_CONNECTION,
+  BULLMQ_RESOLVED_CONFIG,
+  resolveBullMqConfig,
+  type BullMqExtensionsConfig,
+} from './bullmq.config';
 
 /**
  * Drizzle backend extensions surface. None are wired into the Drizzle
@@ -44,19 +51,8 @@ export interface DrizzleBackendExtensions {
   pollIntervalMs?: number;
 }
 
-// Phase 6+ — typed-but-unimplemented BullMQ extension slot. Kept as a
-// commented-out interface to make the future shape discoverable without
-// shipping dead runtime code. Per CLAUDE.md "no feature-flag-guarded dead
-// code" we don't ship the option in `JobsDomainModuleOptions.extensions`
-// either; flip it on when JOB-Phase-6 lands the BullMQ orchestrator.
-//
-// export interface BullMqBackendExtensions {
-//   bullBoard?: { enabled: boolean; mountPath?: string };
-//   redisUrl?: string;
-// }
-
 export interface JobsDomainModuleOptions {
-  backend: 'drizzle' | 'memory';
+  backend: 'drizzle' | 'memory' | 'bullmq';
   /**
    * Backend-specific extensions. Only the matching backend's extensions
    * are read at boot; non-matching keys are ignored. This is the
@@ -64,7 +60,12 @@ export interface JobsDomainModuleOptions {
    */
   extensions?: {
     drizzle?: DrizzleBackendExtensions;
-    // bullmq?: BullMqBackendExtensions;   // Phase 6+
+    /**
+     * BullMQ backend extensions (BULLMQ-1). Snake_case mirrors the YAML
+     * under `jobs.extensions.bullmq`. `redis_url` falls back to
+     * `process.env.REDIS_URL` then `redis://localhost:6379`.
+     */
+    bullmq?: BullMqExtensionsConfig;
   };
   /** Multi-tenancy opt-in. Wired by JOB-8; module signature stays stable. */
   multiTenant?: boolean;
@@ -73,8 +74,6 @@ export interface JobsDomainModuleOptions {
 @Module({})
 export class JobsDomainModule {
   static forRoot(opts: JobsDomainModuleOptions): DynamicModule {
-    void opts.extensions; // typed reservation; consumed by Phase 6+ wiring
-
     const multiTenant = opts.multiTenant ?? false;
 
     const providers: Provider[] = [
@@ -98,22 +97,42 @@ export class JobsDomainModule {
       providers.push({ provide: JOB_ORCHESTRATOR, useExisting: MemoryJobOrchestrator });
       providers.push(MemoryJobRunService);
       providers.push({ provide: JOB_RUN_SERVICE, useExisting: MemoryJobRunService });
+    } else if (opts.backend === 'bullmq') {
+      // BULLMQ-1 — BullMQ orchestrator over a Postgres source of truth. The
+      // run/step services stay Drizzle (domain reads + `listForScope` are
+      // Postgres queries, unchanged per spec). Only the orchestrator's
+      // claim/dispatch half swaps to BullMQ.
+      const resolved = resolveBullMqConfig(opts.extensions?.bullmq);
+      providers.push({ provide: BULLMQ_CONNECTION, useValue: resolved.connection });
+      providers.push({ provide: BULLMQ_RESOLVED_CONFIG, useValue: resolved });
+      providers.push({ provide: JOB_ORCHESTRATOR, useClass: BullMQJobOrchestrator });
+      providers.push({ provide: JOB_RUN_SERVICE, useClass: DrizzleJobRunService });
+      providers.push({ provide: JOB_STEP_SERVICE, useClass: DrizzleJobStepService });
     } else {
       providers.push({ provide: JOB_ORCHESTRATOR, useClass: DrizzleJobOrchestrator });
       providers.push({ provide: JOB_RUN_SERVICE, useClass: DrizzleJobRunService });
       providers.push({ provide: JOB_STEP_SERVICE, useClass: DrizzleJobStepService });
     }
 
+    const exports = [
+      JOB_ORCHESTRATOR,
+      JOB_RUN_SERVICE,
+      JOB_STEP_SERVICE,
+      JOBS_MULTI_TENANT,
+    ];
+    // BULLMQ-1 — only export the BullMQ tokens when they were actually
+    // provided. Nest throws "exported but not provided" otherwise. Exported so
+    // JobWorkerModule (which imports this module) can read the resolved
+    // connection/config to spawn BullMQ workers.
+    if (opts.backend === 'bullmq') {
+      exports.push(BULLMQ_CONNECTION, BULLMQ_RESOLVED_CONFIG);
+    }
+
     return {
       module: JobsDomainModule,
       global: true,
       providers,
-      exports: [
-        JOB_ORCHESTRATOR,
-        JOB_RUN_SERVICE,
-        JOB_STEP_SERVICE,
-        JOBS_MULTI_TENANT,
-      ],
+      exports,
     };
   }
 }

package/runtime/subsystems/jobs/pool-config.loader.ts

@@ -194,6 +194,17 @@ export function allNonReservedPoolNames(config: PoolConfig): string[] {
   return out;
 }
 
+/**
+ * Names of **every** pool in the resolved config, reserved `events_*` lanes
+ * included. The activation set for a standalone worker booted with
+ * `JobWorkerModule.forRoot({ allPools: true })` (BULLMQ-1 Phase 1) — the
+ * single worker process drains both user pools and the bridge's reserved
+ * pools so wrapper `job_run` rows are never stranded.
+ */
+export function allPoolNames(config: PoolConfig): string[] {
+  return [...config.keys()];
+}
+
 // ─── internals ──────────────────────────────────────────────────────────────
 
 interface UserPoolShape {

package/runtime/subsystems/observability/index.ts

@@ -30,6 +30,14 @@ export type {
   IObservability,
   PoolStatusCount,
   JobRunFailure,
+  JobRunSummary,
+  JobRunPage,
+  ListJobRunsQuery,
+  EventSummary,
+  EventPage,
+  ListEventsQuery,
+  CorrelationTimeline,
+  CorrelationTimelineEntry,
   StatusHistogram,
   SyncRunSummary,
   CursorSnapshot,

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

@@ -21,12 +21,49 @@
 
 import type {
   JobRunFailure,
+  JobRunPage,
+  JobRunSummary,
+  ListJobRunsQuery,
   PoolStatusCount,
 } from '../jobs/job-run-service.protocol';
+import type {
+  EventPage,
+  EventSummary,
+  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';
 
+/**
+ * One chronological entry in a correlation timeline (OBS-LIST-1). Either a
+ * `job_run` or a `domain_event` sharing the same `rootRunId`, tagged with a
+ * `kind` discriminator and a single `at` timestamp used for ordering.
+ */
+export type CorrelationTimelineEntry =
+  | { kind: 'job_run'; at: Date; run: JobRunSummary }
+  | { kind: 'event'; at: Date; event: EventSummary };
+
+/**
+ * Stitched view of everything correlated to a single `rootRunId`
+ * (OBS-LIST-1): the job runs sharing that root plus the domain events whose
+ * `metadata.rootRunId` matches, merged into one ascending timeline with a
+ * small roll-up summary.
+ */
+export interface CorrelationTimeline {
+  rootRunId: string;
+  /** Ascending by `at`. Job runs ordered by `createdAt`; events by `occurredAt`. */
+  entries: CorrelationTimelineEntry[];
+  summary: {
+    runCount: number;
+    eventCount: number;
+    /** Earliest `at` across all entries, or `null` when empty. */
+    startedAt: Date | null;
+    /** Latest `at` across all entries, or `null` when empty. */
+    lastActivityAt: Date | null;
+  };
+}
+
 export interface IObservability {
   /**
    * Live `(pool, status)` counts across `job_run`. Delegates to
@@ -79,6 +116,39 @@ export interface IObservability {
    * Empty array when the sync subsystem is not installed.
    */
   getCursors(tenantId?: string | null): Promise<CursorSnapshot[]>;
+
+  /**
+   * Paginated, filterable `job_run` list (OBS-LIST-1). Delegates to
+   * `IJobRunService.listJobRuns`. Keyset pagination on `created_at`.
+   *
+   * Returns an empty page (`{ items: [], nextCursor: null }`) when the jobs
+   * subsystem is not installed.
+   */
+  listJobRuns(query?: ListJobRunsQuery): Promise<JobRunPage>;
+
+  /**
+   * Paginated, filterable `domain_events` list (OBS-LIST-1). Delegates to
+   * `IEventReadPort.listEvents`. Keyset pagination on `occurred_at`.
+   *
+   * Returns an empty page when the events read port is not installed (e.g.
+   * the events subsystem is absent, or its backend is `redis` which retains
+   * no history).
+   */
+  listEvents(query?: ListEventsQuery): Promise<EventPage>;
+
+  /**
+   * Stitch the job runs and domain events sharing a `rootRunId` into a
+   * single ascending timeline + summary (OBS-LIST-1). Composes
+   * `IJobRunService.listJobRuns` (filtered by the run tree) and
+   * `IEventReadPort.listEvents({ rootRunId })`.
+   *
+   * Returns an empty timeline (zero counts, null bounds) when neither the
+   * jobs subsystem nor the events read port is installed.
+   */
+  getCorrelationTimeline(
+    rootRunId: string,
+    tenantId?: string | null,
+  ): Promise<CorrelationTimeline>;
 }
 
 // Re-export composed return types so consumers of IObservability can import
@@ -86,6 +156,12 @@ export interface IObservability {
 export type {
   PoolStatusCount,
   JobRunFailure,
+  JobRunSummary,
+  JobRunPage,
+  ListJobRunsQuery,
+  EventSummary,
+  EventPage,
+  ListEventsQuery,
   StatusHistogram,
   SyncRunSummary,
   CursorSnapshot,

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

@@ -33,9 +33,20 @@ import { JOB_RUN_SERVICE } from '../jobs/jobs-domain.tokens';
 import type {
   IJobRunService,
   JobRunFailure,
+  JobRunPage,
+  JobRunSummary,
+  ListJobRunsQuery,
   PoolStatusCount,
 } from '../jobs/job-run-service.protocol';
 
+import { EVENT_READ_PORT } from '../events/events.tokens';
+import type {
+  EventPage,
+  EventSummary,
+  IEventReadPort,
+  ListEventsQuery,
+} from '../events/event-read.protocol';
+
 import { BRIDGE_DELIVERY_REPO } from '../bridge/bridge.tokens';
 import type { IJobBridge, StatusHistogram } from '../bridge/bridge.protocol';
 
@@ -49,7 +60,19 @@ import type {
   ICursorStore,
 } from '../sync/sync-cursor-store.protocol';
 
-import type { IObservability } from './observability.protocol';
+import type {
+  CorrelationTimeline,
+  CorrelationTimelineEntry,
+  IObservability,
+} from './observability.protocol';
+
+/**
+ * Safety bound on how many pages the correlation timeline will walk when
+ * draining a sibling port. A single run tree producing more than
+ * 50 pages × default page size of correlated rows is pathological; cap to
+ * keep the stitch bounded rather than unbounded-loop on bad data.
+ */
+const MAX_TIMELINE_PAGES = 50;
 
 @Injectable()
 export class ObservabilityService implements IObservability {
@@ -65,6 +88,16 @@ export class ObservabilityService implements IObservability {
     failed: 0,
   };
 
+  /** Empty page used when a sibling read port is absent. */
+  private static readonly EMPTY_JOB_RUN_PAGE: JobRunPage = {
+    items: [],
+    nextCursor: null,
+  };
+  private static readonly EMPTY_EVENT_PAGE: EventPage = {
+    items: [],
+    nextCursor: null,
+  };
+
   constructor(
     @Optional()
     @Inject(JOB_RUN_SERVICE)
@@ -78,6 +111,9 @@ export class ObservabilityService implements IObservability {
     @Optional()
     @Inject(SYNC_CURSOR_STORE)
     private readonly cursors?: ICursorStore,
+    @Optional()
+    @Inject(EVENT_READ_PORT)
+    private readonly events?: IEventReadPort | null,
   ) {}
 
   async getPoolDepths(tenantId?: string | null): Promise<PoolStatusCount[]> {
@@ -114,4 +150,115 @@ export class ObservabilityService implements IObservability {
     if (!this.cursors) return [];
     return this.cursors.listAll(tenantId);
   }
+
+  async listJobRuns(query?: ListJobRunsQuery): Promise<JobRunPage> {
+    if (!this.jobRuns) {
+      return { ...ObservabilityService.EMPTY_JOB_RUN_PAGE };
+    }
+    return this.jobRuns.listJobRuns(query);
+  }
+
+  async listEvents(query?: ListEventsQuery): Promise<EventPage> {
+    if (!this.events) {
+      return { ...ObservabilityService.EMPTY_EVENT_PAGE };
+    }
+    return this.events.listEvents(query);
+  }
+
+  async getCorrelationTimeline(
+    rootRunId: string,
+    tenantId?: string | null,
+  ): Promise<CorrelationTimeline> {
+    const runs = await this.collectRuns(rootRunId, tenantId);
+    const events = await this.collectEvents(rootRunId, tenantId);
+
+    const entries: CorrelationTimelineEntry[] = [
+      ...runs.map(
+        (run): CorrelationTimelineEntry => ({
+          kind: 'job_run',
+          at: run.createdAt,
+          run,
+        }),
+      ),
+      ...events.map(
+        (event): CorrelationTimelineEntry => ({
+          kind: 'event',
+          at: event.occurredAt,
+          event,
+        }),
+      ),
+    ];
+
+    // Ascending chronological order. Stable tie-break: job runs before
+    // events at the same instant (the run that emits an event precedes it).
+    entries.sort((a, b) => {
+      const dt = a.at.getTime() - b.at.getTime();
+      if (dt !== 0) return dt;
+      if (a.kind === b.kind) return 0;
+      return a.kind === 'job_run' ? -1 : 1;
+    });
+
+    const startedAt = entries.length > 0 ? entries[0]!.at : null;
+    const lastActivityAt =
+      entries.length > 0 ? entries[entries.length - 1]!.at : null;
+
+    return {
+      rootRunId,
+      entries,
+      summary: {
+        runCount: runs.length,
+        eventCount: events.length,
+        startedAt,
+        lastActivityAt,
+      },
+    };
+  }
+
+  /**
+   * Drain every `job_run` sharing `rootRunId` by walking the keyset cursor.
+   * Empty when the jobs subsystem is absent.
+   */
+  private async collectRuns(
+    rootRunId: string,
+    tenantId?: string | null,
+  ): Promise<JobRunSummary[]> {
+    if (!this.jobRuns) return [];
+    const out: JobRunSummary[] = [];
+    let cursor: string | undefined;
+    for (let page = 0; page < MAX_TIMELINE_PAGES; page += 1) {
+      const result = await this.jobRuns.listJobRuns({
+        rootRunId,
+        tenantId,
+        cursor,
+      });
+      out.push(...result.items);
+      if (!result.nextCursor) break;
+      cursor = result.nextCursor;
+    }
+    return out;
+  }
+
+  /**
+   * Drain every `domain_event` whose `metadata.rootRunId` matches by walking
+   * the keyset cursor. Empty when the events read port is absent.
+   */
+  private async collectEvents(
+    rootRunId: string,
+    tenantId?: string | null,
+  ): Promise<EventSummary[]> {
+    if (!this.events) return [];
+    const out: EventSummary[] = [];
+    let cursor: string | undefined;
+    for (let page = 0; page < MAX_TIMELINE_PAGES; page += 1) {
+      const result = await this.events.listEvents({
+        rootRunId,
+        tenantId,
+        cursor,
+      });
+      out.push(...result.items);
+      if (!result.nextCursor) break;
+      cursor = result.nextCursor;
+    }
+    return out;
+  }
 }

package/templates/entity/new/clean-lite-ps/prompt-extension.js

@@ -495,28 +495,30 @@ function collectDrizzleImports(processedFields, belongsTo, hasTimestamps, hasSof
 function zodChainForCreate(field) {
   const { type, nullable, required, hasDefault, hasChoices, choices } = field;
 
+  // Apply nullability and optionality INDEPENDENTLY. A nullable column accepts
+  // null (`.nullable()`); a field without `required: true` may be omitted from
+  // the create payload (`.optional()`). A field that is both gets
+  // `.nullable().optional()`. Previously the `nullable` branch returned early,
+  // so a nullable-and-optional field never got `.optional()` — forcing callers
+  // to send an explicit `null` for every optional column (e.g. POST /accounts
+  // rejecting a body that omits `domain`/`industry`).
   if (hasChoices) {
-    const base = `z.enum([${choices.map((c) => `'${c}'`).join(', ')}])`;
-    if (!required && !nullable) return base + '.optional()';
-    if (nullable) return base + '.nullable()';
+    let base = `z.enum([${choices.map((c) => `'${c}'`).join(', ')}])`;
+    if (nullable) base += '.nullable()';
+    if (!required) base += '.optional()';
     return base;
   }
 
   let base = ZOD_TYPE_MAP[type] || 'z.unknown()';
 
   if (type === 'boolean' && hasDefault) {
+    // `.default()` already makes the input optional in Zod.
     base += `.default(${field.default ?? false})`;
     return base;
   }
 
-  if (nullable) {
-    return base + '.nullable()';
-  }
-
-  if (!required) {
-    return base + '.optional()';
-  }
-
+  if (nullable) base += '.nullable()';
+  if (!required) base += '.optional()';
   return base;
 }
 
@@ -1132,7 +1134,7 @@ export function buildCleanLitePsLocals(definition, baseLocals) {
   // FK fields from belongs_to for create/output DTOs
   const belongsToFkFields = belongsTo.map((rel) => ({
     camelName: rel.camelField,
-    zodChainCreate: rel.nullable ? 'z.string().uuid().nullable()' : 'z.string().uuid()',
+    zodChainCreate: rel.nullable ? 'z.string().uuid().nullable().optional()' : 'z.string().uuid()',
     zodChainOutput: rel.nullable ? 'z.string().uuid().nullable()' : 'z.string().uuid()',
     nullable: rel.nullable,
   }));

package/templates/relationship/new/prompt.js

@@ -203,10 +203,13 @@ function processFields(fields) {
 function zodChainForCreate(field) {
   const { type, nullable, required, hasDefault, hasChoices, choices } = field;
 
+  // Nullability and optionality are independent — see the clean-lite-ps copy of
+  // this function for the rationale (nullable-and-optional fields must get both
+  // `.nullable()` and `.optional()`, not just `.nullable()`).
   if (hasChoices) {
-    const base = `z.enum([${choices.map((c) => `'${c}'`).join(", ")}])`;
-    if (!required && !nullable) return base + ".optional()";
-    if (nullable) return base + ".nullable()";
+    let base = `z.enum([${choices.map((c) => `'${c}'`).join(", ")}])`;
+    if (nullable) base += ".nullable()";
+    if (!required) base += ".optional()";
     return base;
   }
 
@@ -215,8 +218,8 @@ function zodChainForCreate(field) {
     base += `.default(${field.default ?? false})`;
     return base;
   }
-  if (nullable) return base + ".nullable()";
-  if (!required) return base + ".optional()";
+  if (nullable) base += ".nullable()";
+  if (!required) base += ".optional()";
   return base;
 }
 

package/templates/subsystem/jobs/worker.ejs.t

@@ -5,13 +5,30 @@ unless_exists: true
 /**
  * Standalone job worker entrypoint — emitted by `codegen subsystem install jobs`.
  *
- * Boots a Nest application context (NO HTTP listener) wiring the jobs domain
- * module plus JobWorkerModule in `standalone` mode. Run with:
+ * Boots a Nest application context (NO HTTP listener) wiring the full
+ * subsystem barrel (`SUBSYSTEM_MODULES` — events + jobs + bridge + sync, in
+ * dependency order) plus `JobWorkerModule.forRoot({ mode: 'standalone',
+ * allPools: true })`. Run with:
  *
  *   bun worker.ts
  *
+ * Why the barrel + `allPools`:
+ *   - The events subsystem's outbox drain and the bridge's fanout wrappers
+ *     run as `job_run` rows in the RESERVED `events_*` pools. A worker that
+ *     only polls the non-reserved pools (`interactive`, `batch`, …) leaves
+ *     those lanes stranded — `BridgeDeliveryHandler` never fires and durable
+ *     event→job fanout silently stops.
+ *   - `allPools: true` activates every pool in the resolved config, reserved
+ *     lanes included, so this single standalone process drains both user work
+ *     and the framework's reserved lanes.
+ *   - Importing `SUBSYSTEM_MODULES` (rather than `JobsDomainModule` alone)
+ *     registers `EVENT_BUS` / `JOB_ORCHESTRATOR` / `BRIDGE_*` so the
+ *     framework `@framework/bridge_delivery` handler resolves its DI deps.
+ *     `BridgeModule`'s reserved-pool guard short-circuits to pass because
+ *     `allPools` is set.
+ *
  * Embedded mode (single-process) is configured by importing
- * JobWorkerModule.forRoot({ mode: 'embedded' }) inside AppModule instead —
+ * `JobWorkerModule.forRoot({ mode: 'embedded' })` inside AppModule instead —
  * see the commented guidance injected into `src/main.ts`.
  *
  * SIGTERM triggers graceful shutdown bounded by SHUTDOWN_TIMEOUT_MS; after the
@@ -23,16 +40,22 @@ import { Logger, Module } from '@nestjs/common';
 import { NestFactory } from '@nestjs/core';
 
 import { DatabaseModule } from '@shared/database/database.module';
-import { JobsDomainModule } from '@shared/subsystems/jobs/jobs-domain.module';
 import { JobWorkerModule } from '@shared/subsystems/jobs/job-worker.module';
+import { SUBSYSTEM_MODULES } from '@generated/subsystems';
 
 const SHUTDOWN_TIMEOUT_MS = 30_000;
 
 @Module({
   imports: [
     DatabaseModule,
-    JobsDomainModule.forRoot({ backend: 'drizzle' }),
-    JobWorkerModule.forRoot({ mode: 'standalone' }),
+    // Events + Jobs + Bridge + Sync (dependency-ordered) from the generated
+    // barrel. This is the same composition AppModule imports — keeping the
+    // worker's DI graph identical to the HTTP app's so handlers resolve the
+    // same way in both processes.
+    ...SUBSYSTEM_MODULES,
+    // `allPools: true` drains the reserved `events_*` lanes (events outbox +
+    // bridge wrappers) alongside the user pools.
+    JobWorkerModule.forRoot({ mode: 'standalone', allPools: true }),
   ],
 })
 class WorkerAppModule {}
@@ -72,7 +95,7 @@ async function bootstrap(): Promise<void> {
     void shutdown('SIGINT');
   });
 
-  logger.log('job worker started (standalone mode)');
+  logger.log('job worker started (standalone mode, all pools)');
 }
 
 bootstrap().catch((err) => {

package/templates/subsystem/sync/sync-audit.schema.ejs.t

@@ -19,14 +19,16 @@ force: true
  *       is owned by the sync subsystem's runtime protocol
  *       (`sync-field-diff.protocol.ts` from SYNC-2).
  *
- * ## `tenant_id` columns — scaffold-time conditional
+ * ## `tenant_id` columns — always emitted
  *
- * When `sync.multi_tenant: true` in `codegen.config.yaml`, this schema
- * emits `tenant_id` as a nullable text column on all three tables. The
- * `SYNC_MULTI_TENANT` DI flag (SYNC-6) enforces non-null at runtime
- * across the orchestrator + Drizzle backends. Enabling post-install
- * requires reinstalling this subsystem (`subsystem install sync --force
- * --force-config`) plus an Atlas migration.
+ * `tenant_id` is emitted as a nullable text column on all three tables
+ * REGARDLESS of `sync.multi_tenant` — the runtime sync code (cursor store +
+ * run recorder) references `tenant_id` unconditionally, so a `multi_tenant:
+ * false` consumer that omitted the column failed to type-check (the column
+ * was referenced but absent). The `SYNC_MULTI_TENANT` DI flag (SYNC-6) gates
+ * non-null *enforcement* at runtime; it does not gate the column's existence
+ * (mirrors the jobs subsystem). Under `multi_tenant: false` the column simply
+ * stays null.
  *
  * See SYNC-1 / SYNC-6 in epic #60 for the decision rationale.
  */
@@ -98,9 +100,7 @@ export const syncSubscriptions = pgTable(
     config: jsonb('config').notNull().default({}).$type<Record<string, unknown>>(),
     cursor: jsonb('cursor').$type<unknown>(),
     lastSyncAt: timestamp('last_sync_at', { withTimezone: true }),
-<% if (multiTenant) { -%>
-    tenantId: text('tenant_id'),                // scaffold-time conditional — see sync.multi_tenant
-<% } -%>
+    tenantId: text('tenant_id'),                // always emitted — the runtime sync code (cursor store + run recorder) references tenant_id unconditionally; SYNC_MULTI_TENANT gates enforcement, not the column's existence (mirrors jobs)
     createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
     updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
   },
@@ -141,9 +141,7 @@ export const syncRuns = pgTable(
       .notNull()
       .defaultNow(),
     completedAt: timestamp('completed_at', { withTimezone: true }),
-<% if (multiTenant) { -%>
-    tenantId: text('tenant_id'),                // scaffold-time conditional — see sync.multi_tenant
-<% } -%>
+    tenantId: text('tenant_id'),                // always emitted — the runtime sync code (cursor store + run recorder) references tenant_id unconditionally; SYNC_MULTI_TENANT gates enforcement, not the column's existence (mirrors jobs)
   },
   (t) => ({
     idxSyncRunsSubscriptionStartedAt: index(
@@ -178,9 +176,7 @@ export const syncRunItems = pgTable(
     createdAt: timestamp('created_at', { withTimezone: true })
       .notNull()
       .defaultNow(),
-<% if (multiTenant) { -%>
-    tenantId: text('tenant_id'),                // scaffold-time conditional — see sync.multi_tenant
-<% } -%>
+    tenantId: text('tenant_id'),                // always emitted — the runtime sync code (cursor store + run recorder) references tenant_id unconditionally; SYNC_MULTI_TENANT gates enforcement, not the column's existence (mirrors jobs)
   },
   (t) => ({
     idxSyncRunItemsRunCreatedAt: index('idx_sync_run_items_run_created_at').on(