refactor(webapp): remove worker queue feature flag overrides

## Summary

Remove the worker queue v2 and scheduled-split feature flag overrides
and admin controls. Both behaviours remain controlled by their existing
environment variables, with unchanged defaults.

Preserve development exclusions, unknown-queue fallback,
compatibility/channel selection, and routing for existing executions and
restores. Obsolete stored flags are ignored by the existing catalogue
validation.

Mono-RevId: 9a686dd37689c4950483502ae3a040a1e0d3d6f7

Author: carderne

apps/webapp/app/env.server.ts

@@ -1570,14 +1570,7 @@ const EnvironmentSchema = z
     COMMON_WORKER_REDIS_TLS_DISABLED: z.string().default(process.env.REDIS_TLS_DISABLED ?? "false"),
     COMMON_WORKER_REDIS_CLUSTER_MODE_ENABLED: z.string().default("0"),
 
-    // Global default for the scheduled worker-queue split. When "1", runs in a
-    // scheduled lineage (rootTriggerSource === "schedule") are routed to a
-    // dedicated `<region>:scheduled` worker queue so a separate consumer fleet
-    // can dequeue them independently of standard/agent runs. The per-org
-    // `workerQueueScheduledSplitEnabled` feature flag overrides this default in
-    // BOTH directions (an org set to false stays on the single queue even when
-    // this is "1"; an org set to true splits even when this is "0"). Never
-    // applies to DEVELOPMENT environments.
+    // Requires consumers configured for scheduled queues. Never applies to development.
     TRIGGER_WORKER_QUEUE_SCHEDULED_SPLIT_ENABLED: z.string().default("0"),
     // Controls new assignments only; existing v2 runs retain their routing.
     TRIGGER_WORKER_QUEUE_V2_ENABLED: z.string().default("0"),

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

