fix(run-engine): re-arm the park deadline when a parked run is not due yet

The external-deployment park deadline is armed once, when the run is first
parked, from max(now, delayUntil) + deadline. Debounce can push delayUntil out
afterwards: rescheduleDelayedRun reschedules enqueueDelayedRun:<id>, and the
redis-worker reschedule is an update-only ZADD, so expireParkedExternalDeploymentRun:<id>
is never re-armed.

Repeat triggers on one debounce key therefore walk delayUntil past a deadline
that no longer moves, and the run is expired with EXTERNAL_DEPLOYMENT_NOT_FOUND
before it was ever due to start. Reproduced against a local instance: a run due
at 14:01:37 was expired at 13:57:02, blaming a missing deployment.

The expiry job already loads delayUntil, so it now re-arms from the current
value and returns instead of expiring a run that is not due. Putting the guard
here rather than in the debounce path covers every caller that moves delayUntil,
and it stays bounded by the debounce max-duration contract.

Author: 0ski

internal-packages/run-engine/src/engine/systems/pendingVersionSystem.ts

@@ -470,6 +470,22 @@ export class PendingVersionSystem {
       );
     }
 
+    if (run.delayUntil && run.delayUntil > new Date()) {
+      this.$.logger.info(
+        "expireParkedExternalDeploymentRun: run is not due yet, re-arming the park deadline",
+        { runId, externalDeploymentId, delayUntil: run.delayUntil }
+      );
+
+      await this.scheduleExternalDeploymentParkDeadline({
+        runId,
+        externalDeploymentId,
+        ttl: run.ttl,
+        delayUntil: run.delayUntil,
+      });
+
+      return;
+    }
+
     const error: TaskRunError = {
       type: "STRING_ERROR",
       raw: `Run expired because no deployment with external id '${externalDeploymentId}' became available`,

internal-packages/run-engine/src/engine/tests/externalDeploymentParking.test.ts

@@ -566,6 +566,66 @@ describe("RunEngine external deployment parking", () => {
     }
   );
 
+  containerTest(
+    "the parking deadline re-arms instead of expiring a run whose delay was pushed past it",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+      const engine = createEngine(prisma, redisOptions);
+
+      try {
+        const taskIdentifier = "test-task";
+
+        const run = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_1234",
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t1234",
+            spanId: "s1234",
+            queue: `task/${taskIdentifier}`,
+            isTest: false,
+            tags: [],
+            delayUntil: new Date(Date.now() + 60 * 1000),
+            annotations: {
+              triggerSource: "sdk",
+              triggerAction: "trigger",
+              rootTriggerSource: "sdk",
+              externalDeploymentId: "commit-pushed",
+            },
+            parkedOnExternalDeploymentId: "commit-pushed",
+          },
+          prisma
+        );
+
+        // Stand in for a debounce push: the run's delay moves out, but nothing re-arms the
+        // deadline that was computed when the run was first parked.
+        const pushedDelayUntil = new Date(Date.now() + 60 * 60 * 1000);
+        await prisma.taskRun.update({
+          where: { id: run.id },
+          data: { delayUntil: pushedDelayUntil },
+        });
+
+        await engine.pendingVersionSystem.expireParkedExternalDeploymentRun({
+          runId: run.id,
+          externalDeploymentId: "commit-pushed",
+        });
+
+        const stillParked = await prisma.taskRun.findFirstOrThrow({ where: { id: run.id } });
+
+        expect(stillParked.status).toBe("PENDING_VERSION");
+        expect(stillParked.statusReason).toBe("EXTERNAL_DEPLOYMENT_PENDING");
+        expect(stillParked.expiredAt).toBeNull();
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
   containerTest(
     "the parking deadline expires a run whose deployment never arrived",
     async ({ prisma, redisOptions }) => {