@porulle/core 0.9.0 → 0.10.0

package/src/modules/catalog/schema.ts

@@ -1,4 +1,5 @@
 import type { AnyPgColumn } from "drizzle-orm/pg-core";
+import { sql } from "drizzle-orm";
 import {
   boolean,
   index,
@@ -17,6 +18,8 @@ export const sellableEntities = pgTable(
   {
     id: uuid("id").defaultRandom().primaryKey(),
     organizationId: text("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    // Connected-store id when externally sourced; null means platform-native.
+    sourceStoreId: text("source_store_id"),
     type: text("type").notNull(),
     slug: text("slug").notNull(),
     status: text("status", {
@@ -179,24 +182,36 @@ export const optionValues = pgTable("option_values", {
   metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
 });
 
-export const variants = pgTable("variants", {
-  id: uuid("id").defaultRandom().primaryKey(),
-  entityId: uuid("entity_id")
-    .references(() => sellableEntities.id, { onDelete: "cascade" })
-    .notNull(),
-  sku: text("sku").unique(),
-  barcode: text("barcode"),
-  // Overrides the entity's taxClass when set (issue #57).
-  taxClass: text("tax_class"),
-  status: text("status", { enum: ["active", "discontinued"] })
-    .notNull()
-    .default("active"),
-  sortOrder: integer("sort_order").notNull().default(0),
-  metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
-}, (table) => ({
-  barcodeIdx: index("idx_variants_barcode").on(table.barcode),
-  skuIdx: index("idx_variants_sku").on(table.sku),
-}));
+export const variants = pgTable(
+  "variants",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    entityId: uuid("entity_id")
+      .references(() => sellableEntities.id, { onDelete: "cascade" })
+      .notNull(),
+    organizationId: text("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    sourceStoreId: text("source_store_id"),
+    sku: text("sku"),
+    barcode: text("barcode"),
+    // Overrides the entity's taxClass when set (issue #57).
+    taxClass: text("tax_class"),
+    status: text("status", { enum: ["active", "discontinued"] })
+      .notNull()
+      .default("active"),
+    sortOrder: integer("sort_order").notNull().default(0),
+    metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
+  },
+  (table) => ({
+    barcodeIdx: index("idx_variants_barcode").on(table.barcode),
+    skuIdx: index("idx_variants_sku").on(table.sku),
+    nativeSkuUnique: uniqueIndex("variants_native_org_sku_unique")
+      .on(table.organizationId, table.sku)
+      .where(sql`${table.sourceStoreId} IS NULL AND ${table.sku} IS NOT NULL`),
+    sourceSkuUnique: uniqueIndex("variants_source_store_sku_unique")
+      .on(table.sourceStoreId, table.sku)
+      .where(sql`${table.sourceStoreId} IS NOT NULL AND ${table.sku} IS NOT NULL`),
+  }),
+);
 
 export const variantOptionValues = pgTable("variant_option_values", {
   variantId: uuid("variant_id")

package/src/modules/catalog/schemas.ts

@@ -92,7 +92,9 @@ export const GenerateVariantsBodySchema = z
 
 // ─── Derived Input Types ─────────────────────────────────────────────────────
 
-export type CreateEntityInput = z.infer<typeof CreateEntityBodySchema>;
+export type CreateEntityInput = z.infer<typeof CreateEntityBodySchema> & {
+  sourceStoreId?: string;
+};
 
 export type UpdateEntityInput = z.infer<typeof UpdateEntityBodySchema>;
 

package/src/modules/channels/adapter.ts

@@ -0,0 +1,139 @@
+import type { Result } from "../../kernel/result.js";
+
+export interface ChannelConnectorError {
+  code: string;
+  message: string;
+  retriable?: boolean;
+}
+
+export interface ChannelConnectorCapabilities {
+  readonly importCatalog: boolean;
+  readonly importInventory: boolean;
+  readonly pushOrder: boolean;
+  readonly receiveWebhooks: boolean;
+  readonly reserve?: boolean;
+}
+
+export interface ChannelStore {
+  id: string;
+  organizationId: string;
+  provider: string;
+  credentials: Record<string, unknown>;
+  storeDomain: string;
+  status: "connected" | "disconnected" | "error";
+  webhookSecret: string | null;
+}
+
+export interface ChannelCatalogVariant {
+  externalId: string;
+  sku?: string;
+  barcode?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface ChannelCatalogItem {
+  externalId: string;
+  slug: string;
+  title: string;
+  description?: string;
+  variants: ChannelCatalogVariant[];
+  metadata?: Record<string, unknown>;
+}
+
+export interface ChannelCatalogPage {
+  items: ChannelCatalogItem[];
+  nextCursor?: string | null;
+}
+
+export interface ChannelInventoryLevel {
+  externalId: string;
+  available: number;
+}
+
+export interface ChannelOrderLine {
+  externalVariantId: string;
+  sku?: string;
+  title: string;
+  quantity: number;
+  unitPrice: number;
+  totalPrice: number;
+}
+
+export interface ChannelOrderSlice {
+  orderId: string;
+  currency: string;
+  grandTotal: number;
+  lines: ChannelOrderLine[];
+  customer: {
+    name: string;
+    email: string;
+    shippingAddress: Record<string, unknown>;
+  };
+}
+
+export interface ChannelPushOrderResult {
+  remoteOrderId: string;
+  remoteUrl?: string;
+}
+
+export interface ChannelOrderStatus {
+  status: "pending" | "confirmed" | "failed" | "cancelled" | "fulfilled";
+}
+
+export interface ChannelWebhookEvent {
+  id: string;
+  type: string;
+  data: unknown;
+}
+
+export interface ChannelReservation {
+  id: string;
+  expiresAt?: Date;
+}
+
+export interface ChannelRefundResult {
+  remoteRefundId: string;
+  status: string;
+}
+
+export interface ChannelConnector {
+  readonly providerId: string;
+  readonly capabilities: ChannelConnectorCapabilities;
+  buildAuthUrl?(params: {
+    storeDomain: string;
+    state: string;
+    redirectUri: string;
+    callbackUri: string;
+    scopes: string[];
+  }): Result<string, ChannelConnectorError>;
+  completeAuth?(
+    request: Request,
+    ctx: { storeDomain: string },
+  ): Promise<Result<{ credentials: Record<string, unknown>; storeDomain: string }, ChannelConnectorError>>;
+  importCatalog(store: ChannelStore, cursor?: string): Promise<Result<ChannelCatalogPage>>;
+  fetchInventory(store: ChannelStore, ids?: string[]): Promise<Result<ChannelInventoryLevel[]>>;
+  pushOrder(store: ChannelStore, slice: ChannelOrderSlice): Promise<Result<ChannelPushOrderResult, ChannelConnectorError>>;
+  fetchOrderStatus(store: ChannelStore, remoteId: string): Promise<Result<ChannelOrderStatus, ChannelConnectorError>>;
+  verifyWebhook(store: ChannelStore, request: Request): Promise<Result<ChannelWebhookEvent>>;
+  verifyAppWebhook?(
+    request: Request,
+  ): Promise<Result<{ topic: string; shopDomain: string; data: unknown }, ChannelConnectorError>>;
+  registerWebhooks?(
+    store: ChannelStore,
+    topics: string[],
+    callbackUrl: string,
+  ): Promise<Result<{ registered: number }, ChannelConnectorError>>;
+  reserve?(
+    store: ChannelStore,
+    lines: ChannelOrderLine[],
+  ): Promise<Result<ChannelReservation>>;
+  refundExecute(
+    store: ChannelStore,
+    slice: ChannelOrderSlice,
+    amount: number,
+  ): Promise<Result<ChannelRefundResult>>;
+}
+
+export function defineChannelConnector<T extends ChannelConnector>(connector: T): T {
+  return connector;
+}

package/src/modules/inventory/repository/index.ts

@@ -1,5 +1,5 @@
 import { eq, and, inArray, isNull, sql } from "drizzle-orm";
-import { CommerceValidationError } from "../../../kernel/errors.js";
+import { CommerceValidationError, INVENTORY_RECORD_NOT_FOUND_MESSAGE } from "../../../kernel/errors.js";
 import type { TxContext } from "../../../kernel/database/tx-context.js";
 import type {
   DrizzleDatabase,
@@ -495,7 +495,7 @@ export class InventoryRepository {
     if (!level) {
       return {
         ok: false,
-        reason: "No inventory record found for this entity.",
+        reason: INVENTORY_RECORD_NOT_FOUND_MESSAGE,
       };
     }
 
@@ -550,7 +550,7 @@ export class InventoryRepository {
     if (!level) {
       return {
         ok: false,
-        reason: "No inventory record found for this entity.",
+        reason: INVENTORY_RECORD_NOT_FOUND_MESSAGE,
       };
     }
 
@@ -600,7 +600,7 @@ export class InventoryRepository {
     if (!level) {
       return {
         ok: false,
-        reason: "No inventory record found for this entity.",
+        reason: INVENTORY_RECORD_NOT_FOUND_MESSAGE,
       };
     }
 

package/src/modules/inventory/service.ts

@@ -3,8 +3,10 @@ import { assertPermission } from "../../auth/permissions.js";
 import type { Actor } from "../../auth/types.js";
 import type { CommerceConfig } from "../../config/types.js";
 import {
+  CommerceInventoryRecordNotFoundError,
   CommerceNotFoundError,
   CommerceValidationError,
+  INVENTORY_RECORD_NOT_FOUND_MESSAGE,
   toCommerceError,
 } from "../../kernel/errors.js";
 import { runAfterHooks } from "../../kernel/hooks/executor.js";
@@ -232,7 +234,11 @@ export class InventoryService {
       );
 
       if (!reserveResult.ok) {
-        return Err(new CommerceValidationError(reserveResult.reason));
+        return Err(
+          reserveResult.reason === INVENTORY_RECORD_NOT_FOUND_MESSAGE
+            ? new CommerceInventoryRecordNotFoundError()
+            : new CommerceValidationError(reserveResult.reason),
+        );
       }
 
       await this.repo.createMovement(
@@ -281,7 +287,11 @@ export class InventoryService {
       );
 
       if (!releaseResult.ok) {
-        return Err(new CommerceValidationError(releaseResult.reason));
+        return Err(
+          releaseResult.reason === INVENTORY_RECORD_NOT_FOUND_MESSAGE
+            ? new CommerceInventoryRecordNotFoundError()
+            : new CommerceValidationError(releaseResult.reason),
+        );
       }
 
       await this.repo.createMovement(

package/src/modules/orders/service.ts

@@ -10,6 +10,7 @@ import {
 } from "../../kernel/errors.js";
 import { runAfterHooks, runBeforeHooks } from "../../kernel/hooks/executor.js";
 import { createHookContext } from "../../kernel/hooks/create-context.js";
+import type { JobsAdapter } from "../../kernel/jobs/adapter.js";
 import type {
   AfterHook,
   BeforeHook,
@@ -130,6 +131,7 @@ function context(
     tx,
     logger: createLogger("orders"),
     services,
+    ...(services.jobs ? { jobs: services.jobs as JobsAdapter } : {}),
     context: { moduleName: "orders" },
     database: { db: database.db as PluginDb },
   });
@@ -808,12 +810,9 @@ export class OrderService {
             );
             if (!releaseResult.ok) {
               const err = toCommerceError(releaseResult.error);
-              if (
-                !(
-                  err instanceof CommerceValidationError &&
-                  err.message === "No inventory record found for this entity."
-                )
-              ) {
+              // Tolerate a missing inventory record (nothing to release); surface
+              // any other inventory error. Check the typed code, not the message.
+              if (err.code !== "INVENTORY_RECORD_NOT_FOUND") {
                 return Err(err);
               }
             }
@@ -935,12 +934,9 @@ export class OrderService {
             );
             if (!releaseResult.ok) {
               const err = toCommerceError(releaseResult.error);
-              if (
-                !(
-                  err instanceof CommerceValidationError &&
-                  err.message === "No inventory record found for this entity."
-                )
-              ) {
+              // Tolerate a missing inventory record (nothing to release); surface
+              // any other inventory error. Check the typed code, not the message.
+              if (err.code !== "INVENTORY_RECORD_NOT_FOUND") {
                 return Err(err);
               }
             }

package/src/modules/orders/stale-order-cleanup.ts

@@ -45,17 +45,6 @@ export const staleOrderCleanupTask: TaskDefinition<
     const thresholdHours = input.thresholdHours ?? 48;
     const cutoff = new Date(Date.now() - thresholdHours * 60 * 60 * 1000);
 
-    // Find stale pending orders
-    const staleOrders = await ctx.db
-      .select()
-      .from(orders)
-      .where(
-        and(
-          eq(orders.status, "pending"),
-          lt(orders.placedAt, cutoff),
-        ),
-      );
-
     const cancelledIds: string[] = [];
 
     // Cancel each stale order via the service (triggers inventory release + payment refund)
@@ -63,20 +52,42 @@ export const staleOrderCleanupTask: TaskDefinition<
       cancel(orderId: string, actor: Actor | null, reason: string): Promise<unknown>;
     };
 
-    for (const order of staleOrders) {
-      try {
-        await orderService.cancel(
-          order.id,
-          systemActorForOrg(order.organizationId),
-          `Auto-cancelled: pending for >${thresholdHours}h`,
+    // This is a cross-org system sweep, but the row reads stay org-scoped: first
+    // enumerate the orgs that have stale orders (id-only projection), then read
+    // each org's stale orders under an explicit organizationId predicate. No
+    // query returns another tenant's order rows.
+    const staleOrgs = await ctx.db
+      .selectDistinct({ organizationId: orders.organizationId })
+      .from(orders)
+      .where(and(eq(orders.status, "pending"), lt(orders.placedAt, cutoff)));
+
+    for (const { organizationId } of staleOrgs) {
+      const staleOrders = await ctx.db
+        .select()
+        .from(orders)
+        .where(
+          and(
+            eq(orders.organizationId, organizationId),
+            eq(orders.status, "pending"),
+            lt(orders.placedAt, cutoff),
+          ),
         );
-        cancelledIds.push(order.id);
-        ctx.logger.info(`Stale order ${order.orderNumber} auto-cancelled`, {
-          orderId: order.id,
-          placedAt: order.placedAt,
-        });
-      } catch (error) {
-        ctx.logger.error(`Failed to cancel stale order ${order.orderNumber}`, { error });
+
+      for (const order of staleOrders) {
+        try {
+          await orderService.cancel(
+            order.id,
+            systemActorForOrg(order.organizationId),
+            `Auto-cancelled: pending for >${thresholdHours}h`,
+          );
+          cancelledIds.push(order.id);
+          ctx.logger.info(`Stale order ${order.orderNumber} auto-cancelled`, {
+            orderId: order.id,
+            placedAt: order.placedAt,
+          });
+        } catch (error) {
+          ctx.logger.error(`Failed to cancel stale order ${order.orderNumber}`, { error });
+        }
       }
     }
 

package/src/modules/promotions/repository/index.ts

@@ -182,6 +182,7 @@ export class PromotionsRepository {
 
   async createUsage(
     data: PromotionUsageInsert,
+    orgId: string,
     ctx?: TxContext,
   ): Promise<PromotionUsage> {
     const db = this.getDb(ctx);
@@ -190,10 +191,13 @@ export class PromotionsRepository {
     // race conditions between concurrent checkouts using the same coupon.
     // A plain count-then-insert has a TOCTOU gap; this single statement
     // ensures the insert only succeeds if the limit has not been reached.
+    // Both reads are scoped by organizationId: these are raw/lock queries that
+    // bypass the scoped-db proxy, so a promotionId from another tenant must
+    // resolve to no row rather than reading/locking a foreign promotion.
     const promo = await db
       .select({ usageLimitTotal: promotions.usageLimitTotal })
       .from(promotions)
-      .where(eq(promotions.id, data.promotionId));
+      .where(and(eq(promotions.id, data.promotionId), eq(promotions.organizationId, orgId)));
 
     const limit = promo[0]?.usageLimitTotal;
 
@@ -206,7 +210,7 @@ export class PromotionsRepository {
       // concurrent callers. If the caller is already inside a transaction
       // (ctx.tx), the lock is held until that transaction commits.
       await db.execute(
-        sql`SELECT id FROM promotions WHERE id = ${data.promotionId} FOR UPDATE`,
+        sql`SELECT id FROM promotions WHERE id = ${data.promotionId} AND organization_id = ${orgId} FOR UPDATE`,
       );
 
       const currentCount = await this.countUsages(data.promotionId, ctx);

package/src/modules/promotions/service.ts

@@ -500,6 +500,7 @@ export class PromotionService {
   async recordUsage(
     input: {
       promotions: AppliedPromotion[];
+      organizationId: string;
       customerId?: string;
       orderId?: string;
     },
@@ -513,6 +514,7 @@ export class PromotionService {
           customerId: input.customerId ?? null,
           orderId: input.orderId ?? null,
         },
+        input.organizationId,
         ctx,
       );
       usages.push(usage);

package/src/modules/webhooks/repository/index.ts

@@ -1,4 +1,4 @@
-import { eq, and, lte, isNull, or, desc, sql } from "drizzle-orm";
+import { eq, and, lte, isNull, or, desc, sql, inArray } from "drizzle-orm";
 import type { TxContext } from "../../../kernel/database/tx-context.js";
 import type {
   DrizzleDatabase,
@@ -195,28 +195,30 @@ export class WebhooksRepository {
   }
 
   async findFailedDeliveries(
+    orgId: string,
     endpointId?: string,
     ctx?: TxContext,
   ): Promise<WebhookDelivery[]> {
     const db = this.getDb(ctx);
 
-    if (endpointId) {
-      return db
-        .select()
-        .from(webhookDeliveries)
-        .where(
-          and(
-            eq(webhookDeliveries.endpointId, endpointId),
-            sql`${webhookDeliveries.failedAt} IS NOT NULL`,
-          ),
-        )
-        .orderBy(desc(webhookDeliveries.failedAt));
-    }
+    // webhook_deliveries has no organizationId column — org lives on the parent
+    // endpoint. Scope failed deliveries to endpoints owned by orgId so this can
+    // never read another tenant's deliveries.
+    const orgEndpointIds = db
+      .select({ id: webhookEndpoints.id })
+      .from(webhookEndpoints)
+      .where(eq(webhookEndpoints.organizationId, orgId));
+
+    const conditions = [
+      sql`${webhookDeliveries.failedAt} IS NOT NULL`,
+      inArray(webhookDeliveries.endpointId, orgEndpointIds),
+    ];
+    if (endpointId) conditions.push(eq(webhookDeliveries.endpointId, endpointId));
 
     return db
       .select()
       .from(webhookDeliveries)
-      .where(sql`${webhookDeliveries.failedAt} IS NOT NULL`)
+      .where(and(...conditions))
       .orderBy(desc(webhookDeliveries.failedAt));
   }
 

package/src/runtime/kernel.ts

@@ -11,6 +11,7 @@ import { withTiming } from "../kernel/service-timing.js";
 import { setBootDefaultOrgId } from "../auth/org.js";
 import { setBootStrictOrgResolution } from "../auth/strict-org-resolution.js";
 import { DrizzleJobsAdapter } from "../kernel/jobs/drizzle-adapter.js";
+import type { ExecutionEngine } from "../kernel/jobs/adapter.js";
 import { CompensationFailuresRepository } from "../kernel/compensation/repository.js";
 
 import {
@@ -72,8 +73,21 @@ export function createKernel(config: CommerceConfig): Kernel {
   const jobsTaskMap = new Map(
     (config.jobs?.tasks ?? []).map((t) => [t.slug, t]),
   );
-  const jobsAdapter = new DrizzleJobsAdapter(db, jobsTaskMap);
-  serviceContainer.jobs = jobsAdapter;
+  const jobsEngine: ExecutionEngine =
+    config.jobs?.adapter ?? new DrizzleJobsAdapter(db);
+  const jobLogger = {
+    info: (message: string, data?: unknown) => logger.info(message, data),
+    warn: (message: string, data?: unknown) => logger.warn(message, data),
+    error: (message: string, data?: unknown) => logger.error(message, data),
+  };
+  jobsEngine.register({
+    tasks: jobsTaskMap,
+    context: { logger: jobLogger, db, services: serviceContainer },
+    ...(config.jobs?.processingOrder !== undefined
+      ? { processingOrder: config.jobs.processingOrder }
+      : {}),
+  });
+  serviceContainer.jobs = jobsEngine;
 
   const topoGraph = kernelModulesForTopoSort();
   const order = topoSortModules(topoGraph);

package/src/runtime/server.ts

@@ -17,7 +17,6 @@ import { createCustomerPortalRoutes } from "../interfaces/rest/customer-portal.j
 import { createKernel } from "./kernel.js";
 import { ensureDefaultOrg } from "../auth/org.js";
 import { createLogger, type Logger } from "./logger.js";
-import type { DrizzleDatabase } from "../kernel/database/drizzle-db.js";
 import { createCommerce, type CommerceInstance } from "./commerce.js";
 import { rewriteCommerceAliasRequest } from "./url-alias-rewrite.js";
 import { mapErrorToResponse } from "../kernel/error-mapper.js";
@@ -408,48 +407,18 @@ export async function createServer(config: CommerceConfig) {
   //   2. GET /api/jobs/run: cron endpoint (serverless — Vercel, Cloudflare)
   //   3. runPendingJobs() export (custom worker process)
 
-  const { runPendingJobs } = await import("../kernel/jobs/runner.js");
-  const { runStaleJobReaper, getJobReapThresholdMs, getJobsReaperIntervalMs } =
-    await import("../kernel/jobs/reaper.js");
-  const taskMap = new Map<string, unknown>();
-  for (const task of config.jobs?.tasks ?? []) {
-    const t = task as { slug?: string; name?: string };
-    taskMap.set(t.slug ?? t.name ?? "", task);
-  }
-
-  const jobLogger = {
-    info: (msg: string, data?: unknown) => logger.info(data != null ? { data } : {}, msg),
-    warn: (msg: string, data?: unknown) => logger.warn(data != null ? { data } : {}, msg),
-    error: (msg: string, data?: unknown) => logger.error(data != null ? { data } : {}, msg),
-  };
-
-  let lastStaleJobReaperAt = 0;
+  const jobsEngine = (kernel.services as Record<string, unknown>)
+    .jobs as import("../kernel/jobs/adapter.js").ExecutionEngine;
 
-  const maybeRunStaleJobReaper = async () => {
-    const interval = getJobsReaperIntervalMs();
-    const now = Date.now();
-    if (now - lastStaleJobReaperAt < interval) return;
-    lastStaleJobReaperAt = now;
-    try {
-      await runStaleJobReaper(
-        kernel.database.db as DrizzleDatabase,
-        getJobReapThresholdMs(),
-        jobLogger,
+  const runJobs = async (queue?: string, limit?: number) => {
+    if (jobsEngine.execution.mode !== "pull") {
+      throw new Error(
+        "The configured push execution engine is driven by its native runtime and cannot be polled with runJobs().",
       );
-    } catch (err) {
-      logger.error({ err }, "Stale job reaper failed");
     }
-  };
-
-  const runJobs = async (queue?: string, limit?: number) => {
-    await maybeRunStaleJobReaper();
-    return runPendingJobs({
-      db: kernel.database.db as DrizzleDatabase,
-      tasks: taskMap as Parameters<typeof runPendingJobs>[0]["tasks"],
+    return jobsEngine.execution.run({
       queue: queue ?? "default",
       limit: limit ?? 10,
-      logger: jobLogger,
-      services: kernel.services as Parameters<typeof runPendingJobs>[0]["services"],
     });
   };
 
@@ -478,6 +447,11 @@ export async function createServer(config: CommerceConfig) {
   // Strategy 2: In-process polling for long-running servers (ECS, Cloud Run, Docker).
   // Enable via config.jobs.autorun.enabled = true
   if (config.jobs?.autorun?.enabled) {
+    if (jobsEngine.execution.mode !== "pull") {
+      throw new Error(
+        "jobs.autorun is only valid for pull execution engines. Serve the configured push engine through its native runtime.",
+      );
+    }
     const intervalMs = config.jobs.autorun.intervalMs ?? 10_000;
 
     const jobInterval = setInterval(async () => {
@@ -494,10 +468,16 @@ export async function createServer(config: CommerceConfig) {
 
     logger.info({ intervalMs }, "Job queue autorun started (in-process polling)");
   } else {
-    logger.info(
-      "Job queue autorun disabled. Use GET /api/jobs/run for serverless cron, " +
-      "or set config.jobs.autorun.enabled = true for in-process polling.",
-    );
+    if (jobsEngine.execution.mode === "push") {
+      logger.info(
+        "Push job engine registered. Serve it through its native runtime.",
+      );
+    } else {
+      logger.info(
+        "Job queue autorun disabled. Use GET /api/jobs/run for serverless cron, " +
+        "or set config.jobs.autorun.enabled = true for in-process polling.",
+      );
+    }
   }
 
   const dispatchFetch = app.fetch.bind(app);