refactor(run-ops): drop known-migrated from write-path + read repos; id-shape only

Migration is deferred, so child/batch residency is a pure id-shape check.
Remove the isKnownMigrated (and mint-only isSplitEnabled) deps from the mint
sites (triggerTask, triggerFailedTask, batchTriggerV3) and call the now-
synchronous resolveInheritedMintKind(parentFriendlyId) with no deps arg.

Read paths: drop the isKnownMigrated re-probe-avoidance from the ClickHouse
runs hydrate (probe all missing on legacy), the runsRepository readThrough
options type, resolveWaitpointThroughReadThrough deps, and the BulkActionV2
batch seam adapter — keeping the genuine cross-seam fallback that reads NEW
first for unclassifiable/legacy-candidate ids.

Delete the injected-marker test cases; the remaining residency tests assert
pure id-shape inheritance.

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

Author: d-cs

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

@@ -1,13 +1,11 @@
 import type { PrismaReplicaClient } from "~/db.server";
 import { $replica } from "~/db.server";
 import { readThroughRun } from "~/v3/runOpsMigration/readThrough.server";
-import { isKnownMigrated as defaultIsKnownMigrated } from "~/v3/runOpsMigration/knownMigratedFilter.server";
 
 type ResolveWaitpointDeps = {
   newClient?: PrismaReplicaClient;
   legacyReplica?: PrismaReplicaClient;
   splitEnabled?: boolean;
-  isKnownMigrated?: (id: string) => Promise<boolean>;
   isPastRetention?: (id: string) => boolean;
 };
 
@@ -26,7 +24,6 @@ export async function resolveWaitpointThroughReadThrough<T>(opts: {
       splitEnabled: opts.deps?.splitEnabled,
       newClient: opts.deps?.newClient ?? $replica,
       legacyReplica: opts.deps?.legacyReplica ?? $replica,
-      isKnownMigrated: opts.deps?.isKnownMigrated ?? defaultIsKnownMigrated,
       isPastRetention: opts.deps?.isPastRetention,
     },
   });

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

@@ -6,8 +6,6 @@ import type { PrismaClientOrTransaction } from "@trigger.dev/database";
 import type { AuthenticatedEnvironment } from "~/services/apiAuth.server";
 import { logger } from "~/services/logger.server";
 import { resolveRunIdMintKind } from "~/v3/engineVersion.server";
-import { isKnownMigrated as defaultIsKnownMigrated } from "~/v3/runOpsMigration/knownMigratedFilter.server";
-import { isSplitEnabled as defaultIsSplitEnabled } from "~/v3/runOpsMigration/splitMode.server";
 import { resolveInheritedMintKind } from "~/v3/runOpsMigration/resolveInheritedMintKind.server";
 import { getEventRepository } from "~/v3/eventRepository/index.server";
 import { PerformTaskRunAlertsService } from "~/v3/services/alerts/performTaskRunAlerts.server";
