@indigoai-us/hq-cloud 6.15.19 → 6.15.21

package/dist/cli/sync.test.js

@@ -118,7 +118,23 @@ import * as s3Module from "../s3.js";
 import { reindex } from "./reindex.js";
 import { readSyncProgress } from "../sync-progress.js";
 import { VaultAuthError } from "../vault-client.js";
-import { readJournal, getEntry } from "../journal.js";
+import { readJournal, getEntry, listJournals } from "../journal.js";
+/**
+ * Read a journal the way production does.
+ *
+ * These tests used to `JSON.parse` `sync-journal.<slug>.json` directly, back
+ * when that file held a full copy of the journal. It is now a small locator —
+ * the authority is the v3 state store — so the assertions below go through
+ * `readJournal`, which is what the sync engine itself uses. The slug is
+ * recovered from the path so each call site keeps naming the journal it means.
+ */
+function journalAt(journalPath) {
+    const slug = path
+        .basename(journalPath)
+        .replace(/^sync-journal\./, "")
+        .replace(/\.json$/, "");
+    return readJournal(slug);
+}
 const mockConfig = {
     apiUrl: "https://vault-api.test",
     authToken: "test-jwt-token",
@@ -516,13 +532,50 @@ describe("sync", () => {
             hqRoot: tmpDir,
         });
         expect(result.conflicts).toBe(1);
-        const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journal = journalAt(journalPath);
         // remoteEtag still recorded so the conflict can't re-fire (#137 invariant)…
         expect(journal.files["docs/handoff.md"].remoteEtag).toBeTruthy();
         // …but the kept-local copy is flagged divergent so a later currency-gated
         // delete cannot fire on a journal that lies about local==remote.
         expect(journal.files["docs/handoff.md"].localDiverges).toBe(true);
     });
