@remnic/core 9.52.2 → 9.54.0

package/src/lifecycle/tombstones.test.ts

@@ -1,29 +1,23 @@
-import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtemp, readFile, writeFile, rm, mkdir, appendFile, utimes } from "node:fs/promises";
-import { tmpdir } from "node:os";
 import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
 import { statSync } from "node:fs";
+import { appendFile, mkdir, mkdtemp, readFile, rm, utimes, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import path from "node:path";
-import { createHash } from "node:crypto";
+import { describe, it } from "node:test";
+import {
+  computeContentHash as computeHash,
+  computeLegacyContentHash,
+  normalizeContent,
+  normalizeLegacyContent,
+} from "../content-hash.js";
 import {
   TombstoneStore,
   parseTombstoneLine,
   type TombstoneFileIo,
 } from "./tombstones.js";
 
-// Mirror the dedup normalizer EXACTLY — these are the wired injections.
-function normalizeContent(content: string): string {
-  return content
-    .toLowerCase()
-    .replace(/[^a-z0-9\s]/g, " ")
-    .replace(/\s+/g, " ")
-    .trim();
-}
-function computeHash(content: string): string {
-  return createHash("sha256").update(normalizeContent(content)).digest("hex");
-}
-
 function makeIo(): TombstoneFileIo {
   return {
     read: (p) => readFile(p, "utf8"),
@@ -134,6 +128,663 @@ describe("TombstoneStore — append/lookup round-trip", () => {
   });
 });
 
+describe("TombstoneStore — Unicode normalizer migration", () => {
+  it("migrates a legacy Japanese identity before indexing, then survives restart", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "tomb-unicode-migration-"));
+    const filePath = path.join(dir, "tombstones.jsonl");
+    const japanese = "利用者は紅茶を好む。";
+    const legacyNormalize = (content: string) =>
+      content.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
+    const legacyEntry = {
+      id: "tomb-legacy-japanese",
+      kind: "tombstone" as const,
+      reason: "correction" as const,
+      sourceMemoryId: "fact-japanese",
+      contentHash: createHash("sha256").update(legacyNormalize(japanese)).digest("hex"),
+      normalizedText: legacyNormalize(japanese),
+      namespace: "default",
+      createdAt: "2026-01-01T00:00:00.000Z",
+      createdBy: "user_correction" as const,
+    };
+    const legacyAscii = {
+      ...legacyEntry,
+      id: "tomb-legacy-ascii",
+      sourceMemoryId: "fact-ascii",
+      contentHash: createHash("sha256").update(legacyNormalize("ASCII survives")).digest("hex"),
+      normalizedText: legacyNormalize("ASCII survives"),
+    };
+    await writeFile(
+      filePath,
+      `${JSON.stringify(legacyEntry)}\n${JSON.stringify(legacyAscii)}\n`,
+      "utf8",
+    );
+    const options = {
+      enabled: true,
+      semanticMatch: false,
+      semanticThreshold: 0.9,
+      hashContent: computeHash,
+      normalizeText: normalizeContent,
+      sourceContentsForMemoryIds: async (ids: readonly string[]) =>
+        new Map(ids.map((id) => [id, id === "fact-japanese" ? japanese : "ASCII survives"])),
+    };
+    const store = new TombstoneStore(filePath, "default", options, makeIo());
+    await store.load();
+    assert.equal(
+      store.lookup({ namespace: "default", contentHash: computeHash(japanese) })?.matchedTier,
+      "exact",
+    );
+    assert.equal(
+      store.lookup({ namespace: "default", normalizedText: normalizeContent(japanese) })?.matchedTier,
+      "normalized",
+    );
+    assert.equal(
+      store.lookup({ namespace: "default", contentHash: computeHash("ASCII survives") })?.matchedTier,
+      "exact",
+    );
+    assert.equal(store.snapshot().find((entry) => entry.id === legacyEntry.id)?.normalizerVersion, 2);
+
+    const restarted = new TombstoneStore(filePath, "default", options, makeIo());
+    await restarted.load();
+    assert.equal(
+      restarted.lookup({ namespace: "default", contentHash: computeHash(japanese) })?.matchedTier,
+      "exact",
+    );
+    assert.equal(
+      restarted.lookup({ namespace: "default", normalizedText: normalizeContent(japanese) })?.matchedTier,
+      "normalized",
+    );
+    assert.equal(
+      restarted.lookup({ namespace: "default", contentHash: computeHash("ASCII survives") })?.matchedTier,
+      "exact",
+    );
+  });
+
+  it("preserves an explicit pre-upgrade contentHashSource identity after migration and restart", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "tomb-content-hash-source-migration-"));
+    const filePath = path.join(dir, "tombstones.jsonl");
+    const source = "利用者は紅茶を好む。";
+    const override = computeHash("external contentHashSource identity");
+    const legacyNormalize = (content: string) =>
+      content.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
+    const legacyEntry = {
+      id: "tomb-legacy-override",
+      kind: "tombstone" as const,
+      reason: "correction" as const,
+      sourceMemoryId: "fact-override",
+      contentHash: override,
+      normalizedText: legacyNormalize(source),
+      namespace: "default",
+      createdAt: "2026-01-01T00:00:00.000Z",
+      createdBy: "user_correction" as const,
+    };
+    await writeFile(filePath, `${JSON.stringify(legacyEntry)}\n`, "utf8");
+    const options = {
+      enabled: true,
+      semanticMatch: false,
+      semanticThreshold: 0.9,
+      hashContent: computeHash,
+      normalizeText: normalizeContent,
+      sourceContentsForMemoryIds: async () =>
+        new Map<string, string>([["fact-override", source]]),
+    };
+    const store = new TombstoneStore(filePath, "default", options, makeIo());
+    await store.load();
+    const query = {
+      namespace: "default",
+      contentHash: override,
+      normalizedText: normalizeContent(source),
+    };
+    assert.equal(store.lookup(query)?.matchedTier, "exact");
+
+    const restarted = new TombstoneStore(filePath, "default", options, makeIo());
+    await restarted.load();
+    assert.equal(restarted.lookup(query)?.matchedTier, "exact");
+  });
+});
+
+describe("TombstoneStore — Unicode migration safety", () => {
+  it("does not cross-block unrelated pure-CJK tombstones through an empty legacy alias", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "tomb-cjk-alias-safety-"));
+    const filePath = path.join(dir, "tombstones.jsonl");
+    const first = "利用者は紅茶を好む。";
+    const unrelated = "利用者は珈琲を好む。";
+    const legacyHash = computeLegacyContentHash(first);
+    await writeFile(
+      filePath,
+      `${JSON.stringify({
+        id: "tomb-cjk-first",
+        kind: "tombstone",
+        reason: "correction",
+        sourceMemoryId: "fact-cjk-first",
+        contentHash: legacyHash,
+        normalizedText: normalizeLegacyContent(first),
+        namespace: "default",
+        createdAt: "2026-01-01T00:00:00.000Z",
+        createdBy: "user_correction",
+      })}\n`,
+      "utf8",
+    );
+    const store = new TombstoneStore(
+      filePath,
+      "default",
+      {
+        enabled: true,
+        semanticMatch: false,
+        semanticThreshold: 0.9,
+        hashContent: computeHash,
+        normalizeText: normalizeContent,
+        sourceContentsForMemoryIds: async () =>
+          new Map<string, string>([["fact-cjk-first", first]]),
+      },
+      makeIo(),
+    );
+    await store.load();
+    assert.equal(
+      store.lookup({ namespace: "default", contentHash: computeHash(first) })?.matchedTier,
+      "exact",
+    );
+    assert.equal(
+      store.lookup({
+        namespace: "default",
+        contentHash: computeHash(unrelated),
+      }),
+      null,
+    );
+  });
+
+  it("does not publish legacy identities when migration fails and retries on the next load", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "tomb-migration-retry-"));
+    const filePath = path.join(dir, "tombstones.jsonl");
+    const source = "利用者は緑茶を好む。";
+    const legacyEntry = {
+      id: "tomb-migration-retry",
+      kind: "tombstone" as const,
+      reason: "correction" as const,
+      sourceMemoryId: "fact-migration-retry",
+      contentHash: computeLegacyContentHash(source),
+      normalizedText: normalizeLegacyContent(source),
+      namespace: "default",
+      createdAt: "2026-01-01T00:00:00.000Z",
+      createdBy: "user_correction" as const,
+    };
+    await writeFile(filePath, `${JSON.stringify(legacyEntry)}\n`, "utf8");
+    let sourceReadAttempts = 0;
+    const store = new TombstoneStore(
+      filePath,
+      "default",
+      {
+        enabled: true,
+        semanticMatch: false,
+        semanticThreshold: 0.9,
+        hashContent: computeHash,
+        normalizeText: normalizeContent,
+        sourceContentsForMemoryIds: async () => {
+          sourceReadAttempts += 1;
+          if (sourceReadAttempts === 1) throw new Error("transient source read failure");
+          return new Map<string, string>([[legacyEntry.sourceMemoryId, source]]);
+        },
+      },
+      makeIo(),
+    );
+
+    await assert.rejects(store.load(), /transient source read failure/);
+    assert.deepEqual(store.snapshot(), []);
+    assert.equal(
+      store.lookup({ namespace: "default", contentHash: computeHash(source) }),
+      null,
+    );
+
+    await store.load();
+    assert.equal(sourceReadAttempts, 2);
+    assert.equal(
+      store.lookup({ namespace: "default", contentHash: computeHash(source) })?.matchedTier,
+      "exact",
+    );
+  });
+
+  it("does not publish an empty index after a transient ledger read failure", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "tomb-load-retry-"));
+    const filePath = path.join(dir, "tombstones.jsonl");
+    const source = "Current tombstone identity";
+    const entry = {
+      id: "tomb-load-retry",
+      kind: "tombstone" as const,
+      reason: "correction" as const,
+      sourceMemoryId: "fact-load-retry",
+      contentHash: computeHash(source),
+      normalizedText: normalizeContent(source),
+      normalizerVersion: 2,
+      namespace: "default",
+      createdAt: "2026-01-01T00:00:00.000Z",
+      createdBy: "user_correction" as const,
+    };
+    await writeFile(filePath, `${JSON.stringify(entry)}\n`, "utf8");
+    let readAttempts = 0;
+    const io = makeIo();
+    io.read = async (target) => {
+      readAttempts += 1;
+      if (readAttempts === 1) {
+        const error = new Error("transient ledger read failure") as NodeJS.ErrnoException;
+        error.code = "EACCES";
+        throw error;
+      }
+      return readFile(target, "utf8");
+    };
+    const store = new TombstoneStore(
+      filePath,
+      "default",
+      {
+        enabled: true,
+        semanticMatch: false,
+        semanticThreshold: 0.9,
+        hashContent: computeHash,
+        normalizeText: normalizeContent,
+      },
+      io,
+    );
+
+    await assert.rejects(store.load(), /transient ledger read failure/);
+    assert.deepEqual(store.snapshot(), []);
+
+    await store.load();
+    assert.equal(readAttempts, 2);
+    assert.equal(
+      store.lookup({ namespace: "default", contentHash: computeHash(source) })?.matchedTier,
+      "exact",
+    );
+  });
+
+  it("withholds unverified legacy hash tiers until the source becomes available", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "tomb-unverified-legacy-"));
+    const filePath = path.join(dir, "tombstones.jsonl");
+    const source = "The user prefers café.";
+    const collision = "The user prefers caf.";
+    const legacyEntry = {
+      id: "tomb-unverified-legacy",
+      kind: "tombstone" as const,
+      reason: "correction" as const,
+      sourceMemoryId: "fact-unverified-legacy",
+      contentHash: computeLegacyContentHash(source),
+      normalizedText: normalizeLegacyContent(source),
+      namespace: "default",
+      createdAt: "2026-01-01T00:00:00.000Z",
+      createdBy: "user_correction" as const,
+    };
+    await writeFile(filePath, `${JSON.stringify(legacyEntry)}\n`, "utf8");
+    let sourceAvailable = false;
+    const store = new TombstoneStore(
+      filePath,
+      "default",
+      {
+        enabled: true,
+        semanticMatch: true,
+        semanticThreshold: 0.9,
+        hashContent: computeHash,
+        normalizeText: normalizeContent,
+        semanticSimilarity: () => 1,
+        sourceContentsForMemoryIds: async () =>
+          sourceAvailable
+            ? new Map<string, string>([[legacyEntry.sourceMemoryId, source]])
+            : new Map(),
+      },
+      makeIo(),
+    );
+
+    await store.load();
+    assert.equal(store.snapshot()[0]?.normalizerVersion, undefined);
+    assert.equal(
+      store.lookup({ namespace: "default", contentHash: computeHash(collision) }),
+      null,
+    );
+    assert.equal(
+      store.lookup({ namespace: "default", normalizedText: normalizeContent(collision) }),
+      null,
+    );
+
+    sourceAvailable = true;
+    store.invalidate();
+    await store.load();
+    assert.equal(
+      store.lookup({ namespace: "default", contentHash: computeHash(source) })?.matchedTier,
+      "exact",
+    );
+    assert.equal(
+      store.lookup({ namespace: "default", contentHash: computeHash(collision) }),
+      null,
+    );
+  });
+
+  it("replaces a mixed-Unicode legacy hash instead of blocking its ASCII collision", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "tomb-mixed-unicode-alias-safety-"));
+    const filePath = path.join(dir, "tombstones.jsonl");
+    const source = "The user prefers café.";
+    const asciiCollision = "The user prefers caf.";
+    await writeFile(
+      filePath,
+      `${JSON.stringify({
+        id: "tomb-mixed-unicode",
+        kind: "tombstone",
+        reason: "correction",
+        sourceMemoryId: "fact-mixed-unicode",
+        contentHash: computeLegacyContentHash(source),
+        normalizedText: normalizeLegacyContent(source),
+        namespace: "default",
+        createdAt: "2026-01-01T00:00:00.000Z",
+        createdBy: "user_correction",
+      })}\n`,
+      "utf8",
+    );
+    const store = new TombstoneStore(
+      filePath,
+      "default",
+      {
+        enabled: true,
+        semanticMatch: false,
+        semanticThreshold: 0.9,
+        hashContent: computeHash,
+        normalizeText: normalizeContent,
+        sourceContentsForMemoryIds: async () =>
+          new Map<string, string>([["fact-mixed-unicode", source]]),
+      },
+      makeIo(),
+    );
+    await store.load();
+
+    assert.equal(
+      store.lookup({ namespace: "default", contentHash: computeHash(source) })?.matchedTier,
+      "exact",
+    );
+    assert.equal(
+      store.lookup({ namespace: "default", contentHash: computeHash(asciiCollision) }),
+      null,
+    );
+  });
+
+  it("migrates the raw source identity when a stored fact has structured attributes", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "tomb-attribute-source-migration-"));
+    const filePath = path.join(dir, "tombstones.jsonl");
+    const source = "利用者は紅茶を好む。";
+    const storedBody = `${source}\n[Attributes: topic: 紅茶]`;
+    await writeFile(
+      filePath,
+      `${JSON.stringify({
+        id: "tomb-attribute-source",
+        kind: "tombstone",
+        reason: "correction",
+        sourceMemoryId: "fact-attribute-source",
+        contentHash: computeLegacyContentHash(source),
+        normalizedText: normalizeLegacyContent(source),
+        namespace: "default",
+        createdAt: "2026-01-01T00:00:00.000Z",
+        createdBy: "user_correction",
+      })}\n`,
+      "utf8"
+    );
+    const store = new TombstoneStore(
+      filePath,
+      "default",
+      {
+        enabled: true,
+        semanticMatch: false,
+        semanticThreshold: 0.9,
+        hashContent: computeHash,
+        normalizeText: normalizeContent,
+        sourceContentsForMemoryIds: async () => new Map([["fact-attribute-source", [storedBody, source]]]),
+      },
+      makeIo()
+    );
+    await store.load();
+
+    assert.equal(store.lookup({ namespace: "default", contentHash: computeHash(source) })?.matchedTier, "exact");
+    assert.equal(store.snapshot()[0]?.normalizerVersion, 2);
+  });
+
+  it("does not finalize migration from a body with an unrecognized stale citation", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "tomb-stale-citation-migration-"));
+    const filePath = path.join(dir, "tombstones.jsonl");
+    const source = "The user prefers café.";
+    const storedBody = `${source} [legacy-source:planner]`;
+    await writeFile(
+      filePath,
+      `${JSON.stringify({
+        id: "tomb-stale-citation",
+        kind: "tombstone",
+        reason: "correction",
+        sourceMemoryId: "fact-stale-citation",
+        contentHash: computeLegacyContentHash(source),
+        normalizedText: normalizeLegacyContent(source),
+        namespace: "default",
+        createdAt: "2026-01-01T00:00:00.000Z",
+        createdBy: "user_correction",
+      })}\n`,
+      "utf8",
+    );
+    const store = new TombstoneStore(
+      filePath,
+      "default",
+      {
+        enabled: true,
+        semanticMatch: false,
+        semanticThreshold: 0.9,
+        hashContent: computeHash,
+        normalizeText: normalizeContent,
+        sourceContentsForMemoryIds: async () =>
+          new Map<string, string>([["fact-stale-citation", storedBody]]),
+      },
+      makeIo(),
+    );
+    await store.load();
+
+    const entry = store.snapshot()[0];
+    assert.equal(entry?.normalizerVersion, undefined);
+    assert.equal(entry?.currentContentHashAlias, undefined);
+  });
+
+  it("migrates valid rows while preserving malformed JSONL rows", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "tomb-corrupt-migration-"));
+    const filePath = path.join(dir, "tombstones.jsonl");
+    const source = "The user prefers café.";
+    const valid = JSON.stringify({
+      id: "tomb-corrupt-migration",
+      kind: "tombstone",
+      reason: "correction",
+      sourceMemoryId: "fact-corrupt-migration",
+      contentHash: computeLegacyContentHash(source),
+      normalizedText: normalizeLegacyContent(source),
+      namespace: "default",
+      createdAt: "2026-01-01T00:00:00.000Z",
+      createdBy: "user_correction",
+    });
+    const original = `${valid}\n{not-json}\n`;
+    await writeFile(filePath, original, "utf8");
+    const store = new TombstoneStore(
+      filePath,
+      "default",
+      {
+        enabled: true,
+        semanticMatch: false,
+        semanticThreshold: 0.9,
+        hashContent: computeHash,
+        normalizeText: normalizeContent,
+        sourceContentsForMemoryIds: async () =>
+          new Map<string, string>([["fact-corrupt-migration", source]]),
+      },
+      makeIo(),
+    );
+    await store.load();
+
+    const rewritten = await readFile(filePath, "utf8");
+    assert.equal(rewritten.split("\n")[1], "{not-json}");
+    assert.equal(rewritten.endsWith("{not-json}\n"), true);
+    assert.equal(store.snapshot()[0]?.normalizerVersion, 2);
+    assert.equal(store.snapshot()[0]?.contentHash, computeHash(source));
+    assert.equal(store.stats().corruptedLines, 1);
+  });
+
+  it("blocks the same pure-CJK body without cross-blocking an unrelated body", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "tomb-cjk-override-safety-"));
+    const filePath = path.join(dir, "tombstones.jsonl");
+    const source = "東京の会社は紅茶を好む。";
+    await writeFile(
+      filePath,
+      `${JSON.stringify({
+        id: "tomb-cjk-override",
+        kind: "tombstone",
+        reason: "correction",
+        sourceMemoryId: "fact-cjk-override",
+        contentHash: computeLegacyContentHash(source),
+        normalizedText: normalizeLegacyContent(source),
+        namespace: "default",
+        createdAt: "2026-01-01T00:00:00.000Z",
+        createdBy: "user_correction",
+      })}\n`,
+      "utf8",
+    );
+    const store = new TombstoneStore(
+      filePath,
+      "default",
+      {
+        enabled: true,
+        semanticMatch: false,
+        semanticThreshold: 0.9,
+        hashContent: computeHash,
+        normalizeText: normalizeContent,
+        sourceContentsForMemoryIds: async () =>
+          new Map<string, string>([["fact-cjk-override", source]]),
+      },
+      makeIo(),
+    );
+    await store.load();
+    assert.equal(
+      store.lookup({ namespace: "default", normalizedText: normalizeContent(source) })?.matchedTier,
+      "normalized",
+    );
+    assert.equal(
+      store.lookup({ namespace: "default", normalizedText: normalizeContent("大阪の会社は珈琲を好む。") }),
+      null,
+    );
+  });
+
+  it("rejects invalid legacy migration limits and accepts zero", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "tomb-migration-limit-"));
+    const options = {
+      enabled: true,
+      semanticMatch: false,
+      semanticThreshold: 0.9,
+      hashContent: computeHash,
+      normalizeText: normalizeContent,
+    };
+    for (const limit of [-1, 1.5, Number.NaN, Number.POSITIVE_INFINITY]) {
+      assert.throws(
+        () => new TombstoneStore(path.join(dir, `${String(limit)}.jsonl`), "default", { ...options, legacyMigrationLimit: limit }, makeIo()),
+        /legacyMigrationLimit must be a finite non-negative integer/,
+      );
+    }
+    assert.doesNotThrow(
+      () => new TombstoneStore(path.join(dir, "zero.jsonl"), "default", { ...options, legacyMigrationLimit: 0 }, makeIo()),
+    );
+  });
+
+  it("retries a missing migration source after restart and upgrades when it appears", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "tomb-migration-missing-source-"));
+    const filePath = path.join(dir, "tombstones.jsonl");
+    const source = "The user prefers café.";
+    await writeFile(
+      filePath,
+      `${JSON.stringify({
+        id: "tomb-missing-source",
+        kind: "tombstone",
+        reason: "correction",
+        sourceMemoryId: "fact-missing-source",
+        contentHash: computeLegacyContentHash(source),
+        normalizedText: normalizeLegacyContent(source),
+        namespace: "default",
+        createdAt: "2026-01-01T00:00:00.000Z",
+        createdBy: "user_correction",
+      })}\n`,
+      "utf8",
+    );
+    let requests = 0;
+    let sourceAvailable = false;
+    const options = {
+      enabled: true,
+      semanticMatch: false,
+      semanticThreshold: 0.9,
+      hashContent: computeHash,
+      normalizeText: normalizeContent,
+      sourceContentsForMemoryIds: async () => {
+        requests += 1;
+        return new Map<string, string>(
+          sourceAvailable ? [["fact-missing-source", source]] : [],
+        );
+      },
+    };
+    const first = new TombstoneStore(filePath, "default", options, makeIo());
+    await first.load();
+    assert.equal(requests, 1);
+    assert.equal(first.lookup({ namespace: "default", contentHash: computeHash(source) }), null);
+
+    sourceAvailable = true;
+    const restarted = new TombstoneStore(filePath, "default", options, makeIo());
+    await restarted.load();
+    assert.equal(requests, 2);
+    assert.equal(
+      restarted.lookup({ namespace: "default", contentHash: computeHash(source) })?.matchedTier,
+      "exact",
+    );
+  });
+
+  it("migrates every legacy entry before one load becomes authoritative", async (t) => {
+    const dir = await mkdtemp(path.join(tmpdir(), "tomb-migration-all-batches-"));
+    t.after(() => rm(dir, { recursive: true, force: true }));
+    const filePath = path.join(dir, "tombstones.jsonl");
+    const sources = new Map([
+      ["fact-first", "利用者は紅茶を好む。"],
+      ["fact-second", "利用者は珈琲を好む。"],
+    ]);
+    const entries = [...sources].map(([sourceMemoryId, content], index) => ({
+      id: `tomb-batch-${index}`,
+      kind: "tombstone",
+      reason: "correction",
+      sourceMemoryId,
+      contentHash: computeLegacyContentHash(content),
+      normalizedText: normalizeLegacyContent(content),
+      namespace: "default",
+      createdAt: `2026-01-0${index + 1}T00:00:00.000Z`,
+      createdBy: "user_correction",
+    }));
+    await writeFile(filePath, `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`, "utf8");
+    const requestedBatches: string[][] = [];
+    const store = new TombstoneStore(
+      filePath,
+      "default",
+      {
+        enabled: true,
+        semanticMatch: false,
+        semanticThreshold: 0.9,
+        hashContent: computeHash,
+        normalizeText: normalizeContent,
+        legacyMigrationLimit: 1,
+        sourceContentsForMemoryIds: async (sourceMemoryIds) => {
+          requestedBatches.push([...sourceMemoryIds]);
+          return new Map(sourceMemoryIds.map((id) => [id, sources.get(id) as string]));
+        },
+      },
+      makeIo(),
+    );
+
+    await store.load();
+
+    assert.deepEqual(requestedBatches, [["fact-first"], ["fact-second"]]);
+    for (const content of sources.values()) {
+      assert.equal(
+        store.lookup({ namespace: "default", contentHash: computeHash(content) })?.matchedTier,
+        "exact",
+      );
+    }
+  });
+});
+
 describe("TombstoneStore — revocation supersedes tombstone", () => {
   it("a revocation entry re-allows the fact (newest wins)", async () => {
     const env = await makeStore("default");
@@ -251,6 +902,7 @@ describe("TombstoneStore — corrupted line skipped with counter, not crash", ()
       sourceMemoryId: "fact-1",
       contentHash: computeHash("good content"),
       normalizedText: normalizeContent("good content"),
+      normalizerVersion: 2,
       namespace: "default",
       createdAt: "2026-01-01T00:00:00.000Z",
       createdBy: "user_correction",
@@ -502,6 +1154,101 @@ describe("TombstoneStore — cross-process write lock (issue #1639)", () => {
     await rm(lockPath, { force: true });
   });
 
+  it("does not deadlock when mtime freshness sees legacy entries before append or rebuild", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "tomb-migration-deadlock-"));
+    const filePath = path.join(dir, "tombstones.jsonl");
+    const japanese = "利用者は紅茶を好む。";
+    const legacyNormalize = (content: string) =>
+      content.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
+    const legacyEntry = {
+      id: "tomb-legacy-before-append",
+      kind: "tombstone" as const,
+      reason: "correction" as const,
+      sourceMemoryId: "fact-legacy-before-append",
+      contentHash: createHash("sha256").update(legacyNormalize(japanese)).digest("hex"),
+      normalizedText: legacyNormalize(japanese),
+      namespace: "default",
+      createdAt: "2026-01-01T00:00:00.000Z",
+      createdBy: "user_correction" as const,
+    };
+    let resolveSources = false;
+    const options = {
+      enabled: true,
+      semanticMatch: false,
+      semanticThreshold: 0.9,
+      hashContent: computeHash,
+      normalizeText: normalizeContent,
+      sourceContentsForMemoryIds: async (ids: readonly string[]) =>
+        resolveSources
+          ? new Map(ids.map((id) => [id, japanese]))
+          : new Map<string, string>(),
+    };
+    await mkdir(path.dirname(filePath), { recursive: true });
+    const withTurnTimeout = async <T>(operation: Promise<T>, message: string): Promise<T> => {
+      let settled = false;
+      const timeout = new Promise<never>((_, reject) => {
+        let turns = 0;
+        const check = () => {
+          if (settled) return;
+          turns += 1;
+          if (turns >= 100_000) reject(new Error(message));
+          else setImmediate(check);
+        };
+        setImmediate(check);
+      });
+      try {
+        return await Promise.race([operation, timeout]);
+      } finally {
+        settled = true;
+      }
+    };
+    await writeFile(filePath, `${JSON.stringify(legacyEntry)}\n`, "utf8");
+    const store = new TombstoneStore(filePath, "default", options, makeReadMergeWriteIo());
+    await store.load();
+    resolveSources = true;
+
+    const peerEntry = {
+      ...legacyEntry,
+      id: "tomb-peer-before-append",
+      sourceMemoryId: "fact-peer",
+    };
+    await appendFile(filePath, `${JSON.stringify(peerEntry)}\n`, "utf8");
+    const appendMtime = new Date(Date.now() + 2_000);
+    await utimes(filePath, appendMtime, appendMtime);
+    const appended = await withTurnTimeout(
+      store.appendTombstone({
+        reason: "correction",
+        createdBy: "user_correction",
+        sourceMemoryId: "fact-new",
+        rawContent: "A new fact after the peer append.",
+      }),
+      "append migration deadlock",
+    );
+    assert.match(appended, /^tomb-/);
+
+    const rebuildPeer = {
+      ...legacyEntry,
+      id: "tomb-peer-before-rebuild",
+      sourceMemoryId: "fact-peer-rebuild",
+    };
+    await appendFile(filePath, `${JSON.stringify(rebuildPeer)}\n`, "utf8");
+    const rebuildMtime = new Date(Date.now() + 4_000);
+    await utimes(filePath, rebuildMtime, rebuildMtime);
+    const rebuilt = await withTurnTimeout(
+      store.rebuild([
+        {
+          memoryId: "fact-rebuild",
+          rawContent: japanese,
+          reason: "correction" as const,
+          createdBy: "user_correction" as const,
+          createdAt: "2026-01-02T00:00:00.000Z",
+        },
+      ]),
+      "rebuild migration deadlock",
+    );
+    assert.equal(rebuilt, 1);
+  });
+
   it("rebuild preserves a peer's revocation appended before rebuild acquired the lock (cursor/codex #1639)", async () => {
     // Regression for the rebuild race: rebuild must re-read the log under the
     // lock (ensureFreshAgainstDisk) before computing its payload, otherwise a