fix(run-ops split): resolve parent run through an injectable run store in TriggerFailedTaskService

TriggerFailedTaskService read the parent run via the ambient module-singleton
store while the engine wrote the run through its own store, so a ksuid parent's
row was not found and parentTaskRunId came back null. Add an optional injected
runStore (defaults to the shared singleton, preserving production behaviour) and
resolve the parent through it at both call sites, mirroring triggerTask.server.ts.

Align the three affected webapp tests to read through the same store the engine
wrote to: triggerFailedTask.test.ts passes engine.runStore; performTaskRunAlerts
routing passes a passthrough store over the seeded container; triggerTask.test.ts
stubs the run-ops db handles and pins split mode off so the idempotency dedup uses
the container client.

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

Author: d-cs

apps/webapp/app/runEngine/services/triggerFailedTask.server.ts

@@ -13,7 +13,8 @@ import { getEventRepository } from "~/v3/eventRepository/index.server";
 import { PerformTaskRunAlertsService } from "~/v3/services/alerts/performTaskRunAlerts.server";
 import { DefaultQueueManager } from "../concerns/queues.server";
 import type { TriggerTaskRequest } from "../types";
-import { runStore } from "~/v3/runStore.server";
+import { runStore as defaultRunStore } from "~/v3/runStore.server";
+import type { RunStore } from "@internal/run-store";
 
 export type TriggerFailedTaskRequest = {
   /** The task identifier (e.g. "my-task") */
@@ -65,19 +66,25 @@ export class TriggerFailedTaskService {
   // Injected so the migrated-marker read stays off the hot path when split is off
   // (same guard as RunEngineTriggerTaskService); defaults to the live resolver.
   private readonly isSplitEnabled: () => Promise<boolean>;
+  // Resolves the parent run for depth/root/parent linkage. Defaults to the shared
+  // singleton (in production the same store the engine writes through). Injected in
+  // tests so the read resolves on the same store the engine wrote to.
+  private readonly runStore: RunStore;
 
   constructor(opts: {
     prisma: PrismaClientOrTransaction;
     engine: RunEngine;
     replicaPrisma?: PrismaClientOrTransaction;
     isKnownMigrated?: (runId: string) => Promise<boolean>;
     isSplitEnabled?: () => Promise<boolean>;
+    runStore?: RunStore;
   }) {
     this.prisma = opts.prisma;
     this.replicaPrisma = opts.replicaPrisma ?? opts.prisma;
     this.engine = opts.engine;
     this.isKnownMigrated = opts.isKnownMigrated ?? defaultIsKnownMigrated;
     this.isSplitEnabled = opts.isSplitEnabled ?? defaultIsSplitEnabled;
+    this.runStore = opts.runStore ?? defaultRunStore;
   }
 
   // Mint a failed run's friendlyId. The id-kind decides which store the run is
@@ -135,7 +142,7 @@ export class TriggerFailedTaskService {
 
       // Resolve parent run for rootTaskRunId and depth (same as triggerTask.server.ts)
       const parentRun = request.parentRunId
-        ? await runStore.findRun(
+        ? await this.runStore.findRun(
             {
               id: RunId.fromFriendlyId(request.parentRunId),
               runtimeEnvironmentId: request.environment.id,
@@ -341,7 +348,7 @@ export class TriggerFailedTaskService {
       let depth = 0;
 
       if (opts.parentRunId) {
-        const parentRun = await runStore.findRun(
+        const parentRun = await this.runStore.findRun(
           {
             id: RunId.fromFriendlyId(opts.parentRunId),
             runtimeEnvironmentId: opts.environmentId,

apps/webapp/test/engine/triggerFailedTask.test.ts

@@ -43,6 +43,8 @@ describe("TriggerFailedTaskService — failed run residency", () => {
       const service = new TriggerFailedTaskService({
         prisma,
         engine,
+        // Read the parent through the same store the engine wrote it to.
+        runStore: engine.runStore,
         isKnownMigrated: async () => false,
       });
 
@@ -97,6 +99,8 @@ describe("TriggerFailedTaskService — failed run residency", () => {
       const service = new TriggerFailedTaskService({
         prisma,
         engine,
+        // Read the parent through the same store the engine wrote it to.
+        runStore: engine.runStore,
         isKnownMigrated: async () => false,
       });
 
@@ -154,6 +158,8 @@ describe("TriggerFailedTaskService — failed run residency", () => {
       const service = new TriggerFailedTaskService({
         prisma,
         engine,
+        // Read the parent through the same store the engine wrote it to.
+        runStore: engine.runStore,
         isKnownMigrated: async () => false,
       });
 
@@ -201,6 +207,8 @@ describe("TriggerFailedTaskService — failed run residency", () => {
       const service = new TriggerFailedTaskService({
         prisma,
         engine,
+        // Read the parent through the same store the engine wrote it to.
+        runStore: engine.runStore,
         isKnownMigrated: async (id: string) => id === parentFriendlyId,
       });
 
@@ -247,6 +255,8 @@ describe("TriggerFailedTaskService — failed run residency", () => {
       const service = new TriggerFailedTaskService({
         prisma,
         engine,
+        // Read the parent through the same store the engine wrote it to.
+        runStore: engine.runStore,
         isKnownMigrated: async () => false,
       });
 
@@ -278,6 +288,8 @@ describe("TriggerFailedTaskService — failed run residency", () => {
       const service = new TriggerFailedTaskService({
         prisma,
         engine,
+        // Read the parent through the same store the engine wrote it to.
+        runStore: engine.runStore,
         isKnownMigrated: async () => false,
       });
 

apps/webapp/test/engine/triggerTask.test.ts

@@ -1,11 +1,18 @@
 import { describe, expect, vi } from "vitest";
 
-// Mock the db prisma client
+// Mock the db prisma client. The run-ops handles are stubbed so the idempotency
+// dedup import resolves; with split off (below) they are never used — the concern's
+// constructor prisma is passed through to every store call.
 vi.mock("~/db.server", () => ({
   prisma: {},
   $replica: {},
+  runOpsNewPrisma: {},
+  runOpsLegacyPrisma: {},
 }));
 
+// Keep split off so resolveIdempotencyDedupClient returns the passed container client.
+vi.mock("~/v3/runOpsMigration/splitMode.server", () => ({ isSplitEnabled: async () => false }));
+
 vi.mock("~/services/platform.v3.server", async (importOriginal) => {
   const actual = (await importOriginal()) as Record<string, unknown>;
   return {

apps/webapp/test/performTaskRunAlertsStoreRouting.test.ts

@@ -338,6 +338,10 @@ describe("PerformTaskRunAlertsService passthrough (single-DB)", () => {
 
       const service = new PerformTaskRunAlertsService({
         prisma,
+        // The single-DB default store: a passthrough PostgresRunStore over the one
+        // container. Injected explicitly so the read resolves on the container the run
+        // was seeded into, not the ambient module singleton.
+        runStore: new PostgresRunStore({ prisma, readOnlyPrisma: prisma }),
         controlPlaneResolver: buildControlPlaneResolver(prisma),
       });
       await service.call(id).catch(() => {});