@@ -13,7 +13,11 @@ const here = dirname(fileURLToPath(import.meta.url));
 // Returns the module specifiers a file imports FOR VALUE (i.e. that survive to runtime). `import type`
 // declarations and named blocks whose specifiers are all inline `type` are erased and excluded.
 function valueImports(sourcePath: string): string[] {
-  const src = readFileSync(sourcePath, "utf8").replace(/\/\*[\s\S]*?\*\//g, "");
+  // Strip block AND line comments so a comment mentioning `import(` or `import ... from` cannot
+  // produce a false positive.
+  const src = readFileSync(sourcePath, "utf8")
+    .replace(/\/\*[\s\S]*?\*\//g, "")
+    .replace(/\/\/.*$/gm, "");
   const out: string[] = [];
 
   if (/(^|[^.\w])import\s*\(/.test(src)) out.push("<dynamic import()>");
 
@@ -2,10 +2,12 @@ import { expect, it, describe } from "vitest";
 import {
   diffLatest,
   diffSince,
+  normalizeFromRedis,
   SnapshotComparator,
   type DivergenceClass,
   type NormalizedSnapshot,
 } from "./snapshotComparator.js";
+import type { SnapshotRead } from "./redisSnapshotStore.js";
 
 function norm(over: Partial<NormalizedSnapshot> = {}): NormalizedSnapshot {
   const base: NormalizedSnapshot = {
@@ -98,6 +100,37 @@ describe("diffLatest", () => {
     const d = diffLatest(norm(), { ...norm(), somethingNew: 1 } as NormalizedSnapshot);
     expect(d).toEqual([expect.objectContaining({ field: "somethingNew", class: "unknownField" })]);
   });
+
+  it("normalizeFromRedis carries an unrecognised entry field, so unknownField fires on real input", () => {
+    const read: SnapshotRead = {
+      id: "s1",
+      seq: 1,
+      isValid: true,
+      raw: "{}",
+      entry: {
+        engine: "V2",
+        executionStatus: "RUN_CREATED",
+        description: "d",
+        runId: "r1",
+        runStatus: "PENDING",
+        createdAt: "2026-08-24T00:00:00.000Z",
+        environmentId: "env",
+        environmentType: "DEVELOPMENT",
+        projectId: "p",
+        organizationId: "o",
+        mysteryField: "surprise",
+      },
+    };
+    const redis = normalizeFromRedis(read);
+    expect(redis.mysteryField).toBe("surprise"); // not dropped by normalization
+    const d = diffLatest(
+      norm({ id: "s1", createdAt: redis.createdAt, updatedAt: redis.updatedAt }),
+      redis
+    );
+    expect(d).toEqual([
+      expect.objectContaining({ field: "mysteryField", class: "unknownField", redis: "surprise" }),
+    ]);
+  });
 });
 
 describe("diffSince", () => {
 
@@ -25,6 +25,10 @@ export type SnapshotDivergence = {
   redis?: unknown;
 };
 
+// The read operations the comparator samples. Bounded so the `op` metric attribute cannot become a
+// high-cardinality label (a caller cannot pass a run id or other unbounded value).
+export type SnapshotReadOp = "getLatest" | "getById" | "getSince" | "getSnapshotWaitpointIds";
+
 export type NormalizedSnapshot = {
   [k: string]: unknown;
   id: string;
@@ -67,6 +71,21 @@ export const EXCLUDED_FIELDS = ["lastHeartbeatAt", "checkpoint", "completedWaitp
 
 const SCALAR_FIELDS = COMPARED_FIELDS.filter((f) => f !== "metadata");
 
+const KNOWN_KEYS = new Set<string>([
+  ...COMPARED_FIELDS,
+  ...EXCLUDED_FIELDS,
+  "completedWaitpointOrder",
+  "waitpointIdSet",
+]);
+
+// Carry a source key normalization does not recognise onto the normalized object, so the
+// unknownField check sees it instead of it being silently dropped (a false clean comparison).
+function carryUnknownKeys(target: NormalizedSnapshot, source: Record<string, unknown>): void {
+  for (const k of Object.keys(source)) {
+    if (!KNOWN_KEYS.has(k) && !(k in target)) target[k] = source[k];
+  }
+}
+
 function canonicalJson(v: unknown): string {
   if (v === null || typeof v !== "object") return JSON.stringify(v) ?? "null";
   if (Array.isArray(v)) return `[${v.map(canonicalJson).join(",")}]`;
@@ -79,7 +98,7 @@ export function normalizeFromPg(
   row: Prisma.TaskRunExecutionSnapshotGetPayload<{ include: { completedWaitpoints: true } }>
 ): NormalizedSnapshot {
   const wps = (row.completedWaitpoints ?? []) as Array<{ id: string }>;
-  return {
+  const n: NormalizedSnapshot = {
     id: row.id,
     engine: row.engine,
     executionStatus: row.executionStatus,
@@ -104,14 +123,16 @@ export function normalizeFromPg(
     completedWaitpointOrder: [...(row.completedWaitpointOrder ?? [])],
     waitpointIdSet: [...wps.map((w) => w.id)].sort(),
   };
+  carryUnknownKeys(n, row as unknown as Record<string, unknown>);
+  return n;
 }
 
 export function normalizeFromRedis(read: SnapshotRead): NormalizedSnapshot {
   const e = read.entry as Record<string, unknown>;
   const createdAtMs = new Date(String(e.createdAt)).getTime();
   const order = read.completedWaitpointIds?.order ?? [];
   const idSet = [...(read.completedWaitpointIds?.distinctIds ?? [])].sort();
-  return {
+  const n: NormalizedSnapshot = {
     id: read.id,
     engine: (e.engine ?? "V2") as string,
     executionStatus: e.executionStatus as string,
@@ -136,6 +157,8 @@ export function normalizeFromRedis(read: SnapshotRead): NormalizedSnapshot {
     completedWaitpointOrder: [...order],
     waitpointIdSet: idSet,
   };
+  carryUnknownKeys(n, e);
+  return n;
 }
 
 function sameArray(a: string[], b: string[]): boolean {
@@ -144,12 +167,6 @@ function sameArray(a: string[], b: string[]): boolean {
 
 function fieldDivergences(pg: NormalizedSnapshot, redis: NormalizedSnapshot): SnapshotDivergence[] {
   const out: SnapshotDivergence[] = [];
-  const known = new Set<string>([
-    ...COMPARED_FIELDS,
-    ...EXCLUDED_FIELDS,
-    "completedWaitpointOrder",
-    "waitpointIdSet",
-  ]);
 
   for (const f of SCALAR_FIELDS) {
     if (pg[f] !== redis[f]) {
@@ -180,8 +197,11 @@ function fieldDivergences(pg: NormalizedSnapshot, redis: NormalizedSnapshot): Sn
       redis: redis.waitpointIdSet,
     });
   }
-  for (const k of Object.keys(redis)) {
-    if (!known.has(k)) out.push({ field: k, class: "unknownField", redis: redis[k] });
+  // Unknown keys on EITHER side, so a new field in either store fails loudly.
+  for (const k of new Set([...Object.keys(pg), ...Object.keys(redis)])) {
+    if (!KNOWN_KEYS.has(k)) {
+      out.push({ field: k, class: "unknownField", pg: pg[k], redis: redis[k] });
+    }
   }
   return out;
 }
@@ -197,8 +217,8 @@ export function diffLatest(
 }
 
 export type SnapshotComparatorMetrics = {
-  recordDivergence(op: string, cls: DivergenceClass): void;
-  recordSample(op: string): void;
+  recordDivergence(op: SnapshotReadOp, cls: DivergenceClass): void;
+  recordSample(op: SnapshotReadOp): void;
 };
 
 // Samples reads and records divergence metrics. Holds no store and returns nothing from record(), so
@@ -222,7 +242,7 @@ export class SnapshotComparator {
     return this.#rng() * 100 < this.#samplePercent;
   }
 
-  record(op: string, divergences: SnapshotDivergence[]): void {
+  record(op: SnapshotReadOp, divergences: SnapshotDivergence[]): void {
     this.#metrics?.recordSample(op);
     for (const d of divergences) this.#metrics?.recordDivergence(op, d.class);
   }
 
@@ -8,9 +8,23 @@ describe("slotOf", () => {
     expect(slotOf("engine:snap:{run_2}:e")).toBe(12239);
   });
 
-  it("hashes the whole key when the tag is empty or malformed", () => {
-    expect(slotOf("snap:{}:e")).toBe(slotOf("snap:{}:e"));
-    expect(slotOf("plain-key")).toBe(slotOf("plain-key"));
+  it("groups keys that share a non-empty tag into one slot", () => {
+    expect(slotOf("a{tag}b")).toBe(slotOf("c{tag}d"));
+  });
+
+  it("hashes the whole key when the tag is empty (not the empty tag)", () => {
+    // If the empty `{}` were used as the tag, these would collide; hashing the whole key keeps them apart.
+    expect(slotOf("a{}b")).not.toBe(slotOf("c{}d"));
+  });
+
+  it("hashes the whole key when a brace is unclosed (malformed tag)", () => {
+    // `b` is not a tag here (no closing brace), so these must not share a slot the way `{b}` would.
+    expect(slotOf("a{b")).not.toBe(slotOf("x{b"));
+  });
+
+  it("hashes UTF-8 bytes, matching Redis for a non-ASCII tag", () => {
+    // Redis (cluster-key-slot) hashes the UTF-8 bytes of `é` to slot 10180.
+    expect(slotOf("{é}")).toBe(10180);
   });
 });
 
 
@@ -1,10 +1,11 @@
 // CRC16/XMODEM over a key's hash tag, computed here because CLUSTER KEYSLOT is unavailable on a
-// standalone test container. Pinned against the cluster-key-slot package for our key shapes.
+// standalone test container. Pinned against the cluster-key-slot package for our key shapes. Hashes
+// UTF-8 BYTES (as Redis does), not UTF-16 code units, so a non-ASCII key still matches Redis's slot.
 
 function crc16(str: string): number {
   let crc = 0;
-  for (let i = 0; i < str.length; i++) {
-    crc ^= str.charCodeAt(i) << 8;
+  for (const byte of Buffer.from(str, "utf8")) {
+    crc ^= byte << 8;
     for (let j = 0; j < 8; j++) {
       crc = crc & 0x8000 ? (crc << 1) ^ 0x1021 : crc << 1;
       crc &= 0xffff;
 
@@ -41,6 +41,14 @@ describe("createFaultInjector", () => {
     expect(f.fired("afterPgBeforeRedis")).toBe(1);
   });
 
+  it("rejects a non-integer or negative times, but allows the default (Infinity)", () => {
+    const f = make();
+    expect(() => f.arm("midFlushRetry", { times: Number.NaN })).toThrow(RangeError);
+    expect(() => f.arm("midFlushRetry", { times: 1.5 })).toThrow(RangeError);
+    expect(() => f.arm("midFlushRetry", { times: -1 })).toThrow(RangeError);
+    expect(() => f.arm("midFlushRetry")).not.toThrow(); // unlimited
+  });
+
   it("disarm clears a boundary", () => {
     const f = make();
     f.arm("afterPgBeforeRedis");
 
@@ -20,7 +20,11 @@ export function createFaultInjector<TBoundary extends string>(opts: {
 
   return {
     arm(boundary, o) {
-      armed.set(boundary, { remaining: o?.times ?? Infinity, runId: o?.runId });
+      const times = o?.times ?? Infinity;
+      if (times !== Infinity && (!Number.isInteger(times) || times < 0)) {
+        throw new RangeError("times must be a non-negative integer or Infinity");
+      }
+      armed.set(boundary, { remaining: times, runId: o?.runId });
     },
     disarm(boundary) {
       if (boundary === undefined) armed.clear();