+    // `publish-local` reaches the PULL leg too, because the strategy is set once
+    // for a bidirectional run. It has no meaning here — there is nothing to
+    // publish while deciding what to do with an incoming object — so it MUST
+    // degrade to `keep`. If it instead fell through to the download branch it
+    // would overwrite the very local body the operator elected to publish, which
+    // is precisely the data loss the strategy exists to prevent.
+    it("conflict publish-local on the pull leg keeps local and never downloads over it", async () => {
+        const companyDocs = path.join(tmpDir, "companies", "acme", "docs");
+        fs.mkdirSync(companyDocs, { recursive: true });
+        fs.writeFileSync(path.join(companyDocs, "handoff.md"), "my elected local version");
+        fs.writeFileSync(journalPath, JSON.stringify({
+            version: "1",
+            lastSync: new Date().toISOString(),
+            files: {
+                "docs/handoff.md": {
+                    hash: "old-hash-from-last-sync",
+                    size: 20,
+                    syncedAt: new Date(Date.now() - 3600000).toISOString(),
+                    direction: "down",
+                },
+            },
+        }));
+        const result = await sync({
+            company: "acme",
+            onConflict: "publish-local",
+            vaultConfig: mockConfig,
+            hqRoot: tmpDir,
+        });
+        expect(result.conflicts).toBe(1);
+        expect(fs.readFileSync(path.join(companyDocs, "handoff.md"), "utf-8")).toBe("my elected local version");
+        // Identical bookkeeping to `keep`: the etag is stamped so the conflict
+        // cannot re-fire, and the honesty flag is armed so the push leg knows this
+        // is the divergent body it may promote under an If-Match fence.
+        const journal = journalAt(journalPath);
+        expect(journal.files["docs/handoff.md"].remoteEtag).toBeTruthy();
+        expect(journal.files["docs/handoff.md"].localDiverges).toBe(true);
+    });
     it("a genuine download clears a stale localDiverges flag (entry is now truly local==remote)", async () => {
         const companyDocs = path.join(tmpDir, "companies", "acme", "docs");
         fs.mkdirSync(companyDocs, { recursive: true });
@@ -548,7 +601,7 @@ describe("sync", () => {
         ]);
         await sync({ company: "acme", vaultConfig: mockConfig, hqRoot: tmpDir });
         expect(fs.existsSync(path.join(companyDocs, "handoff.md"))).toBe(true);
-        const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journal = journalAt(journalPath);
         expect(journal.files["docs/handoff.md"]?.localDiverges).toBeFalsy();
     });
     it("leaves a downloaded unreadable link unjournaled without emitting a fatal error", async () => {
@@ -587,7 +640,7 @@ describe("sync", () => {
                 samplePaths: [linkKey],
             });
             expect(events.some((event) => event.type === "error")).toBe(false);
-            const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+            const journal = journalAt(journalPath);
             expect(journal.files[linkKey]).toBeUndefined();
         }
         finally {
@@ -685,7 +738,7 @@ describe("sync", () => {
         expect(litter).toEqual([]);
         // Journal re-stamped off the stale baseline (hash now matches local,
         // remoteEtag recorded) so the phantom conflict can't re-fire.
-        const journalAfter = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journalAfter = journalAt(journalPath);
         expect(journalAfter.files["docs/handoff.md"].hash).not.toBe("stale-hash");
         expect(journalAfter.files["docs/handoff.md"].remoteEtag).toBeTruthy();
     });
@@ -743,7 +796,7 @@ describe("sync", () => {
             });
             expect(events.some((event) => event.type === "error")).toBe(false);
             expect(fs.readFileSync(localPath, "utf-8")).toBe("local version");
-            const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+            const journal = journalAt(journalPath);
             expect(journal.files[linkKey].hash).toBe("stale-hash");
         }
         finally {
@@ -1131,7 +1184,7 @@ describe("sync", () => {
             .filter((f) => f.includes(".conflict-"));
         expect(litter).toHaveLength(0);
         // Journal stamped, so the next pass is a plain unchanged-skip.
-        const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journal = journalAt(journalPath);
         expect(journal.files["docs/handoff.md"]).toBeDefined();
     });
     it("RF-F02EXEC: refuses a download whose parent symlink appears after planning", async () => {
@@ -1291,7 +1344,7 @@ describe("sync", () => {
         });
         expect(fs.readFileSync(untrackedPath, "utf-8")).toBe("brand new local work");
         expect(fs.existsSync(trackedPath)).toBe(false);
-        const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journal = journalAt(journalPath);
         expect(journal.files[untrackedKey]).toBeUndefined();
         expect(journal.files[trackedKey]).toBeUndefined();
     });
@@ -1364,7 +1417,7 @@ describe("sync", () => {
         await sync({ company: "acme", vaultConfig: mockConfig, hqRoot: tmpDir });
         expect(s3Module.downloadFile).toHaveBeenCalledWith(expect.anything(), key, expect.anything(), expect.anything());
         expect(fs.readFileSync(localPath, "utf-8")).toBe("mock file content");
-        const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journal = journalAt(journalPath);
         expect(journal.files[key]?.removedAt).toBeUndefined();
     });
     it("does not canonicalize ignored remote-missing journal keys in the tombstone sweep", async () => {
@@ -1412,7 +1465,7 @@ describe("sync", () => {
         // Equivalence: an ignored key is never tombstoned — the local file and its
         // journal entry both survive, exactly as before the fix.
         expect(fs.existsSync(ignoredLocal)).toBe(true);
-        const sweptJournal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const sweptJournal = journalAt(journalPath);
         expect(sweptJournal.files[ignoredKey]).toBeDefined();
     });
     it("tombstone lookup failure does not resurrect a current intent-backed delete", async () => {
@@ -1446,7 +1499,7 @@ describe("sync", () => {
         await sync({ company: "acme", vaultConfig: mockConfig, hqRoot: tmpDir });
         expect(s3Module.downloadFile).not.toHaveBeenCalledWith(expect.anything(), key, expect.anything(), expect.anything());
         expect(fs.existsSync(localPath)).toBe(false);
-        expect(JSON.parse(fs.readFileSync(journalPath, "utf8")).files[key]
+        expect(journalAt(journalPath).files[key]
             ?.removedReason).toBe("local-delete");
     });
     it("pull producer: a BULK disappearance is drift-restored, NOT tombstoned (ridge-incident guard in the pull leg)", async () => {
@@ -1482,7 +1535,7 @@ describe("sync", () => {
         await sync({ company: "acme", vaultConfig: mockConfig, hqRoot: tmpDir });
         // All restored, none tombstoned.
         expect(s3Module.downloadFile).toHaveBeenCalledTimes(12);
-        const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journal = journalAt(journalPath);
         for (const k of keys) {
             expect(journal.files[k]?.removedAt).toBeUndefined();
         }
@@ -1523,7 +1576,7 @@ describe("sync", () => {
         await sync({ company: "acme", vaultConfig: mockConfig, hqRoot: tmpDir });
         expect(s3Module.downloadFile).not.toHaveBeenCalledWith(expect.anything(), key, expect.anything());
         expect(fs.existsSync(localPath)).toBe(false);
-        const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journal = journalAt(journalPath);
         // Entry PRESERVED as a tombstone, not removed.
         expect(journal.files[key]?.removedAt).toBeTruthy();
         expect(journal.files[key]?.removedReason).toBe("local-delete");
@@ -1555,7 +1608,7 @@ describe("sync", () => {
     it("stamps journal.lastSync on every successful run, even when nothing transferred", async () => {
         // First run downloads both remote files and stamps lastSync.
         await sync({ company: "acme", vaultConfig: mockConfig, hqRoot: tmpDir });
-        const firstStamp = JSON.parse(fs.readFileSync(journalPath, "utf-8")).lastSync;
+        const firstStamp = journalAt(journalPath).lastSync;
         expect(firstStamp).not.toBe("");
         // Second run: same remote, same local — Stage-2 plan is all-skip, so
         // updateEntry never fires. lastSync must still advance, otherwise the
@@ -1563,7 +1616,7 @@ describe("sync", () => {
         await new Promise((r) => setTimeout(r, 5));
         const result = await sync({ company: "acme", vaultConfig: mockConfig, hqRoot: tmpDir });
         expect(result.filesDownloaded).toBe(0);
-        const secondStamp = JSON.parse(fs.readFileSync(journalPath, "utf-8")).lastSync;
+        const secondStamp = journalAt(journalPath).lastSync;
         expect(new Date(secondStamp).getTime()).toBeGreaterThan(new Date(firstStamp).getTime());
     });
     it("journalSlug: 'personal' routes journal I/O to sync-journal.personal.json", async () => {
@@ -1654,13 +1707,9 @@ describe("sync", () => {
         expect(fs.existsSync(path.join(tmpDir, "companies", "foo", "bar.md"))).toBe(false);
         // The whole point: it now gets a journal baseline, so the push side stops
         // re-firing a transient conflict every sync (the bug this fix closes).
-        const journaledManifest = fs
-            .readdirSync(stateDir)
-            .filter((f) => f.startsWith("sync-journal."))
-            .some((f) => {
-            const j = JSON.parse(fs.readFileSync(path.join(stateDir, f), "utf8"));
-            return j.files?.["companies/manifest.yaml"] != null;
-        });
+        // Enumerate through the API: the per-slug JSON files are locators now, so
+        // reading them directly finds no `files` map at all.
+        const journaledManifest = listJournals().some((j) => j.journal.files?.["companies/manifest.yaml"] != null);
         expect(journaledManifest).toBe(true);
     });
     it("personalMode pull lands the session-continuity pointer + active thread file under <hqRoot>/workspace/threads/ so a handoff resumes on machine B (DEV-1778)", async () => {
@@ -1913,7 +1962,7 @@ describe("sync", () => {
         expect(result.filesTombstoned).toBeGreaterThanOrEqual(1);
         // Journal entry for the deleted path must be gone too — otherwise
         // the next sync would tombstone the same key on every run.
-        const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journal = journalAt(journalPath);
         expect(journal.files["docs/deleted-by-peer.md"]).toBeUndefined();
         expect(journal.files["docs/kept.md"]).toBeDefined();
     });
@@ -1978,7 +2027,7 @@ describe("sync", () => {
         expect(result.filesTombstoned).toBe(0);
         // The journal is healed: the malformed key is gone, the canonical POSIX key
         // points at the live file (so a future pull stays converged, not poisoned).
-        const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journal = journalAt(journalPath);
         expect(journal.files[backslashKey]).toBeUndefined();
         expect(journal.files[posixKey]).toBeDefined();
         expect(Object.keys(journal.files).some((k) => k.includes("\\"))).toBe(false);
@@ -2031,7 +2080,7 @@ describe("sync", () => {
         expect(result.filesTombstoned).toBe(0);
         // Journal entry retained — next sync (push) will re-evaluate and
         // either re-upload the divergent local or surface as a conflict.
-        const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journal = journalAt(journalPath);
         expect(journal.files["docs/edited-locally.md"]).toBeDefined();
         expect(journal.files["docs/edited-locally.md"].hash).toBe(baselineHash);
     });
@@ -2075,7 +2124,7 @@ describe("sync", () => {
         expect(result.filesTombstoned).toBe(0);
         expect(fs.existsSync(racedPath)).toBe(true);
         expect(fs.readFileSync(racedPath, "utf-8")).toBe("concurrent local edit");
-        const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journal = journalAt(journalPath);
         expect(journal.files["docs/racy-delete.md"]).toBeDefined();
         expect(journal.files["docs/racy-delete.md"].hash).toBe(baselineHash);
     });
@@ -2112,7 +2161,7 @@ describe("sync", () => {
         expect(result.filesTombstoned).toBe(0);
         expect(result.conflicts).toBe(1);
         expect(fs.readFileSync(localPath, "utf-8")).toBe(baseline);
-        const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journal = journalAt(journalPath);
         expect(journal.files["docs/created-after-plan.md"]).toBeDefined();
     });
     it("CAS: preserves a concurrent local edit when a staged download is ready to replace it", async () => {
@@ -2196,7 +2245,7 @@ describe("sync", () => {
             propagateDeletePolicy: "all",
         });
         expect(s3Module.deleteRemoteFile).not.toHaveBeenCalled();
-        const journal = JSON.parse(fs.readFileSync(personalJournalPath, "utf-8"));
+        const journal = journalAt(personalJournalPath);
         expect(journal.files["core/core.yaml"]).toBeDefined();
         expect(journal.files[".claude/skills/core:demo/SKILL.md"]).toBeDefined();
     });
@@ -2230,7 +2279,7 @@ describe("sync", () => {
         });
         expect(s3Module.deleteRemoteFile).not.toHaveBeenCalled();
         expect(result.filesRefusedStale).toBe(2);
-        const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journal = journalAt(journalPath);
         expect(journal.files["docs/a.md"]).toBeDefined();
         expect(journal.files["docs/b.md"]).toBeDefined();
     });
@@ -2322,7 +2371,7 @@ describe("sync", () => {
         expect(fs.lstatSync(linkPath).isSymbolicLink()).toBe(true);
         expect(fs.readlinkSync(linkPath)).toBe("new-target.md");
         expect(result.filesTombstoned).toBe(0);
-        const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journal = journalAt(journalPath);
         expect(journal.files["docs/link.md"]).toBeDefined();
         expect(journal.files["docs/link.md"].hash).toBe(baselineHash);
     });
@@ -2389,7 +2438,7 @@ describe("sync", () => {
         // The really-deleted file MUST be tombstoned.
         expect(fs.existsSync(reallyDeletedPath)).toBe(false);
         expect(result.filesTombstoned).toBe(1);
-        const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journal = journalAt(journalPath);
         // Journal entry retained for the invisible key (so next sync at
         // broader scope can re-evaluate).
         expect(journal.files["docs/invisible-to-list.md"]).toBeDefined();
@@ -2463,7 +2512,7 @@ describe("sync", () => {
         expect(result.filesDownloaded).toBe(0);
         expect(result.filesTombstoned).toBeGreaterThanOrEqual(1);
         // Journal entry dropped so it converges (no re-tombstone next run).
-        const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journal = journalAt(journalPath);
         expect(journal.files["docs/shared.md"]).toBeUndefined();
     });
     it("delete-resync: a re-created object NEWER than the tombstone DOES sync (tombstone is not permanent)", async () => {
@@ -2627,7 +2676,7 @@ describe("sync", () => {
         });
         expect(fs.existsSync(deniedPath)).toBe(true);
         expect(result.filesTombstoned).toBe(0);
-        const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journal = journalAt(journalPath);
         expect(journal.files["docs/out-of-scope.md"]).toBeDefined();
     });
     it("retains the journal entry when tombstone unlink fails with EACCES (Codex P1 — Bug #9 follow-up)", async () => {
@@ -2675,7 +2724,7 @@ describe("sync", () => {
             // Tombstone NOT counted — the delete wasn't honored.
             expect(result.filesTombstoned).toBe(0);
             // Journal entry MUST be retained so the next sync retries.
-            const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+            const journal = journalAt(journalPath);
             expect(journal.files["docs/locked-by-peer.md"]).toBeDefined();
             expect(journal.files["docs/locked-by-peer.md"].hash).toBe("locked-hash");
         }
@@ -2902,7 +2951,7 @@ describe("sync", () => {
             expect(s3Module.downloadFile).not.toHaveBeenCalled();
             expect(fs.existsSync(escapedPath)).toBe(false);
             expect(fs.existsSync(path.join(companyRoot, traversalKey))).toBe(false);
-            const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+            const journal = journalAt(journalPath);
             expect(journal.files[traversalKey]).toBeUndefined();
         }
         finally {
@@ -2936,7 +2985,7 @@ describe("sync", () => {
             expect(s3Module.downloadFile).not.toHaveBeenCalled();
             expect(fs.existsSync(escapedPath)).toBe(false);
             expect(fs.existsSync(path.join(companyRoot, remoteKey))).toBe(false);
-            const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+            const journal = journalAt(journalPath);
             expect(journal.files[remoteKey]).toBeUndefined();
         }
         finally {
@@ -3011,7 +3060,7 @@ describe("sync", () => {
             vaultConfig: mockConfig,
             hqRoot: tmpDir,
         });
-        const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journal = journalAt(journalPath);
         expect(journal.files["docs/handoff.md"].remoteEtag).toBe("abc123");
         expect(journal.files["knowledge/readme.md"].remoteEtag).toBe("def456");
     });
@@ -3032,7 +3081,7 @@ describe("sync", () => {
                 if (key === "bulk/file-8.md") {
                     // This models the next transfer crashing the process. The first
                     // eight entries must already be durable before the final writer.
-                    const checkpoint = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+                    const checkpoint = journalAt(journalPath);
                     expect(Object.keys(checkpoint.files)).toHaveLength(8);
                     throw new Error("simulated crash after checkpoint");
                 }
@@ -3046,7 +3095,7 @@ describe("sync", () => {
                 onEvent: () => undefined,
             });
             expect(first.filesDownloaded).toBe(8);
-            const checkpoint = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+            const checkpoint = journalAt(journalPath);
             expect(Object.keys(checkpoint.files)).toHaveLength(8);
             vi.mocked(s3Module.downloadFile).mockImplementation(defaultDownload);
             vi.mocked(s3Module.downloadFile).mockClear();
@@ -3497,7 +3546,7 @@ describe("sync", () => {
         // skip-unchanged works on the next tick.
         const journalMod = await import("../journal.js");
         const expectedHash = journalMod.hashSymlinkTarget(linkTarget);
-        const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journal = journalAt(journalPath);
         expect(journal.files[linkKey]).toMatchObject({
             hash: expectedHash,
             size: 0,
@@ -4144,7 +4193,7 @@ describe("sync", () => {
         // The journal MUST be updated to reflect the user's keep
         // decision. Pre-fix: catch swallowed the ENOENT, journal stayed
         // at oldHash + old etag, every subsequent sync re-fired.
-        const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journal = journalAt(journalPath);
         const entry = journal.files[linkKey];
         expect(entry.hash).toBe(expectedNewHash);
         expect(entry.size).toBe(0);
@@ -4443,7 +4492,7 @@ describe("scope-invalid key hardening (companies/ prefix in a company vault —
         // Cleaned, not re-uploaded: local doubled-tree copy gone, journal dropped.
         expect(fs.existsSync(path.join(doubled, "poison.md"))).toBe(false);
         expect(result.filesTombstoned).toBeGreaterThanOrEqual(1);
-        const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journal = journalAt(journalPath);
         expect(journal.files["companies/acme/knowledge/poison.md"]).toBeUndefined();
         // No HEAD verify against the invalid key — the server validator would
         // reject it (INVALID_KEY_COMPANIES_SCOPED) and defer the cleanup forever.
@@ -4571,7 +4620,7 @@ describe("junk key-spelling guard (US-002 mixed-version amplifier)", () => {
         expect(events.filter((e) => e.type === "error")).toHaveLength(0);
         expect(result.aborted).toBe(false);
         expect(result.filesSkipped).toBe(1);
-        const journalAfter = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journalAfter = journalAt(journalPath);
         expect(Object.keys(journalAfter.files)).not.toContain(junkKey);
     });
     it("still pulls a junk-spelling key that is ALREADY journaled under that exact spelling", async () => {
@@ -4616,7 +4665,7 @@ describe("junk key-spelling guard (US-002 mixed-version amplifier)", () => {
         // Junk twin still gated; the canonical journal entry tombstones out.
         expect(events.filter((e) => e.type === "skip-junk-key-spelling")).toHaveLength(1);
         expect(result.filesTombstoned).toBe(1);
-        const journalAfter = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journalAfter = journalAt(journalPath);
         expect(Object.keys(journalAfter.files)).not.toContain(canonicalKey);
     });
     it("always downloads a CANONICAL remote key even when the journal holds only its junk twin (post-doctor convergence)", async () => {
@@ -4633,7 +4682,7 @@ describe("junk key-spelling guard (US-002 mixed-version amplifier)", () => {
         expect(vi.mocked(s3Module.downloadFile)).toHaveBeenCalledTimes(1);
         expect(vi.mocked(s3Module.downloadFile).mock.calls[0][1]).toBe(canonicalKey);
         expect(result.filesDownloaded).toBe(1);
-        const journalAfter = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journalAfter = journalAt(journalPath);
         expect(Object.keys(journalAfter.files)).toContain(canonicalKey);
     });
     it("does not tombstone a journaled canonical key when the LIST holds only its junk twin", async () => {
@@ -4649,7 +4698,7 @@ describe("junk key-spelling guard (US-002 mixed-version amplifier)", () => {
         const { events, result } = await runSync();
         // Junk twin skipped, canonical entry NOT tombstoned.
         expect(events.filter((e) => e.type === "skip-junk-key-spelling")).toHaveLength(1);
-        const journalAfter = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+        const journalAfter = journalAt(journalPath);
         expect(Object.keys(journalAfter.files)).toContain(canonicalKey);
         expect(result.filesTombstoned ?? 0).toBe(0);
         expect(events.filter((e) => e.type === "error")).toHaveLength(0);