fix(run-ops split): make webapp assertEnvExists a no-op when split is OFF

With the split OFF there is a single DB, so a run and its environment are
co-located and there is no cross-seam FK/check to replace (matches main).
Skip the always-on hot-path read in that branch; the split-ON branch is
unchanged (cache-first, throws on a genuinely missing env).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: d-cs

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

@@ -394,12 +394,8 @@ export class ControlPlaneResolver {
 
   async assertEnvExists(environmentId: string): Promise<void> {
     if (!this.splitEnabled()) {
-      const exists = await this.#queryEnvExists(this.controlPlanePrimary, environmentId);
-      if (!exists) {
-        throw new ControlPlaneReferenceError(
-          `Referenced environment does not exist: ${environmentId}`
-        );
-      }
+      // Split OFF = single DB, so run and env are co-located and there is no FK/check
+      // to replace (matches main). Skip the hot-path read entirely.
       return;
     }
 

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

@@ -335,21 +335,22 @@ heteroPostgresTest(
 );
 
 heteroPostgresTest(
-  "assertEnvExists passthrough (split OFF) still validates a real env",
+  "assertEnvExists passthrough (split OFF) is a no-op: never reads, never throws",
   async ({ prisma14 }) => {
     const { environment } = await seedControlPlane(prisma14);
-    const { client: counting } = countQueries(prisma14);
+    const { client: counting, reads } = countQueries(prisma14);
     const resolver = new ControlPlaneResolver({
       controlPlaneReplica: counting,
       controlPlanePrimary: counting,
       cache: new ControlPlaneCache(),
       splitEnabled: () => false,
     });
 
+    // Split OFF = single DB, run and env co-located, so there is nothing to assert
+    // and the hot-path read is skipped entirely — resolves for present and missing.
     await expect(resolver.assertEnvExists(environment.id)).resolves.toBeUndefined();
-    await expect(resolver.assertEnvExists("env_missing")).rejects.toBeInstanceOf(
-      ControlPlaneReferenceError
-    );
+    await expect(resolver.assertEnvExists("env_missing")).resolves.toBeUndefined();
+    expect(reads()).toBe(0);
   }
 );
 

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

@@ -205,10 +205,14 @@ describe("RunEngineControlPlaneResolver adapter", () => {
   );
 
   heteroPostgresTest(
-    "assertEnvExists resolves for a present env, rejects for a missing one",
+    "assertEnvExists (split ON) resolves for a present env, rejects for a missing one",
     async ({ prisma14 }) => {
       const { environment } = await seedEnv(prisma14, "PRODUCTION");
-      const adapter = new RunEngineControlPlaneResolver(buildAppResolver(prisma14));
+      // split ON: the only mode where assertEnvExists asserts (split OFF is a no-op,
+      // covered in controlPlaneResolver.server.test.ts).
+      const adapter = new RunEngineControlPlaneResolver(
+        buildAppResolver(prisma14, { splitEnabled: true })
+      );
 
       await expect(adapter.assertEnvExists(environment.id)).resolves.toBeUndefined();
       await expect(adapter.assertEnvExists("env_missing")).rejects.toThrow();