@@ -20,9 +20,7 @@ import {
 } from "~/db.server";
 import { env } from "~/env.server";
 import { singleton } from "~/utils/singleton";
-import { isSnapshotStoreConfigured } from "./snapshotStoreConfigured.server";
 import { decorateWithSnapshotStore } from "./snapshotStoreInstance.server";
-import { snapshotStoreModeResolver } from "./snapshotStoreMode.server";
 import {
   resilienceForClient,
   type TransactionResilienceConfig,
@@ -56,10 +54,6 @@ type BuildRunStoreDeps = {
   singleResilience?: TransactionResilienceConfig;
   newResilience?: TransactionResilienceConfig;
   legacyResilience?: TransactionResilienceConfig;
-  /** The redis-only PG-suppression predicate, or undefined for a plain passthrough. Passed in (never
-   * read from env here) so this builder stays pure; the caller wires it only when the store is
-   * configured, so an unconfigured deploy writes every snapshot row with no per-write resolution. */
-  snapshotWrites?: (organizationId?: string) => boolean;
 };
 
 /**
@@ -74,24 +68,19 @@ type BuildRunStoreDeps = {
  * Split ON: returns a RoutingRunStore that selects between a NEW store (where new runs
  * are born) and a LEGACY store (draining) by run-id residency (id shape). There is no cuid
  * migration, so a LEGACY-classified id is always LEGACY-resident.
+ *
+ * Postgres snapshot-row suppression is NOT wired here. It is a per-run decision the snapshot
+ * decorator threads onto each snapshot input (`writeSnapshotRow`), fixed at the run's birth, so the
+ * store never re-derives residency from the live org dial. An unwired/unconfigured deploy leaves the
+ * field unset and every snapshot row is written, byte-identical to before.
  */
-// A run's org is redis-only exactly when the same resolver the snapshot decorator uses says so, so
-// the Redis mirror and the Postgres suppression always agree on the effective mode for that run.
-const suppressPgAtRedisOnly = (organizationId?: string) =>
-  snapshotStoreModeResolver.resolve(organizationId) !== "redis-only";
-
-// Wired into the store only when the snapshot store is configured. Unconfigured, this stays undefined
-// and PostgresRunStore writes every snapshot row with no per-write mode resolution (the inert state).
-const snapshotWritesPredicate = isSnapshotStoreConfigured() ? suppressPgAtRedisOnly : undefined;
-
 export function buildRunStore(deps: BuildRunStoreDeps): RunStore {
   if (!deps.splitEnabled) {
     return new PostgresRunStore({
       prisma: deps.singleWriter,
       readOnlyPrisma: deps.singleReplica,
       maxWait: deps.singleResilience?.maxWait,
       transactionStartRetry: deps.singleResilience?.startRetry,
-      snapshotWrites: deps.snapshotWrites,
     });
   }
 
@@ -107,14 +96,12 @@ export function buildRunStore(deps: BuildRunStoreDeps): RunStore {
     schemaVariant: "dedicated",
     maxWait: deps.newResilience?.maxWait,
     transactionStartRetry: deps.newResilience?.startRetry,
-    snapshotWrites: deps.snapshotWrites,
   });
   const legacyStore = new PostgresRunStore({
     prisma: deps.legacyWriter,
     readOnlyPrisma: deps.legacyReplica,
     maxWait: deps.legacyResilience?.maxWait,
     transactionStartRetry: deps.legacyResilience?.startRetry,
-    snapshotWrites: deps.snapshotWrites,
   });
 
   // Gen-2 shards: one dedicated store per descriptor, handed to the N-way router. An aliased shard
@@ -128,7 +115,6 @@ export function buildRunStore(deps: BuildRunStoreDeps): RunStore {
       schemaVariant: "dedicated" as const,
       maxWait: shard.resilience?.maxWait,
       transactionStartRetry: shard.resilience?.startRetry,
-      snapshotWrites: deps.snapshotWrites,
     }),
     aliasOf: shard.aliasOf,
   }));
@@ -227,7 +213,6 @@ export const runStoreWithoutSnapshotDecorator: RunStore = singleton("RunStore.un
       singleWriter: prisma,
       singleReplica: $replica,
       singleResilience: resilienceForClient(prisma),
-      snapshotWrites: snapshotWritesPredicate,
     });
   }
   const { shardHandles, ...storeHandles } = handles;