@@ -7,25 +7,44 @@ const assignment = {
   region: "us-east-1",
   envType: "PRODUCTION",
   orgFeatureFlags: null,
-  globalDefault: false,
+  v2Enabled: true,
+  splitEnabled: true,
   workerGroups: [{ masterQueue: "us-east-1-next", workloadType: "MICROVM" as const }],
   rootTriggerSource: "api",
-  splitEnabled: true,
 };
 
 describe("workerQueueForBirth", () => {
-  it("keeps legacy assignment and scheduled lineage when v2 is off", () => {
-    expect(workerQueueForBirth(assignment)).toBe("us-east-1-next");
-    expect(workerQueueForBirth({ ...assignment, rootTriggerSource: "schedule" })).toBe(
-      "us-east-1-next:scheduled"
-    );
+  it.each([false, true])(
+    "keeps legacy assignment when v2 is disabled (split=%s)",
+    (splitEnabled) => {
+      expect(
+        workerQueueForBirth({
+          ...assignment,
+          workerQueue: "my workers",
+          region: undefined,
+          workerGroups: [{ masterQueue: "my workers", workloadType: "CONTAINER" }],
+          v2Enabled: false,
+          splitEnabled,
+          rootTriggerSource: "schedule",
+          orgFeatureFlags: {
+            workerQueueV2Enabled: true,
+            workerQueueScheduledSplitEnabled: true,
+          },
+        })
+      ).toBe(splitEnabled ? "my workers:scheduled" : "my workers");
+    }
+  );
+
+  it("keeps scheduled runs on the ondemand v2 queue when the split is disabled", () => {
+    expect(
+      workerQueueForBirth({ ...assignment, splitEnabled: false, rootTriggerSource: "schedule" })
+    ).toBe("us-east-1:v2:ondemand:fresh:compute:stable");
   });
 
   it("keeps legacy routing when the selected queue is absent from a loaded registry", () => {
     const input = {
       ...assignment,
       region: assignment.workerQueue,
-      globalDefault: true,
       workerGroups: [{ masterQueue: "us-west-2", workloadType: "CONTAINER" as const }],
     };
     expect(workerQueueForBirth(input)).toBe("us-east-1-next");
@@ -34,25 +53,21 @@ describe("workerQueueForBirth", () => {
     );
   });
 
-  it("uses the geographic region and selected runtime when v2 is enabled", () => {
-    expect(workerQueueForBirth({ ...assignment, globalDefault: true })).toBe(
-      "us-east-1:v2:ondemand:fresh:compute:stable"
-    );
+  it("uses the geographic region and selected runtime for deployed runs", () => {
+    expect(workerQueueForBirth(assignment)).toBe("us-east-1:v2:ondemand:fresh:compute:stable");
     expect(
       workerQueueForBirth({
         ...assignment,
-        globalDefault: true,
         workerGroups: [{ masterQueue: "us-east-1-next", workloadType: "CONTAINER" }],
       })
     ).toBe("us-east-1:v2:ondemand:fresh:container:stable");
   });
 
-  it("honors org opt-in, channel and explicit shared-runtime assignment", () => {
+  it("honors channel and explicit shared-runtime assignment", () => {
     expect(
       workerQueueForBirth({
         ...assignment,
         orgFeatureFlags: {
-          [FEATURE_FLAG.workerQueueV2Enabled]: true,
           [FEATURE_FLAG.workerQueueCompatibility]: "any",
           [FEATURE_FLAG.workerQueueChannel]: "canary",
         },
@@ -61,25 +76,29 @@ describe("workerQueueForBirth", () => {
     ).toBe("us-east-1:v2:scheduled:fresh:any:canary");
   });
 
-  it("honors org opt-out even when the global default is enabled", () => {
+  it("ignores obsolete opt-outs for v2 and scheduled assignment", () => {
     expect(
       workerQueueForBirth({
         ...assignment,
-        globalDefault: true,
-        orgFeatureFlags: { [FEATURE_FLAG.workerQueueV2Enabled]: false },
+        orgFeatureFlags: {
+          workerQueueV2Enabled: false,
+          workerQueueScheduledSplitEnabled: false,
+        },
+        rootTriggerSource: "schedule",
       })
-    ).toBe("us-east-1-next");
+    ).toBe("us-east-1:v2:scheduled:fresh:compute:stable");
   });
 
-  it("leaves development on the legacy path even with an org opt-in", () => {
-    expect(
-      workerQueueForBirth({
-        ...assignment,
-        envType: "DEVELOPMENT",
-        splitEnabled: false,
-        globalDefault: true,
-        orgFeatureFlags: { [FEATURE_FLAG.workerQueueV2Enabled]: true },
-      })
-    ).toBe("us-east-1-next");
-  });
+  it.each(["api", "schedule"])(
+    "leaves development on the base legacy queue for %s",
+    (rootTriggerSource) => {
+      expect(
+        workerQueueForBirth({
+          ...assignment,
+          envType: "DEVELOPMENT",
+          rootTriggerSource,
+        })
+      ).toBe("us-east-1-next");
+    }
+  );
 });

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

@@ -8,27 +8,27 @@ export function workerQueueForBirth({
   region,
   envType,
   orgFeatureFlags,
-  globalDefault,
+  v2Enabled,
+  splitEnabled,
   workerGroups,
   rootTriggerSource,
-  splitEnabled,
 }: {
   workerQueue: string;
   region: string | undefined;
   envType: string;
   orgFeatureFlags: Record<string, unknown> | null | undefined;
-  globalDefault: boolean;
+  v2Enabled: boolean;
+  splitEnabled: boolean;
   workerGroups: readonly Pick<WorkerGroupRegionRow, "masterQueue" | "workloadType">[];
   rootTriggerSource: string | undefined;
-  splitEnabled: boolean;
 }): string {
-  const enabled = orgFeatureFlags?.[FEATURE_FLAG.workerQueueV2Enabled];
-  const useV2 =
-    envType !== "DEVELOPMENT" && (typeof enabled === "boolean" ? enabled : globalDefault);
+  if (envType === "DEVELOPMENT") {
+    return workerQueue;
+  }
 
   // An unknown queue (e.g. cold registry) has no trustworthy region or runtime, so stay legacy.
   const group = workerGroups.find((group) => group.masterQueue === workerQueue);
-  if (!useV2 || !group) {
+  if (!v2Enabled || !group) {
     return workerQueueForRun({ workerQueue, rootTriggerSource, splitEnabled });
   }
 

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

@@ -4,7 +4,6 @@ import {
   WORKER_QUEUE_VERSION,
   type WorkerQueueClass,
 } from "@trigger.dev/core/v3/workers";
-import { FEATURE_FLAG, FeatureFlagCatalog } from "~/v3/featureFlags";
 
 export { SCHEDULED_WORKER_QUEUE_SUFFIX } from "@trigger.dev/core/v3/workers";
 
@@ -45,35 +44,6 @@ export function regionForDisplay(
 /** `TriggerSource` value used for runs originating from a schedule. */
 const SCHEDULE_TRIGGER_SOURCE = "schedule";
 
-/**
- * Resolve whether the scheduled worker-queue split is enabled for a run, reading
- * only the in-memory org feature-flags JSON (already loaded on the authenticated
- * environment) — never a DB query, so it is safe on the trigger hot path.
- *
- * Precedence: a per-org override wins in BOTH directions; the global default is
- * used only when the org has not set the flag.
- */
-export function resolveScheduledQueueSplitEnabled({
-  orgFeatureFlags,
-  globalDefault,
-}: {
-  orgFeatureFlags: Record<string, unknown> | null | undefined;
-  globalDefault: boolean;
-}): boolean {
-  const override = orgFeatureFlags?.[FEATURE_FLAG.workerQueueScheduledSplitEnabled];
-
-  if (override !== undefined) {
-    const parsed =
-      FeatureFlagCatalog[FEATURE_FLAG.workerQueueScheduledSplitEnabled].safeParse(override);
-
-    if (parsed.success) {
-      return parsed.data;
-    }
-  }
-
-  return globalDefault;
-}
-
 /**
  * Pick the worker queue a run should be enqueued onto. Runs in a scheduled
  * lineage (`rootTriggerSource === "schedule"`, which propagates from a scheduled

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

@@ -40,7 +40,6 @@ import {
   type IdempotencyKeyConcern,
   type ClaimedIdempotency,
 } from "../concerns/idempotencyKeys.server";
-import { resolveScheduledQueueSplitEnabled } from "../concerns/workerQueueSplit.server";
 import { workerQueueForBirth } from "../concerns/workerQueueAssignment.server";
 import { resolveComputeMigration } from "../concerns/computeMigration.server";
 import { workerRegionRegistry, backingForQueue, regionForQueue } from "~/v3/workerRegions.server";
@@ -541,17 +540,6 @@ export class RunEngineTriggerTaskService {
             webhookEndpointId: options.webhookEndpointId,
           };
 
-          // Preserve scheduled lineage independently of the queue-name version.
-          // Rollout decisions use already-loaded org flags and registry data.
-          const scheduledQueueSplitEnabled =
-            environment.type !== "DEVELOPMENT" &&
-            resolveScheduledQueueSplitEnabled({
-              orgFeatureFlags: environment.organization.featureFlags as Record<
-                string,
-                unknown
-              > | null,
-              globalDefault: env.TRIGGER_WORKER_QUEUE_SCHEDULED_SPLIT_ENABLED === "1",
-            });
           const workerQueue =
             migrated.workerQueue !== undefined
               ? workerQueueForBirth({
@@ -562,10 +550,10 @@ export class RunEngineTriggerTaskService {
                     string,
                     unknown
                   > | null,
-                  globalDefault: env.TRIGGER_WORKER_QUEUE_V2_ENABLED === "1",
+                  v2Enabled: env.TRIGGER_WORKER_QUEUE_V2_ENABLED === "1",
+                  splitEnabled: env.TRIGGER_WORKER_QUEUE_SCHEDULED_SPLIT_ENABLED === "1",
                   workerGroups,
                   rootTriggerSource: annotations.rootTriggerSource,
-                  splitEnabled: scheduledQueueSplitEnabled,
                 })
               : migrated.workerQueue;
 

apps/webapp/app/v3/featureFlags.ts

@@ -19,8 +19,6 @@ export const FEATURE_FLAG = {
   hasSso: "hasSso",
   hasThemeSwitcher: "hasThemeSwitcher",
   mollifierEnabled: "mollifierEnabled",
-  workerQueueScheduledSplitEnabled: "workerQueueScheduledSplitEnabled",
-  workerQueueV2Enabled: "workerQueueV2Enabled",
   workerQueueCompatibility: "workerQueueCompatibility",
   workerQueueChannel: "workerQueueChannel",
   internalApiOriginEnabled: "internalApiOriginEnabled",
@@ -99,8 +97,6 @@ export const FeatureFlagCatalog = {
   // Gates the Interface theme setting in /account. Off by default.
   [FEATURE_FLAG.hasThemeSwitcher]: z.coerce.boolean(),
   [FEATURE_FLAG.mollifierEnabled]: z.coerce.boolean(),
-  [FEATURE_FLAG.workerQueueScheduledSplitEnabled]: z.coerce.boolean(),
-  [FEATURE_FLAG.workerQueueV2Enabled]: z.boolean(),
   // Mirrors the core worker-queue enums; defined here because this module is imported client-side.
   [FEATURE_FLAG.workerQueueCompatibility]: z.enum(["any", "container", "compute"]),
   [FEATURE_FLAG.workerQueueChannel]: z.enum(["stable", "canary"]),
@@ -211,7 +207,6 @@ export const GLOBAL_LOCKED_FLAGS: FeatureFlagKey[] = [
   FEATURE_FLAG.runOpsMintShard,
   FEATURE_FLAG.runOpsMintShardEnvPins,
   FEATURE_FLAG.apiRateLimitMetricsEnabled,
-  FEATURE_FLAG.workerQueueV2Enabled,
   FEATURE_FLAG.workerQueueCompatibility,
   FEATURE_FLAG.workerQueueChannel,
   // Grace stamps are computed server-side. An editable control here would discard what it saves.

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

@@ -19,6 +19,7 @@ vi.mock("~/services/platform.v3.server", async (importOriginal) => {
   };
 });
 
+import { env } from "~/env.server";
 import { RunEngine } from "@internal/run-engine";
 import { setupAuthenticatedEnvironment, setupBackgroundWorker } from "@internal/run-engine/tests";
 import { assertNonNullable, containerTest } from "@internal/testcontainers";
@@ -199,6 +200,12 @@ describe("RunEngineTriggerTaskService", () => {
   containerTest(
     "routes scheduled-lineage runs to a separate worker queue that dequeues independently",
     async ({ prisma, redisOptions }) => {
+      const previousSplitEnabled = env.TRIGGER_WORKER_QUEUE_SCHEDULED_SPLIT_ENABLED;
+      env.TRIGGER_WORKER_QUEUE_SCHEDULED_SPLIT_ENABLED = "1";
+      onTestFinished(() => {
+        env.TRIGGER_WORKER_QUEUE_SCHEDULED_SPLIT_ENABLED = previousSplitEnabled;
+      });
+
       const engine = new RunEngine({
         prisma,
         worker: {
@@ -233,12 +240,6 @@ describe("RunEngineTriggerTaskService", () => {
       try {
         const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
 
-        // Turn the per-org split flag on in-memory — the resolver reads this
-        // object directly (no DB round-trip on the trigger hot path).
-        (authenticatedEnvironment.organization as { featureFlags?: unknown }).featureFlags = {
-          workerQueueScheduledSplitEnabled: true,
-        };
-
         const taskIdentifier = "test-task";
         await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
 

apps/webapp/test/retiredWorkerQueueFlags.test.ts

@@ -0,0 +1,14 @@
+import { expect, it } from "vitest";
+import { FEATURE_FLAG, validatePartialFeatureFlags } from "~/v3/featureFlags";
+
+it("ignores retired worker queue flags without discarding active flags", () => {
+  const result = validatePartialFeatureFlags({
+    workerQueueV2Enabled: false,
+    workerQueueScheduledSplitEnabled: "obsolete",
+    [FEATURE_FLAG.workerQueueChannel]: "canary",
+  });
+
+  expect(result.success).toBe(true);
+  if (!result.success) throw result.error;
+  expect(result.data).toEqual({ [FEATURE_FLAG.workerQueueChannel]: "canary" });
+});