@pattern-stack/codegen 0.8.0 → 0.9.0

package/dist/runtime/subsystems/index.js

@@ -14,6 +14,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 
 // runtime/subsystems/events/events.tokens.ts
 var EVENT_BUS = "EVENT_BUS";
+var EVENT_READ_PORT = "EVENT_READ_PORT";
 var TYPED_EVENT_BUS = "TYPED_EVENT_BUS";
 var EVENTS_MULTI_TENANT = "EVENTS_MULTI_TENANT";
 var REDIS_URL = /* @__PURE__ */ Symbol("REDIS_URL");
@@ -247,7 +248,38 @@ var DRIZZLE = "DRIZZLE";
 
 // runtime/subsystems/events/event-bus.drizzle-backend.ts
 import { Injectable as Injectable2, Inject as Inject2, Logger, Optional } from "@nestjs/common";
-import { eq, and, inArray, asc } from "drizzle-orm";
+import { eq, and, inArray, asc, desc, gte, lt, or, sql as sql2 } from "drizzle-orm";
+
+// runtime/subsystems/events/event-keyset-cursor.ts
+var DEFAULT_EVENT_LIST_LIMIT = 50;
+var MAX_EVENT_LIST_LIMIT = 200;
+function clampEventLimit(limit) {
+  if (typeof limit !== "number" || !Number.isFinite(limit)) {
+    return DEFAULT_EVENT_LIST_LIMIT;
+  }
+  const floored = Math.floor(limit);
+  if (floored < 1) return 1;
+  if (floored > MAX_EVENT_LIST_LIMIT) return MAX_EVENT_LIST_LIMIT;
+  return floored;
+}
+function encodeEventCursor(keyset) {
+  const tuple = [keyset.occurredAt.toISOString(), keyset.id];
+  return Buffer.from(JSON.stringify(tuple), "utf8").toString("base64url");
+}
+function decodeEventCursor(cursor) {
+  try {
+    const json = Buffer.from(cursor, "base64url").toString("utf8");
+    const parsed = JSON.parse(json);
+    if (!Array.isArray(parsed) || parsed.length !== 2) return null;
+    const [iso, id] = parsed;
+    if (typeof iso !== "string" || typeof id !== "string") return null;
+    const occurredAt = new Date(iso);
+    if (Number.isNaN(occurredAt.getTime())) return null;
+    return { occurredAt, id };
+  } catch {
+    return null;
+  }
+}
 
 // runtime/subsystems/events/domain-events.schema.ts
 import {
@@ -352,6 +384,24 @@ function toInsertValues(event) {
     tenantId
   };
 }
+function toEventSummary(r) {
+  const metadata = r.metadata ?? void 0;
+  const rootRunId = metadata?.["rootRunId"];
+  return {
+    id: r.id,
+    type: r.type,
+    aggregateId: r.aggregateId,
+    aggregateType: r.aggregateType,
+    status: r.status,
+    pool: r.pool,
+    direction: r.direction,
+    tier: r.tier,
+    rootRunId: typeof rootRunId === "string" ? rootRunId : null,
+    tenantId: r.tenantId,
+    occurredAt: r.occurredAt instanceof Date ? r.occurredAt : new Date(r.occurredAt),
+    processedAt: r.processedAt == null ? null : r.processedAt instanceof Date ? r.processedAt : new Date(r.processedAt)
+  };
+}
 var DrizzleEventBus = class {
   constructor(db, opts, bridgeHook = null) {
     this.db = db;
@@ -417,6 +467,48 @@ var DrizzleEventBus = class {
     };
   }
   // ============================================================================
+  // IEventReadPort (OBS-LIST-1)
+  // ============================================================================
+  async listEvents(query = {}) {
+    const limit = clampEventLimit(query.limit);
+    const conditions = [];
+    if (query.poolId) conditions.push(eq(domainEvents.pool, query.poolId));
+    if (query.direction)
+      conditions.push(eq(domainEvents.direction, query.direction));
+    if (query.since) conditions.push(gte(domainEvents.occurredAt, query.since));
+    if (query.rootRunId) {
+      conditions.push(
+        sql2`${domainEvents.metadata}->>'rootRunId' = ${query.rootRunId}`
+      );
+    }
+    if (query.tenantId !== void 0) {
+      conditions.push(
+        query.tenantId === null ? sql2`${domainEvents.tenantId} is null` : eq(domainEvents.tenantId, query.tenantId)
+      );
+    }
+    if (query.cursor) {
+      const keyset = decodeEventCursor(query.cursor);
+      if (keyset) {
+        conditions.push(
+          or(
+            lt(domainEvents.occurredAt, keyset.occurredAt),
+            and(
+              eq(domainEvents.occurredAt, keyset.occurredAt),
+              lt(domainEvents.id, keyset.id)
+            )
+          )
+        );
+      }
+    }
+    const rows = await this.db.select().from(domainEvents).where(conditions.length > 0 ? and(...conditions) : void 0).orderBy(desc(domainEvents.occurredAt), desc(domainEvents.id)).limit(limit + 1);
+    const hasMore = rows.length > limit;
+    const page = hasMore ? rows.slice(0, limit) : rows;
+    const items = page.map(toEventSummary);
+    const last = page[page.length - 1];
+    const nextCursor = hasMore && last ? encodeEventCursor({ occurredAt: last.occurredAt, id: last.id }) : null;
+    return { items, nextCursor };
+  }
+  // ============================================================================
   // Polling
   // ============================================================================
   /**
@@ -541,6 +633,27 @@ DrizzleEventBus = __decorateClass([
 
 // runtime/subsystems/events/event-bus.memory-backend.ts
 import { Inject as Inject3, Injectable as Injectable3, Logger as Logger2, Optional as Optional2 } from "@nestjs/common";
+function toEventSummary2(event) {
+  const metadata = event.metadata;
+  const str = (key) => {
+    const v = metadata?.[key];
+    return typeof v === "string" ? v : null;
+  };
+  return {
+    id: event.id,
+    type: event.type,
+    aggregateId: event.aggregateId,
+    aggregateType: event.aggregateType,
+    status: "processed",
+    pool: str("pool"),
+    direction: str("direction"),
+    tier: str("tier") ?? "domain",
+    rootRunId: str("rootRunId"),
+    tenantId: str("tenantId"),
+    occurredAt: event.occurredAt,
+    processedAt: event.occurredAt
+  };
+}
 var MemoryEventBus = class {
   logger = new Logger2(MemoryEventBus.name);
   /** All events published since construction (or last clear). */
@@ -576,6 +689,53 @@ var MemoryEventBus = class {
       set.delete(h);
     };
   }
+  // ============================================================================
+  // IEventReadPort (OBS-LIST-1)
+  // ============================================================================
+  async listEvents(query = {}) {
+    const limit = clampEventLimit(query.limit);
+    const keyset = query.cursor ? decodeEventCursor(query.cursor) : null;
+    const str = (e, key) => {
+      const v = e.metadata?.[key];
+      return typeof v === "string" ? v : null;
+    };
+    const matched = this.publishedEvents.filter((e) => {
+      if (query.poolId && str(e, "pool") !== query.poolId) return false;
+      if (query.direction && str(e, "direction") !== query.direction)
+        return false;
+      if (query.rootRunId && str(e, "rootRunId") !== query.rootRunId)
+        return false;
+      if (query.since && e.occurredAt.getTime() < query.since.getTime())
+        return false;
+      if (query.tenantId !== void 0) {
+        const t = str(e, "tenantId");
+        if (query.tenantId === null) {
+          if (t !== null) return false;
+        } else if (t !== query.tenantId) {
+          return false;
+        }
+      }
+      return true;
+    });
+    matched.sort((a, b) => {
+      const dt = b.occurredAt.getTime() - a.occurredAt.getTime();
+      if (dt !== 0) return dt;
+      return a.id < b.id ? 1 : a.id > b.id ? -1 : 0;
+    });
+    const seeked = keyset ? matched.filter((e) => {
+      const ct = e.occurredAt.getTime();
+      const kt = keyset.occurredAt.getTime();
+      if (ct < kt) return true;
+      if (ct > kt) return false;
+      return e.id < keyset.id;
+    }) : matched;
+    const hasMore = seeked.length > limit;
+    const page = hasMore ? seeked.slice(0, limit) : seeked;
+    const items = page.map(toEventSummary2);
+    const last = page[page.length - 1];
+    const nextCursor = hasMore && last ? encodeEventCursor({ occurredAt: last.occurredAt, id: last.id }) : null;
+    return { items, nextCursor };
+  }
   /** Remove all published events and subscriptions. Useful in beforeEach. */
   clear() {
     this.publishedEvents.length = 0;
@@ -933,10 +1093,20 @@ var EventsModule = class {
             REDIS_URL
           ]
         },
+        {
+          // Read port (OBS-LIST-1). Drizzle + memory backends implement
+          // IEventReadPort on the EVENT_BUS instance; the redis backend
+          // retains no history, so EVENT_READ_PORT resolves to `null` and
+          // optional consumers (the observability combiner) degrade to
+          // empty results.
+          provide: EVENT_READ_PORT,
+          useFactory: (options, bus) => options.backend === "redis" ? null : bus,
+          inject: [EVENTS_MODULE_OPTIONS, EVENT_BUS]
+        },
         TypedEventBus,
         { provide: TYPED_EVENT_BUS, useExisting: TypedEventBus }
       ],
-      exports: [EVENT_BUS, TYPED_EVENT_BUS, EVENTS_MULTI_TENANT]
+      exports: [EVENT_BUS, EVENT_READ_PORT, TYPED_EVENT_BUS, EVENTS_MULTI_TENANT]
     };
   }
   static forRoot(options = { backend: "drizzle" }) {
@@ -964,9 +1134,13 @@ var EventsModule = class {
       providers: [
         { provide: EVENTS_MODULE_OPTIONS, useValue: options },
         provider,
+        // Read port (OBS-LIST-1): drizzle + memory backends implement
+        // IEventReadPort on the same instance as EVENT_BUS. The redis
+        // backend retains no history and does not provide this token.
+        { provide: EVENT_READ_PORT, useExisting: EVENT_BUS },
         ...buildTypedBusProviders(multiTenant)
       ],
-      exports: [EVENT_BUS, TYPED_EVENT_BUS, EVENTS_MULTI_TENANT]
+      exports: [EVENT_BUS, EVENT_READ_PORT, TYPED_EVENT_BUS, EVENTS_MULTI_TENANT]
     };
   }
 };
