fix(webapp,run-store): correct run-ops routing in finalization, resume, and edge cleanup

- Skip the legacy attempt-create when a run-ops-resident run reaches the
  no-attempt branch during finalization; it is already finalized on its own
  database, so minting a legacy attempt would orphan a row on the wrong one.
- Cancel and finalize the same run by taking the run id from the fetched
  attempt rather than a caller-supplied id.
- When resuming dependent parents, read the owning primary for the run and
  attempts just finalized in the same operation so replica lag cannot skip a
  resume, and stop when the environment cannot be resolved instead of treating
  it as production.
- Delete run/waitpoint edges from both stores so a cross-database edge cannot
  leave a run blocked.
- Drop a redundant read client on the bulk-action source-run lookup so it uses
  the residency-routed replica.

Author: d-cs

apps/webapp/app/v3/services/bulk/performBulkAction.server.ts

@@ -27,7 +27,8 @@ export class PerformBulkActionService extends BaseService {
     }
 
     // Fetch the source run through the store (it may reside in a different DB than the item).
-    const sourceRun = await this.runStore.findRunOrThrow({ id: item.sourceRunId }, this._prisma);
+    // No client: routing keys off the run id, and this pre-existing run needs no read-your-writes.
+    const sourceRun = await this.runStore.findRunOrThrow({ id: item.sourceRunId });
 
     switch (item.type) {
       case "REPLAY": {

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

@@ -71,7 +71,7 @@ export class CancelAttemptService extends BaseService {
 
       const finalizeService = new FinalizeTaskRunService();
       await finalizeService.call({
-        id: taskRunId,
+        id: taskRunAttempt.taskRun.id,
         status: isCancellable ? "INTERRUPTED" : undefined,
         completedAt: isCancellable ? cancelledAt : undefined,
         attemptStatus: isCancellable ? "CANCELED" : undefined,

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

@@ -1,4 +1,5 @@
 import { type FlushedRunMetadata, type TaskRunError, sanitizeError } from "@trigger.dev/core/v3";
+import { ownerEngine } from "@trigger.dev/core/v3/isomorphic";
 import { type Prisma, type TaskRun } from "@trigger.dev/database";
 import { runOpsLegacyPrisma } from "~/db.server";
 import { findQueueInEnvironment } from "~/models/taskQueue.server";
@@ -314,6 +315,17 @@ export class FinalizeTaskRunService extends BaseService {
       error,
     });
 
+    // TaskRunAttempt is V1-residual, minted only for legacy (cuid) runs on the legacy client below.
+    // A NEW-resident run reaching here (via CompleteAttemptService's fan-out lookup) is already
+    // finalized on its owning store above, so skip the orphan legacy attempt.
+    if (ownerEngine(run.id) === "NEW") {
+      logger.error(
+        "FinalizeTaskRunService: reached no-attempt branch for a run-ops (NEW-resident) run; skipping legacy attempt-create",
+        { runId: run.id, status: run.status }
+      );
+      return;
+    }
+
     if (!run.lockedById) {
       // This happens when a run is expired or was cancelled before an attempt, it's not a problem
       logger.info(

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

@@ -55,11 +55,14 @@ type Dependency = NonNullable<RunWithDependency["dependency"]>;
 export class ResumeDependentParentsService extends BaseService {
   public async call({ id }: { id: string }): Promise<Output> {
     try {
+      // Read-your-writes: the caller just committed this run's final status, so read the owning
+      // primary (writer) — a lagging replica could show a non-final status and skip resumption.
       const run = await this.runStore.findRun(
         { id },
         {
           select: runWithDependencySelect,
-        }
+        },
+        this._prisma
       );
 
       const dependency = run?.dependency ?? null;
@@ -83,7 +86,21 @@ export class ResumeDependentParentsService extends BaseService {
 
       const environment = await findEnvironmentById(run.runtimeEnvironmentId);
 
-      if (environment?.type === "DEVELOPMENT") {
+      if (!environment) {
+        // Bail rather than fall through: an unresolved env would otherwise be treated as
+        // production and mutate dependency state.
+        logger.error("ResumeDependentParentsService: environment not found", {
+          runId: id,
+          runtimeEnvironmentId: run.runtimeEnvironmentId,
+        });
+
+        return {
+          success: false,
+          error: `Environment not found for run ${id}`,
+        };
+      }
+
+      if (environment.type === "DEVELOPMENT") {
         return {
           success: true,
           action: "dev",
@@ -137,18 +154,22 @@ export class ResumeDependentParentsService extends BaseService {
       }
     );
 
-    const lastAttempt = await this.runStore.findTaskRunAttempt({
-      select: {
-        id: true,
-        status: true,
-      },
-      where: {
-        taskRunId: dependency.taskRunId,
-      },
-      orderBy: {
-        id: "desc",
+    // Read-your-writes: the just-finalized attempt was written by the same finalize operation.
+    const lastAttempt = await this.runStore.findTaskRunAttempt(
+      {
+        select: {
+          id: true,
+          status: true,
+        },
+        where: {
+          taskRunId: dependency.taskRunId,
+        },
+        orderBy: {
+          id: "desc",
+        },
       },
-    });
+      this._prisma
+    );
 
     if (!lastAttempt) {
       logger.error(
@@ -210,18 +231,22 @@ export class ResumeDependentParentsService extends BaseService {
       };
     }
 
-    const lastAttempt = await this.runStore.findTaskRunAttempt({
-      select: {
-        id: true,
-        status: true,
-      },
-      where: {
-        taskRunId: dependency.taskRunId,
-      },
-      orderBy: {
-        id: "desc",
+    // Read-your-writes: the just-finalized attempt was written by the same finalize operation.
+    const lastAttempt = await this.runStore.findTaskRunAttempt(
+      {
+        select: {
+          id: true,
+          status: true,
+        },
+        where: {
+          taskRunId: dependency.taskRunId,
+        },
+        orderBy: {
+          id: "desc",
+        },
       },
-    });
+      this._prisma
+    );
 
     if (!lastAttempt) {
       logger.error(

internal-packages/run-store/src/runOpsStore.ts

@@ -1362,15 +1362,9 @@ export class RoutingRunStore implements RunStore {
     args: Prisma.TaskRunWaitpointDeleteManyArgs,
     tx?: PrismaClientOrTransaction
   ): Promise<Prisma.BatchPayload> {
-    const where = args.where as { waitpointId?: unknown } | undefined;
-    const waitpointId = typeof where?.waitpointId === "string" ? where.waitpointId : undefined;
-    if (waitpointId !== undefined) {
-      const store = await this.#resolveWaitpointStore(waitpointId);
-      return store.deleteManyTaskRunWaitpoints(args, undefined);
-    }
-    // Keyed by taskRunId (or other): a run's edges may straddle DBs mid-drain, so delete from both.
-    // The caller's `tx` is never forwarded — each leg deletes on its own store's client, so neither
-    // leg is tied to a caller-supplied transaction.
+    // Edges co-locate with their RUN, not their waitpoint, so a waitpointId/taskRunId predicate may
+    // match edges on either store; delete from both so no cross-DB edge keeps a run blocked. The
+    // caller's `tx` is never forwarded — each leg deletes on its own store's client.
     const [fromNew, fromLegacy] = await Promise.all([
       this.#new.deleteManyTaskRunWaitpoints(args),
       this.#legacy.deleteManyTaskRunWaitpoints(args),