fix(webapp): send keyless canary runs to the stable container lane

Fixed an issue where some runs from deployments without a prebuilt
template could stay queued instead of starting.

Mono-RevId: 2a8e5c624437ab80277ea56bb7b97ea6cb932230

Author: 1stvamp

apps/webapp/app/runEngine/concerns/computeMigration.server.ts

@@ -79,6 +79,8 @@ export function resolveComputeMigration({
   workerQueue: string | undefined;
   region: string | undefined;
   enableFastPath: boolean;
+  /** Set when the missing template key kept a migrated run on the base queue. */
+  templateFallback?: true;
 } {
   const passthrough = { workerQueue: baseWorkerQueue, region, enableFastPath: baseEnableFastPath };
   if (baseWorkerQueue === undefined) return passthrough;
@@ -91,6 +93,6 @@ export function resolveComputeMigration({
         ? false
         : isOrgMigrated(decision);
   if (!migrated) return passthrough;
-  if (!templateKey) return passthrough;
+  if (!templateKey) return { ...passthrough, templateFallback: true };
   return { workerQueue: backing.workerQueue, region, enableFastPath: backing.enableFastPath };
 }

apps/webapp/app/runEngine/concerns/workerQueueAssignment.server.test.ts

@@ -229,11 +229,13 @@ describe("per-environment worker queue overrides", () => {
       environmentType = "STAGING",
       v2Enabled = true,
       migrationEnabled = false,
+      templateKey = "a".repeat(64),
     }: {
       orgFeatureFlags: Record<string, unknown>;
       environmentType?: string;
       v2Enabled?: boolean;
       migrationEnabled?: boolean;
+      templateKey?: string | null;
     }) {
       const environmentOverride = environmentWorkerQueueOverride({
         orgFeatureFlags,
@@ -251,7 +253,7 @@ describe("per-environment worker queue overrides", () => {
         flags: { computeMigrationEnabled: migrationEnabled, computeMigrationFreePercentage: 100 },
         envType: environmentType,
         environmentCompat: environmentOverride.compat,
-        templateKey: "a".repeat(64),
+        templateKey,
       });
       const workerQueue = workerQueueForBirth({
         workerQueue: migrated.workerQueue!,
@@ -263,6 +265,7 @@ describe("per-environment worker queue overrides", () => {
         splitEnabled: true,
         workerGroups,
         rootTriggerSource: "api",
+        templateFallback: migrated.templateFallback,
       });
       return { workerQueue, enableFastPath: migrated.enableFastPath };
     }
@@ -386,5 +389,39 @@ describe("per-environment worker queue overrides", () => {
         enableFastPath: true,
       });
     });
+
+    it("puts a migrated org's keyless run on the stable container channel", () => {
+      const canaryStaging = {
+        [FEATURE_FLAG.workerQueueEnvironmentOverrides]: { STAGING: { channel: "canary" } },
+      };
+      const canaryOrg = { [FEATURE_FLAG.workerQueueChannel]: "canary" };
+      for (const orgFeatureFlags of [canaryStaging, canaryOrg]) {
+        expect(trigger({ orgFeatureFlags, migrationEnabled: true, templateKey: null })).toEqual({
+          workerQueue: "us-east-1:v2:ondemand:fresh:container:stable",
+          enableFastPath: false,
+        });
+        // A run that is not migrated keeps its channel, keyless or not.
+        expect(trigger({ orgFeatureFlags, templateKey: null })).toEqual({
+          workerQueue: "us-east-1:v2:ondemand:fresh:container:canary",
+          enableFastPath: false,
+        });
+      }
+    });
+
+    it("keeps an explicit compute compatibility for a keyless run, for the dequeue check", () => {
+      expect(
+        trigger({
+          orgFeatureFlags: {
+            [FEATURE_FLAG.workerQueueCompatibility]: "compute",
+            [FEATURE_FLAG.workerQueueChannel]: "canary",
+          },
+          migrationEnabled: true,
+          templateKey: null,
+        })
+      ).toEqual({
+        workerQueue: "us-east-1:v2:ondemand:fresh:compute:canary",
+        enableFastPath: false,
+      });
+    });
   });
 });

apps/webapp/app/runEngine/concerns/workerQueueAssignment.server.ts

@@ -49,6 +49,7 @@ export function workerQueueForBirth({
   splitEnabled,
   workerGroups,
   rootTriggerSource,
+  templateFallback,
 }: {
   workerQueue: string;
   region: string | undefined;
@@ -59,6 +60,8 @@ export function workerQueueForBirth({
   splitEnabled: boolean;
   workerGroups: readonly Pick<WorkerGroupRegionRow, "masterQueue" | "workloadType">[];
   rootTriggerSource: string | undefined;
+  /** The run stays off compute because its deployment has no template key. */
+  templateFallback?: boolean;
 }): string {
   if (envType === "DEVELOPMENT") {
     return workerQueue;
@@ -79,13 +82,16 @@ export function workerQueueForBirth({
   const channel = FeatureFlagCatalog[FEATURE_FLAG.workerQueueChannel].safeParse(
     environmentOverride.channel ?? orgFeatureFlags?.[FEATURE_FLAG.workerQueueChannel] ?? "stable"
   );
+  const compat = compatibility.success ? compatibility.data : defaultCompatibility;
+  // Match the dequeue fallback: container consumers take only the stable channel.
+  const keylessOnContainers = templateFallback && compat === "container";
   const assignment = formatWorkerQueue({
     region: region ?? workerQueue,
     version: WORKER_QUEUE_VERSION,
     class: "ondemand",
     phase: "fresh",
-    compat: compatibility.success ? compatibility.data : defaultCompatibility,
-    channel: channel.success ? channel.data : "stable",
+    compat,
+    channel: !keylessOnContainers && channel.success ? channel.data : "stable",
   });
 
   return workerQueueForRun({

apps/webapp/app/runEngine/services/triggerTask.server.ts

@@ -563,6 +563,7 @@ export class RunEngineTriggerTaskService {
                   splitEnabled: env.TRIGGER_WORKER_QUEUE_SCHEDULED_SPLIT_ENABLED === "1",
                   workerGroups,
                   rootTriggerSource: annotations.rootTriggerSource,
+                  templateFallback: migrated.templateFallback,
                 })
               : migrated.workerQueue;
 

apps/webapp/test/computeMigration.test.ts

@@ -312,7 +312,7 @@ describe("resolveComputeMigration template key", () => {
       for (const templateKey of [null, undefined, ""]) {
         expect(
           resolveComputeMigration({ ...input, ...migrated, environmentCompat, templateKey })
-        ).toEqual(base);
+        ).toEqual({ ...base, templateFallback: true });
       }
     });
     it(`swaps a migrated org's keyed deployment to compute (compat=${environmentCompat})`, () => {

apps/webapp/test/engine/triggerTask.templateKey.test.ts

@@ -30,6 +30,7 @@ import { containerTest } from "@internal/testcontainers";
 import type { PrismaClient } from "@trigger.dev/database";
 import { Redis } from "ioredis";
 import { resolveComputeMigration } from "~/runEngine/concerns/computeMigration.server";
+import { workerQueueForBirth } from "~/runEngine/concerns/workerQueueAssignment.server";
 import { DefaultQueueManager } from "~/runEngine/concerns/queues.server";
 import type { RunEngine } from "~/v3/runEngine.server";
 import { RedisTaskMetadataCache } from "~/services/taskMetadataCache.server";
@@ -211,6 +212,45 @@ describe("template key in the task metadata cache", () => {
     }
   );
 
+  containerTest(
+    "a keyless promotion births a canary-channel migrated run on the stable container queue",
+    async ({ prisma, redisOptions }) => {
+      db.client = prisma;
+      const environment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+      const { deployment } = await createDeployment(prisma, environment, {
+        version: "20260101.1",
+      });
+      const cache = newCache(redisOptions);
+      await new ChangeCurrentDeploymentService(prisma, prisma, cache).call(deployment, "promote");
+
+      const queues = new DefaultQueueManager(prisma, noEngine, undefined, cache);
+      const { templateKey } = await queues.resolveQueueProperties({
+        taskId: SLUG,
+        environment,
+        body: { payload: {} },
+      } as any);
+      const orgFeatureFlags = { ...migratedOrg.orgFeatureFlags, workerQueueChannel: "canary" };
+      const migrated = resolveComputeMigration({ ...migratedOrg, orgFeatureFlags, templateKey });
+      const birth = workerQueueForBirth({
+        workerQueue: migrated.workerQueue!,
+        region: migrated.region,
+        envType: "PRODUCTION",
+        orgFeatureFlags,
+        environmentOverride: {},
+        v2Enabled: true,
+        splitEnabled: false,
+        workerGroups: [
+          { masterQueue: "us-east-1", workloadType: "CONTAINER" },
+          { masterQueue: "us-east-1-next", workloadType: "MICROVM" },
+        ],
+        rootTriggerSource: "api",
+        templateFallback: migrated.templateFallback,
+      });
+      // Container consumers take only stable, so a canary container queue would strand the run.
+      expect(birth).toBe("us-east-1:v2:ondemand:fresh:container:stable");
+    }
+  );
+
   containerTest(
     "a late build stamps its own worker's hashes but not a newer promotion's env hash",
     async ({ prisma, redisOptions }) => {