@@ -423,6 +423,9 @@ export class RunEngine {
       resources,
       executionSnapshotSystem: this.executionSnapshotSystem,
       enqueueSystem: this.enqueueSystem,
+      ...(options.completedWaitpointRecordsEnabled && {
+        completedWaitpointRecordsEnabled: options.completedWaitpointRecordsEnabled,
+      }),
     });
 
     this.ttlSystem = new TtlSystem({
 
@@ -24,6 +24,19 @@ export type WaitpointSystemOptions = {
   resources: SystemResources;
   executionSnapshotSystem: ExecutionSnapshotSystem;
   enqueueSystem: EnqueueSystem;
+  /**
+   * Whether this run's snapshots can hold a completed-waitpoint record set. Must be O(1).
+   *
+   * Sits in FRONT of the id-format scan so a run that cannot hold records pays one predicate
+   * call, not one `parseWaitpointId` per blocking waitpoint. It has to be injected rather than
+   * derived here: the answer is per-organisation, since it follows the snapshot store's own
+   * rollout, and the store keeps that state private to itself.
+   *
+   * Defaults to never. A record set is only reachable through the snapshot store, so until the
+   * ticket that wires that store supplies this predicate there is no run for which one could
+   * exist, and no resume does any of this work.
+   */
+  completedWaitpointRecordsEnabled?: (runId: string) => boolean;
 };
 
 type WaitpointContinuationWaitpoint = Pick<Waitpoint, "id" | "type" | "completedAfter" | "status">;
@@ -47,11 +60,13 @@ export class WaitpointSystem {
   private readonly executionSnapshotSystem: ExecutionSnapshotSystem;
   private readonly enqueueSystem: EnqueueSystem;
   private readonly coordinator: WaitpointCoordinator;
+  private readonly recordsEnabled: (runId: string) => boolean;
 
   constructor(private readonly options: WaitpointSystemOptions) {
     this.$ = options.resources;
     this.executionSnapshotSystem = options.executionSnapshotSystem;
     this.enqueueSystem = options.enqueueSystem;
+    this.recordsEnabled = options.completedWaitpointRecordsEnabled ?? (() => false);
     this.coordinator = new LegacyPostgresWaitpointCoordinator({
       runStore: this.$.runStore,
       prisma: this.$.prisma,
@@ -759,7 +774,8 @@ export class WaitpointSystem {
    * The record set for one resume, or undefined when no blocking waitpoint carries a store-format
    * id.
    *
-   * Gated on id FORMAT, not residency. The two are not the same during a migration: a
+   * Gated on the record set being reachable at all, and only then on id FORMAT rather than
+   * residency. Format and residency are not the same during a migration: a
    * store-format id can still be served by the Postgres arm, exactly as run-ops ids were for
    * runs. Whichever arm owns it answers, so the gate only decides whether to ask at all.
    *
@@ -778,10 +794,18 @@ export class WaitpointSystem {
     runId: string,
     blockingWaitpoints: RunBlockEdge[]
   ): Promise<CompletedWaitpointRecord[] | undefined> {
-    // `.some` before the dedup, so the gate allocates nothing in the case that is universal
-    // today and stays common through a partial rollout: no blocking waitpoint is store-format.
-    // Building the mapped array, the filtered array and the Set first meant three allocations
-    // per resume -- for a 1000-wide batch fan-in too -- to discover there was nothing to ask for.
+    // O(1) first, and unconditionally first: a run whose snapshots cannot hold a record set has
+    // nothing to build, and deciding that by walking its blocking waitpoints made every resume
+    // for every organisation pay a scan proportional to its fan-in to reach the same answer.
+    // Defaults to never, so today this returns here for everyone.
+    if (!this.recordsEnabled(runId)) {
+      return undefined;
+    }
+
+    // Only then the id-format scan, which is what keeps a MIXED cycle working once records are
+    // enabled: an organisation mid-rollout holds waitpoints minted either side of the flip, and
+    // the format is the only thing that says which half each id belongs to. `.some` before the
+    // dedup so an enabled run holding no store-format id still allocates nothing.
     if (!blockingWaitpoints.some((b) => parseWaitpointId(b.waitpoint.id).format === "b32hexW")) {
       return undefined;
     }
 
@@ -0,0 +1,189 @@
+// The O(1) gate in front of the completed-waitpoint record build.
+//
+// Deciding whether to build a record set by scanning a run's blocking waitpoints made every
+// resume, for every organisation, pay work proportional to its fan-in to reach the same answer:
+// no. The predicate moves that decision in front of the scan, and defaults to never.
+import { containerTest } from "@internal/testcontainers";
+import { trace } from "@internal/tracing";
+import { expect } from "vitest";
+import { RunEngine } from "../index.js";
+import { setTimeout } from "node:timers/promises";
+import { setupAuthenticatedEnvironment, setupBackgroundWorker } from "./setup.js";
+
+// The trigger has to reach the queue, and the completion resumes the run out of band, so both
+// need settling before the assertions read state back.
+const SETTLE_MS = 500;
+
+async function waitForResume(
+  engine: RunEngine,
+  runId: string
+): Promise<{ completedWaitpointIds: string[] }> {
+  for (let attempt = 0; attempt < 20; attempt++) {
+    const data = await engine.getRunExecutionData({ runId });
+    const ids = data?.completedWaitpoints?.map((w) => w.id) ?? [];
+    if (ids.length > 0) {
+      return { completedWaitpointIds: ids };
+    }
+    await setTimeout(100);
+  }
+  return { completedWaitpointIds: [] };
+}
+
+vi.setConfig({ testTimeout: 60_000 });
+
+function engineWith(
+  prisma: never,
+  redisOptions: never,
+  completedWaitpointRecordsEnabled?: (runId: string) => boolean
+) {
+  return new RunEngine({
+    prisma,
+    worker: { redis: redisOptions, workers: 1, tasksPerWorker: 10, pollIntervalMs: 100 },
+    queue: { redis: redisOptions },
+    runLock: { redis: redisOptions },
+    machines: {
+      defaultMachine: "small-1x",
+      machines: {
+        "small-1x": { name: "small-1x" as const, cpu: 0.5, memory: 0.5, centsPerMs: 0.0001 },
+      },
+      baseCostInCents: 0.0001,
+    },
+    tracer: trace.getTracer("test", "0.0.0"),
+    ...(completedWaitpointRecordsEnabled && { completedWaitpointRecordsEnabled }),
+  });
+}
+
+describe("the completed-waitpoint records gate", () => {
+  containerTest(
+    "is consulted once per resume, and the resume is unaffected",
+    async ({ prisma, redisOptions }) => {
+      const consulted: string[] = [];
+      const engine = engineWith(prisma as never, redisOptions as never, (runId) => {
+        consulted.push(runId);
+        return false;
+      });
+
+      try {
+        const env = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+        const taskIdentifier = "test-task";
+        await setupBackgroundWorker(engine, env, taskIdentifier);
+
+        const run = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_gate1",
+            environment: env,
+            taskIdentifier,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12345",
+            spanId: "s12345",
+            workerQueue: "main",
+            queue: `task/${taskIdentifier}`,
+            isTest: false,
+            tags: [],
+          },
+          prisma
+        );
+
+        await setTimeout(SETTLE_MS);
+        const dequeued = await engine.dequeueFromWorkerQueue({
+          consumerId: "test_12345",
+          workerQueue: "main",
+        });
+        const attempt = await engine.startRunAttempt({
+          runId: dequeued[0]!.run.id,
+          snapshotId: dequeued[0]!.snapshot.id,
+        });
+
+        // Block on a manual waitpoint, then release it: the release is what resumes the run and
+        // reaches the gate.
+        const waitpoint = await engine.createManualWaitpoint({
+          environmentId: env.id,
+          projectId: env.projectId,
+        });
+        await engine.blockRunWithWaitpoint({
+          runId: run.id,
+          waitpoints: [waitpoint.waitpoint.id],
+          projectId: env.project.id,
+          organizationId: env.organization.id,
+        });
+
+        await engine.completeWaitpoint({ id: waitpoint.waitpoint.id });
+
+        const { completedWaitpointIds } = await waitForResume(engine, run.id);
+
+        // The run resumed, because a disabled gate only skips the record build...
+        expect(completedWaitpointIds).toContain(waitpoint.waitpoint.id);
+        // ...and the gate was consulted for it, which is what puts it in the resume path.
+        expect(consulted).toContain(run.id);
+        expect(attempt.run.id).toBe(run.id);
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest("defaults to never, so no resume consults it", async ({ prisma, redisOptions }) => {
+    // No predicate supplied, which is every deployment until the store that consumes a record set
+    // is wired. The default has to be a constant false rather than a scan, or the cost this gate
+    // exists to remove comes straight back for everyone.
+    const engine = engineWith(prisma as never, redisOptions as never);
+
+    try {
+      const env = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+      const taskIdentifier = "test-task";
+      await setupBackgroundWorker(engine, env, taskIdentifier);
+
+      const run = await engine.trigger(
+        {
+          number: 1,
+          friendlyId: "run_gate2",
+          environment: env,
+          taskIdentifier,
+          payload: "{}",
+          payloadType: "application/json",
+          context: {},
+          traceContext: {},
+          traceId: "t22345",
+          spanId: "s22345",
+          workerQueue: "main",
+          queue: `task/${taskIdentifier}`,
+          isTest: false,
+          tags: [],
+        },
+        prisma
+      );
+
+      await setTimeout(SETTLE_MS);
+      const dequeued = await engine.dequeueFromWorkerQueue({
+        consumerId: "test_22345",
+        workerQueue: "main",
+      });
+      await engine.startRunAttempt({
+        runId: dequeued[0]!.run.id,
+        snapshotId: dequeued[0]!.snapshot.id,
+      });
+
+      const waitpoint = await engine.createManualWaitpoint({
+        environmentId: env.id,
+        projectId: env.projectId,
+      });
+      await engine.blockRunWithWaitpoint({
+        runId: run.id,
+        waitpoints: [waitpoint.waitpoint.id],
+        projectId: env.project.id,
+        organizationId: env.organization.id,
+      });
+
+      await engine.completeWaitpoint({ id: waitpoint.waitpoint.id });
+
+      const { completedWaitpointIds } = await waitForResume(engine, run.id);
+      expect(completedWaitpointIds).toContain(waitpoint.waitpoint.id);
+    } finally {
+      await engine.quit();
+    }
+  });
+});
@@ -77,6 +77,14 @@ export type RunEngineOptions = {
   billing?: {
     getCurrentPlan: (orgId: string) => Promise<BillingPlan>;
   };
+  /**
+   * Whether a run's snapshots can hold a completed-waitpoint record set. Must be O(1): it is
+   * consulted on every resume, ahead of any work proportional to the run's fan-in.
+   *
+   * Per-run rather than global because the answer follows the snapshot store's own
+   * per-organisation rollout. Omitted means never, so no resume builds a record set.
+   */
+  completedWaitpointRecordsEnabled?: (runId: string) => boolean;
   queue: {
     redis: RedisOptions;
     shardCount?: number;