@@ -986,7 +1160,7 @@ import {
   index as index2,
   uniqueIndex
 } from "drizzle-orm/pg-core";
-import { sql as sql2 } from "drizzle-orm";
+import { sql as sql3 } from "drizzle-orm";
 var jobRunStatusEnum = pgEnum("job_run_status", [
   "pending",
   "running",
@@ -1091,10 +1265,10 @@ var jobRuns = pgTable2(
     /** listForScope query. */
     idxJobRunScope: index2("idx_job_run_scope").on(t.scopeEntityType, t.scopeEntityId),
     /** Idempotency collapse — partial index. */
-    idxJobRunDedupe: index2("idx_job_run_dedupe").on(t.jobType, t.dedupeKey).where(sql2`${t.dedupeKey} IS NOT NULL`),
+    idxJobRunDedupe: index2("idx_job_run_dedupe").on(t.jobType, t.dedupeKey).where(sql3`${t.dedupeKey} IS NOT NULL`),
     /** Collision check — partial index. */
     idxJobRunConcurrency: index2("idx_job_run_concurrency").on(t.concurrencyKey).where(
-      sql2`${t.concurrencyKey} IS NOT NULL AND ${t.status} IN ('pending','running')`
+      sql3`${t.concurrencyKey} IS NOT NULL AND ${t.status} IN ('pending','running')`
     )
   })
 );
@@ -1151,7 +1325,7 @@ var HandlerRegistry;
 // runtime/subsystems/jobs/job-orchestrator.drizzle-backend.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { Inject as Inject5, Injectable as Injectable5, Logger as Logger4 } from "@nestjs/common";
-import { and as and2, desc, eq as eq2, gt, inArray as inArray2, isNotNull, ne, notInArray, sql as sql3 } from "drizzle-orm";
+import { and as and2, desc as desc2, eq as eq2, gt, inArray as inArray2, isNotNull, ne, notInArray, sql as sql4 } from "drizzle-orm";
 
 // runtime/subsystems/jobs/jobs-errors.ts
 var JobTypeNotFoundError = class extends Error {
@@ -1292,7 +1466,7 @@ var DrizzleJobOrchestrator = class {
           // status NOT IN ('canceled', 'failed')
           notInStatus(DEDUPE_EXCLUDED_STATUSES)
         )
-      ).orderBy(desc(jobRuns.createdAt)).limit(1);
+      ).orderBy(desc2(jobRuns.createdAt)).limit(1);
       if (existing.length > 0) {
         return existing[0];
       }
