fix(webapp,run-engine): replays survive gate growth across deploys

Gate capacity is four end to end (three requested gates plus the
task's anonymous inline-limit gate), so replaying a three-gate run
against a task that later gained an inline limit resolves to four and
still enqueues. A run stored without gates now replays with the task's
currently declared limits instead of a fabricated empty array that
silently cleared them, matching how replays adopt the current queue
and retry config.

Author: matt-aitken

apps/webapp/app/v3/services/replayTaskRun.server.ts

@@ -142,9 +142,15 @@ export class ReplayTaskRunService extends BaseService {
               : undefined,
             concurrencyKey:
               overrideOptions.concurrencyKey ?? existingTaskRun.concurrencyKey ?? undefined,
+            /**
+             * A run that held gates replays with those same gates. A run with none
+             * stored passes undefined (never a fabricated empty array, which reads
+             * as "clear the named limits") so the replay honors whatever limits the
+             * task declares now, like it honors the current queue and retry config.
+             */
             gates: Array.isArray(existingTaskRun.gates)
               ? (existingTaskRun.gates as Array<{ queue: string; concurrencyKey?: string }>)
-              : [],
+              : undefined,
             maxAttempts: overrideOptions.maxAttempts,
             maxDuration: overrideOptions.maxDurationSeconds,
             machine:

internal-packages/run-engine/src/engine/gateParsing.test.ts

@@ -2,18 +2,20 @@ import { describe, expect, it } from "vitest";
 import { parseGates } from "./gateParsing.js";
 
 describe("parseGates", () => {
-  it("keeps well-shaped gates and caps at three", () => {
+  it("keeps well-shaped gates and caps at four", () => {
     expect(
       parseGates([
         { queue: "a" },
         { queue: "b", concurrencyKey: "shared" },
         { queue: "c" },
         { queue: "d" },
+        { queue: "e" },
       ])
     ).toEqual([
       { queue: "a", concurrencyKey: undefined },
       { queue: "b", concurrencyKey: "shared" },
       { queue: "c", concurrencyKey: undefined },
+      { queue: "d", concurrencyKey: undefined },
     ]);
   });
 

internal-packages/run-engine/src/engine/gateParsing.ts

@@ -4,8 +4,8 @@
  * value can never fail a trigger or an enqueue. A gate needs a queue name within
  * the manifest bounds (1-128 chars); a literal concurrency key must fit the same
  * bounds, and an empty-string key means "omitted" so the gate inherits the run's
- * key. At most three gates apply: a task's anonymous inline-limit gate plus two
- * named limits.
+ * key. At most four gates apply: three requested gates plus the task's anonymous
+ * inline-limit gate.
  */
 export type ParsedGate = { queue: string; concurrencyKey?: string };
 
@@ -30,5 +30,5 @@ export function parseGates(gates: unknown): ParsedGate[] {
     return [{ queue, concurrencyKey }];
   });
 
-  return parsed.slice(0, 3);
+  return parsed.slice(0, 4);
 }

internal-packages/run-engine/src/engine/types.ts

@@ -332,7 +332,8 @@ export type TriggerParams = {
   sdkVersion?: string;
   cliVersion?: string;
   concurrencyKey?: string;
-  /** Other queues this run must also hold a concurrency slot in while executing. At most two. */
+  /** Other queues this run must also hold a concurrency slot in while executing. At
+   * most four: three requested gates plus the task's anonymous inline-limit gate. */
   gates?: QueueGate[];
   workerQueue?: string;
   region?: string;