fix(webapp): reject locked triggers when the task is missing on that worker, clear stale cache on zero-task deploys

Two CodeRabbit findings:

1. The locked + queue-override branch silently accepted a missing task slug
   on the locked worker version, leaving `taskKind` / `ttl` as undefined
   instead of erroring. Now matches the no-override branch and throws a
   ServiceValidationError if the task isn't on the locked worker.

2. The cache populate methods short-circuited on empty entries, leaving
   stale hashes in Redis when a worker registered or got promoted with
   zero tasks. The Lua scripts already handle the empty-entries case
   (DEL + no HSET), so just drop the gates at the cache class and at the
   four call sites so promotion correctly clears prior data.

Author: ericallam

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

@@ -124,10 +124,17 @@ export class DefaultQueueManager implements QueueManager {
           request.taskId
         );
 
+        if (!lockedMeta) {
+          throw new ServiceValidationError(
+            `Task '${request.taskId}' not found on locked version '${lockedBackgroundWorker.version ?? "<unknown>"
+            }'.`
+          );
+        }
+
         if (request.body.options?.ttl === undefined) {
-          taskTtl = lockedMeta?.ttl ?? undefined;
+          taskTtl = lockedMeta.ttl ?? undefined;
         }
-        taskKind = lockedMeta?.triggerSource;
+        taskKind = lockedMeta.triggerSource;
       } else {
         // No queue override - resolve default queue + TTL + triggerSource via cache,
         // falling back to a single BackgroundWorkerTask lookup on miss.

apps/webapp/app/services/taskMetadataCache.server.ts

@@ -267,8 +267,10 @@ export class RedisTaskMetadataCache implements TaskMetadataCache {
     workerId: string,
     entries: TaskMetadataEntry[]
   ): Promise<void> {
-    if (entries.length === 0) return;
     try {
+      // Always invoke the script — empty `entries` is valid and causes both
+      // keyspaces to be cleared (DEL + no HSET), which is the right behavior
+      // when promoting a worker with no tasks.
       const argv: string[] = [
         String(this.currentEnvTtlSeconds),
         String(this.byWorkerTtlSeconds),
@@ -291,8 +293,8 @@ export class RedisTaskMetadataCache implements TaskMetadataCache {
   }
 
   async populateByWorker(workerId: string, entries: TaskMetadataEntry[]): Promise<void> {
-    if (entries.length === 0) return;
     try {
+      // Always invoke the script — empty `entries` clears the keyspace.
       const argv: string[] = [String(this.byWorkerTtlSeconds)];
       for (const entry of entries) {
         argv.push(entry.slug, encode(entry));

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

@@ -234,8 +234,9 @@ export class CreateBackgroundWorkerService extends BaseService {
       // here — promotion writes the `:env:` keyspace later in
       // changeCurrentDeployment / createDeploymentBackgroundWorkerV3.
       // Cache calls log+swallow internally, so a Redis blip can't break
-      // anything else here.
-      if (workerTaskEntries && workerTaskEntries.length > 0) {
+      // anything else here. Empty `workerTaskEntries` is intentional — the
+      // populate methods clear stale hashes for zero-task deploys.
+      if (workerTaskEntries) {
         if (environment.type === "DEVELOPMENT") {
           await this._taskMetaCache.populateByCurrentWorker(
             environment.id,

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

@@ -168,14 +168,13 @@ export class CreateDeploymentBackgroundWorkerServiceV3 extends BaseService {
 
       // V3 promotes the deployment immediately above, so this worker is now
       // current for the env — write both keyspaces atomically. Cache calls
-      // log+swallow internally.
-      if (workerTaskEntries.length > 0) {
-        await this._taskMetaCache.populateByCurrentWorker(
-          environment.id,
-          backgroundWorker.id,
-          workerTaskEntries
-        );
-      }
+      // log+swallow internally. Empty `workerTaskEntries` is intentional: the
+      // populate methods clear stale hashes for zero-task deploys.
+      await this._taskMetaCache.populateByCurrentWorker(
+        environment.id,
+        backgroundWorker.id,
+        workerTaskEntries
+      );
 
       try {
         //send a notification that a new worker has been created

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

@@ -152,12 +152,9 @@ export class CreateDeploymentBackgroundWorkerServiceV4 extends BaseService {
       // triggers against this build hit the cache. Promotion (which writes the
       // env keyspace) happens later via finalizeDeployment → changeCurrentDeployment.
       // Cache calls log+swallow internally, so a Redis blip can't stall the
-      // deployment state machine.
-      if (workerTaskEntries && workerTaskEntries.length > 0) {
-        await this._taskMetaCache.populateByWorker(
-          backgroundWorker.id,
-          workerTaskEntries
-        );
+      // deployment state machine. Empty entries clears stale hashes.
+      if (workerTaskEntries) {
+        await this._taskMetaCache.populateByWorker(backgroundWorker.id, workerTaskEntries);
       }
 
       const [schedulesError] = await tryCatch(