@@ -1510,24 +1684,24 @@ var DrizzleJobOrchestrator = class {
       }).onConflictDoUpdate({
         target: jobs.type,
         set: {
-          pool: sql3`EXCLUDED.pool`,
-          scopeEntityType: sql3`EXCLUDED.scope_entity_type`,
-          retryPolicy: sql3`EXCLUDED.retry_policy`,
-          timeoutMs: sql3`EXCLUDED.timeout_ms`,
-          concurrencyKeyTemplate: sql3`EXCLUDED.concurrency_key_template`,
-          collisionMode: sql3`EXCLUDED.collision_mode`,
-          dedupeKeyTemplate: sql3`EXCLUDED.dedupe_key_template`,
-          dedupeWindowMs: sql3`EXCLUDED.dedupe_window_ms`,
-          priorityDefault: sql3`EXCLUDED.priority_default`,
-          replayFrom: sql3`EXCLUDED.replay_from`,
-          version: sql3`${jobs.version} + 1`,
-          updatedAt: sql3`now()`
+          pool: sql4`EXCLUDED.pool`,
+          scopeEntityType: sql4`EXCLUDED.scope_entity_type`,
+          retryPolicy: sql4`EXCLUDED.retry_policy`,
+          timeoutMs: sql4`EXCLUDED.timeout_ms`,
+          concurrencyKeyTemplate: sql4`EXCLUDED.concurrency_key_template`,
+          collisionMode: sql4`EXCLUDED.collision_mode`,
+          dedupeKeyTemplate: sql4`EXCLUDED.dedupe_key_template`,
+          dedupeWindowMs: sql4`EXCLUDED.dedupe_window_ms`,
+          priorityDefault: sql4`EXCLUDED.priority_default`,
+          replayFrom: sql4`EXCLUDED.replay_from`,
+          version: sql4`${jobs.version} + 1`,
+          updatedAt: sql4`now()`
         },
         // The hash gate: every field listed in the Q3 resolution appears
         // here. `IS DISTINCT FROM` is the null-safe inequality operator;
         // jsonb cast to text gives stable comparison without invoking a
         // dedicated hash column (avoids a JOB-1 schema migration).
-        setWhere: sql3`
+        setWhere: sql4`
             ${jobs.pool} IS DISTINCT FROM EXCLUDED.pool OR
             ${jobs.retryPolicy}::text IS DISTINCT FROM EXCLUDED.retry_policy::text OR
             ${jobs.timeoutMs} IS DISTINCT FROM EXCLUDED.timeout_ms OR
@@ -1558,7 +1732,58 @@ function notInStatus(statuses) {
 
 // runtime/subsystems/jobs/job-run-service.drizzle-backend.ts
 import { Inject as Inject6, Injectable as Injectable6 } from "@nestjs/common";
-import { and as and3, asc as asc2, desc as desc2, eq as eq3, inArray as inArray3, isNull, sql as sql4 } from "drizzle-orm";
+import { and as and3, asc as asc2, desc as desc3, eq as eq3, gte as gte2, inArray as inArray3, isNull, lt as lt2, or as or2, sql as sql5 } from "drizzle-orm";
+
+// runtime/subsystems/jobs/job-run-keyset-cursor.ts
+var DEFAULT_LIST_LIMIT = 50;
+var MAX_LIST_LIMIT = 200;
+function clampLimit(limit) {
+  if (typeof limit !== "number" || !Number.isFinite(limit)) {
+    return DEFAULT_LIST_LIMIT;
+  }
+  const floored = Math.floor(limit);
+  if (floored < 1) return 1;
+  if (floored > MAX_LIST_LIMIT) return MAX_LIST_LIMIT;
+  return floored;
+}
+function encodeKeysetCursor(keyset) {
+  const tuple = [keyset.createdAt.toISOString(), keyset.id];
+  return Buffer.from(JSON.stringify(tuple), "utf8").toString("base64url");
+}
+function decodeKeysetCursor(cursor) {
+  try {
+    const json = Buffer.from(cursor, "base64url").toString("utf8");
+    const parsed = JSON.parse(json);
+    if (!Array.isArray(parsed) || parsed.length !== 2) return null;
+    const [iso, id] = parsed;
+    if (typeof iso !== "string" || typeof id !== "string") return null;
+    const createdAt = new Date(iso);
+    if (Number.isNaN(createdAt.getTime())) return null;
+    return { createdAt, id };
+  } catch {
+    return null;
+  }
+}
+function toJobRunSummary(r) {
+  return {
+    runId: r.id,
+    rootRunId: r.rootRunId,
+    jobType: r.jobType,
+    pool: r.pool,
+    status: r.status,
+    scopeEntityType: r.scopeEntityType,
+    scopeEntityId: r.scopeEntityId,
+    tenantId: r.tenantId,
+    attempts: r.attempts,
+    errorMessage: r.error?.message ?? null,
+    runAt: r.runAt,
+    startedAt: r.startedAt,
+    finishedAt: r.finishedAt,
+    createdAt: r.createdAt
+  };
+}
+
+// runtime/subsystems/jobs/job-run-service.drizzle-backend.ts
 var NON_TERMINAL_STATUSES = [
   "pending",
   "running",
@@ -1606,12 +1831,12 @@ var DrizzleJobRunService = class {
         case "created_at asc":
           return asc2(jobRuns.createdAt);
         case "run_at desc":
-          return desc2(jobRuns.runAt);
+          return desc3(jobRuns.runAt);
         case "run_at asc":
           return asc2(jobRuns.runAt);
         case "created_at desc":
         default:
-          return desc2(jobRuns.createdAt);
+          return desc3(jobRuns.createdAt);
       }
     })();
     let q = this.db.select().from(jobRuns).where(and3(...conditions)).orderBy(orderCol).$dynamic();
@@ -1655,7 +1880,7 @@ var DrizzleJobRunService = class {
     const rows = await this.db.select({
       pool: jobRuns.pool,
       status: jobRuns.status,
-      count: sql4`count(*)::int`.as("count")
+      count: sql5`count(*)::int`.as("count")
     }).from(jobRuns).where(tenantCond ?? void 0).groupBy(jobRuns.pool, jobRuns.status);
     return rows.map((r) => ({
       pool: r.pool,
@@ -1667,7 +1892,7 @@ var DrizzleJobRunService = class {
     const conditions = [eq3(jobRuns.status, "failed")];
     const tenantCond = this.tenantCondition("listRecentFailed", tenantId);
     if (tenantCond) conditions.push(tenantCond);
-    const rows = await this.db.select().from(jobRuns).where(and3(...conditions)).orderBy(desc2(jobRuns.finishedAt), desc2(jobRuns.updatedAt)).limit(limit);
+    const rows = await this.db.select().from(jobRuns).where(and3(...conditions)).orderBy(desc3(jobRuns.finishedAt), desc3(jobRuns.updatedAt)).limit(limit);
     return rows.map((r) => ({
       runId: r.id,
       jobType: r.jobType,
@@ -1681,6 +1906,37 @@ var DrizzleJobRunService = class {
       createdAt: r.createdAt
     }));
   }
+  async listJobRuns(query = {}) {
+    const limit = clampLimit(query.limit);
+    const conditions = [];
+    const tenantCond = this.tenantCondition("listJobRuns", query.tenantId);
+    if (tenantCond) conditions.push(tenantCond);
+    if (query.poolId) conditions.push(eq3(jobRuns.pool, query.poolId));
+    if (query.rootRunId) conditions.push(eq3(jobRuns.rootRunId, query.rootRunId));
+    if (query.status) conditions.push(eq3(jobRuns.status, query.status));
+    if (query.since) conditions.push(gte2(jobRuns.createdAt, query.since));
+    if (query.cursor) {
+      const keyset = decodeKeysetCursor(query.cursor);
+      if (keyset) {
+        conditions.push(
+          or2(
+            lt2(jobRuns.createdAt, keyset.createdAt),
+            and3(
+              eq3(jobRuns.createdAt, keyset.createdAt),
+              lt2(jobRuns.id, keyset.id)
+            )
+          )
+        );
+      }
+    }
+    const rows = await this.db.select().from(jobRuns).where(conditions.length > 0 ? and3(...conditions) : void 0).orderBy(desc3(jobRuns.createdAt), desc3(jobRuns.id)).limit(limit + 1);
+    const hasMore = rows.length > limit;
+    const page = hasMore ? rows.slice(0, limit) : rows;
+    const items = page.map(toJobRunSummary);
+    const last = page[page.length - 1];
+    const nextCursor = hasMore && last ? encodeKeysetCursor({ createdAt: last.createdAt, id: last.id }) : null;
+    return { items, nextCursor };
+  }
   /**
    * Internal helper used by cascade paths (not on the public protocol).
    * Exposed as a public method on the concrete class so infrastructure
@@ -1729,22 +1985,608 @@ var DrizzleJobStepService = class {
         finishedAt: values.finishedAt,
         attempts: values.attempts
       }
-    }).returning();
-    return row;
+    }).returning();
+    return row;
+  }
+  async findStep(runId, stepId) {
+    const [row] = await this.db.select().from(jobSteps).where(and4(eq4(jobSteps.jobRunId, runId), eq4(jobSteps.stepId, stepId))).limit(1);
+    return row ?? null;
+  }
+};
+DrizzleJobStepService = __decorateClass([
+  Injectable7(),
+  __decorateParam(0, Inject7(DRIZZLE))
+], DrizzleJobStepService);
+
+// runtime/subsystems/jobs/job-orchestrator.bullmq-backend.ts
+import { createHash } from "crypto";
+import { Inject as Inject8, Injectable as Injectable8, Logger as Logger5, Optional as Optional3 } from "@nestjs/common";
+import { eq as eq5 } from "drizzle-orm";
+
+// runtime/subsystems/jobs/pool-config.loader.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+import { parse as parseYaml } from "yaml";
+var FRAMEWORK_POOLS = Object.freeze({
+  events_inbound: Object.freeze({
+    queue: "jobs-events-inbound",
+    concurrency: 20,
+    reserved: true,
+    description: "Inbound events drain (events subsystem outbox)."
+  }),
+  events_change: Object.freeze({
+    queue: "jobs-events-change",
+    concurrency: 30,
+    reserved: true,
+    description: "Change events drain (events subsystem outbox)."
+  }),
+  events_outbound: Object.freeze({
+    queue: "jobs-events-outbound",
+    concurrency: 10,
+    reserved: true,
+    description: "Outbound events drain (events subsystem outbox)."
+  }),
+  interactive: Object.freeze({
+    queue: "jobs-interactive",
+    concurrency: 20,
+    reserved: false,
+    description: "User-facing latency-sensitive jobs."
+  }),
+  batch: Object.freeze({
+    queue: "jobs-batch",
+    concurrency: 5,
+    reserved: false,
+    description: "Default pool for background jobs."
+  })
+});
+var RESERVED_POOL_NAMES = new Set(
+  Object.entries(FRAMEWORK_POOLS).filter(([, def]) => def.reserved).map(([name]) => name)
+);
+var cache = /* @__PURE__ */ new Map();
+function loadPoolConfig(configPath) {
+  const resolved = resolve(configPath ?? `${process.cwd()}/codegen.config.yaml`);
+  const cached = cache.get(resolved);
+  if (cached) return cached;
+  const merged = /* @__PURE__ */ new Map();
+  for (const [name, def] of Object.entries(FRAMEWORK_POOLS)) {
+    merged.set(name, { ...def });
+  }
+  if (!existsSync(resolved)) {
+    cache.set(resolved, merged);
+    return merged;
+  }
+  let raw;
+  try {
+    raw = parseYaml(readFileSync(resolved, "utf8"));
+  } catch (err) {
+    throw new Error(
+      `pool-config.loader: failed to parse YAML at ${resolved}: ${err.message}`
+    );
+  }
+  const userPools = extractUserPools(raw);
+  for (const [name, userDef] of Object.entries(userPools)) {
+    const existing = merged.get(name);
+    if (existing) {
+      const next = {
+        queue: existing.queue,
+        concurrency: typeof userDef.concurrency === "number" ? userDef.concurrency : existing.concurrency,
+        reserved: existing.reserved,
+        description: userDef.description ?? existing.description
+      };
+      merged.set(name, next);
+      continue;
+    }
+    if (typeof userDef.queue !== "string" || userDef.queue.length === 0) {
+      throw new Error(
+        `pool-config.loader: pool '${name}' must declare a non-empty 'queue'.`
+      );
+    }
+    if (typeof userDef.concurrency !== "number" || userDef.concurrency <= 0) {
+      throw new Error(
+        `pool-config.loader: pool '${name}' must declare a positive 'concurrency'.`
+      );
+    }
+    if (userDef.reserved === true) {
+      throw new Error(
+        `pool-config.loader: user-defined pool '${name}' cannot set 'reserved: true' \u2014 reserved is framework-only.`
+      );
+    }
+    merged.set(name, {
+      queue: userDef.queue,
+      concurrency: userDef.concurrency,
+      reserved: false,
+      description: userDef.description
+    });
+  }
+  cache.set(resolved, merged);
+  return merged;
+}
+function allNonReservedPoolNames(config) {
+  const out = [];
+  for (const [name, def] of config) {
+    if (!def.reserved) out.push(name);
+  }
+  return out;
+}
+function allPoolNames(config) {
+  return [...config.keys()];
+}
+function extractUserPools(raw) {
+  if (!raw || typeof raw !== "object") return {};
+  const jobs2 = raw.jobs;
+  if (!jobs2 || typeof jobs2 !== "object") return {};
+  const pools = jobs2.pools;
+  if (!pools || typeof pools !== "object") return {};
+  const out = {};
+  for (const [name, def] of Object.entries(pools)) {
+    if (!def || typeof def !== "object") continue;
+    out[name] = def;
+  }
+  return out;
+}
+
+// runtime/subsystems/jobs/bullmq.config.ts
+var BULLMQ_CONNECTION = /* @__PURE__ */ Symbol("BULLMQ_CONNECTION");
+var BULLMQ_RESOLVED_CONFIG = /* @__PURE__ */ Symbol("BULLMQ_RESOLVED_CONFIG");
+var DEFAULT_REDIS_URL = "redis://localhost:6379";
+var DEFAULT_BULL_BOARD_MOUNT = "/admin/queues";
+function resolveBullMqConfig(ext) {
+  const url = ext?.redis_url ?? process.env.REDIS_URL ?? DEFAULT_REDIS_URL;
+  const resolved = {
+    connection: { url },
+    queuePrefix: ext?.queue_prefix
+  };
+  if (ext?.bull_board?.enabled) {
+    resolved.bullBoard = {
+      enabled: true,
+      mountPath: ext.bull_board.mount_path ?? DEFAULT_BULL_BOARD_MOUNT
+    };
+  }
+  return resolved;
+}
+function resolvePoolQueueName(pool, config, poolConfig = loadPoolConfig()) {
+  const alias = poolConfig.get(pool)?.queue ?? pool;
+  const prefix = config?.queuePrefix;
+  return prefix ? `${prefix}:${alias}` : alias;
+}
+
+// runtime/subsystems/jobs/job-orchestrator.bullmq-backend.ts
+function sha1JobId(idempotencyKey) {
+  return createHash("sha1").update(idempotencyKey).digest("hex");
+}
+var BullMQJobOrchestrator = class extends DrizzleJobOrchestrator {
+  constructor(db, multiTenant, connection, bullConfig = null) {
+    super(db, multiTenant);
+    this.connection = connection;
+    this.bullConfig = bullConfig;
+    this.bullDb = db;
+  }
+  connection;
+  bullConfig;
+  // TODO(logging-subsystem): swap to ILogger once ADR-028 lands
+  bullLogger = new Logger5(BullMQJobOrchestrator.name);
+  /** Lazily-opened `Queue` handles, one per pool. */
+  queues = /* @__PURE__ */ new Map();
+  /** Single FlowProducer for parent/child hierarchies. Lazily opened. */
+  _flow = null;
+  /**
+   * Cached `bullmq` value constructors, populated by `loadBullMq()` on first
+   * use (the `start`/`cancel`/`replay` entrypoints `await` it before touching
+   * a queue). Kept off the import graph so a `drizzle`-only consumer never
+   * resolves the optional `'bullmq'` package.
+   */
+  QueueCtor = null;
+  FlowProducerCtor = null;
+  bullMqLoad = null;
+  /**
+   * Own reference to the Drizzle client. `DrizzleJobOrchestrator.db` is
+   * `private` (can't be redeclared even privately in a subclass), and the
+   * spec forbids touching that file — so the subclass keeps its own handle
+   * under a distinct name (same instance, passed through to `super`) for the
+   * cancel-cascade snapshot + definition/run loads below.
+   */
+  bullDb;
+  /**
+   * Lazily load the optional `bullmq` package and cache its value
+   * constructors. Idempotent (single in-flight promise). Throws a friendly,
+   * actionable error when the consumer selected `backend: 'bullmq'` but did
+   * not install the package — mirrors `createRedisClient` in the redis event
+   * backend. Must be `await`ed before any `queueFor`/`flow` access.
+   */
+  async loadBullMq() {
+    if (this.QueueCtor && this.FlowProducerCtor) return;
+    if (!this.bullMqLoad) {
+      this.bullMqLoad = (async () => {
+        try {
+          const mod = await import("bullmq");
+          this.QueueCtor = mod.Queue;
+          this.FlowProducerCtor = mod.FlowProducer;
+        } catch {
+          throw new Error(
+            'BullMQ backend requires the "bullmq" package. Install it with: npm install bullmq'
+          );
+        }
+      })();
+    }
+    await this.bullMqLoad;
+  }
+  /**
+   * Open (or reuse) the `Queue` for a pool. Synchronous — callers `await
+   * loadBullMq()` first so `QueueCtor` is populated.
+   */
+  queueFor(pool) {
+    if (!this.QueueCtor) {
+      throw new Error("BullMQJobOrchestrator: queueFor called before loadBullMq()");
+    }
+    const name = resolvePoolQueueName(pool, this.bullConfig);
+    let q = this.queues.get(name);
+    if (!q) {
+      q = new this.QueueCtor(name, { connection: this.connection });
+      this.queues.set(name, q);
+    }
+    return q;
+  }
+  flow() {
+    if (!this.FlowProducerCtor) {
+      throw new Error("BullMQJobOrchestrator: flow called before loadBullMq()");
+    }
+    if (!this._flow) {
+      this._flow = new this.FlowProducerCtor({ connection: this.connection });
+    }
+    return this._flow;
+  }
+  // ==========================================================================
+  // start — Postgres insert (super) + BullMQ dispatch
+  // ==========================================================================
+  async start(type, input, opts = {}, tx) {
+    const run = await super.start(type, input, opts, tx);
+    await this.dispatch(run, type);
+    return run;
+  }
+  /**
+   * Map a `job_run` row onto a BullMQ job via `queue.add`. When the run has a
+   * `parentRunId` we attach it to the parent's existing BullMQ job through the
+   * `parent: { id, queue }` opt — BullMQ then tracks the parent/child link in
+   * its own graph. (The FlowProducer is reserved for whole-tree atomic
+   * submits, exposed as an opt-in extension via `flowProducer()`; runtime
+   * `ctx.spawnChild` is incremental, so `queue.add` with a parent ref is the
+   * correct primitive here.)
+   *
+   * The `jobId` is colon-safe + stable: `sha1(dedupeKey)` when a dedupe key is
+   * present (so the same logical key dedups), else the `job_run.id` UUID
+   * (already colon-free).
+   *
+   * The domain `parentClosePolicy` cascade is still enforced in Postgres by
+   * the shared `cancel` path — BullMQ's parent link is dispatch bookkeeping,
+   * not the authority.
+   */
+  async dispatch(run, type) {
+    await this.loadBullMq();
+    const def = await this.loadDefinition(type);
+    const jobId = run.dedupeKey ? sha1JobId(run.dedupeKey) : run.id;
+    const jobOpts = {
+      jobId,
+      ...this.retryOpts(def),
+      ...this.dedupeOpts(run, def)
+    };
+    if (run.parentRunId) {
+      const parentRow = await this.loadRun(run.parentRunId);
+      if (parentRow) {
+        const parentJobId = parentRow.dedupeKey ? sha1JobId(parentRow.dedupeKey) : parentRow.id;
+        jobOpts.parent = {
+          id: parentJobId,
+          queue: resolvePoolQueueName(parentRow.pool, this.bullConfig)
+        };
+      }
+    }
+    const payload = { runId: run.id, type, input: run.input };
+    await this.queueFor(run.pool).add(type, payload, jobOpts);
+  }
+  /**
+   * Opt-in extension (spec §Extensions): expose the FlowProducer for
+   * consumers that want to submit a whole parent/child DAG atomically up
+   * front, rather than incrementally via `ctx.spawnChild`. Backend-specific —
+   * code using it is not portable to the Drizzle backend. Async because it
+   * lazily loads the optional `bullmq` package on first use.
+   */
+  async flowProducer() {
+    await this.loadBullMq();
+    return this.flow();
+  }
+  retryOpts(def) {
+    const policy = def.retryPolicy;
+    if (!policy) return {};
+    return {
+      attempts: policy.attempts,
+      backoff: {
+        type: policy.backoff === "exponential" ? "exponential" : "fixed",
+        delay: policy.baseMs
+      }
+    };
+  }
+  dedupeOpts(run, def) {
+    if (!run.dedupeKey || !def.dedupeWindowMs) return {};
+    return {
+      deduplication: {
+        id: sha1JobId(run.dedupeKey),
+        ttl: def.dedupeWindowMs
+      }
+    };
+  }
+  // ==========================================================================
+  // cancel — Postgres cascade (super) + remove from queue
+  // ==========================================================================
+  async cancel(runId, opts = {}) {
+    const target = await this.loadRun(runId);
+    await super.cancel(runId, opts);
+    if (!target) return;
+    await this.loadBullMq();
+    await this.removeFromQueue(target);
+    if (opts.cascade === false) return;
+    const descendants = await this.bullDb.select().from(jobRuns).where(eq5(jobRuns.rootRunId, target.rootRunId));
+    for (const child of descendants) {
+      if (child.id === runId) continue;
+      await this.removeFromQueue(child);
+    }
+  }
+  async removeFromQueue(run) {
+    const jobId = run.dedupeKey ? sha1JobId(run.dedupeKey) : run.id;
+    try {
+      const job = await this.queueFor(run.pool).getJob(jobId);
+      if (job) await job.remove();
+    } catch (err) {
+      this.bullLogger.warn(
+        `cancel: could not remove BullMQ job ${jobId} (pool=${run.pool}): ${err.message}`
+      );
+    }
+  }
+  // ==========================================================================
+  // replay — Postgres reset (super) + re-enqueue
+  // ==========================================================================
+  async replay(runId) {
+    const run = await super.replay(runId);
+    await this.dispatch(run, run.jobType);
+    return run;
+  }
+  // ==========================================================================
+  // Internals
+  // ==========================================================================
+  async loadDefinition(type) {
+    const [def] = await this.bullDb.select().from(jobs).where(eq5(jobs.type, type)).limit(1);
+    if (!def) {
+      throw new Error(`BullMQJobOrchestrator: no job definition for '${type}'`);
+    }
+    return def;
+  }
+  async loadRun(id) {
+    const [row] = await this.bullDb.select().from(jobRuns).where(eq5(jobRuns.id, id)).limit(1);
+    return row ?? null;
+  }
+  /** Close all open queue + flow connections. Called on module destroy. */
+  async closeConnections() {
+    for (const q of this.queues.values()) {
+      await q.close().catch(() => void 0);
+    }
+    this.queues.clear();
+    if (this._flow) {
+      await this._flow.close().catch(() => void 0);
+      this._flow = null;
+    }
+  }
+};
+BullMQJobOrchestrator = __decorateClass([
+  Injectable8(),
+  __decorateParam(0, Inject8(DRIZZLE)),
+  __decorateParam(1, Inject8(JOBS_MULTI_TENANT)),
+  __decorateParam(2, Inject8(BULLMQ_CONNECTION)),
+  __decorateParam(3, Optional3()),
+  __decorateParam(3, Inject8(BULLMQ_RESOLVED_CONFIG))
+], BullMQJobOrchestrator);
+
+// runtime/subsystems/jobs/job-worker.bullmq-backend.ts
+import { Logger as Logger6 } from "@nestjs/common";
+import { eq as eq6 } from "drizzle-orm";
+function serialiseError(err, attempt, retryable) {
+  const e = err;
+  return {
+    message: e?.message ?? String(err),
+    stack: e?.stack,
+    retryable,
+    attempt
+  };
+}
+var BullMQJobWorker = class _BullMQJobWorker {
+  constructor(db, orchestrator, stepService, options, moduleRef) {
+    this.db = db;
+    this.orchestrator = orchestrator;
+    this.stepService = stepService;
+    this.options = options;
+    this.moduleRef = moduleRef;
+  }
+  db;
+  orchestrator;
+  stepService;
+  options;
+  moduleRef;
+  logger = new Logger6(_BullMQJobWorker.name);
+  worker = null;
+  async onModuleInit() {
+    let WorkerCtor;
+    try {
+      const mod = await import("bullmq");
+      WorkerCtor = mod.Worker;
+    } catch {
+      throw new Error(
+        'BullMQ backend requires the "bullmq" package. Install it with: npm install bullmq'
+      );
+    }
+    this.worker = new WorkerCtor(
+      this.options.queueName,
+      (job) => this.process(job),
+      {
+        connection: this.options.connection,
+        concurrency: this.options.concurrency
+      }
+    );
+    this.worker.on("failed", (job, err) => {
+      if (!job) return;
+      const attemptsMade = job.attemptsMade;
+      const maxAttempts = job.opts.attempts ?? 1;
+      if (attemptsMade >= maxAttempts) {
+        void this.markFailed(job.data.runId, err, attemptsMade);
+      }
+    });
+    this.logger.log(
+      `BullMQ worker started: pool='${this.options.pool}' queue='${this.options.queueName}' concurrency=${this.options.concurrency}`
+    );
+  }
+  async onModuleDestroy() {
+    if (this.worker) {
+      await this.worker.close();
+      this.worker = null;
+    }
+  }
+  /**
+   * Process one BullMQ job. Returns the handler output (stored by BullMQ as
+   * the job return value AND written to `job_run.output`). Throws on handler
+   * failure so BullMQ applies the retry policy.
+   */
+  async process(job) {
+    const { runId } = job.data;
+    const [row] = await this.db.select().from(jobRuns).where(eq6(jobRuns.id, runId)).limit(1);
+    if (!row) {
+      this.logger.warn(`process: job_run ${runId} not found; skipping`);
+      return {};
+    }
+    const run = row;
+    if (run.status === "canceled") {
+      return {};
+    }
+    const registryEntry = JOB_HANDLER_REGISTRY.get(run.jobType);
+    if (!registryEntry) {
+      throw new Error(
+        `No handler registered for jobType='${run.jobType}' (run ${run.id})`
+      );
+    }
+    await this.db.update(jobRuns).set({
+      status: "running",
+      claimedAt: /* @__PURE__ */ new Date(),
+      startedAt: /* @__PURE__ */ new Date(),
+      attempts: job.attemptsMade + 1,
+      updatedAt: /* @__PURE__ */ new Date()
+    }).where(eq6(jobRuns.id, run.id));
+    const HandlerClass = registryEntry.handlerClass;
+    const handler = this.moduleRef.get(
+      HandlerClass,
+      { strict: false }
+    );
+    const ctx = {
+      input: run.input,
+      run,
+      step: this.makeStepFn(run),
+      spawnChild: this.makeSpawnFn(run),
+      logger: new Logger6(`JobRun:${run.id}`)
+    };
+    const output = await handler.run(ctx);
+    await this.db.update(jobRuns).set({
+      status: "completed",
+      output: output ?? {},
+      finishedAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    }).where(eq6(jobRuns.id, run.id));
+    return output ?? {};
+  }
+  async markFailed(runId, err, finalAttempts) {
+    const [row] = await this.db.select().from(jobRuns).where(eq6(jobRuns.id, runId)).limit(1);
+    if (!row) return;
+    const run = row;
+    await this.db.update(jobRuns).set({
+      status: "failed",
+      attempts: finalAttempts,
+      finishedAt: /* @__PURE__ */ new Date(),
+      error: serialiseError(err, finalAttempts, false),
+      updatedAt: /* @__PURE__ */ new Date()
+    }).where(eq6(jobRuns.id, runId));
+    if (run.parentClosePolicy === "terminate") {
+      try {
+        await this.orchestrator.cancel(run.id, {
+          cascade: true,
+          reason: "parent-failed",
+          tenantId: run.tenantId
+        });
+      } catch (cascadeErr) {
+        this.logger.warn(
+          `cascade on failed run ${run.id}: ${cascadeErr.message}`
+        );
+      }
+    }
+  }
+  // ── ctx.step / ctx.spawnChild (mirror JobWorker) ──────────────────────────
+  makeStepFn(run) {
+    return async (stepId, fn, _opts) => {
+      void _opts;
+      const existing = await this.stepService.findStep(run.id, stepId);
+      if (existing?.status === "completed") {
+        return existing.output;
+      }
+      const nextAttempts = (existing?.attempts ?? 0) + 1;
+      const seq = nextAttempts;
+      await this.stepService.recordStep({
+        jobRunId: run.id,
+        stepId,
+        kind: "task",
+        seq,
+        status: "running",
+        startedAt: /* @__PURE__ */ new Date(),
+        attempts: nextAttempts
+      });
+      try {
+        const output = await fn();
+        await this.stepService.recordStep({
+          jobRunId: run.id,
+          stepId,
+          kind: "task",
+          seq,
+          status: "completed",
+          output,
+          finishedAt: /* @__PURE__ */ new Date(),
+          attempts: nextAttempts
+        });
+        return output;
+      } catch (err) {
+        await this.stepService.recordStep({
+          jobRunId: run.id,
+          stepId,
+          kind: "task",
+          seq,
+          status: "failed",
+          error: serialiseError(err, nextAttempts, false),
+          finishedAt: /* @__PURE__ */ new Date(),
+          attempts: nextAttempts
+        });
+        throw err;
+      }
+    };
   }
-  async findStep(runId, stepId) {
-    const [row] = await this.db.select().from(jobSteps).where(and4(eq4(jobSteps.jobRunId, runId), eq4(jobSteps.stepId, stepId))).limit(1);
-    return row ?? null;
+  makeSpawnFn(run) {
+    return async (type, input, opts) => {
+      return this.orchestrator.start(type, input, {
+        parentRunId: run.id,
+        parentClosePolicy: opts?.closePolicy,
+        runAt: opts?.runAt,
+        priority: opts?.priority,
+        tags: opts?.tags,
+        triggerSource: "parent",
+        triggerRef: run.id,
+        tenantId: run.tenantId
+      });
+    };
   }
 };
-DrizzleJobStepService = __decorateClass([
-  Injectable7(),
-  __decorateParam(0, Inject7(DRIZZLE))
-], DrizzleJobStepService);
 
 // runtime/subsystems/jobs/job-worker.ts
-import { Inject as Inject8, Injectable as Injectable8, Logger as Logger5 } from "@nestjs/common";
-import { and as and5, asc as asc3, desc as desc3, eq as eq5, inArray as inArray4, lt, lte, sql as sql5 } from "drizzle-orm";
+import { Inject as Inject9, Injectable as Injectable9, Logger as Logger7 } from "@nestjs/common";
+import { and as and5, asc as asc3, desc as desc4, eq as eq7, inArray as inArray4, lt as lt3, lte, sql as sql6 } from "drizzle-orm";
 var JOB_WORKER_OPTIONS = /* @__PURE__ */ Symbol("JOB_WORKER_OPTIONS");
 var DEFAULT_POLL_INTERVAL_MS = 1e3;
 var DEFAULT_STALE_SWEEPER_INTERVAL_MS = 6e4;
@@ -1773,7 +2615,7 @@ function classifyError(err, policy, currentAttempts) {
   if (currentAttempts + 1 >= policy.attempts) return "fail";
   return "retry";
 }
-function serialiseError(err, attempt, retryable) {
+function serialiseError2(err, attempt, retryable) {
   const e = err;
   return {
     message: e?.message ?? String(err),
@@ -1807,7 +2649,7 @@ var JobWorker = class {
   stepService;
   options;
   moduleRef;
-  logger = new Logger5(JobWorker.name);
+  logger = new Logger7(JobWorker.name);
   shuttingDown = false;
   inFlight = /* @__PURE__ */ new Set();
   pollTimer = null;
@@ -1848,7 +2690,7 @@ var JobWorker = class {
     await this.drainInFlight();
     try {
       await this.db.update(jobRuns).set({ status: "pending", claimedAt: null, startedAt: null }).where(
-        and5(eq5(jobRuns.status, "running"), eq5(jobRuns.pool, this.options.pool))
+        and5(eq7(jobRuns.status, "running"), eq7(jobRuns.pool, this.options.pool))
       );
     } catch (err) {
       this.logger.error(`shutdown reset failed: ${err.message}`);
@@ -1898,11 +2740,11 @@ var JobWorker = class {
     return this.db.transaction(async (tx) => {
       const candidates = await tx.select({ id: jobRuns.id }).from(jobRuns).where(
         and5(
-          eq5(jobRuns.status, "pending"),
-          eq5(jobRuns.pool, pool),
+          eq7(jobRuns.status, "pending"),
+          eq7(jobRuns.pool, pool),
           lte(jobRuns.runAt, /* @__PURE__ */ new Date())
         )
-      ).orderBy(desc3(jobRuns.priority), asc3(jobRuns.runAt)).limit(1).for("update", { skipLocked: true });
+      ).orderBy(desc4(jobRuns.priority), asc3(jobRuns.runAt)).limit(1).for("update", { skipLocked: true });
       const candidate = candidates[0];
       if (!candidate) return null;
       const [claimed] = await tx.update(jobRuns).set({
@@ -1910,7 +2752,7 @@ var JobWorker = class {
         claimedAt: /* @__PURE__ */ new Date(),
         startedAt: /* @__PURE__ */ new Date(),
         updatedAt: /* @__PURE__ */ new Date()
-      }).where(eq5(jobRuns.id, candidate.id)).returning();
+      }).where(eq7(jobRuns.id, candidate.id)).returning();
       return claimed ?? null;
     });
   }
@@ -1928,7 +2770,7 @@ var JobWorker = class {
       await this.db.transaction(async (tx) => {
         const threshold = new Date(Date.now() - this.staleThresholdMs);
         const stale = await tx.select({ id: jobRuns.id }).from(jobRuns).where(
-          and5(eq5(jobRuns.status, "running"), lt(jobRuns.claimedAt, threshold))
+          and5(eq7(jobRuns.status, "running"), lt3(jobRuns.claimedAt, threshold))
         ).for("update", { skipLocked: true });
         if (stale.length === 0) return;
         const ids = stale.map((r) => r.id);
@@ -1961,8 +2803,8 @@ var JobWorker = class {
     if (claimed.concurrencyKey) {
       const inflight = await this.db.select({ id: jobRuns.id }).from(jobRuns).where(
         and5(
-          eq5(jobRuns.concurrencyKey, claimed.concurrencyKey),
-          eq5(jobRuns.status, "running")
+          eq7(jobRuns.concurrencyKey, claimed.concurrencyKey),
+          eq7(jobRuns.status, "running")
         )
       );
       const other = inflight.find((r) => r.id !== claimed.id);
@@ -1972,7 +2814,7 @@ var JobWorker = class {
           claimedAt: null,
           startedAt: null,
           updatedAt: /* @__PURE__ */ new Date()
-        }).where(eq5(jobRuns.id, claimed.id));
+        }).where(eq7(jobRuns.id, claimed.id));
         return;
       }
     }
@@ -1987,7 +2829,7 @@ var JobWorker = class {
       run: claimed,
       step: this.makeStepFn(claimed),
       spawnChild: this.makeSpawnFn(claimed),
-      logger: new Logger5(`JobRun:${claimed.id}`)
+      logger: new Logger7(`JobRun:${claimed.id}`)
     };
     const attemptsBefore = claimed.attempts ?? 0;
     try {
@@ -1998,7 +2840,7 @@ var JobWorker = class {
         finishedAt: /* @__PURE__ */ new Date(),
         updatedAt: /* @__PURE__ */ new Date(),
         attempts: attemptsBefore + 1
-      }).where(eq5(jobRuns.id, claimed.id));
+      }).where(eq7(jobRuns.id, claimed.id));
     } catch (err) {
       const policy = meta.retry;
       const decision = classifyError(err, policy, attemptsBefore);
@@ -2011,9 +2853,9 @@ var JobWorker = class {
           runAt: new Date(Date.now() + delay),
           startedAt: null,
           claimedAt: null,
-          error: serialiseError(err, nextAttempts, true),
+          error: serialiseError2(err, nextAttempts, true),
           updatedAt: /* @__PURE__ */ new Date()
-        }).where(eq5(jobRuns.id, claimed.id));
+        }).where(eq7(jobRuns.id, claimed.id));
       } else {
         await this.markFailed(claimed, err, nextAttempts);
       }
@@ -2024,9 +2866,9 @@ var JobWorker = class {
       status: "failed",
       attempts: finalAttempts,
       finishedAt: /* @__PURE__ */ new Date(),
-      error: serialiseError(err, finalAttempts, false),
+      error: serialiseError2(err, finalAttempts, false),
       updatedAt: /* @__PURE__ */ new Date()
-    }).where(eq5(jobRuns.id, claimed.id));
+    }).where(eq7(jobRuns.id, claimed.id));
     if (claimed.parentClosePolicy === "terminate") {
       try {
         await this.orchestrator.cancel(claimed.id, {
@@ -2083,7 +2925,7 @@ var JobWorker = class {
           kind: "task",
           seq,
           status: "failed",
-          error: serialiseError(err, nextAttempts, false),
+          error: serialiseError2(err, nextAttempts, false),
           finishedAt: /* @__PURE__ */ new Date(),
           attempts: nextAttempts
         });
@@ -2113,7 +2955,7 @@ var JobWorker = class {
    */
   async nextStepSeq(runId) {
     const [row] = await this.db.execute(
-      sql5`SELECT COALESCE(MAX(seq), 0) + 1 AS next FROM job_step WHERE job_run_id = ${runId}`
+      sql6`SELECT COALESCE(MAX(seq), 0) + 1 AS next FROM job_step WHERE job_run_id = ${runId}`
     );
     const maybeRows = row?.rows;
     if (Array.isArray(maybeRows) && maybeRows.length > 0) {
@@ -2129,12 +2971,12 @@ var JobWorker = class {
   // ============================================================================
 };
 JobWorker = __decorateClass([
-  Injectable8(),
-  __decorateParam(0, Inject8(DRIZZLE)),
-  __decorateParam(1, Inject8(JOB_ORCHESTRATOR)),
-  __decorateParam(2, Inject8(JOB_RUN_SERVICE)),
-  __decorateParam(3, Inject8(JOB_STEP_SERVICE)),
-  __decorateParam(4, Inject8(JOB_WORKER_OPTIONS))
+  Injectable9(),
+  __decorateParam(0, Inject9(DRIZZLE)),
+  __decorateParam(1, Inject9(JOB_ORCHESTRATOR)),
+  __decorateParam(2, Inject9(JOB_RUN_SERVICE)),
+  __decorateParam(3, Inject9(JOB_STEP_SERVICE)),
+  __decorateParam(4, Inject9(JOB_WORKER_OPTIONS))
 ], JobWorker);
 
 // runtime/subsystems/jobs/memory-job-store.ts
@@ -2155,7 +2997,7 @@ var MemoryJobStore = class {
 
 // runtime/subsystems/jobs/job-orchestrator.memory-backend.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { Inject as Inject9, Injectable as Injectable9, Logger as Logger6, Optional as Optional3 } from "@nestjs/common";
+import { Inject as Inject10, Injectable as Injectable10, Logger as Logger8, Optional as Optional4 } from "@nestjs/common";
 var QUEUED_RUN_AT = /* @__PURE__ */ new Date(864e13);
 var TERMINAL_STATUSES2 = [
   "completed",
@@ -2202,7 +3044,7 @@ var MemoryJobOrchestrator = class {
   stepService;
   multiTenant;
   moduleRef;
-  logger = new Logger6(MemoryJobOrchestrator.name);
+  logger = new Logger8(MemoryJobOrchestrator.name);
   mutex = new PromiseMutex();
   handlerRegistry = /* @__PURE__ */ new Map();
   /**
@@ -2551,7 +3393,7 @@ var MemoryJobOrchestrator = class {
       run,
       step: this.makeStepFn(run),
       spawnChild: this.makeSpawnFn(run),
-      logger: new Logger6(`JobRun:${run.id}`)
+      logger: new Logger8(`JobRun:${run.id}`)
     };
     const attemptsBefore = run.attempts ?? 0;
     try {
@@ -2608,7 +3450,7 @@ var MemoryJobOrchestrator = class {
           kind: "task",
           seq,
           status: "failed",
-          error: serialiseError2(err, nextAttempts, false),
+          error: serialiseError3(err, nextAttempts, false),
           finishedAt: /* @__PURE__ */ new Date(),
           attempts: nextAttempts
         });
@@ -2663,7 +3505,7 @@ var MemoryJobOrchestrator = class {
         finishedAt: now,
         updatedAt: now,
         attempts,
-        error: serialiseError2(err, attempts, false)
+        error: serialiseError3(err, attempts, false)
       });
       this.unblockQueuedDependents(run.id);
     });
@@ -2694,7 +3536,7 @@ var MemoryJobOrchestrator = class {
         startedAt: null,
         claimedAt: null,
         updatedAt: now,
-        error: serialiseError2(err, attempts, true)
+        error: serialiseError3(err, attempts, true)
       });
     });
   }
@@ -2724,9 +3566,9 @@ var MemoryJobOrchestrator = class {
   }
 };
 MemoryJobOrchestrator = __decorateClass([
-  Injectable9(),
-  __decorateParam(2, Inject9(JOBS_MULTI_TENANT)),
-  __decorateParam(3, Optional3())
+  Injectable10(),
+  __decorateParam(2, Inject10(JOBS_MULTI_TENANT)),
+  __decorateParam(3, Optional4())
 ], MemoryJobOrchestrator);
 function classifyError2(err, policy, currentAttempts) {
   if (!policy) return "fail";
@@ -2749,7 +3591,7 @@ function computeBackoff2(policy, attempts) {
   }
   return raw;
 }
-function serialiseError2(err, attempt, retryable) {
+function serialiseError3(err, attempt, retryable) {
   const e = err;
   return {
     message: e?.message ?? String(err),
@@ -2760,7 +3602,7 @@ function serialiseError2(err, attempt, retryable) {
 }
 
 // runtime/subsystems/jobs/job-run-service.memory-backend.ts
-import { Inject as Inject10, Injectable as Injectable10 } from "@nestjs/common";
+import { Inject as Inject11, Injectable as Injectable11 } from "@nestjs/common";
 var NON_TERMINAL_STATUSES2 = [
   "pending",
   "running",
@@ -2877,6 +3719,38 @@ var MemoryJobRunService = class {
       createdAt: r.createdAt
     }));
   }
+  async listJobRuns(query = {}) {
+    const limit = clampLimit(query.limit);
+    const tenantCheck = this.tenantPredicate("listJobRuns", query.tenantId);
+    const keyset = query.cursor ? decodeKeysetCursor(query.cursor) : null;
+    const matched = [];
+    for (const r of this.store.runs.values()) {
+      if (tenantCheck && !tenantCheck(r)) continue;
+      if (query.poolId && r.pool !== query.poolId) continue;
+      if (query.rootRunId && r.rootRunId !== query.rootRunId) continue;
+      if (query.status && r.status !== query.status) continue;
+      if (query.since && r.createdAt.getTime() < query.since.getTime()) continue;
+      matched.push(r);
+    }
+    matched.sort((a, b) => {
+      const dt = b.createdAt.getTime() - a.createdAt.getTime();
+      if (dt !== 0) return dt;
+      return a.id < b.id ? 1 : a.id > b.id ? -1 : 0;
+    });
+    const seeked = keyset ? matched.filter((r) => {
+      const ct = r.createdAt.getTime();
+      const kt = keyset.createdAt.getTime();
+      if (ct < kt) return true;
+      if (ct > kt) return false;
+      return r.id < keyset.id;
+    }) : matched;
+    const hasMore = seeked.length > limit;
+    const page = hasMore ? seeked.slice(0, limit) : seeked;
+    const items = page.map(toJobRunSummary);
+    const last = page[page.length - 1];
+    const nextCursor = hasMore && last ? encodeKeysetCursor({ createdAt: last.createdAt, id: last.id }) : null;
+    return { items, nextCursor };
+  }
   /**
    * Direct lookup. Not on the protocol — concrete-class convenience for
    * tests. Matches `DrizzleJobRunService.findByRootRunId` in spirit; both
@@ -2895,9 +3769,9 @@ var MemoryJobRunService = class {
   }
 };
 MemoryJobRunService = __decorateClass([
-  Injectable10(),
-  __decorateParam(1, Inject10(JOB_ORCHESTRATOR)),
-  __decorateParam(2, Inject10(JOBS_MULTI_TENANT))
+  Injectable11(),
+  __decorateParam(1, Inject11(JOB_ORCHESTRATOR)),
+  __decorateParam(2, Inject11(JOBS_MULTI_TENANT))
 ], MemoryJobRunService);
 function compareBy(a, b, order) {
   switch (order) {
@@ -2915,7 +3789,7 @@ function compareBy(a, b, order) {
 
 // runtime/subsystems/jobs/job-step-service.memory-backend.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { Injectable as Injectable11 } from "@nestjs/common";
+import { Injectable as Injectable12 } from "@nestjs/common";
 var MemoryJobStepService = class {
   constructor(store) {
     this.store = store;
@@ -3008,14 +3882,13 @@ var MemoryJobStepService = class {
   }
 };
 MemoryJobStepService = __decorateClass([
-  Injectable11()
+  Injectable12()
 ], MemoryJobStepService);
 
 // runtime/subsystems/jobs/jobs-domain.module.ts
 import { Module as Module2 } from "@nestjs/common";
 var JobsDomainModule = class {
   static forRoot(opts) {
-    void opts.extensions;
     const multiTenant = opts.multiTenant ?? false;
     const providers = [
       // JOB-8 — boolean provider consumed by the four service-layer backends.
@@ -3034,21 +3907,32 @@ var JobsDomainModule = class {
       providers.push({ provide: JOB_ORCHESTRATOR, useExisting: MemoryJobOrchestrator });
       providers.push(MemoryJobRunService);
       providers.push({ provide: JOB_RUN_SERVICE, useExisting: MemoryJobRunService });
+    } else if (opts.backend === "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
+    ];
+    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
     };
   }
 };
@@ -3058,143 +3942,24 @@ JobsDomainModule = __decorateClass([
 
 // runtime/subsystems/jobs/job-worker.module.ts
 import {
-  Inject as Inject11,
-  Injectable as Injectable12,
-  Logger as Logger7,
+  Inject as Inject12,
+  Injectable as Injectable13,
+  Logger as Logger9,
   Module as Module3,
-  Optional as Optional4
+  Optional as Optional5
 } from "@nestjs/common";
-
-// runtime/subsystems/jobs/pool-config.loader.ts
-import { existsSync, readFileSync } from "fs";
-import { resolve } from "path";
-import { parse as parseYaml } from "yaml";
-var FRAMEWORK_POOLS = Object.freeze({
-  events_inbound: Object.freeze({
-    queue: "jobs-events-inbound",
-    concurrency: 20,
-    reserved: true,
-    description: "Inbound events drain (events subsystem outbox)."
-  }),
-  events_change: Object.freeze({
-    queue: "jobs-events-change",
-    concurrency: 30,
-    reserved: true,
-    description: "Change events drain (events subsystem outbox)."
-  }),
-  events_outbound: Object.freeze({
-    queue: "jobs-events-outbound",
-    concurrency: 10,
-    reserved: true,
-    description: "Outbound events drain (events subsystem outbox)."
-  }),
-  interactive: Object.freeze({
-    queue: "jobs-interactive",
-    concurrency: 20,
-    reserved: false,
-    description: "User-facing latency-sensitive jobs."
-  }),
-  batch: Object.freeze({
-    queue: "jobs-batch",
-    concurrency: 5,
-    reserved: false,
-    description: "Default pool for background jobs."
-  })
-});
-var RESERVED_POOL_NAMES = new Set(
-  Object.entries(FRAMEWORK_POOLS).filter(([, def]) => def.reserved).map(([name]) => name)
-);
-var cache = /* @__PURE__ */ new Map();
-function loadPoolConfig(configPath) {
-  const resolved = resolve(configPath ?? `${process.cwd()}/codegen.config.yaml`);
-  const cached = cache.get(resolved);
-  if (cached) return cached;
-  const merged = /* @__PURE__ */ new Map();
-  for (const [name, def] of Object.entries(FRAMEWORK_POOLS)) {
-    merged.set(name, { ...def });
-  }
-  if (!existsSync(resolved)) {
-    cache.set(resolved, merged);
-    return merged;
-  }
-  let raw;
-  try {
-    raw = parseYaml(readFileSync(resolved, "utf8"));
-  } catch (err) {
-    throw new Error(
-      `pool-config.loader: failed to parse YAML at ${resolved}: ${err.message}`
-    );
-  }
-  const userPools = extractUserPools(raw);
-  for (const [name, userDef] of Object.entries(userPools)) {
-    const existing = merged.get(name);
-    if (existing) {
-      const next = {
-        queue: existing.queue,
-        concurrency: typeof userDef.concurrency === "number" ? userDef.concurrency : existing.concurrency,
-        reserved: existing.reserved,
-        description: userDef.description ?? existing.description
-      };
-      merged.set(name, next);
-      continue;
-    }
-    if (typeof userDef.queue !== "string" || userDef.queue.length === 0) {
-      throw new Error(
-        `pool-config.loader: pool '${name}' must declare a non-empty 'queue'.`
-      );
-    }
-    if (typeof userDef.concurrency !== "number" || userDef.concurrency <= 0) {
-      throw new Error(
-        `pool-config.loader: pool '${name}' must declare a positive 'concurrency'.`
-      );
-    }
-    if (userDef.reserved === true) {
-      throw new Error(
-        `pool-config.loader: user-defined pool '${name}' cannot set 'reserved: true' \u2014 reserved is framework-only.`
-      );
-    }
-    merged.set(name, {
-      queue: userDef.queue,
-      concurrency: userDef.concurrency,
-      reserved: false,
-      description: userDef.description
-    });
-  }
-  cache.set(resolved, merged);
-  return merged;
-}
-function allNonReservedPoolNames(config) {
-  const out = [];
-  for (const [name, def] of config) {
-    if (!def.reserved) out.push(name);
-  }
-  return out;
-}
-function extractUserPools(raw) {
-  if (!raw || typeof raw !== "object") return {};
-  const jobs2 = raw.jobs;
-  if (!jobs2 || typeof jobs2 !== "object") return {};
-  const pools = jobs2.pools;
-  if (!pools || typeof pools !== "object") return {};
-  const out = {};
-  for (const [name, def] of Object.entries(pools)) {
-    if (!def || typeof def !== "object") continue;
-    out[name] = def;
-  }
-  return out;
-}
-
-// runtime/subsystems/jobs/job-worker.module.ts
 var DEFAULT_SHUTDOWN_TIMEOUT_MS2 = 3e4;
 var JOB_WORKER_MODULE_OPTIONS = /* @__PURE__ */ Symbol("JOB_WORKER_MODULE_OPTIONS");
 var JobWorkerOrchestrator = class {
-  constructor(orchestrator, runService, stepService, options, db = null, moduleRef) {
+  constructor(orchestrator, runService, stepService, options, db = null, moduleRef, bullConnection = null, bullConfig = null) {
     this.orchestrator = orchestrator;
     this.runService = runService;
     this.stepService = stepService;
     this.options = options;
     this.db = db;
     this.moduleRef = moduleRef;
+    this.bullConnection = bullConnection;
+    this.bullConfig = bullConfig;
   }
   orchestrator;
   runService;
@@ -3202,7 +3967,9 @@ var JobWorkerOrchestrator = class {
   options;
   db;
   moduleRef;
-  logger = new Logger7(JobWorkerOrchestrator.name);
+  bullConnection;
+  bullConfig;
+  logger = new Logger9(JobWorkerOrchestrator.name);
   workers = [];
   // ============================================================================
   // Lifecycle
@@ -3219,7 +3986,7 @@ var JobWorkerOrchestrator = class {
     if (backend !== "memory" && orphaned.length > 0) {
       throw new BootValidationError(orphaned);
     }
-    const activePools = this.options.pools ?? allNonReservedPoolNames(poolConfig);
+    const activePools = this.options.pools ? this.options.pools : this.options.allPools ? allPoolNames(poolConfig) : allNonReservedPoolNames(poolConfig);
     for (const poolName of activePools) {
       const def = poolConfig.get(poolName);
       if (!def) {
@@ -3232,11 +3999,11 @@ var JobWorkerOrchestrator = class {
         concurrency: def.concurrency,
         shutdownTimeoutMs: this.options.shutdownTimeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS2
       };
-      const worker = this.options.workerFactory ? this.options.workerFactory(workerOptions) : this.spawnWorker(workerOptions);
-      worker.onModuleInit();
+      const worker = this.options.workerFactory ? this.options.workerFactory(workerOptions) : backend === "bullmq" ? this.spawnBullMQWorker(poolName, def.queue, def.concurrency, poolConfig) : this.spawnWorker(workerOptions);
+      await worker.onModuleInit();
       this.workers.push(worker);
       this.logger.log(
-        `JobWorker started: pool='${poolName}' (queue='${def.queue}') concurrency=${def.concurrency}`
+        `JobWorker started: pool='${poolName}' (queue='${def.queue}') concurrency=${def.concurrency} backend='${backend}'`
       );
     }
   }
@@ -3253,6 +4020,16 @@ var JobWorkerOrchestrator = class {
       }
     }
     this.workers.length = 0;
+    const orch = this.orchestrator;
+    if (typeof orch.closeConnections === "function") {
+      try {
+        await orch.closeConnections();
+      } catch (err) {
+        this.logger.error(
+          `BullMQ orchestrator connection close failed: ${err.message}`
+        );
+      }
+    }
   }
   // ============================================================================
   // Internals
@@ -3314,15 +4091,57 @@ var JobWorkerOrchestrator = class {
       this.moduleRef
     );
   }
+  /**
+   * BULLMQ-1 — spawn a per-pool `BullMQJobWorker`. Requires the Drizzle
+   * client (the worker drives `job_run` as the source of truth) AND the
+   * resolved BullMQ connection (bound by `JobsDomainModule` when
+   * `backend: 'bullmq'`). The queue name is derived identically to the
+   * orchestrator's `dispatch` via `resolvePoolQueueName(pool, …)` so producer
+   * and consumer agree.
+   */
+  spawnBullMQWorker(pool, _queueAlias, concurrency, poolConfig) {
+    if (!this.db) {
+      throw new Error(
+        `JobWorkerModule: BullMQ worker spawning requires the Drizzle client (no DRIZZLE provider available) \u2014 job_run remains the source of truth.`
+      );
+    }
+    if (!this.bullConnection) {
+      throw new Error(
+        `JobWorkerModule: BullMQ worker spawning requires a resolved BULLMQ_CONNECTION. Ensure JobsDomainModule was booted with backend: 'bullmq'.`
+      );
+    }
+    if (!this.moduleRef) {
+      throw new Error(
+        `JobWorkerModule: ModuleRef not available \u2014 cannot construct BullMQJobWorker with handler DI support.`
+      );
+    }
+    const queueName = resolvePoolQueueName(pool, this.bullConfig, poolConfig);
+    return new BullMQJobWorker(
+      this.db,
+      this.orchestrator,
+      this.stepService,
+      {
+        pool,
+        queueName,
+        concurrency,
+        connection: this.bullConnection
+      },
+      this.moduleRef
+    );
+  }
 };
 JobWorkerOrchestrator = __decorateClass([
-  Injectable12(),
-  __decorateParam(0, Inject11(JOB_ORCHESTRATOR)),
-  __decorateParam(1, Inject11(JOB_RUN_SERVICE)),
-  __decorateParam(2, Inject11(JOB_STEP_SERVICE)),
-  __decorateParam(3, Inject11(JOB_WORKER_MODULE_OPTIONS)),
-  __decorateParam(4, Optional4()),
-  __decorateParam(4, Inject11(DRIZZLE))
+  Injectable13(),
+  __decorateParam(0, Inject12(JOB_ORCHESTRATOR)),
+  __decorateParam(1, Inject12(JOB_RUN_SERVICE)),
+  __decorateParam(2, Inject12(JOB_STEP_SERVICE)),
+  __decorateParam(3, Inject12(JOB_WORKER_MODULE_OPTIONS)),
+  __decorateParam(4, Optional5()),
+  __decorateParam(4, Inject12(DRIZZLE)),
+  __decorateParam(6, Optional5()),
+  __decorateParam(6, Inject12(BULLMQ_CONNECTION)),
+  __decorateParam(7, Optional5()),
+  __decorateParam(7, Inject12(BULLMQ_RESOLVED_CONFIG))
 ], JobWorkerOrchestrator);
 var JobWorkerModule = class {
   static forRoot(opts) {
@@ -3339,7 +4158,14 @@ var JobWorkerModule = class {
         { provide: JOB_WORKER_MODULE_OPTIONS, useValue: opts },
         JobWorkerOrchestrator
       ],
-      exports: []
+      // BULLMQ-1 Phase 1 — export the options token so `BridgeModule`'s
+      // reserved-pool guard (`onModuleInit`) can actually inject it.
+      // Previously `exports: []` left the `@Optional()` inject resolving to
+      // `undefined` and the guard silently no-opped (a dead check). With the
+      // token exported the guard fires for real; consumers that omit the
+      // reserved pools (and don't set `allPools`) now fail fast with
+      // `BridgeReservedPoolsNotPolledError` — which is correct.
+      exports: [JOB_WORKER_MODULE_OPTIONS]
     };
   }
 };
@@ -3355,8 +4181,8 @@ var CACHE_DEFAULT_TTL = /* @__PURE__ */ Symbol("CACHE_DEFAULT_TTL");
 import { Module as Module4 } from "@nestjs/common";
 
 // runtime/subsystems/cache/cache.drizzle-backend.ts
-import { Injectable as Injectable13, Inject as Inject12, Optional as Optional5 } from "@nestjs/common";
-import { gt as gt2, or, like, sql as sql6, eq as eq6 } from "drizzle-orm";
+import { Injectable as Injectable14, Inject as Inject13, Optional as Optional6 } from "@nestjs/common";
+import { gt as gt2, or as or3, like, sql as sql7, eq as eq8 } from "drizzle-orm";
 
 // runtime/subsystems/cache/cache.schema.ts
 import { pgTable as pgTable3, text as text3, jsonb as jsonb3, timestamp as timestamp3 } from "drizzle-orm/pg-core";
@@ -3399,7 +4225,7 @@ var DrizzleCacheService = class {
   async get(key) {
     try {
       const rows = await this.db.select().from(cacheEntries).where(
-        sql6`${cacheEntries.key} = ${key} AND (${cacheEntries.expiresAt} IS NULL OR ${cacheEntries.expiresAt} > now())`
+        sql7`${cacheEntries.key} = ${key} AND (${cacheEntries.expiresAt} IS NULL OR ${cacheEntries.expiresAt} > now())`
       ).limit(1);
       if (rows.length === 0) return null;
       return rows[0].value;
@@ -3417,7 +4243,7 @@ var DrizzleCacheService = class {
     });
   }
   async delete(key) {
-    await this.db.delete(cacheEntries).where(eq6(cacheEntries.key, key));
+    await this.db.delete(cacheEntries).where(eq8(cacheEntries.key, key));
   }
   async invalidateByPrefix(prefix) {
     const escaped = prefix.replace(/%/g, "\\%").replace(/_/g, "\\_");
@@ -3450,8 +4276,8 @@ var DrizzleCacheService = class {
   async deleteExpired() {
     try {
       await this.db.delete(cacheEntries).where(
-        or(
-          gt2(sql6`now()`, cacheEntries.expiresAt)
+        or3(
+          gt2(sql7`now()`, cacheEntries.expiresAt)
         )
       );
     } catch {
@@ -3459,14 +4285,14 @@ var DrizzleCacheService = class {
   }
 };
 DrizzleCacheService = __decorateClass([
-  Injectable13(),
-  __decorateParam(0, Inject12(DRIZZLE)),
-  __decorateParam(1, Optional5()),
-  __decorateParam(1, Inject12(CACHE_DEFAULT_TTL))
+  Injectable14(),
+  __decorateParam(0, Inject13(DRIZZLE)),
+  __decorateParam(1, Optional6()),
+  __decorateParam(1, Inject13(CACHE_DEFAULT_TTL))
 ], DrizzleCacheService);
 
 // runtime/subsystems/cache/cache.memory-backend.ts
-import { Injectable as Injectable14, Inject as Inject13, Optional as Optional6 } from "@nestjs/common";
+import { Injectable as Injectable15, Inject as Inject14, Optional as Optional7 } from "@nestjs/common";
 var MemoryCacheService = class {
   constructor(defaultTtl = null) {
     this.defaultTtl = defaultTtl;
@@ -3540,9 +4366,9 @@ var MemoryCacheService = class {
   }
 };
 MemoryCacheService = __decorateClass([
-  Injectable14(),
-  __decorateParam(0, Optional6()),
-  __decorateParam(0, Inject13(CACHE_DEFAULT_TTL))
+  Injectable15(),
+  __decorateParam(0, Optional7()),
+  __decorateParam(0, Inject14(CACHE_DEFAULT_TTL))
 ], MemoryCacheService);
 
 // runtime/subsystems/cache/cache.module.ts
@@ -3802,24 +4628,27 @@ var OBSERVABILITY_MODULE_OPTIONS = "OBSERVABILITY_MODULE_OPTIONS";
 import { Module as Module6 } from "@nestjs/common";
 
 // runtime/subsystems/observability/observability.service.ts
-import { Inject as Inject14, Injectable as Injectable15, Optional as Optional7 } from "@nestjs/common";
+import { Inject as Inject15, Injectable as Injectable16, Optional as Optional8 } from "@nestjs/common";
 
 // runtime/subsystems/sync/sync.tokens.ts
 var SYNC_CURSOR_STORE = "SYNC_CURSOR_STORE";
 var SYNC_RUN_RECORDER = "SYNC_RUN_RECORDER";
 
 // runtime/subsystems/observability/observability.service.ts
+var MAX_TIMELINE_PAGES = 50;
 var ObservabilityService = class {
-  constructor(jobRuns2, bridge, syncRuns, cursors) {
+  constructor(jobRuns2, bridge, syncRuns, cursors, events) {
     this.jobRuns = jobRuns2;
     this.bridge = bridge;
     this.syncRuns = syncRuns;
     this.cursors = cursors;
+    this.events = events;
   }
   jobRuns;
   bridge;
   syncRuns;
   cursors;
+  events;
   async getPoolDepths(tenantId) {
     if (!this.jobRuns) return [];
     return this.jobRuns.countByPoolAndStatus(tenantId);
@@ -3840,6 +4669,96 @@ var ObservabilityService = class {
     if (!this.cursors) return [];
     return this.cursors.listAll(tenantId);
   }
+  async listJobRuns(query) {
+    if (!this.jobRuns) {
+      return { ...ObservabilityService.EMPTY_JOB_RUN_PAGE };
+    }
+    return this.jobRuns.listJobRuns(query);
+  }
+  async listEvents(query) {
+    if (!this.events) {
+      return { ...ObservabilityService.EMPTY_EVENT_PAGE };
+    }
+    return this.events.listEvents(query);
+  }
+  async getCorrelationTimeline(rootRunId, tenantId) {
+    const runs = await this.collectRuns(rootRunId, tenantId);
+    const events = await this.collectEvents(rootRunId, tenantId);
+    const entries = [
+      ...runs.map(
+        (run) => ({
+          kind: "job_run",
+          at: run.createdAt,
+          run
+        })
+      ),
+      ...events.map(
+        (event) => ({
+          kind: "event",
+          at: event.occurredAt,
+          event
+        })
+      )
+    ];
+    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.
+   */
+  async collectRuns(rootRunId, tenantId) {
+    if (!this.jobRuns) return [];
+    const out = [];
+    let cursor;
+    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.
+   */
+  async collectEvents(rootRunId, tenantId) {
+    if (!this.events) return [];
+    const out = [];
+    let cursor;
+    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;
+  }
 };
 /**
  * All-zero histogram used when the bridge subsystem is absent. Matches
@@ -3852,23 +4771,34 @@ __publicField(ObservabilityService, "EMPTY_HISTOGRAM", {
   skipped: 0,
   failed: 0
 });
+/** Empty page used when a sibling read port is absent. */
+__publicField(ObservabilityService, "EMPTY_JOB_RUN_PAGE", {
+  items: [],
+  nextCursor: null
+});
+__publicField(ObservabilityService, "EMPTY_EVENT_PAGE", {
+  items: [],
+  nextCursor: null
+});
 ObservabilityService = __decorateClass([
-  Injectable15(),
-  __decorateParam(0, Optional7()),
-  __decorateParam(0, Inject14(JOB_RUN_SERVICE)),
-  __decorateParam(1, Optional7()),
-  __decorateParam(1, Inject14(BRIDGE_DELIVERY_REPO)),
-  __decorateParam(2, Optional7()),
-  __decorateParam(2, Inject14(SYNC_RUN_RECORDER)),
-  __decorateParam(3, Optional7()),
-  __decorateParam(3, Inject14(SYNC_CURSOR_STORE))
+  Injectable16(),
+  __decorateParam(0, Optional8()),
+  __decorateParam(0, Inject15(JOB_RUN_SERVICE)),
+  __decorateParam(1, Optional8()),
+  __decorateParam(1, Inject15(BRIDGE_DELIVERY_REPO)),
+  __decorateParam(2, Optional8()),
+  __decorateParam(2, Inject15(SYNC_RUN_RECORDER)),
+  __decorateParam(3, Optional8()),
+  __decorateParam(3, Inject15(SYNC_CURSOR_STORE)),
+  __decorateParam(4, Optional8()),
+  __decorateParam(4, Inject15(EVENT_READ_PORT))
 ], ObservabilityService);
 
 // runtime/subsystems/observability/reporters/bridge-metrics.reporter.ts
 import {
-  Inject as Inject15,
-  Injectable as Injectable16,
-  Logger as Logger8
+  Inject as Inject16,
+  Injectable as Injectable17,
+  Logger as Logger10
 } from "@nestjs/common";
 var BridgeMetricsReporter = class {
   constructor(observability, options) {
@@ -3876,7 +4806,7 @@ var BridgeMetricsReporter = class {
     this.config = options.reporters?.bridgeMetrics;
   }
   observability;
-  logger = new Logger8(BridgeMetricsReporter.name);
+  logger = new Logger10(BridgeMetricsReporter.name);
   handle = null;
   config;
   onModuleInit() {
@@ -3927,9 +4857,9 @@ var BridgeMetricsReporter = class {
   }
 };
 BridgeMetricsReporter = __decorateClass([
-  Injectable16(),
-  __decorateParam(0, Inject15(OBSERVABILITY)),
-  __decorateParam(1, Inject15(OBSERVABILITY_MODULE_OPTIONS))
+  Injectable17(),
+  __decorateParam(0, Inject16(OBSERVABILITY)),
+  __decorateParam(1, Inject16(OBSERVABILITY_MODULE_OPTIONS))
 ], BridgeMetricsReporter);
 
 // runtime/subsystems/observability/observability.module.ts
@@ -4223,7 +5153,7 @@ var MemoryOAuthStateStore = class {
 
 // runtime/subsystems/auth/backends/state-store.drizzle-backend.ts
 import { randomBytes as randomBytes3 } from "crypto";
-import { eq as eq7 } from "drizzle-orm";
+import { eq as eq9 } from "drizzle-orm";
 var DrizzleOAuthStateStore = class {
   constructor(db, opts = {}) {
     this.db = db;
@@ -4247,7 +5177,7 @@ var DrizzleOAuthStateStore = class {
     return state;
   }
   async consume(state) {
-    const rows = await this.db.delete(authOAuthState).where(eq7(authOAuthState.state, state)).returning();
+    const rows = await this.db.delete(authOAuthState).where(eq9(authOAuthState.state, state)).returning();
     const row = rows[0];
     if (!row) {
       throw new OAuthStateError(
@@ -4269,7 +5199,7 @@ var DrizzleOAuthStateStore = class {
 import {
   Controller,
   Get,
-  Inject as Inject16,
+  Inject as Inject17,
   Param,
   Query,
   Req,
@@ -4371,13 +5301,17 @@ __decorateClass([
 ], AuthController.prototype, "callback", 1);
 AuthController = __decorateClass([
   Controller("auth"),
-  __decorateParam(0, Inject16(STRATEGY_REGISTRY)),
-  __decorateParam(1, Inject16(AUTH_USER_CONTEXT)),
-  __decorateParam(2, Inject16(OAUTH_STATE_STORE)),
-  __decorateParam(3, Inject16(AUTH_INTEGRATION_GRANT_SINK)),
-  __decorateParam(4, Inject16(AUTH_OPTIONS))
+  __decorateParam(0, Inject17(STRATEGY_REGISTRY)),
+  __decorateParam(1, Inject17(AUTH_USER_CONTEXT)),
+  __decorateParam(2, Inject17(OAUTH_STATE_STORE)),
+  __decorateParam(3, Inject17(AUTH_INTEGRATION_GRANT_SINK)),
+  __decorateParam(4, Inject17(AUTH_OPTIONS))
 ], AuthController);
 
+// runtime/base-classes/tenant-context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var als = new AsyncLocalStorage();
+
 // runtime/subsystems/auth/auth.module.ts
 import { Module as Module7 } from "@nestjs/common";
 function resolveEncryptionKeyProvider(choice) {