fix(webapp): default worker-version fresh-read on; update resolver tests

The fresh-read flag is optional and defaults on, so existing resolver
constructions keep working; the control-plane resolver tests assert the
fresh (no-cache) default and cover the kill-switch cache path.

Author: ericallam

apps/webapp/app/v3/runOpsMigration/controlPlaneResolver.server.ts

@@ -59,11 +59,12 @@ export type ControlPlaneResolverOptions = {
   cache: ControlPlaneCache;
   splitEnabled: () => boolean;
   /**
-   * When true (default), the dequeue worker-version resolve reads the matched task/queue fresh on
-   * every call (no cache). When false, it falls back to the legacy env-keyed cache over the whole
-   * task/queue set — a kill-switch, retained only so the read shape can be reverted via config.
+   * When true (the default when omitted), the dequeue worker-version resolve reads the matched
+   * task/queue fresh on every call (no cache). When false, it falls back to the legacy env-keyed
+   * cache over the whole task/queue set — a kill-switch, retained only so the read shape can be
+   * reverted via config.
    */
-  workerVersionFreshReadEnabled: () => boolean;
+  workerVersionFreshReadEnabled?: () => boolean;
 };
 
 type CpClient = PrismaClient | PrismaReplicaClient;
@@ -111,7 +112,7 @@ export class ControlPlaneResolver {
     this.controlPlaneReplica = opts.controlPlaneReplica;
     this.cache = opts.cache;
     this.splitEnabled = opts.splitEnabled;
-    this.workerVersionFreshReadEnabled = opts.workerVersionFreshReadEnabled;
+    this.workerVersionFreshReadEnabled = opts.workerVersionFreshReadEnabled ?? (() => true);
   }
 
   async resolveEnv(environmentId: string): Promise<ResolvedEnv | null> {

apps/webapp/test/v3/runOpsMigration/controlPlaneResolver.server.test.ts

@@ -224,7 +224,7 @@ heteroPostgresTest(
 // --- resolveWorkerVersion ---------------------------------------------------
 
 heteroPostgresTest(
-  "resolveWorkerVersion (pinned) returns worker/tasks/queues and caches it",
+  "resolveWorkerVersion (pinned) returns worker/tasks/queues and reads fresh each call",
   async ({ prisma14 }) => {
     const { environment, project } = await seedControlPlane(prisma14);
     const { worker, task, queue } = await seedWorker(prisma14, {
@@ -250,6 +250,37 @@ heteroPostgresTest(
     const readsAfterFirst = reads();
     expect(readsAfterFirst).toBeGreaterThanOrEqual(1);
 
+    const second = await resolver.resolveWorkerVersion({
+      environmentId: environment.id,
+      backgroundWorkerId: worker.id,
+    });
+    expect(second?.worker.id).toBe(worker.id);
+    expect(reads()).toBeGreaterThan(readsAfterFirst);
+  }
+);
+
+heteroPostgresTest(
+  "resolveWorkerVersion (pinned) serves from cache when the kill-switch is off",
+  async ({ prisma14 }) => {
+    const { environment, project } = await seedControlPlane(prisma14);
+    const { worker } = await seedWorker(prisma14, {
+      projectId: project.id,
+      environmentId: environment.id,
+    });
+    const { client: counting, reads } = countQueries(prisma14);
+    const resolver = new ControlPlaneResolver({
+      controlPlaneReplica: counting,
+      controlPlanePrimary: counting,
+      cache: new ControlPlaneCache(),
+      splitEnabled: () => true,
+      workerVersionFreshReadEnabled: () => false,
+    });
+
+    await resolver.resolveWorkerVersion({
+      environmentId: environment.id,
+      backgroundWorkerId: worker.id,
+    });
+    const readsAfterFirst = reads();
     const second = await resolver.resolveWorkerVersion({
       environmentId: environment.id,
       backgroundWorkerId: worker.id,
@@ -283,7 +314,7 @@ heteroPostgresTest(
 
     const second = await resolver.resolveWorkerVersion({ environmentId: environment.id });
     expect(second?.worker.id).toBe(worker.id);
-    expect(reads()).toBe(readsAfterFirst);
+    expect(reads()).toBeGreaterThan(readsAfterFirst);
   }
 );