@@ -246,7 +231,6 @@ export const runStoreWithoutSnapshotDecorator: RunStore = singleton("RunStore.un
     singleResilience: resilienceForClient(prisma),
     newResilience: resilienceForClient(handles.newWriter),
     legacyResilience: resilienceForClient(handles.legacyWriter),
-    snapshotWrites: snapshotWritesPredicate,
   });
 });
 
 
@@ -1,31 +1,9 @@
 import { LRUCache } from "lru-cache";
-import { prisma } from "~/db.server";
 import { env } from "~/env.server";
 import { singleton } from "~/utils/singleton";
 
-/**
- * How long an authoritative run→org read will wait before giving up. Shares the shape of the
- * org-mode source's warm timeout, but here the deadline REJECTS: this feeds the redis-only fallback
- * gate, which must fail closed rather than answer with a wrong org.
- */
-const AUTHORITATIVE_TIMEOUT_MS = 500;
-
 const DEFAULT_CACHE_MAX = 50_000;
 
-/**
- * What resolution needs from Prisma, narrowed so a test injects a hand-written fake rather than
- * mocking the client. A run's organisation is reached through its environment: TaskRun.organizationId
- * is nullable on historical rows, while RuntimeEnvironment.organizationId is not.
- */
-type RunOrgClient = {
-  taskRun: {
-    findFirst(args: {
-      where: { id: string };
-      select: { runtimeEnvironment: { select: { organizationId: true } } };
-    }): Promise<{ runtimeEnvironment: { organizationId: string } } | null>;
-  };
-};
-
 export type SnapshotRunOrgSource = {
   /**
    * A PURE cache get: the cached org id, or undefined on a miss. Never queries, never blocks, never
@@ -41,39 +19,14 @@ export type SnapshotRunOrgSource = {
    * changes), no TTL, no invalidation. Fire-and-forget: never queries, never throws.
    */
   prime(runId: string, organizationId: string): void;
-  /**
-   * Awaits a bounded primary read, caches, and returns the org id. Throws on timeout, client
-   * failure, or a run with no organisation, so a caller can fail closed. This is the redis-only
-   * fallback gate's last leg, reached only when the sync cache is cold AND some org is redis-only.
-   */
-  resolveAuthoritative(runId: string): Promise<string>;
 };
 
