@pattern-stack/codegen 0.4.4 → 0.4.6

package/dist/runtime/subsystems/index.js

@@ -1,5 +1,29 @@
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc5) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc5 = __getOwnPropDesc(from, key)) || desc5.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __decorateClass = (decorators, target, key, kind) => {
   var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
@@ -8,7 +32,470 @@ var __decorateClass = (decorators, target, key, kind) => {
   if (kind && result) __defProp(target, key, result);
   return result;
 };
-var __decorateParam = (index3, decorator) => (target, key) => decorator(target, key, index3);
+var __decorateParam = (index5, decorator) => (target, key) => decorator(target, key, index5);
+
+// runtime/constants/tokens.ts
+var DRIZZLE;
+var init_tokens = __esm({
+  "runtime/constants/tokens.ts"() {
+    "use strict";
+    DRIZZLE = "DRIZZLE";
+  }
+});
+
+// runtime/subsystems/events/domain-events.schema.ts
+import {
+  index,
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  uuid
+} from "drizzle-orm/pg-core";
+var domainEvents;
+var init_domain_events_schema = __esm({
+  "runtime/subsystems/events/domain-events.schema.ts"() {
+    "use strict";
+    domainEvents = pgTable(
+      "domain_events",
+      {
+        id: uuid("id").primaryKey(),
+        type: text("type").notNull(),
+        aggregateId: text("aggregate_id").notNull(),
+        aggregateType: text("aggregate_type").notNull(),
+        payload: jsonb("payload").notNull().$type(),
+        occurredAt: timestamp("occurred_at", { withTimezone: true }).notNull(),
+        processedAt: timestamp("processed_at", { withTimezone: true }),
+        /** Lifecycle status: pending | processed | failed */
+        status: text("status").notNull().default("pending"),
+        /** Error message from the last failed dispatch attempt. */
+        error: text("error"),
+        metadata: jsonb("metadata").$type(),
+        /** Routing pool (e.g. `events_inbound`, `events_change`, `events_outbound`). Populated by DrizzleEventBus.publish() in EVT-4. */
+        pool: text("pool"),
+        /** Routing direction: `inbound` | `change` | `outbound`. Populated by DrizzleEventBus.publish() in EVT-4. */
+        direction: text("direction"),
+        // conditional: emitted only when events.multi_tenant: true
+        tenantId: text("tenant_id")
+      },
+      (t) => ({
+        /** Polling drain filter (existing — promoted from comment to declaration in EVT-1). */
+        idxDomainEventsStatusOccurredAt: index("idx_domain_events_status_occurred_at").on(
+          t.status,
+          t.occurredAt
+        ),
+        /** Event replay per aggregate (existing — promoted from comment to declaration in EVT-1). */
+        idxDomainEventsAggregate: index("idx_domain_events_aggregate").on(
+          t.aggregateId,
+          t.aggregateType
+        ),
+        /** Per-pool drain filter (EVT-1). Enables DrizzleEventBus to drain a single pool without scanning all events. */
+        idxDomainEventsPoolStatusOccurredAt: index(
+          "idx_domain_events_pool_status_occurred_at"
+        ).on(t.pool, t.status, t.occurredAt)
+      })
+    );
+  }
+});
+
+// runtime/subsystems/jobs/job-orchestration.schema.ts
+import {
+  pgEnum,
+  pgTable as pgTable2,
+  uuid as uuid2,
+  text as text2,
+  jsonb as jsonb2,
+  integer,
+  timestamp as timestamp2,
+  index as index2,
+  uniqueIndex
+} from "drizzle-orm/pg-core";
+import { sql } from "drizzle-orm";
+var jobRunStatusEnum, jobStepKindEnum, jobStepStatusEnum, collisionModeEnum, replayFromEnum, parentClosePolicyEnum, waitKindEnum, triggerSourceEnum, jobs, jobRuns, jobSteps;
+var init_job_orchestration_schema = __esm({
+  "runtime/subsystems/jobs/job-orchestration.schema.ts"() {
+    "use strict";
+    jobRunStatusEnum = pgEnum("job_run_status", [
+      "pending",
+      "running",
+      "waiting",
+      "completed",
+      "failed",
+      "timed_out",
+      "canceled"
+    ]);
+    jobStepKindEnum = pgEnum("job_step_kind", ["task"]);
+    jobStepStatusEnum = pgEnum("job_step_status", [
+      "pending",
+      "running",
+      "completed",
+      "failed",
+      "skipped"
+    ]);
+    collisionModeEnum = pgEnum("job_collision_mode", [
+      "queue",
+      "reject",
+      "replace"
+    ]);
+    replayFromEnum = pgEnum("job_replay_from", [
+      "scratch",
+      "last_step",
+      "last_checkpoint"
+    ]);
+    parentClosePolicyEnum = pgEnum("job_parent_close_policy", [
+      "terminate",
+      "cancel",
+      "abandon"
+    ]);
+    waitKindEnum = pgEnum("job_wait_kind", ["signal"]);
+    triggerSourceEnum = pgEnum("job_trigger_source", [
+      "manual",
+      "schedule",
+      "event",
+      "parent"
+    ]);
+    jobs = pgTable2("job", {
+      type: text2("type").primaryKey(),
+      version: integer("version").notNull().default(1),
+      pool: text2("pool").notNull(),
+      scopeEntityType: text2("scope_entity_type"),
+      retryPolicy: jsonb2("retry_policy").notNull().$type(),
+      timeoutMs: integer("timeout_ms"),
+      concurrencyKeyTemplate: text2("concurrency_key_template"),
+      collisionMode: collisionModeEnum("collision_mode").notNull().default("queue"),
+      dedupeKeyTemplate: text2("dedupe_key_template"),
+      dedupeWindowMs: integer("dedupe_window_ms"),
+      priorityDefault: integer("priority_default").notNull().default(0),
+      replayFrom: replayFromEnum("replay_from").notNull().default("last_checkpoint"),
+      createdAt: timestamp2("created_at", { withTimezone: true }).notNull().defaultNow(),
+      updatedAt: timestamp2("updated_at", { withTimezone: true }).notNull().defaultNow()
+    });
+    jobRuns = pgTable2(
+      "job_run",
+      {
+        id: uuid2("id").primaryKey().defaultRandom(),
+        jobType: text2("job_type").notNull().references(() => jobs.type),
+        jobVersion: integer("job_version").notNull(),
+        parentRunId: uuid2("parent_run_id").references(() => jobRuns.id),
+        /**
+         * Service generates `id` client-side via randomUUID() and sets
+         * root_run_id = id for root runs (single INSERT, no self-FK race).
+         */
+        rootRunId: uuid2("root_run_id").notNull(),
+        parentClosePolicy: parentClosePolicyEnum("parent_close_policy").notNull().default("terminate"),
+        scopeEntityType: text2("scope_entity_type"),
+        scopeEntityId: text2("scope_entity_id"),
+        tenantId: text2("tenant_id"),
+        tags: jsonb2("tags").notNull().default({}).$type(),
+        pool: text2("pool").notNull(),
+        priority: integer("priority").notNull().default(0),
+        concurrencyKey: text2("concurrency_key"),
+        dedupeKey: text2("dedupe_key"),
+        status: jobRunStatusEnum("status").notNull().default("pending"),
+        input: jsonb2("input").notNull().$type(),
+        output: jsonb2("output").$type(),
+        error: jsonb2("error").$type(),
+        triggerSource: triggerSourceEnum("trigger_source").notNull(),
+        triggerRef: text2("trigger_ref"),
+        runAt: timestamp2("run_at", { withTimezone: true }).notNull().defaultNow(),
+        startedAt: timestamp2("started_at", { withTimezone: true }),
+        finishedAt: timestamp2("finished_at", { withTimezone: true }),
+        claimedAt: timestamp2("claimed_at", { withTimezone: true }),
+        attempts: integer("attempts").notNull().default(0),
+        // Phase 3 placeholder — see ADR-025
+        waitKind: waitKindEnum("wait_kind"),
+        // Phase 3 placeholder — see ADR-025
+        resumeToken: text2("resume_token"),
+        // Phase 3 placeholder — see ADR-025
+        waitDeadline: timestamp2("wait_deadline", { withTimezone: true }),
+        createdAt: timestamp2("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp2("updated_at", { withTimezone: true }).notNull().defaultNow()
+      },
+      (t) => ({
+        /** Claim query: ORDER BY priority DESC, run_at ASC. */
+        idxJobRunClaim: index2("idx_job_run_claim").on(t.status, t.pool, t.runAt),
+        /** Tree traversal / cascade cancel. */
+        idxJobRunRoot: index2("idx_job_run_root").on(t.rootRunId),
+        /** 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(sql`${t.dedupeKey} IS NOT NULL`),
+        /** Collision check — partial index. */
+        idxJobRunConcurrency: index2("idx_job_run_concurrency").on(t.concurrencyKey).where(
+          sql`${t.concurrencyKey} IS NOT NULL AND ${t.status} IN ('pending','running')`
+        )
+      })
+    );
+    jobSteps = pgTable2(
+      "job_step",
+      {
+        id: uuid2("id").primaryKey().defaultRandom(),
+        jobRunId: uuid2("job_run_id").notNull().references(() => jobRuns.id),
+        stepId: text2("step_id").notNull(),
+        kind: jobStepKindEnum("kind").notNull().default("task"),
+        /**
+         * Monotonic within run. integer (max ~2B per run) is sufficient —
+         * downgraded from ADR-022's bigint; revisit only if a single run
+         * ever exceeds 2 billion steps.
+         */
+        seq: integer("seq").notNull(),
+        status: jobStepStatusEnum("status").notNull().default("pending"),
+        input: jsonb2("input").$type(),
+        /** Memoised on success for replay. */
+        output: jsonb2("output").$type(),
+        error: jsonb2("error").$type(),
+        attempts: integer("attempts").notNull().default(0),
+        startedAt: timestamp2("started_at", { withTimezone: true }),
+        finishedAt: timestamp2("finished_at", { withTimezone: true })
+      },
+      (t) => ({
+        /** No duplicate step IDs per run. */
+        idxJobStepRunStep: uniqueIndex("idx_job_step_run_step").on(t.jobRunId, t.stepId),
+        /** Ordered timeline reads. */
+        idxJobStepTimeline: index2("idx_job_step_timeline").on(t.jobRunId, t.seq)
+      })
+    );
+  }
+});
+
+// runtime/subsystems/bridge/bridge-delivery.schema.ts
+import {
+  index as index4,
+  jsonb as jsonb5,
+  pgEnum as pgEnum3,
+  pgTable as pgTable5,
+  text as text5,
+  timestamp as timestamp5,
+  unique,
+  uuid as uuid4
+} from "drizzle-orm/pg-core";
+import { sql as sql6 } from "drizzle-orm";
+var bridgeDeliveryStatusEnum, bridgeDelivery;
+var init_bridge_delivery_schema = __esm({
+  "runtime/subsystems/bridge/bridge-delivery.schema.ts"() {
+    "use strict";
+    init_domain_events_schema();
+    init_job_orchestration_schema();
+    bridgeDeliveryStatusEnum = pgEnum3("bridge_delivery_status", [
+      "pending",
+      "delivered",
+      "skipped",
+      "failed"
+    ]);
+    bridgeDelivery = pgTable5(
+      "bridge_delivery",
+      {
+        id: uuid4("id").primaryKey().defaultRandom(),
+        /** FK to the source event in the outbox. */
+        eventId: uuid4("event_id").notNull().references(() => domainEvents.id),
+        /**
+         * Stable codegen-emitted identifier for the (job, trigger) pair, of the
+         * form `<job_type>#<triggerIndex>` (BRIDGE-6). Forms the second half of
+         * the UNIQUE idempotency key.
+         */
+        triggerId: text5("trigger_id").notNull(),
+        /**
+         * Wrapper `job_run.id` (the framework `@framework/bridge_delivery` run
+         * that drove this delivery). Nullable: the facade-eager path
+         * (`publishAndStart` Case B) pre-writes a delivered row with no wrapper.
+         */
+        wrapperRunId: uuid4("wrapper_run_id").references(() => jobRuns.id),
+        /**
+         * Spawned user `job_run.id`. Null until status is `delivered`; remains
+         * null for `skipped` and `failed` deliveries.
+         */
+        userRunId: uuid4("user_run_id").references(() => jobRuns.id),
+        status: bridgeDeliveryStatusEnum("status").notNull().default("pending"),
+        /** Populated when status=`skipped` (e.g. `'when_returned_false'`, `'trigger_unregistered'`). */
+        skipReason: text5("skip_reason"),
+        /** Populated when status=`failed`. Mirrors `job_run.error` shape. */
+        error: jsonb5("error").$type(),
+        /**
+         * Emitted unconditionally and nullable (JOB-8 / SYNC-6 precedent).
+         * Enforcement gated on `BRIDGE_MULTI_TENANT` at the service layer
+         * (BRIDGE-8); no DB constraint.
+         */
+        tenantId: text5("tenant_id"),
+        attemptedAt: timestamp5("attempted_at", { withTimezone: true }).notNull().defaultNow(),
+        deliveredAt: timestamp5("delivered_at", { withTimezone: true })
+      },
+      (t) => ({
+        /**
+         * Idempotency ledger. Outbox replays and facade-vs-drain collisions both
+         * dedup through this constraint.
+         */
+        uqBridgeDeliveryEventTrigger: unique("uq_bridge_delivery_event_trigger").on(
+          t.eventId,
+          t.triggerId
+        ),
+        /** Lookup all deliveries for an event (fanout report, debugging). */
+        idxBridgeDeliveryEvent: index4("idx_bridge_delivery_event").on(t.eventId),
+        /**
+         * Ops dashboard filter — only the actionable states. Partial index keeps
+         * it small at scale (the bulk of rows will be `delivered`).
+         */
+        idxBridgeDeliveryStatus: index4("idx_bridge_delivery_status").on(t.status).where(sql6`${t.status} IN ('pending','failed')`),
+        /**
+         * Reverse lookup from a spawned user run back to its delivery row.
+         * Partial — most rows in the bridge ledger but only successful
+         * deliveries have a `user_run_id`.
+         */
+        idxBridgeDeliveryUserRun: index4("idx_bridge_delivery_user_run").on(t.userRunId).where(sql6`${t.userRunId} IS NOT NULL`)
+      })
+    );
+  }
+});
+
+// runtime/subsystems/observability/reporters/bridge-metrics.reporter.ts
+var bridge_metrics_reporter_exports = {};
+__export(bridge_metrics_reporter_exports, {
+  BridgeMetricsReporter: () => BridgeMetricsReporter
+});
+import {
+  Inject as Inject15,
+  Injectable as Injectable17,
+  Logger as Logger8,
+  Optional as Optional7
+} from "@nestjs/common";
+import { and as and6, eq as eq8, gt as gt3, sql as sql7 } from "drizzle-orm";
+var INTERVAL_NAME, DEFAULT_INTERVAL_MS, MIN_INTERVAL_MS, BridgeMetricsReporter;
+var init_bridge_metrics_reporter = __esm({
+  "runtime/subsystems/observability/reporters/bridge-metrics.reporter.ts"() {
+    "use strict";
+    init_tokens();
+    init_bridge_delivery_schema();
+    init_domain_events_schema();
+    INTERVAL_NAME = "bridge-metrics-tick";
+    DEFAULT_INTERVAL_MS = 6e4;
+    MIN_INTERVAL_MS = 1e3;
+    BridgeMetricsReporter = class {
+      constructor(db, scheduler = null) {
+        this.db = db;
+        this.scheduler = scheduler;
+        this.intervalMs = this.resolveIntervalMs();
+        this.lastTickAt = /* @__PURE__ */ new Date();
+      }
+      db;
+      scheduler;
+      logger = new Logger8(BridgeMetricsReporter.name);
+      intervalMs;
+      lastTickAt;
+      /**
+       * Timer handle retained as a field when `SchedulerRegistry` isn't
+       * available (optional dep). `SchedulerRegistry` is the Nest-idiomatic
+       * home for interval cleanup, but global-module wiring across consumer
+       * topologies doesn't always make it injectable here — the fallback
+       * keeps the reporter self-sufficient.
+       */
+      ownedTimer = null;
+      onModuleInit() {
+        this.logger.log(
+          `BridgeMetricsReporter starting (intervalMs=${this.intervalMs}).`
+        );
+        const timer = setInterval(() => {
+          void this.tick();
+        }, this.intervalMs);
+        timer.unref?.();
+        if (this.scheduler) {
+          this.scheduler.addInterval(INTERVAL_NAME, timer);
+        } else {
+          this.ownedTimer = timer;
+        }
+      }
+      onModuleDestroy() {
+        if (this.scheduler && this.scheduler.getIntervals().includes(INTERVAL_NAME)) {
+          this.scheduler.deleteInterval(INTERVAL_NAME);
+        }
+        if (this.ownedTimer !== null) {
+          clearInterval(this.ownedTimer);
+          this.ownedTimer = null;
+        }
+      }
+      /**
+       * Run one sampling tick. Public so tests can drive it deterministically
+       * without waiting on the timer.
+       */
+      async tick() {
+        const windowStart = this.lastTickAt;
+        const windowEnd = /* @__PURE__ */ new Date();
+        this.lastTickAt = windowEnd;
+        let rows = [];
+        try {
+          rows = await this.sample(windowStart, windowEnd);
+        } catch (err) {
+          this.logger.error(
+            `bridge metrics sample failed: ${err.message}`
+          );
+          return { windowStart, windowEnd, rows: [] };
+        }
+        this.emit({ windowStart, windowEnd, rows });
+        return { windowStart, windowEnd, rows };
+      }
+      async sample(windowStart, windowEnd) {
+        const lastTransition = sql7`COALESCE(${bridgeDelivery.deliveredAt}, ${bridgeDelivery.attemptedAt})`;
+        const result = await this.db.select({
+          status: bridgeDelivery.status,
+          eventType: domainEvents.type,
+          skipReason: bridgeDelivery.skipReason,
+          count: sql7`COUNT(*)::int`
+        }).from(bridgeDelivery).innerJoin(domainEvents, eq8(bridgeDelivery.eventId, domainEvents.id)).where(
+          and6(
+            gt3(lastTransition, windowStart),
+            sql7`${lastTransition} <= ${windowEnd}`
+          )
+        ).groupBy(
+          bridgeDelivery.status,
+          domainEvents.type,
+          bridgeDelivery.skipReason
+        );
+        return result.map((r) => ({
+          status: r.status,
+          eventType: r.eventType,
+          skipReason: r.skipReason,
+          count: r.count
+        }));
+      }
+      emit(tick) {
+        if (tick.rows.length === 0) {
+          this.logger.log(
+            `bridge_metrics tick=empty window=[${tick.windowStart.toISOString()}..${tick.windowEnd.toISOString()}]`
+          );
+          return;
+        }
+        const totals = tick.rows.reduce(
+          (acc, r) => {
+            acc[r.status] = (acc[r.status] ?? 0) + r.count;
+            return acc;
+          },
+          {}
+        );
+        const detail = tick.rows.map(
+          (r) => `${r.eventType}|${r.status}${r.skipReason ? `:${r.skipReason}` : ""}=${r.count}`
+        ).join(" ");
+        this.logger.log(
+          `bridge_metrics tick window=[${tick.windowStart.toISOString()}..${tick.windowEnd.toISOString()}] totals=${JSON.stringify(totals)} detail=[${detail}]`
+        );
+      }
+      resolveIntervalMs() {
+        const raw = process.env["BRIDGE_METRICS_INTERVAL_MS"];
+        if (!raw) return DEFAULT_INTERVAL_MS;
+        const parsed = Number.parseInt(raw, 10);
+        if (!Number.isFinite(parsed) || parsed < MIN_INTERVAL_MS) {
+          new Logger8(BridgeMetricsReporter.name).warn(
+            `Ignoring BRIDGE_METRICS_INTERVAL_MS='${raw}' (invalid or < ${MIN_INTERVAL_MS}ms); using default ${DEFAULT_INTERVAL_MS}ms.`
+          );
+          return DEFAULT_INTERVAL_MS;
+        }
+        return parsed;
+      }
+    };
+    BridgeMetricsReporter = __decorateClass([
+      Injectable17(),
+      __decorateParam(0, Inject15(DRIZZLE)),
+      __decorateParam(1, Optional7())
+    ], BridgeMetricsReporter);
+  }
+});
 
 // runtime/subsystems/events/events.tokens.ts
 var EVENT_BUS = "EVENT_BUS";
@@ -208,63 +695,14 @@ TypedEventBus = __decorateClass([
 
 // runtime/subsystems/events/events.module.ts
 import { Module } from "@nestjs/common";
-
-// runtime/constants/tokens.ts
-var DRIZZLE = "DRIZZLE";
+init_tokens();
 
 // runtime/subsystems/events/event-bus.drizzle-backend.ts
+init_domain_events_schema();
+init_tokens();
 import { Injectable as Injectable2, Inject as Inject2, Logger, Optional } from "@nestjs/common";
 import { eq, and, inArray, asc } from "drizzle-orm";
 
-// runtime/subsystems/events/domain-events.schema.ts
-import {
-  index,
-  jsonb,
-  pgTable,
-  text,
-  timestamp,
-  uuid
-} from "drizzle-orm/pg-core";
-var domainEvents = pgTable(
-  "domain_events",
-  {
-    id: uuid("id").primaryKey(),
-    type: text("type").notNull(),
-    aggregateId: text("aggregate_id").notNull(),
-    aggregateType: text("aggregate_type").notNull(),
-    payload: jsonb("payload").notNull().$type(),
-    occurredAt: timestamp("occurred_at", { withTimezone: true }).notNull(),
-    processedAt: timestamp("processed_at", { withTimezone: true }),
-    /** Lifecycle status: pending | processed | failed */
-    status: text("status").notNull().default("pending"),
-    /** Error message from the last failed dispatch attempt. */
-    error: text("error"),
-    metadata: jsonb("metadata").$type(),
-    /** Routing pool (e.g. `events_inbound`, `events_change`, `events_outbound`). Populated by DrizzleEventBus.publish() in EVT-4. */
-    pool: text("pool"),
-    /** Routing direction: `inbound` | `change` | `outbound`. Populated by DrizzleEventBus.publish() in EVT-4. */
-    direction: text("direction"),
-    // conditional: emitted only when events.multi_tenant: true
-    tenantId: text("tenant_id")
-  },
-  (t) => ({
-    /** Polling drain filter (existing — promoted from comment to declaration in EVT-1). */
-    idxDomainEventsStatusOccurredAt: index("idx_domain_events_status_occurred_at").on(
-      t.status,
-      t.occurredAt
-    ),
-    /** Event replay per aggregate (existing — promoted from comment to declaration in EVT-1). */
-    idxDomainEventsAggregate: index("idx_domain_events_aggregate").on(
-      t.aggregateId,
-      t.aggregateType
-    ),
-    /** Per-pool drain filter (EVT-1). Enables DrizzleEventBus to drain a single pool without scanning all events. */
-    idxDomainEventsPoolStatusOccurredAt: index(
-      "idx_domain_events_pool_status_occurred_at"
-    ).on(t.pool, t.status, t.occurredAt)
-  })
-);
-
 // runtime/subsystems/bridge/bridge.tokens.ts
 var BRIDGE_OUTBOX_DRAIN_HOOK = "BRIDGE_OUTBOX_DRAIN_HOOK";
 
@@ -893,159 +1331,12 @@ EventsModule = __decorateClass([
   Module({})
 ], EventsModule);
 
-// runtime/subsystems/jobs/job-orchestration.schema.ts
-import {
-  pgEnum,
-  pgTable as pgTable2,
-  uuid as uuid2,
-  text as text2,
-  jsonb as jsonb2,
-  integer,
-  timestamp as timestamp2,
-  index as index2,
-  uniqueIndex
-} from "drizzle-orm/pg-core";
-import { sql } from "drizzle-orm";
-var jobRunStatusEnum = pgEnum("job_run_status", [
-  "pending",
-  "running",
-  "waiting",
-  "completed",
-  "failed",
-  "timed_out",
-  "canceled"
-]);
-var jobStepKindEnum = pgEnum("job_step_kind", ["task"]);
-var jobStepStatusEnum = pgEnum("job_step_status", [
-  "pending",
-  "running",
-  "completed",
-  "failed",
-  "skipped"
-]);
-var collisionModeEnum = pgEnum("job_collision_mode", [
-  "queue",
-  "reject",
-  "replace"
-]);
-var replayFromEnum = pgEnum("job_replay_from", [
-  "scratch",
-  "last_step",
-  "last_checkpoint"
-]);
-var parentClosePolicyEnum = pgEnum("job_parent_close_policy", [
-  "terminate",
-  "cancel",
-  "abandon"
-]);
-var waitKindEnum = pgEnum("job_wait_kind", ["signal"]);
-var triggerSourceEnum = pgEnum("job_trigger_source", [
-  "manual",
-  "schedule",
-  "event",
-  "parent"
-]);
-var jobs = pgTable2("job", {
-  type: text2("type").primaryKey(),
-  version: integer("version").notNull().default(1),
-  pool: text2("pool").notNull(),
-  scopeEntityType: text2("scope_entity_type"),
-  retryPolicy: jsonb2("retry_policy").notNull().$type(),
-  timeoutMs: integer("timeout_ms"),
-  concurrencyKeyTemplate: text2("concurrency_key_template"),
-  collisionMode: collisionModeEnum("collision_mode").notNull().default("queue"),
-  dedupeKeyTemplate: text2("dedupe_key_template"),
-  dedupeWindowMs: integer("dedupe_window_ms"),
-  priorityDefault: integer("priority_default").notNull().default(0),
-  replayFrom: replayFromEnum("replay_from").notNull().default("last_checkpoint"),
-  createdAt: timestamp2("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp2("updated_at", { withTimezone: true }).notNull().defaultNow()
-});
-var jobRuns = pgTable2(
-  "job_run",
-  {
-    id: uuid2("id").primaryKey().defaultRandom(),
-    jobType: text2("job_type").notNull().references(() => jobs.type),
-    jobVersion: integer("job_version").notNull(),
-    parentRunId: uuid2("parent_run_id").references(() => jobRuns.id),
-    /**
-     * Service generates `id` client-side via randomUUID() and sets
-     * root_run_id = id for root runs (single INSERT, no self-FK race).
-     */
-    rootRunId: uuid2("root_run_id").notNull(),
-    parentClosePolicy: parentClosePolicyEnum("parent_close_policy").notNull().default("terminate"),
-    scopeEntityType: text2("scope_entity_type"),
-    scopeEntityId: text2("scope_entity_id"),
-    tenantId: text2("tenant_id"),
-    tags: jsonb2("tags").notNull().default({}).$type(),
-    pool: text2("pool").notNull(),
-    priority: integer("priority").notNull().default(0),
-    concurrencyKey: text2("concurrency_key"),
-    dedupeKey: text2("dedupe_key"),
-    status: jobRunStatusEnum("status").notNull().default("pending"),
-    input: jsonb2("input").notNull().$type(),
-    output: jsonb2("output").$type(),
-    error: jsonb2("error").$type(),
-    triggerSource: triggerSourceEnum("trigger_source").notNull(),
-    triggerRef: text2("trigger_ref"),
-    runAt: timestamp2("run_at", { withTimezone: true }).notNull().defaultNow(),
-    startedAt: timestamp2("started_at", { withTimezone: true }),
-    finishedAt: timestamp2("finished_at", { withTimezone: true }),
-    claimedAt: timestamp2("claimed_at", { withTimezone: true }),
-    attempts: integer("attempts").notNull().default(0),
-    // Phase 3 placeholder — see ADR-025
-    waitKind: waitKindEnum("wait_kind"),
-    // Phase 3 placeholder — see ADR-025
-    resumeToken: text2("resume_token"),
-    // Phase 3 placeholder — see ADR-025
-    waitDeadline: timestamp2("wait_deadline", { withTimezone: true }),
-    createdAt: timestamp2("created_at", { withTimezone: true }).notNull().defaultNow(),
-    updatedAt: timestamp2("updated_at", { withTimezone: true }).notNull().defaultNow()
-  },
-  (t) => ({
-    /** Claim query: ORDER BY priority DESC, run_at ASC. */
-    idxJobRunClaim: index2("idx_job_run_claim").on(t.status, t.pool, t.runAt),
-    /** Tree traversal / cascade cancel. */
-    idxJobRunRoot: index2("idx_job_run_root").on(t.rootRunId),
-    /** 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(sql`${t.dedupeKey} IS NOT NULL`),
-    /** Collision check — partial index. */
-    idxJobRunConcurrency: index2("idx_job_run_concurrency").on(t.concurrencyKey).where(
-      sql`${t.concurrencyKey} IS NOT NULL AND ${t.status} IN ('pending','running')`
-    )
-  })
-);
-var jobSteps = pgTable2(
-  "job_step",
-  {
-    id: uuid2("id").primaryKey().defaultRandom(),
-    jobRunId: uuid2("job_run_id").notNull().references(() => jobRuns.id),
-    stepId: text2("step_id").notNull(),
-    kind: jobStepKindEnum("kind").notNull().default("task"),
-    /**
-     * Monotonic within run. integer (max ~2B per run) is sufficient —
-     * downgraded from ADR-022's bigint; revisit only if a single run
-     * ever exceeds 2 billion steps.
-     */
-    seq: integer("seq").notNull(),
-    status: jobStepStatusEnum("status").notNull().default("pending"),
-    input: jsonb2("input").$type(),
-    /** Memoised on success for replay. */
-    output: jsonb2("output").$type(),
-    error: jsonb2("error").$type(),
-    attempts: integer("attempts").notNull().default(0),
-    startedAt: timestamp2("started_at", { withTimezone: true }),
-    finishedAt: timestamp2("finished_at", { withTimezone: true })
-  },
-  (t) => ({
-    /** No duplicate step IDs per run. */
-    idxJobStepRunStep: uniqueIndex("idx_job_step_run_step").on(t.jobRunId, t.stepId),
-    /** Ordered timeline reads. */
-    idxJobStepTimeline: index2("idx_job_step_timeline").on(t.jobRunId, t.seq)
-  })
-);
+// runtime/subsystems/events/index.ts
+init_domain_events_schema();
+
+// runtime/subsystems/jobs/index.ts
+init_job_orchestration_schema();
+init_job_orchestration_schema();
 
 // runtime/subsystems/jobs/jobs-domain.tokens.ts
 var JOB_ORCHESTRATOR = /* @__PURE__ */ Symbol("JOB_ORCHESTRATOR");
@@ -1068,6 +1359,8 @@ var HandlerRegistry;
 })(HandlerRegistry || (HandlerRegistry = {}));
 
 // runtime/subsystems/jobs/job-orchestrator.drizzle-backend.ts
+init_tokens();
+init_job_orchestration_schema();
 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 sql2 } from "drizzle-orm";
@@ -1152,6 +1445,7 @@ var ReservedPoolViolationError = class extends Error {
 };
 
 // runtime/subsystems/jobs/job-orchestrator.drizzle-backend.ts
+init_job_orchestration_schema();
 var TERMINAL_STATUSES = [
   "completed",
   "failed",
@@ -1476,6 +1770,8 @@ function notInStatus(statuses) {
 }
 
 // runtime/subsystems/jobs/job-run-service.drizzle-backend.ts
+init_tokens();
+init_job_orchestration_schema();
 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 } from "drizzle-orm";
 var NON_TERMINAL_STATUSES = [
@@ -1587,6 +1883,8 @@ DrizzleJobRunService = __decorateClass([
 ], DrizzleJobRunService);
 
 // runtime/subsystems/jobs/job-step-service.drizzle-backend.ts
+init_tokens();
+init_job_orchestration_schema();
 import { Inject as Inject7, Injectable as Injectable7 } from "@nestjs/common";
 import { and as and4, eq as eq4 } from "drizzle-orm";
 var DrizzleJobStepService = class {
@@ -1631,6 +1929,8 @@ DrizzleJobStepService = __decorateClass([
 ], DrizzleJobStepService);
 
 // runtime/subsystems/jobs/job-worker.ts
+init_tokens();
+init_job_orchestration_schema();
 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 sql3 } from "drizzle-orm";
 var JOB_WORKER_OPTIONS = /* @__PURE__ */ Symbol("JOB_WORKER_OPTIONS");
@@ -2904,6 +3204,7 @@ JobsDomainModule = __decorateClass([
 ], JobsDomainModule);
 
 // runtime/subsystems/jobs/job-worker.module.ts
+init_tokens();
 import {
   Inject as Inject11,
   Injectable as Injectable12,
@@ -3200,6 +3501,7 @@ var CACHE_DEFAULT_TTL = /* @__PURE__ */ Symbol("CACHE_DEFAULT_TTL");
 
 // runtime/subsystems/cache/cache.module.ts
 import { Module as Module4 } from "@nestjs/common";
+init_tokens();
 
 // runtime/subsystems/cache/cache.drizzle-backend.ts
 import { Injectable as Injectable13, Inject as Inject12, Optional as Optional5 } from "@nestjs/common";
@@ -3221,6 +3523,7 @@ var cacheEntries = pgTable3(
 );
 
 // runtime/subsystems/cache/cache.drizzle-backend.ts
+init_tokens();
 var CLEANUP_INTERVAL_MS = 5 * 60 * 1e3;
 var DrizzleCacheService = class {
   constructor(db, defaultTtl = null) {
@@ -3641,6 +3944,412 @@ StorageModule = __decorateClass([
   Module5({})
 ], StorageModule);
 
+// runtime/subsystems/observability/observability.tokens.ts
+var OBSERVABILITY = /* @__PURE__ */ Symbol("OBSERVABILITY");
+var OBSERVABILITY_REPORTERS = /* @__PURE__ */ Symbol("OBSERVABILITY_REPORTERS");
+
+// runtime/subsystems/observability/observability.module.ts
+import { Module as Module6 } from "@nestjs/common";
+
+// runtime/subsystems/observability/observability.drizzle-backend.ts
+init_tokens();
+init_job_orchestration_schema();
+import { Inject as Inject14, Injectable as Injectable15 } from "@nestjs/common";
+import { desc as desc4, eq as eq7, sql as sql5 } from "drizzle-orm";
+
+// runtime/subsystems/sync/sync-audit.schema.ts
+import {
+  pgEnum as pgEnum2,
+  pgTable as pgTable4,
+  uuid as uuid3,
+  text as text4,
+  jsonb as jsonb4,
+  integer as integer2,
+  boolean,
+  timestamp as timestamp4,
+  index as index3,
+  uniqueIndex as uniqueIndex2
+} from "drizzle-orm/pg-core";
+var syncRunDirectionEnum = pgEnum2("sync_run_direction", [
+  "inbound",
+  "outbound"
+]);
+var syncRunActionEnum = pgEnum2("sync_run_action", [
+  "poll",
+  "cdc",
+  "webhook",
+  "manual",
+  "writeback"
+]);
+var syncRunStatusEnum = pgEnum2("sync_run_status", [
+  "running",
+  "success",
+  "no_changes",
+  "failed"
+]);
+var syncRunItemOperationEnum = pgEnum2("sync_run_item_operation", [
+  "created",
+  "updated",
+  "deleted",
+  "noop"
+]);
+var syncRunItemStatusEnum = pgEnum2("sync_run_item_status", [
+  "success",
+  "failed",
+  "skipped"
+]);
+var syncSubscriptions = pgTable4(
+  "sync_subscriptions",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    integrationId: text4("integration_id").notNull(),
+    adapter: text4("adapter").notNull(),
+    domain: text4("domain").notNull(),
+    externalRef: text4("external_ref"),
+    enabled: boolean("enabled").notNull().default(true),
+    /**
+     * Per-subscription configuration bag. Strategies type it internally;
+     * e.g. polling strategies stash `{ batchSize, highWatermark }` here.
+     */
+    config: jsonb4("config").notNull().default({}).$type(),
+    /**
+     * Opaque cursor persisted by `ICursorStore.put()`. NULL until the first
+     * successful run advances it.
+     */
+    cursor: jsonb4("cursor").$type(),
+    lastSyncAt: timestamp4("last_sync_at", { withTimezone: true }),
+    /** Runtime-enforced when `SYNC_MULTI_TENANT` is true; see SYNC-6. */
+    tenantId: text4("tenant_id"),
+    createdAt: timestamp4("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp4("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (t) => ({
+    /**
+     * Composite uniqueness per the epic shape. `external_ref` is nullable;
+     * Postgres treats NULLs as distinct in a UNIQUE constraint, which means
+     * two rows with the same `(integration_id, adapter, domain)` and NULL
+     * external_ref are allowed. That's intentional — a subscription with
+     * NULL external_ref covers the full domain, and duplicates there would
+     * be a consumer-layer modeling issue, not a schema concern.
+     */
+    uqSyncSubscriptionTuple: uniqueIndex2("uq_sync_subscriptions_tuple").on(
+      t.integrationId,
+      t.adapter,
+      t.domain,
+      t.externalRef
+    ),
+    /** Scheduling query: list enabled subscriptions ordered by staleness. */
+    idxSyncSubscriptionsEnabledLastSync: index3(
+      "idx_sync_subscriptions_enabled_last_sync"
+    ).on(t.enabled, t.lastSyncAt)
+  })
+);
+var syncRuns = pgTable4(
+  "sync_runs",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    subscriptionId: uuid3("subscription_id").notNull().references(() => syncSubscriptions.id, { onDelete: "cascade" }),
+    direction: syncRunDirectionEnum("direction").notNull(),
+    action: syncRunActionEnum("action").notNull(),
+    status: syncRunStatusEnum("status").notNull().default("running"),
+    recordsFound: integer2("records_found").notNull().default(0),
+    recordsProcessed: integer2("records_processed").notNull().default(0),
+    cursorBefore: jsonb4("cursor_before").$type(),
+    cursorAfter: jsonb4("cursor_after").$type(),
+    durationMs: integer2("duration_ms"),
+    error: text4("error"),
+    startedAt: timestamp4("started_at", { withTimezone: true }).notNull().defaultNow(),
+    completedAt: timestamp4("completed_at", { withTimezone: true }),
+    /** Runtime-enforced when `SYNC_MULTI_TENANT` is true; see SYNC-6. */
+    tenantId: text4("tenant_id")
+  },
+  (t) => ({
+    /** Timeline read: "most recent runs for this subscription". */
+    idxSyncRunsSubscriptionStartedAt: index3(
+      "idx_sync_runs_subscription_started_at"
+    ).on(t.subscriptionId, t.startedAt),
+    /** Stale-run sweeper: "runs that started > N minutes ago and are still running". */
+    idxSyncRunsStatusStartedAt: index3("idx_sync_runs_status_started_at").on(
+      t.status,
+      t.startedAt
+    )
+  })
+);
+var syncRunItems = pgTable4(
+  "sync_run_items",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    syncRunId: uuid3("sync_run_id").notNull().references(() => syncRuns.id, { onDelete: "cascade" }),
+    entityType: text4("entity_type").notNull(),
+    externalId: text4("external_id").notNull(),
+    localId: text4("local_id"),
+    operation: syncRunItemOperationEnum("operation").notNull(),
+    status: syncRunItemStatusEnum("status").notNull(),
+    /**
+     * Structured per-field diff — ADR-0003 shape enforced by
+     * `FieldDiffSchema.parse` at the recorder service layer.
+     *
+     * Shape: `{ [fieldName]: { from: unknown, to: unknown } }`.
+     * Empty `{}` for `noop` items; `{ [field]: { from: null, to: <value> } }`
+     * for created items; `{ [field]: { from: <value>, to: null } }` for
+     * deleted items.
+     */
+    changedFields: jsonb4("changed_fields").notNull().default({}).$type(),
+    title: text4("title"),
+    error: text4("error"),
+    createdAt: timestamp4("created_at", { withTimezone: true }).notNull().defaultNow(),
+    /** Runtime-enforced when `SYNC_MULTI_TENANT` is true; see SYNC-6. */
+    tenantId: text4("tenant_id")
+  },
+  (t) => ({
+    /** Ordered timeline within a run. */
+    idxSyncRunItemsRunCreatedAt: index3("idx_sync_run_items_run_created_at").on(
+      t.syncRunId,
+      t.createdAt
+    ),
+    /** Per-record history: "every sync that touched opportunity/$extId". */
+    idxSyncRunItemsEntityExternal: index3(
+      "idx_sync_run_items_entity_external"
+    ).on(t.entityType, t.externalId)
+  })
+);
+
+// runtime/subsystems/observability/observability.drizzle-backend.ts
+var DrizzleObservabilityService = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  async getPoolDepths() {
+    const result = await this.db.execute(sql5`
+      SELECT
+        pool AS name,
+        COUNT(*) FILTER (WHERE status = 'pending')::int AS pending,
+        COUNT(*) FILTER (WHERE status = 'running')::int AS running,
+        (percentile_cont(0.95) WITHIN GROUP (
+          ORDER BY EXTRACT(EPOCH FROM (now() - claimed_at)) * 1000
+        ) FILTER (WHERE status = 'running' AND claimed_at IS NOT NULL))::int
+          AS claimed_age_p95_ms
+      FROM job_run
+      WHERE status IN ('pending','running')
+      GROUP BY pool
+      ORDER BY pool
+    `);
+    const rows = extractRows(result);
+    return rows.map((r) => ({
+      name: r.name,
+      pending: r.pending,
+      running: r.running,
+      claimedAgeP95Ms: r.claimed_age_p95_ms
+    }));
+  }
+  async getRecentSyncRuns(limit, integrationId) {
+    const base = this.db.select({
+      id: syncRuns.id,
+      subscriptionId: syncRuns.subscriptionId,
+      integrationId: syncSubscriptions.integrationId,
+      adapter: syncSubscriptions.adapter,
+      domain: syncSubscriptions.domain,
+      direction: syncRuns.direction,
+      action: syncRuns.action,
+      status: syncRuns.status,
+      recordsFound: syncRuns.recordsFound,
+      recordsProcessed: syncRuns.recordsProcessed,
+      durationMs: syncRuns.durationMs,
+      error: syncRuns.error,
+      startedAt: syncRuns.startedAt,
+      completedAt: syncRuns.completedAt
+    }).from(syncRuns).innerJoin(
+      syncSubscriptions,
+      eq7(syncRuns.subscriptionId, syncSubscriptions.id)
+    );
+    const filtered = integrationId !== void 0 ? base.where(eq7(syncSubscriptions.integrationId, integrationId)) : base;
+    const rows = await filtered.orderBy(desc4(syncRuns.startedAt)).limit(limit);
+    return rows.map((r) => ({
+      id: r.id,
+      subscriptionId: r.subscriptionId,
+      integrationId: r.integrationId,
+      adapter: r.adapter,
+      domain: r.domain,
+      direction: r.direction,
+      action: r.action,
+      status: r.status,
+      recordsFound: r.recordsFound,
+      recordsProcessed: r.recordsProcessed,
+      durationMs: r.durationMs,
+      error: r.error,
+      startedAt: r.startedAt,
+      completedAt: r.completedAt
+    }));
+  }
+  async getBridgeDeliveryHistogram(windowHours) {
+    const result = await this.db.execute(sql5`
+      SELECT status, COUNT(*)::int AS count
+      FROM bridge_delivery
+      WHERE COALESCE(delivered_at, attempted_at) > now() - make_interval(hours => ${windowHours})
+      GROUP BY status
+    `);
+    const rows = extractRows(result);
+    const hist = {};
+    for (const r of rows) hist[r.status] = r.count;
+    return hist;
+  }
+  async getRecentFailedJobs(limit) {
+    const rows = await this.db.select({
+      id: jobRuns.id,
+      jobType: jobRuns.jobType,
+      pool: jobRuns.pool,
+      status: jobRuns.status,
+      error: jobRuns.error,
+      startedAt: jobRuns.startedAt,
+      finishedAt: jobRuns.finishedAt,
+      attempts: jobRuns.attempts
+    }).from(jobRuns).where(eq7(jobRuns.status, "failed")).orderBy(desc4(jobRuns.finishedAt)).limit(limit);
+    return rows.map((r) => ({
+      id: r.id,
+      jobType: r.jobType,
+      pool: r.pool,
+      status: r.status,
+      error: r.error,
+      startedAt: r.startedAt,
+      finishedAt: r.finishedAt,
+      attempts: r.attempts
+    }));
+  }
+  async getCursors() {
+    const rows = await this.db.select({
+      id: syncSubscriptions.id,
+      integrationId: syncSubscriptions.integrationId,
+      adapter: syncSubscriptions.adapter,
+      domain: syncSubscriptions.domain,
+      cursor: syncSubscriptions.cursor,
+      lastSyncAt: syncSubscriptions.lastSyncAt
+    }).from(syncSubscriptions).where(eq7(syncSubscriptions.enabled, true)).orderBy(syncSubscriptions.integrationId, syncSubscriptions.domain);
+    return rows.map((r) => ({
+      subscriptionId: r.id,
+      integrationId: r.integrationId,
+      adapter: r.adapter,
+      domain: r.domain,
+      lastCursor: r.cursor,
+      lastSyncAt: r.lastSyncAt
+    }));
+  }
+};
+DrizzleObservabilityService = __decorateClass([
+  Injectable15(),
+  __decorateParam(0, Inject14(DRIZZLE))
+], DrizzleObservabilityService);
+function extractRows(result) {
+  const maybe = result;
+  if (Array.isArray(maybe.rows)) return maybe.rows;
+  if (Array.isArray(result)) return result;
+  return [];
+}
+
+// runtime/subsystems/observability/observability.memory-backend.ts
+import { Injectable as Injectable16 } from "@nestjs/common";
+var MemoryObservabilityService = class {
+  pools = [];
+  syncRuns = [];
+  bridgeHistogram = {};
+  failedJobs = [];
+  cursors = [];
+  // ─── Core contract ─────────────────────────────────────────────────────
+  async getPoolDepths() {
+    return [...this.pools];
+  }
+  async getRecentSyncRuns(limit, integrationId) {
+    const filtered = integrationId !== void 0 ? this.syncRuns.filter((r) => r.integrationId === integrationId) : this.syncRuns;
+    return filtered.slice().sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime()).slice(0, limit);
+  }
+  async getBridgeDeliveryHistogram(_windowHours) {
+    return { ...this.bridgeHistogram };
+  }
+  async getRecentFailedJobs(limit) {
+    return this.failedJobs.slice().sort(
+      (a, b) => (b.finishedAt?.getTime() ?? 0) - (a.finishedAt?.getTime() ?? 0)
+    ).slice(0, limit);
+  }
+  async getCursors() {
+    return [...this.cursors];
+  }
+  // ─── Test seams ────────────────────────────────────────────────────────
+  /** Replace the pool-depth slice. */
+  seedPools(pools) {
+    this.pools = [...pools];
+  }
+  /** Replace the sync-run slice. */
+  seedSyncRuns(runs) {
+    this.syncRuns = [...runs];
+  }
+  /** Replace the bridge-delivery histogram. */
+  seedBridgeHistogram(hist) {
+    this.bridgeHistogram = { ...hist };
+  }
+  /** Replace the failed-jobs slice. */
+  seedFailedJobs(jobs2) {
+    this.failedJobs = [...jobs2];
+  }
+  /** Replace the cursor slice. */
+  seedCursors(cursors) {
+    this.cursors = [...cursors];
+  }
+  /** Reset every slice — for afterEach hooks. */
+  reset() {
+    this.pools = [];
+    this.syncRuns = [];
+    this.bridgeHistogram = {};
+    this.failedJobs = [];
+    this.cursors = [];
+  }
+};
+MemoryObservabilityService = __decorateClass([
+  Injectable16()
+], MemoryObservabilityService);
+
+// runtime/subsystems/observability/observability.module.ts
+var ObservabilityModule = class {
+  static forRoot(options = { backend: "drizzle" }) {
+    const ConcreteClass = options.backend === "drizzle" ? DrizzleObservabilityService : MemoryObservabilityService;
+    const wantsBridgeMetrics = options.reporters?.bridgeMetrics === true;
+    const providers = [
+      // Register the concrete class as the canonical instance.
+      ConcreteClass,
+      // OBSERVABILITY token points at the same instance — no duplicate.
+      { provide: OBSERVABILITY, useExisting: ConcreteClass },
+      // Expose the resolved reporter config for introspection / tests.
+      {
+        provide: OBSERVABILITY_REPORTERS,
+        useValue: options.reporters ?? {}
+      }
+    ];
+    const exports = [OBSERVABILITY];
+    if (wantsBridgeMetrics) {
+      const { BridgeMetricsReporter: BridgeMetricsReporter2 } = (init_bridge_metrics_reporter(), __toCommonJS(bridge_metrics_reporter_exports));
+      providers.push(BridgeMetricsReporter2);
+      exports.push(BridgeMetricsReporter2);
+    }
+    const imports = [];
+    if (wantsBridgeMetrics) {
+      const { ScheduleModule } = __require("@nestjs/schedule");
+      imports.push(ScheduleModule.forRoot());
+    }
+    return {
+      module: ObservabilityModule,
+      global: true,
+      imports,
+      providers,
+      exports
+    };
+  }
+};
+ObservabilityModule = __decorateClass([
+  Module6({})
+], ObservabilityModule);
+
+// runtime/subsystems/observability/index.ts
+init_bridge_metrics_reporter();
+
 // runtime/subsystems/auth/auth.tokens.ts
 var ENCRYPTION_KEY = /* @__PURE__ */ Symbol("ENCRYPTION_KEY");
 var OAUTH_STATE_STORE = /* @__PURE__ */ Symbol("OAUTH_STATE_STORE");
@@ -3854,7 +4563,7 @@ var InMemoryOAuthStateStore = class {
 };
 
 // runtime/subsystems/auth/auth.module.ts
-import { Module as Module6 } from "@nestjs/common";
+import { Module as Module7 } from "@nestjs/common";
 function resolveEncryptionKeyProvider(choice) {
   if (choice === "env") {
     return { provide: ENCRYPTION_KEY, useClass: EnvEncryptionKey };
@@ -3884,16 +4593,18 @@ var AuthModule = class {
   }
 };
 AuthModule = __decorateClass([
-  Module6({})
+  Module7({})
 ], AuthModule);
 export {
   AUTH_INTEGRATION_READER,
   AUTH_INTEGRATION_TOKEN_WRITER,
   AuthModule,
+  BridgeMetricsReporter,
   CACHE,
   CacheModule,
   DrizzleCacheService,
   DrizzleEventBus,
+  DrizzleObservabilityService,
   ENCRYPTION_KEY,
   EVENT_BUS,
   EnvEncryptionKey,
@@ -3903,9 +4614,13 @@ export {
   LocalStorageBackend,
   MemoryCacheService,
   MemoryEventBus,
+  MemoryObservabilityService,
   MemoryStorageBackend,
   OAUTH_STATE_STORE,
   OAuth2RefreshStrategy,
+  OBSERVABILITY,
+  OBSERVABILITY_REPORTERS,
+  ObservabilityModule,
   STORAGE,
   SessionExpiredError,
   StorageModule,