@@ -60,12 +58,6 @@ export class TriggerFailedTaskService {
   private readonly prisma: PrismaClientOrTransaction;
   private readonly replicaPrisma: PrismaClientOrTransaction;
   private readonly engine: RunEngine;
-  // Reports whether a run that is legacy by id-shape has already been moved to
-  // the new store. Injected for tests; defaults to the live resolver.
-  private readonly isKnownMigrated: (runId: string) => Promise<boolean>;
-  // 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.
@@ -75,15 +67,11 @@ export class TriggerFailedTaskService {
     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;
   }
 
@@ -98,10 +86,7 @@ export class TriggerFailedTaskService {
     parentRunFriendlyId?: string;
   }): Promise<string> {
     const mintKind = args.parentRunFriendlyId
-      ? await resolveInheritedMintKind(args.parentRunFriendlyId, {
-          isSplitEnabled: this.isSplitEnabled,
-          isKnownMigrated: this.isKnownMigrated,
-        })
+      ? resolveInheritedMintKind(args.parentRunFriendlyId)
       : await resolveRunIdMintKind({
           organizationId: args.organizationId,
           id: args.environmentId,

apps/webapp/app/runEngine/services/triggerTask.server.test.ts

@@ -207,9 +207,6 @@ describe("RunEngineTriggerTaskService parent + locked-worker reads", () => {
           traceEventConcern: new MockTraceEventConcern(),
           tracer: trace.getTracer("test", "0.0.0"),
           metadataMaximumSize: 1024 * 1024 * 1,
-          // Keep the migrated-parent resolver from reaching the empty ~/db.server
-          // mock; mint-kind inheritance is not under test here.
-          isKnownMigrated: async () => false,
         });
 
         // Trigger a ROOT run first to create a real parent TaskRun.
@@ -312,7 +309,6 @@ describe("RunEngineTriggerTaskService parent + locked-worker reads", () => {
           traceEventConcern: new MockTraceEventConcern(),
           tracer: trace.getTracer("test", "0.0.0"),
           metadataMaximumSize: 1024 * 1024 * 1,
-          isKnownMigrated: async () => false,
         });
 
         // A real parent run in envA.
@@ -415,7 +411,6 @@ describe("RunEngineTriggerTaskService parent + locked-worker reads", () => {
           traceEventConcern: new MockTraceEventConcern(),
           tracer: trace.getTracer("test", "0.0.0"),
           metadataMaximumSize: 1024 * 1024 * 1,
-          isKnownMigrated: async () => false,
         });
 
         const result = await triggerTaskService.call({
@@ -533,7 +528,6 @@ describe("RunEngineTriggerTaskService parent + locked-worker reads", () => {
           traceEventConcern: new MockTraceEventConcern(),
           tracer: trace.getTracer("test", "0.0.0"),
           metadataMaximumSize: 1024 * 1024 * 1,
-          isKnownMigrated: async () => false,
         });
 
         // ROOT parent first (uses the unproxied prisma via a separate service so
@@ -552,7 +546,6 @@ describe("RunEngineTriggerTaskService parent + locked-worker reads", () => {
           traceEventConcern: new MockTraceEventConcern(),
           tracer: trace.getTracer("test", "0.0.0"),
           metadataMaximumSize: 1024 * 1024 * 1,
-          isKnownMigrated: async () => false,
         });
         const parentResult = await parentService.call({
           taskId: taskIdentifier,
@@ -655,7 +648,6 @@ describe("RunEngineTriggerTaskService parent + locked-worker reads", () => {
           traceEventConcern: new MockTraceEventConcern(),
           tracer: trace.getTracer("test", "0.0.0"),
           metadataMaximumSize: 1024 * 1024 * 1,
-          isKnownMigrated: async () => false,
         });
 
         const bogusVersion = "v-does-not-exist-0000";
@@ -757,7 +749,6 @@ describe("RunEngineTriggerTaskService parent + locked-worker reads", () => {
           traceEventConcern: new MockTraceEventConcern(),
           tracer: trace.getTracer("test", "0.0.0"),
           metadataMaximumSize: 1024 * 1024 * 1,
-          isKnownMigrated: async () => false,
         });
 
         // Trigger in envB locking to the shared version string.
@@ -799,12 +790,15 @@ describe("RunEngineTriggerTaskService parent + locked-worker reads", () => {
         prisma,
         payloadProcessor: new MockPayloadProcessor(),
         queueConcern: new DefaultQueueManager(prisma, engine),
-        idempotencyKeyConcern: new IdempotencyKeyConcern(prisma, engine, new MockTraceEventConcern()),
+        idempotencyKeyConcern: new IdempotencyKeyConcern(
+          prisma,
+          engine,
+          new MockTraceEventConcern()
+        ),
         validator,
         traceEventConcern: new MockTraceEventConcern(),
         tracer: trace.getTracer("test", "0.0.0"),
         metadataMaximumSize: 1024 * 1024 * 1,
-        isKnownMigrated: async () => false,
       });
 
       // Trigger with NO parentRunId.

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

@@ -27,8 +27,6 @@ import { parseDelay } from "~/utils/delays";
 import { handleMetadataPacket } from "~/utils/packets";
 import { startSpan } from "~/v3/tracing.server";
 import { resolveRunIdMintKind } from "~/v3/engineVersion.server";
-import { isKnownMigrated as defaultIsKnownMigrated } from "~/v3/runOpsMigration/knownMigratedFilter.server";
-import { isSplitEnabled as defaultIsSplitEnabled } from "~/v3/runOpsMigration/splitMode.server";
 import { resolveInheritedMintKind } from "~/v3/runOpsMigration/resolveInheritedMintKind.server";
 import type {
   TriggerTaskServiceOptions,
@@ -96,14 +94,6 @@ export class RunEngineTriggerTaskService {
   private readonly evaluateGate: MollifierEvaluateGate;
   private readonly getMollifierBuffer: MollifierGetBuffer;
   private readonly isMollifierGloballyEnabled: () => boolean;
-  // Resolves whether a run that classifies as legacy-by-id-shape has already
-  // been moved to the new store. Injected so tests can drive the migrated-parent
-  // case without the split-store infrastructure; defaults to the live resolver.
-  private readonly isKnownMigrated: (runId: string) => Promise<boolean>;
-  // Gates whether the marker-aware inheritance branch runs. With split OFF the
-  // child residency is a pure id-shape check — zero I/O on the hot path,
-  // byte-identical to today. Injected so tests can drive split on/off.
-  private readonly isSplitEnabled: () => Promise<boolean>;
 
   constructor(opts: {
     prisma: PrismaClientOrTransaction;
@@ -119,8 +109,6 @@ export class RunEngineTriggerTaskService {
     evaluateGate?: MollifierEvaluateGate;
     getMollifierBuffer?: MollifierGetBuffer;
     isMollifierGloballyEnabled?: () => boolean;
-    isKnownMigrated?: (runId: string) => Promise<boolean>;
-    isSplitEnabled?: () => Promise<boolean>;
   }) {
     this.prisma = opts.prisma;
     this.engine = opts.engine;
@@ -136,28 +124,22 @@ export class RunEngineTriggerTaskService {
     this.getMollifierBuffer = opts.getMollifierBuffer ?? defaultGetMollifierBuffer;
     this.isMollifierGloballyEnabled =
       opts.isMollifierGloballyEnabled ?? (() => env.TRIGGER_MOLLIFIER_ENABLED === "1");
-    this.isKnownMigrated = opts.isKnownMigrated ?? defaultIsKnownMigrated;
-    this.isSplitEnabled = opts.isSplitEnabled ?? defaultIsSplitEnabled;
   }
 
   // Mint a new run's friendlyId. The id-kind decides which store the run is born
   // in (cuid → legacy store, ksuid → new store), so the whole subgraph of a run
   // must agree. Two cases:
   //
   //  - ROOT run (no parent): mint by the environment's cutover setting.
-  //  - CHILD run (has a parent): inherit the parent's CURRENT residency, so a
-  //    parent and child never split across stores. A parent that is legacy by
-  //    id-shape but has already been moved to the new store (reported by the
-  //    migrated check) yields a new-store (ksuid) child.
+  //  - CHILD run (has a parent): inherit the parent's residency by id-shape, so a
+  //    parent and child never split across stores (ksuid parent → ksuid child,
+  //    cuid parent → cuid child).
   private async mintRunFriendlyId(
     environment: AuthenticatedEnvironment,
     parentRunFriendlyId?: string
   ): Promise<string> {
     const mintKind = parentRunFriendlyId
-      ? await resolveInheritedMintKind(parentRunFriendlyId, {
-          isSplitEnabled: this.isSplitEnabled,
-          isKnownMigrated: this.isKnownMigrated,
-        })
+      ? resolveInheritedMintKind(parentRunFriendlyId)
       : await resolveRunIdMintKind({
           organizationId: environment.organizationId,
           id: environment.id,

apps/webapp/app/services/runsRepository/clickhouseRunsRepository.server.ts

@@ -14,7 +14,6 @@ import parseDuration from "parse-duration";
 import { decodeRunsCursor, encodeRunsCursor } from "./runsCursor.server";
 import { runStore } from "~/v3/runStore.server";
 import { type PrismaClientOrTransaction } from "~/db.server";
-import { isKnownMigrated as defaultIsKnownMigrated } from "~/v3/runOpsMigration/knownMigratedFilter.server";
 
 type RunCursorRow = { runId: string; createdAt: number };
 
@@ -181,18 +180,13 @@ export class ClickHouseRunsRepository implements IRunsRepository {
     } else {
       const newClient = this.options.readThrough?.newClient ?? this.options.prisma;
       const legacyReplica = this.options.readThrough?.legacyReplica ?? this.options.prisma;
-      const isKnownMigrated = this.options.readThrough?.isKnownMigrated ?? defaultIsKnownMigrated;
 
       const newRows = await hydrate(newClient, runIds);
       const foundIds = new Set(newRows.map((r) => r.id));
       const missing = runIds.filter((id) => !foundIds.has(id));
 
-      const toProbeLegacy: string[] = [];
-      for (const id of missing) {
-        if (!(await isKnownMigrated(id))) {
-          toProbeLegacy.push(id);
-        }
-      }
+      // Any id not hydrated from the new store is probed on the legacy replica.
+      const toProbeLegacy = missing;
 
       const legacyRows = toProbeLegacy.length ? await hydrate(legacyReplica, toProbeLegacy) : [];
       rows = [...newRows, ...legacyRows];

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

@@ -32,7 +32,6 @@ export type RunsRepositoryOptions = {
     legacyReplica?: PrismaClientOrTransaction;
     // Resolved boot constant; when false the split branch is never entered.
     splitEnabled?: boolean;
-    isKnownMigrated?: (runId: string) => Promise<boolean>;
   };
 };
 

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

@@ -26,8 +26,6 @@ import { logger } from "~/services/logger.server";
 import { getEntitlement } from "~/services/platform.v3.server";
 import { controlPlaneResolver } from "~/v3/runOpsMigration/controlPlaneResolver.server";
 import { resolveRunIdMintKind, type RunIdMintKind } from "~/v3/engineVersion.server";
-import { isKnownMigrated as defaultIsKnownMigrated } from "~/v3/runOpsMigration/knownMigratedFilter.server";
-import { isSplitEnabled as defaultIsSplitEnabled } from "~/v3/runOpsMigration/splitMode.server";
 import { resolveInheritedMintKind } from "~/v3/runOpsMigration/resolveInheritedMintKind.server";
 import { mintBatchFriendlyId } from "~/v3/runOpsMigration/mintBatchFriendlyId.server";
 import { batchTriggerWorker } from "../batchTriggerWorker.server";
@@ -113,20 +111,13 @@ export class BatchTriggerV3Service extends BaseService {
     asyncBatchProcessSizeThreshold: number = ASYNC_BATCH_PROCESS_SIZE_THRESHOLD,
     protected readonly _prisma: PrismaClientOrTransaction = prisma,
     protected readonly runStore: RunStore = defaultRunStore,
-    // Injected so tests drive the migrated-parent branch without the split-store
-    // infrastructure; defaults to the live resolver (same pattern as
-    // RunEngineTriggerTaskService).
-    private readonly isKnownMigrated: (runId: string) => Promise<boolean> = defaultIsKnownMigrated,
     // Injected so tests force the env-default branch deterministically; defaults
     // to the live per-env mint resolver.
     private readonly resolveMintKind: (environment: {
       organizationId: string;
       id: string;
       orgFeatureFlags?: unknown;
-    }) => Promise<RunIdMintKind> = resolveRunIdMintKind,
-    // 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> = defaultIsSplitEnabled
+    }) => Promise<RunIdMintKind> = resolveRunIdMintKind
   ) {
     super(_prisma);
 
@@ -355,19 +346,15 @@ export class BatchTriggerV3Service extends BaseService {
 
   // Mint a child run's friendlyId so it lands in the SAME physical store as its
   // residency anchor. The caller passes the batch's friendlyId, so a ksuid
-  // anchor (or a cuid-shaped one already migrated to the new store) yields a ksuid
-  // (NEW) child and a cuid anchor yields a cuid (LEGACY) child. With no anchor it
-  // falls back to the env's cutover setting. Mirrors
-  // RunEngineTriggerTaskService.mintRunFriendlyId.
+  // (NEW) anchor yields a ksuid (NEW) child and a cuid anchor yields a cuid
+  // (LEGACY) child. With no anchor it falls back to the env's cutover setting.
+  // Mirrors RunEngineTriggerTaskService.mintRunFriendlyId.
   private async mintChildFriendlyId(
     environment: AuthenticatedEnvironment,
     anchorFriendlyId?: string
   ): Promise<string> {
     const mintKind = anchorFriendlyId
-      ? await resolveInheritedMintKind(anchorFriendlyId, {
-          isSplitEnabled: this.isSplitEnabled,
-          isKnownMigrated: this.isKnownMigrated,
-        })
+      ? resolveInheritedMintKind(anchorFriendlyId)
       : await this.resolveMintKind({
           organizationId: environment.organizationId,
           id: environment.id,

apps/webapp/app/v3/services/bulk/BulkActionV2.batchReadThrough.server.test.ts

@@ -1,9 +1,8 @@
 // Real PG14 (legacy replica) + PG17 (new) proof for the bulk batch read-through adapter.
 // We NEVER mock the DB: each closure runs a real `$queryRaw` against the passed container
 // (crossing the actual PG14↔PG17 boundary) then filters an in-memory seeded set by id —
-// mirroring readThrough.server.test.ts's `realRead`. The only injected fakes are the pure
-// boundaries the plan allows (`isKnownMigrated`) plus throwing spies asserting a store was
-// NEVER touched.
+// mirroring readThrough.server.test.ts's `realRead`. The only injected fakes are throwing
+// spies asserting a store was NEVER touched.
 import { heteroPostgresTest } from "@internal/testcontainers";
 import { describe, expect, vi } from "vitest";
 import type { PrismaReplicaClient } from "~/db.server";
@@ -51,7 +50,6 @@ describe("hydrateRunsAcrossSeam (PG14 legacy replica + PG17 new)", () => {
           splitEnabled: true,
           newClient: prisma17 as unknown as PrismaReplicaClient,
           legacyReplica: prisma14 as unknown as PrismaReplicaClient,
-          isKnownMigrated: async () => false,
         },
       });
 
@@ -64,40 +62,12 @@ describe("hydrateRunsAcrossSeam (PG14 legacy replica + PG17 new)", () => {
   );
 
   heteroPostgresTest(
-    "(b) known-migrated short-circuit: legacy-classified id missed by new is not probed and is omitted",
-    async ({ prisma14, prisma17 }) => {
-      const onNew = new Set<string>(); // new misses it
-      const throwingLegacy = vi.fn(async (): Promise<Row[]> => {
-        throw new Error("readLegacyReplica must never run for a known-migrated id");
-      });
-
-      const rows = await hydrateRunsAcrossSeam<Row>({
-        runIds: [LEGACY_RUN_ID],
-        readNew: (client, ids) => realReadFiltered(client, ids, onNew),
-        readLegacyReplica: throwingLegacy,
-        deps: {
-          splitEnabled: true,
-          newClient: prisma17 as unknown as PrismaReplicaClient,
-          legacyReplica: prisma14 as unknown as PrismaReplicaClient,
-          isKnownMigrated: async () => true,
-        },
-      });
-
-      expect(rows).toEqual([]);
-      expect(throwingLegacy).not.toHaveBeenCalled();
-    }
-  );
-
-  heteroPostgresTest(
-    "(c) passthrough: splitEnabled false reads only the single client; legacy + filter never touched",
+    "(c) passthrough: splitEnabled false reads only the single client; legacy never touched",
     async ({ prisma14, prisma17 }) => {
       const onNew = new Set([NEW_RUN_ID, LEGACY_RUN_ID]);
       const throwingLegacy = vi.fn(async (): Promise<Row[]> => {
         throw new Error("readLegacyReplica must never run in single-DB mode");
       });
-      const throwingFilter = vi.fn(async (): Promise<boolean> => {
-        throw new Error("isKnownMigrated must never run in single-DB mode");
-      });
       const readNew = vi.fn((client: PrismaReplicaClient, ids: string[]) =>
         realReadFiltered(client, ids, onNew)
       );
@@ -111,15 +81,13 @@ describe("hydrateRunsAcrossSeam (PG14 legacy replica + PG17 new)", () => {
           // single collapsed store (use prisma17 here as the "new"/primary analog)
           newClient: prisma17 as unknown as PrismaReplicaClient,
           legacyReplica: prisma14 as unknown as PrismaReplicaClient,
-          isKnownMigrated: throwingFilter,
         },
       });
 
       const ids = rows.map((r) => r.id).sort();
       expect(ids).toEqual([LEGACY_RUN_ID, NEW_RUN_ID].sort());
       expect(readNew).toHaveBeenCalledTimes(1);
       expect(throwingLegacy).not.toHaveBeenCalled();
-      expect(throwingFilter).not.toHaveBeenCalled();
     }
   );
 });