-export function createSnapshotRunOrgSource(clients?: {
-  primary: RunOrgClient;
-}): SnapshotRunOrgSource {
-  const primaryClient = (clients?.primary ?? prisma) as RunOrgClient;
+export function createSnapshotRunOrgSource(): SnapshotRunOrgSource {
   // No ttl: run→org is immutable, so a cached mapping never goes stale.
   const cache = new LRUCache<string, string>({
     max: env.RUN_ENGINE_SNAPSHOT_STORE_RUN_ORG_CACHE_MAX ?? DEFAULT_CACHE_MAX,
   });
 
-  async function read(runId: string): Promise<string> {
-    return primaryClient.taskRun
-      .findFirst({
-        where: { id: runId },
-        select: { runtimeEnvironment: { select: { organizationId: true } } },
-      })
-      .then((row) => {
-        const organizationId = row?.runtimeEnvironment?.organizationId;
-        if (!organizationId) {
-          throw new Error(`snapshotRunOrg: no organization for run ${runId}`);
-        }
-        cache.set(runId, organizationId);
-        return organizationId;
-      });
-  }
-
   return {
     resolve(runId) {
       return cache.get(runId);
@@ -83,29 +36,6 @@ export function createSnapshotRunOrgSource(clients?: {
       // active run hot in the LRU, which is exactly the run whose mapping the read path will want.
       cache.set(runId, organizationId);
     },
-    async resolveAuthoritative(runId) {
-      const cached = cache.get(runId);
-      if (cached !== undefined) {
-        return cached;
-      }
-
-      let timer: NodeJS.Timeout | undefined;
-      const deadline = new Promise<never>((_, reject) => {
-        timer = setTimeout(
-          () =>
-            reject(
-              new Error(`snapshotRunOrg: run→org read exceeded ${AUTHORITATIVE_TIMEOUT_MS}ms`)
-            ),
-          AUTHORITATIVE_TIMEOUT_MS
-        );
-      });
-
-      try {
-        return await Promise.race([read(runId), deadline]);
-      } finally {
-        if (timer) clearTimeout(timer);
-      }
-    },
   };
 }
 
 
@@ -90,23 +90,19 @@ export function isSnapshotStoreCohortMember(organizationId: string): boolean {
   return snapshotStoreIsCohortMember(loadedOrgDials(), organizationId);
 }
 
-/** What resolution needs from the org source. Read-only and synchronous; warm is a birth-only hook. */
+/** What resolution needs from the org source. Read-only and synchronous. */
 type ResolverOrgSource = {
   /** The org's dial, or NO_OVERRIDE when absent so `resolveMode` falls back to the global dial. */
   get(organizationId: string): CachedOrgMode | undefined;
-  /** No-op with the map source: the dial arrives via the poll, so there is nothing to warm off-path. */
+  /** No-op with the map source: the dial arrives via the poll, so there is nothing to refresh. */
   refresh(organizationId: string): void;
-  /** No-op with the map source: births read the map synchronously, so there is nothing to await. */
-  warm?(organizationId: string): Promise<void>;
 };
 
 /** Resolves a run to its organisation. Cache-only and synchronous, undefined on a miss. */
 type ResolverRunOrgSource = {
   resolve(runId: string): string | undefined;
   /** Records an immutable run→org mapping learned off a mirrored write or a Redis read hit. */
   prime?(runId: string, organizationId: string): void;
-  /** Bounded authoritative read, throws on failure/timeout, for the redis-only fallback gate. */
-  resolveAuthoritative?(runId: string): Promise<string>;
 };
 
 /** The census read accessors the resolver delegates to. Both synchronous and no-query. */
@@ -169,11 +165,6 @@ export function buildSnapshotStoreModeResolver(deps: {
     // probing rather than suppressing a resident run.
     orgDefinitelyNeverEnabled: (organizationId: string): boolean =>
       deps.orgDefinitelyNeverEnabled?.(organizationId) ?? false,
-    // Awaited at birth sites only. With the map source this resolves immediately: the dial is read
-    // synchronously from the polled map, so there is no per-org read to await.
-    warm: async (organizationId: string): Promise<void> => {
-      await deps.orgMode.warm?.(organizationId);
-    },
     resolve: (organizationId?: string): DialMode => resolveMode(organizationId),
     // The org-scoped read position. Resolve run→org synchronously; on a miss return undefined so
     // the decorator falls back to the global mode, which is safe during soak.
@@ -184,16 +175,6 @@ export function buildSnapshotStoreModeResolver(deps: {
       }
       return resolveMode(organizationId);
     },
-    // Authoritative counterpart, used only when the sync read is unresolved and some org is
-    // redis-only. Resolves run→org from the primary (bounded, throws on failure), then answers with
-    // the org's mode straight from the map. A throw propagates so the decorator fails closed.
-    readModeForAuthoritative: async (runId: string): Promise<DialMode | undefined> => {
-      if (!deps.runOrg?.resolveAuthoritative) {
-        return undefined;
-      }
-      const organizationId = await deps.runOrg.resolveAuthoritative(runId);
-      return resolveMode(organizationId);
-    },
     anyOrgReadEnabled: (): boolean => deps.census?.anyOrgReadEnabled() ?? false,
     anyOrgRedisOnly: (): boolean => deps.census?.anyOrgRedisOnly() ?? false,
     // The decorator hands back a run→org mapping it learned on a mirrored write or a Redis read hit.
@@ -240,12 +221,10 @@ export const snapshotStoreModeResolver: SnapshotStoreModeResolver = buildSnapsho
     // global dial. A cold registry yields an empty map, which reads as NO_OVERRIDE for every org.
     get: (organizationId) => orgDials()[organizationId] ?? NO_OVERRIDE,
     refresh: () => {},
-    warm: async () => {},
   },
   runOrg: {
     resolve: (runId) => snapshotRunOrgSource().resolve(runId),
     prime: (runId, organizationId) => snapshotRunOrgSource().prime(runId, organizationId),
-    resolveAuthoritative: (runId) => snapshotRunOrgSource().resolveAuthoritative(runId),
   },
   census: {
     anyOrgReadEnabled: () => snapshotStoreAnyOrgReadEnabled(loadedOrgDials()),
 
@@ -1,112 +1,37 @@
 import { describe, expect, it } from "vitest";
 import { createSnapshotRunOrgSource } from "~/v3/snapshotRunOrg.server";
 
-type Row = { runtimeEnvironment: { organizationId: string } } | null;
-
-/** A hand-written fake standing in for the Prisma client, so no mocking is needed. */
-function fakeClient(opts: {
-  mapping?: Record<string, string>;
-  reject?: boolean;
-  delayMs?: number;
-}) {
-  let calls = 0;
-  return {
-    get calls() {
-      return calls;
-    },
-    taskRun: {
-      async findFirst(args: { where: { id: string } }): Promise<Row> {
-        calls++;
-        if (opts.delayMs) {
-          await new Promise((resolve) => setTimeout(resolve, opts.delayMs));
-        }
-        if (opts.reject) {
-          throw new Error("db unreachable");
-        }
-        const organizationId = opts.mapping?.[args.where.id];
-        return organizationId ? { runtimeEnvironment: { organizationId } } : null;
-      },
-    },
-  };
-}
-
 const tick = () => new Promise((resolve) => setTimeout(resolve, 10));
 
 describe("snapshot run→org source", () => {
-  it("resolve is a pure cache get: a cold miss is undefined and never queries", async () => {
-    const primary = fakeClient({ mapping: { run_a: "org_a" } });
-    const source = createSnapshotRunOrgSource({ primary });
+  it("resolve is a pure cache get: a cold miss is undefined and never blocks", async () => {
+    const source = createSnapshotRunOrgSource();
 
     expect(source.resolve("run_a")).toBeUndefined();
 
     await tick();
 
-    // No off-path populate exists anymore, so a miss stays a miss and the DB is never touched.
+    // There is no off-path populate and no DB read, so a miss stays a miss for life.
     expect(source.resolve("run_a")).toBeUndefined();
-    expect(primary.calls).toBe(0);
   });
 
-  it("prime makes a later resolve a pure hit, with no query", async () => {
-    const primary = fakeClient({ mapping: { run_a: "org_a" } });
-    const source = createSnapshotRunOrgSource({ primary });
+  it("prime makes a later resolve a pure hit", async () => {
+    const source = createSnapshotRunOrgSource();
 
     source.prime("run_a", "org_a");
 
     expect(source.resolve("run_a")).toBe("org_a");
     await tick();
-    expect(primary.calls).toBe(0);
+    expect(source.resolve("run_a")).toBe("org_a");
   });
 
-  it("prime is idempotent and never queries, however many times it is called", async () => {
-    const primary = fakeClient({ mapping: { run_a: "org_a" } });
-    const source = createSnapshotRunOrgSource({ primary });
+  it("prime is idempotent, however many times it is called", () => {
+    const source = createSnapshotRunOrgSource();
 
     source.prime("run_a", "org_a");
     source.prime("run_a", "org_a");
     source.prime("run_a", "org_a");
 
     expect(source.resolve("run_a")).toBe("org_a");
-    expect(primary.calls).toBe(0);
-  });
-
-  it("resolveAuthoritative returns the org id on success and caches it", async () => {
-    const primary = fakeClient({ mapping: { run_a: "org_a" } });
-    const source = createSnapshotRunOrgSource({ primary });
-
-    await expect(source.resolveAuthoritative("run_a")).resolves.toBe("org_a");
-    expect(source.resolve("run_a")).toBe("org_a");
-  });
-
-  it("resolveAuthoritative serves a primed mapping without querying", async () => {
-    const primary = fakeClient({ mapping: { run_a: "org_a" } });
-    const source = createSnapshotRunOrgSource({ primary });
-
-    source.prime("run_a", "org_a");
-
-    await expect(source.resolveAuthoritative("run_a")).resolves.toBe("org_a");
-    expect(primary.calls).toBe(0);
-  });
-
-  it("resolveAuthoritative throws when the run has no organization", async () => {
-    const primary = fakeClient({ mapping: {} });
-    const source = createSnapshotRunOrgSource({ primary });
-
-    await expect(source.resolveAuthoritative("run_missing")).rejects.toThrow();
-  });
-
-  it("resolveAuthoritative throws when the client rejects", async () => {
-    const primary = fakeClient({ reject: true });
-    const source = createSnapshotRunOrgSource({ primary });
-
-    await expect(source.resolveAuthoritative("run_a")).rejects.toThrow();
-  });
-
-  it("resolveAuthoritative throws when the read exceeds the deadline", async () => {
-    // Just over the 500 ms deadline: enough to trip it, without leaving a long timer running past
-    // the rejection and holding the vitest worker open for the difference.
-    const primary = fakeClient({ mapping: { run_a: "org_a" }, delayMs: 600 });
-    const source = createSnapshotRunOrgSource({ primary });
-
-    await expect(source.resolveAuthoritative("run_a")).rejects.toThrow(/deadline|exceed/i);
   });
 });