@indigoai-us/hq-cloud 6.18.44-alpha.9 → 6.18.44

package/dist/journal.test.js

@@ -1,1074 +0,0 @@
-/**
- * Unit tests for the sync journal (ADR-0001 Phase 5).
- *
- * Verifies per-company isolation, HQ_STATE_DIR override, and filename
- * sanitization — all behaviors that the pre-Phase-5 monolithic journal
- * didn't need.
- */
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { getJournalPath, getStateDir, readJournal, writeJournal, updateEntry, PrematureJournalEntryError, migrateToV2, normalizeJournalKeys, appendPullRecord, lastPullRecord, tombstoneEntry, isTombstone, gcTombstones, generatePullId, TOMBSTONE_TTL_MS, MAX_PULLS_PER_COMPANY, PERSONAL_VAULT_JOURNAL_SLUG, migratePersonalVaultJournal, repairJournalStateIfNeeded, listJournals, listJournalSlugs, markLocalDeleteIntent, journalRows, journalCacheMetric, JOURNAL_DECODE_WINDOW, resetJournalDecodeWindowForTest, setJournalSnapshotEncoderForTest, getScopedJournalStoreSession, disposeScopedJournalStores, } from "./journal.js";
-import { StateStore } from "./sync/state-store.js";
-describe("journal", () => {
-    let stateDir;
-    beforeEach(() => {
-        stateDir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-journal-test-"));
-        process.env.HQ_STATE_DIR = stateDir;
-    });
-    afterEach(() => {
-        disposeScopedJournalStores();
-        fs.rmSync(stateDir, { recursive: true, force: true });
-        delete process.env.HQ_STATE_DIR;
-    });
-    it("bounds scoped journal sessions and disposes the least recently used store", () => {
-        disposeScopedJournalStores();
-        const storeA = getScopedJournalStoreSession("lru-a");
-        const storeB = getScopedJournalStoreSession("lru-b");
-        getScopedJournalStoreSession("lru-c");
-        getScopedJournalStoreSession("lru-d");
-        const disposeB = vi.spyOn(storeB, "dispose");
-        // Refresh A's recency. Opening E must evict B, the oldest unused store.
-        expect(getScopedJournalStoreSession("lru-a")).toBe(storeA);
-        getScopedJournalStoreSession("lru-e");
-        expect(disposeB).toHaveBeenCalledOnce();
-        expect(getScopedJournalStoreSession("lru-a")).toBe(storeA);
-        expect(getScopedJournalStoreSession("lru-b")).not.toBe(storeB);
-    });
-    describe("getStateDir", () => {
-        it("honors HQ_STATE_DIR env var", () => {
-            expect(getStateDir()).toBe(stateDir);
-        });
-        it("falls back to ~/.hq when env var unset", () => {
-            delete process.env.HQ_STATE_DIR;
-            expect(getStateDir()).toBe(path.join(os.homedir(), ".hq"));
-        });
-    });
-    describe("record journal rows", () => {
-        it("does not enumerate inherited legacy record rows", () => {
-            const inherited = {
-                hash: "inherited",
-                size: 1,
-                syncedAt: "2026-09-13T00:00:00.000Z",
-                direction: "down",
-            };
-            const own = {
-                hash: "own",
-                size: 2,
-                syncedAt: "2026-09-13T00:00:00.000Z",
-                direction: "up",
-            };
-            const files = Object.create({ "inherited.md": inherited });
-            files["own.md"] = own;
-            const rows = journalRows({ version: "2", lastSync: "", files, pulls: [] });
-            expect(rows.size).toBe(1);
-            expect([...rows.keys()]).toEqual(["own.md"]);
-            expect([...rows.entries()]).toEqual([["own.md", own]]);
-            expect([...rows.values()]).toEqual([own]);
-        });
-        it("walks a journal larger than the decode window without retaining more than 10k rows", () => {
-            const rowCount = JOURNAL_DECODE_WINDOW + 2_000;
-            const files = {};
-            for (let index = 0; index < rowCount; index++) {
-                files[`tree/${index.toString().padStart(6, "0")}.md`] = {
-                    hash: index.toString(16).padStart(64, "0"),
-                    size: index,
-                    syncedAt: "2026-09-19T00:00:00.000Z",
-                    direction: "up",
-                    kind: "file",
-                    mtimeMs: 1_700_000_000_000 + index,
-                    ctimeMs: 1_700_000_000_001 + index,
-                };
-            }
-            writeJournal("decode-window", { version: "2", lastSync: "", files, pulls: [] });
-            resetJournalDecodeWindowForTest();
-            const journal = readJournal("decode-window");
-            let visited = 0;
-            for (const [, entry] of journalRows(journal).entries()) {
-                expect(entry.size).toBe(visited);
-                visited += 1;
-            }
-            const metric = journalCacheMetric();
-            expect(visited).toBe(rowCount);
-            expect(journalRows(journal).size).toBe(rowCount);
-            expect(metric.peakRowsInFlight).toBeLessThanOrEqual(JOURNAL_DECODE_WINDOW);
-            expect(journalRows(journal).get("tree/000000.md")?.size).toBe(0);
-            expect(journalRows(journal).get(`tree/${(rowCount - 1).toString().padStart(6, "0")}.md`)?.size).toBe(rowCount - 1);
-        }, 60_000);
-    });
-    describe("getJournalPath", () => {
-        it("produces a per-slug filename", () => {
-            expect(getJournalPath("indigo")).toBe(path.join(stateDir, "sync-journal.indigo.json"));
-        });
-        it("isolates different slugs into different files", () => {
-            expect(getJournalPath("indigo")).not.toBe(getJournalPath("brandstage"));
-        });
-        it("sanitizes path-unsafe characters", () => {
-            expect(getJournalPath("foo/bar")).toBe(path.join(stateDir, "sync-journal.foo_bar.json"));
-            expect(getJournalPath("../escape")).toBe(path.join(stateDir, "sync-journal.___escape.json"));
-        });
-        it("throws on empty slug", () => {
-            expect(() => getJournalPath("")).toThrow(/slug is required/);
-        });
-        it("throws on slug that sanitizes to empty", () => {
-            expect(() => getJournalPath("///")).toThrow(/empty identifier/);
-        });
-    });
-    describe("listJournalSlugs", () => {
-        it("discovers locator slugs without opening their aggregate journal state", () => {
-            fs.writeFileSync(getJournalPath("healthy"), "{not valid JSON");
-            fs.writeFileSync(getJournalPath("area-corrupt"), "{also not valid JSON");
-            expect(listJournalSlugs()).toEqual(["area-corrupt", "healthy"]);
-        });
-    });
-    describe("readJournal", () => {
-        it("returns an empty v2 journal when the file doesn't exist", () => {
-            const j = readJournal("indigo");
-            expect(j.version).toBe("2");
-            expect(j.files).toEqual({});
-            expect(j.lastSync).toBe("");
-            expect(j.pulls).toEqual([]);
-        });
-        it("reads a journal written with writeJournal (round-trips through v2 migration)", () => {
-            // writeJournal upgrades the schema in-place to v2, so the read side
-            // sees v2 even if the caller handed a v1 shape.
-            const original = {
-                version: "1",
-                lastSync: "2026-04-19T00:00:00.000Z",
-                files: {
-                    "docs/handoff.md": {
-                        hash: "abc123",
-                        size: 42,
-                        syncedAt: "2026-04-19T00:00:00.000Z",
-                        direction: "down",
-                    },
-                },
-            };
-            writeJournal("indigo", original);
-            const roundTripped = readJournal("indigo");
-            expect(roundTripped.version).toBe("2");
-            expect(roundTripped.lastSync).toBe("2026-04-19T00:00:00.000Z");
-            expect(roundTripped.files).toEqual(original.files);
-            expect(roundTripped.pulls).toEqual([]);
-        });
-        it("migrates a torn v2 primary from its last-good copy into the v3 state store", () => {
-            const lastGood = {
-                version: "2",
-                lastSync: "2026-06-18T00:00:00.000Z",
-                files: {
-                    "docs/stable.md": {
-                        hash: "last-good-hash",
-                        size: 128,
-                        syncedAt: "2026-06-18T00:00:00.000Z",
-                        direction: "down",
-                    },
-                },
-                pulls: [],
-            };
-            fs.writeFileSync(getJournalPath("indigo"), '{"version":"2","files":');
-            fs.writeFileSync(`${getJournalPath("indigo")}.last-good`, JSON.stringify(lastGood));
-            const recovered = readJournal("indigo");
-            expect(recovered.version).toBe("2");
-            expect(recovered.lastSync).toBe(lastGood.lastSync);
-            expect(recovered.files["docs/stable.md"]).toEqual(lastGood.files["docs/stable.md"]);
-            expect(recovered.pulls).toEqual([]);
-        });
-        it("replays full-journal WAL records written by pre-delta releases", () => {
-            const legacy = StateStore.open({
-                rootDir: stateDir,
-                scopeId: "journal:indigo",
-                initialState: {
-                    journal: { version: "2", lastSync: "initial", files: {}, pulls: [] },
-                },
-                reduce: (_state, record) => record.payload,
-            });
-            legacy.append(1, {
-                journal: {
-                    version: "2",
-                    lastSync: "legacy-full-record",
-                    files: {
-                        "knowledge/legacy.md": {
-                            hash: "legacy",
-                            size: 6,
-                            syncedAt: "2026-08-17T00:00:00.000Z",
-                            direction: "down",
-                        },
-                    },
-                    pulls: [],
-                },
-            });
-            expect(readJournal("indigo")).toMatchObject({
-                lastSync: "legacy-full-record",
-                files: { "knowledge/legacy.md": { hash: "legacy" } },
-            });
-        });
-        it("auto-repairs old full records before publishing rollback-readable updates", () => {
-            const files = Object.fromEntries(Array.from({ length: 400 }, (_, index) => [
-                `knowledge/${index}.md`,
-                {
-                    hash: `hash-${index}-${"x".repeat(64)}`,
-                    size: index,
-                    syncedAt: "2026-08-17T00:00:00.000Z",
-                    direction: "down",
-                    remoteEtag: `etag-${index}`,
-                    kind: "file",
-                },
-            ]));
-            const legacyJournal = {
-                version: "2",
-                lastSync: "legacy",
-                files,
-                pulls: [],
-            };
-            const legacy = StateStore.open({
-                rootDir: stateDir,
-                scopeId: "journal:indigo",
-                initialState: { journal: { version: "2", lastSync: "initial", files: {}, pulls: [] } },
-                maxWalBytesBeforeCompaction: 1024 * 1024,
-                reduce: (_state, record) => record.payload,
-            });
-            legacy.append(1, { journal: legacyJournal });
-            const result = repairJournalStateIfNeeded("indigo", {
-                maxWalBytesBeforeCompaction: 32 * 1024,
-            });
-            expect(result.status).toBe("repaired");
-            expect(readJournal("indigo")).toEqual(legacyJournal);
-            const changed = structuredClone(legacyJournal);
-            changed.lastSync = "delta";
-            changed.files["knowledge/10.md"] = { ...changed.files["knowledge/10.md"], hash: "updated" };
-            delete changed.files["knowledge/399.md"];
-            writeJournal("indigo", changed);
-            expect(readJournal("indigo")).toEqual(changed);
-            // The legacy path is a locator, not a copy of the journal: the store is
-            // the only authority, and this file exists so `listJournals` can still
-            // enumerate slugs it cannot recover from a digest-named directory.
-            expect(JSON.parse(fs.readFileSync(getJournalPath("indigo"), "utf8"))).toMatchObject({ schema: "hq-sync-journal-locator@1", slug: "indigo" });
-            const storeDir = path.dirname(fs.readdirSync(path.join(stateDir, "sync-state-v3"), { recursive: true })
-                .map(String)
-                .map((name) => path.join(stateDir, "sync-state-v3", name))
-                .find((name) => /snapshot-\d+\.bin$/.test(name)));
-            expect(fs.readdirSync(storeDir).filter((name) => name.startsWith("snapshot-"))).toHaveLength(2);
-            expect(fs.readdirSync(storeDir).filter((name) => name.startsWith("wal-"))).toHaveLength(2);
-        });
-        it("R-F08: surfaces primary IO errors instead of masking them with last-good", () => {
-            const journalPath = getJournalPath("indigo");
-            fs.mkdirSync(journalPath);
-            expect(() => readJournal("indigo")).toThrow(/EISDIR|directory/i);
-        });
-    });
-    describe("writeJournal", () => {
-        it("creates the state directory if it doesn't exist", () => {
-            const nestedDir = path.join(stateDir, "nested", "deep");
-            process.env.HQ_STATE_DIR = nestedDir;
-            expect(fs.existsSync(nestedDir)).toBe(false);
-            writeJournal("indigo", { version: "1", lastSync: "", files: {} });
-            expect(fs.existsSync(nestedDir)).toBe(true);
-            expect(fs.existsSync(path.join(nestedDir, "sync-journal.indigo.json"))).toBe(true);
-        });
-        it("keeps per-company journals independent", () => {
-            writeJournal("indigo", {
-                version: "1",
-                lastSync: "",
-                files: { "a.md": { hash: "1", size: 1, syncedAt: "", direction: "up" } },
-            });
-            writeJournal("brandstage", {
-                version: "1",
-                lastSync: "",
-                files: { "b.md": { hash: "2", size: 2, syncedAt: "", direction: "up" } },
-            });
-            const indigo = readJournal("indigo");
-            const brandstage = readJournal("brandstage");
-            expect(indigo.files).toHaveProperty("a.md");
-            expect(indigo.files).not.toHaveProperty("b.md");
-            expect(brandstage.files).toHaveProperty("b.md");
-            expect(brandstage.files).not.toHaveProperty("a.md");
-        });
-        it("migrates once, appends authoritative updates, and leaves the locator alone", () => {
-            const initial = { version: "2", lastSync: "one", files: {}, pulls: [] };
-            writeJournal("indigo", initial);
-            const locator = fs.readFileSync(getJournalPath("indigo"));
-            writeJournal("indigo", { version: "2", lastSync: "two", files: {}, pulls: [] });
-            // The locator is immutable content, so an update must not rewrite it.
-            // This used to be a full copy of the journal, republished on every write
-            // — 178 MB a time on a large vault, three times a minute.
-            expect(fs.readFileSync(getJournalPath("indigo"))).toEqual(locator);
-            expect(locator.byteLength).toBeLessThan(4096);
-            // The update itself still lands, in the store where it belongs.
-            expect(readJournal("indigo").lastSync).toBe("two");
-        });
-        it("publishes header-only generations readable by the rollback reducer", () => {
-            // This pins the old v3 delta-reader contract independently of the new
-            // production HQSNAP4 writer. The dedicated writer tests cover v4.
-            setJournalSnapshotEncoderForTest(null);
-            try {
-                const files = Object.fromEntries(Array.from({ length: 1_000 }, (_, index) => [
-                    `knowledge/${index}.md`,
-                    { hash: `hash-${index}`, size: index, syncedAt: "2026-08-17T00:00:00.000Z", direction: "up" },
-                ]));
-                const initial = {
-                    version: "2",
-                    lastSync: "one",
-                    files,
-                    pulls: [],
-                };
-                writeJournal("indigo", initial);
-                const changed = structuredClone(initial);
-                changed.lastSync = "two";
-                changed.files["knowledge/500.md"] = {
-                    hash: "changed",
-                    size: 500,
-                    syncedAt: "2026-08-17T00:01:00.000Z",
-                    direction: "down",
-                };
-                delete changed.files["knowledge/999.md"];
-                writeJournal("indigo", changed);
-                const storeRoot = path.join(stateDir, "sync-state-v3");
-                const storeDir = path.join(storeRoot, fs.readdirSync(storeRoot)[0]);
-                const walSizes = fs.readdirSync(storeDir)
-                    .filter((name) => /^wal-\d+\.bin$/.test(name))
-                    .map((name) => fs.statSync(path.join(storeDir, name)).size);
-                // The update is a delta APPENDED to the WAL, so the WAL carries a record
-                // rather than staying at its 80-byte header. That inversion is the whole
-                // change: a header-only WAL meant every update had republished the entire
-                // state as a fresh snapshot instead.
-                expect(walSizes.some((size) => size > 80)).toBe(true);
-                expect(readJournal("indigo")).toEqual(changed);
-                // A reader that understands ONLY the old full-state record type can no
-                // longer follow this journal. That is the deliberate trade: those client
-                // versions are no longer supported, and refusing to emit deltas for them
-                // is what cost a full snapshot per update. Asserted rather than dropped,
-                // so the day someone needs that compatibility back this test says why it
-                // went and what re-enabling it would mean.
-                expect(() => StateStore.open({
-                    rootDir: stateDir,
-                    scopeId: "journal:indigo",
-                    initialState: { journal: { version: "2", lastSync: "", files: {}, pulls: [] } },
-                    reduce: (_state, record) => {
-                        if (record.type !== 1)
-                            throw new Error(`rollback reader rejects type ${record.type}`);
-                        return record.payload;
-                    },
-                })).toThrow(/rejects type 2|reducer rejected/);
-            }
-            finally {
-                setJournalSnapshotEncoderForTest(undefined);
-            }
-        });
-    });
-    describe("updateEntry", () => {
-        it("stamps lastSync and the per-file syncedAt", () => {
-            const j = { version: "1", lastSync: "", files: {} };
-            const abs = path.join(stateDir, "foo.md");
-            fs.writeFileSync(abs, "x");
-            updateEntry(j, "foo.md", "hash", 10, "up", abs);
-            expect(j.files["foo.md"]?.hash).toBe("hash");
-            expect(j.files["foo.md"]?.direction).toBe("up");
-            expect(j.lastSync).not.toBe("");
-            expect(j.files["foo.md"]?.syncedAt).not.toBe("");
-        });
-        // Load-bearing once delete propagation authorizes on ETag currency alone:
-        // an entry whose file was never written is indistinguishable from "the
-        // user deleted this", and the next push would issue a remote DeleteObject
-        // for what was only premature bookkeeping.
-        it("refuses to journal a path that is not on disk", () => {
-            const j = { version: "1", lastSync: "", files: {} };
-            const missing = path.join(stateDir, "never-written.md");
-            expect(() => updateEntry(j, "never-written.md", "hash", 10, "down", missing)).toThrow(PrematureJournalEntryError);
-            expect(j.files).not.toHaveProperty("never-written.md");
-            expect(j.lastSync).toBe("");
-        });
-        it("accepts a dangling symlink — the link itself is the synced object", () => {
-            const j = { version: "1", lastSync: "", files: {} };
-            const link = path.join(stateDir, "dangling-link");
-            fs.symlinkSync(path.join(stateDir, "no-such-target"), link);
-            expect(() => updateEntry(j, "dangling-link", "hash", 0, "down", link, { kind: "symlink" })).not.toThrow();
-            expect(j.files["dangling-link"]?.kind).toBe("symlink");
-        });
-        // Regression: `kind` and `createdBySub` were adjacent trailing optionals
-        // and two call sites passed kind into the createdBySub slot, leaving
-        // entry.kind unset. entry.kind gates delete-intent minting, so those
-        // entries could never be deleted. Named options make it unrepresentable.
-        it("records kind and createdBySub into their own fields", () => {
-            const j = { version: "1", lastSync: "", files: {} };
-            const abs = path.join(stateDir, "typed.md");
-            fs.writeFileSync(abs, "x");
-            updateEntry(j, "typed.md", "hash", 1, "down", abs, {
-                kind: "file",
-                createdBySub: "sub-123",
-            });
-            expect(j.files["typed.md"]?.kind).toBe("file");
-            expect(j.files["typed.md"]?.createdBySub).toBe("sub-123");
-        });
-    });
-    // ── Journal v2 (US-005): pulls, tombstones, GC, migration ─────────────────
-    describe("migrateToV2", () => {
-        it("upgrades a v1 journal in place", () => {
-            const j = { version: "1", lastSync: "", files: {} };
-            migrateToV2(j);
-            expect(j.version).toBe("2");
-            expect(j.pulls).toEqual([]);
-        });
-        it("is idempotent on a v2 journal", () => {
-            const j = {
-                version: "2",
-                lastSync: "",
-                files: {},
-                pulls: [],
-            };
-            const before = JSON.stringify(j);
-            migrateToV2(j);
-            expect(JSON.stringify(j)).toBe(before);
-        });
-        it("preserves all files when migrating v1 → v2", () => {
-            const j = {
-                version: "1",
-                lastSync: "2026-05-01",
-                files: {
-                    "a.md": {
-                        hash: "h",
-                        size: 1,
-                        syncedAt: "2026-05-01",
-                        direction: "down",
-                    },
-                },
-            };
-            migrateToV2(j);
-            expect(j.files["a.md"]).toBeDefined();
-            expect(j.files["a.md"]?.removedAt).toBeUndefined(); // not a tombstone
-        });
-        it("writeJournal upgrades v1 → v2 on disk", () => {
-            writeJournal("indigo", { version: "1", lastSync: "", files: {} });
-            // Read back through the store, which is where the journal now lives; the
-            // legacy path holds only a locator.
-            const stored = readJournal("indigo");
-            expect(stored.version).toBe("2");
-            expect(stored.pulls).toEqual([]);
-        });
-        it("normalizes backslash keys even on an already-v2 journal", () => {
-            // The landmine predates the v2 bump, so a poisoned journal can be v2.
-            // migrateToV2's early-return must not skip normalization.
-            const j = {
-                version: "2",
-                lastSync: "",
-                files: {
-                    "projects\\forecast\\x.csv": {
-                        hash: "h",
-                        size: 1,
-                        syncedAt: "2026-06-10",
-                        direction: "down",
-                    },
-                },
-                pulls: [],
-            };
-            migrateToV2(j);
-            expect(j.files["projects\\forecast\\x.csv"]).toBeUndefined();
-            expect(j.files["projects/forecast/x.csv"]).toBeDefined();
-        });
-        it("normalizes an existing backslash key when an unrelated store-backed journal write occurs", () => {
-            const malformed = {
-                version: "2",
-                lastSync: "",
-                files: {
-                    "projects\\forecast\\x.csv": {
-                        hash: "malformed",
-                        size: 1,
-                        syncedAt: "2026-06-10",
-                        direction: "down",
-                    },
-                },
-                pulls: [],
-            };
-            const legacy = StateStore.open({
-                rootDir: stateDir,
-                scopeId: "journal:indigo",
-                initialState: { journal: { version: "2", lastSync: "", files: {}, pulls: [] } },
-                reduce: (_state, record) => record.payload,
-            });
-            legacy.append(1, { journal: malformed });
-            const loaded = readJournal("indigo");
-            loaded.files["docs/unrelated.md"] = {
-                hash: "unrelated",
-                size: 2,
-                syncedAt: "2026-06-10",
-                direction: "down",
-            };
-            writeJournal("indigo", loaded);
-            const persisted = readJournal("indigo");
-            expect(persisted.files["projects\\forecast\\x.csv"]).toBeUndefined();
-            expect(persisted.files["projects/forecast/x.csv"]).toMatchObject({ hash: "malformed" });
-            expect(persisted.files["docs/unrelated.md"]).toMatchObject({ hash: "unrelated" });
-        });
-    });
-    describe("normalizeJournalKeys (Windows backslash-key landmine — ridge data loss)", () => {
-        // Regression for feedback_b8d09d0f: pre-5.47.2 Windows clients stamped
-        // journal keys with path.sep ("\\"). Those keys never match the
-        // forward-slash remote LIST, so the cross-machine delete planner classed
-        // live local files as remote-deleted and path.join collapsed the key back
-        // onto the real file — deleting ~36 live files in a single pull. The
-        // canonical defense is rewriting every key to POSIX form on load.
-        it("rewrites backslash keys to POSIX form and reports the count", () => {
-            const j = {
-                version: "2",
-                lastSync: "",
-                files: {
-                    "projects\\forecast-development\\forecasts\\sean-frank.csv": {
-                        hash: "h1",
-                        size: 10,
-                        syncedAt: "2026-06-10",
-                        direction: "down",
-                    },
-                    "docs\\notes.md": {
-                        hash: "h2",
-                        size: 5,
-                        syncedAt: "2026-06-10",
-                        direction: "down",
-                    },
-                },
-                pulls: [],
-            };
-            const rewritten = normalizeJournalKeys(j);
-            expect(rewritten).toBe(2);
-            expect(j.files["projects/forecast-development/forecasts/sean-frank.csv"]).toBeDefined();
-            expect(j.files["docs/notes.md"]).toBeDefined();
-            // No malformed keys survive.
-            expect(Object.keys(j.files).some((k) => k.includes("\\"))).toBe(false);
-            // Entry payload is preserved verbatim under the new key.
-            expect(j.files["docs/notes.md"]?.hash).toBe("h2");
-        });
-        it("leaves a clean (all-POSIX) journal untouched and returns 0", () => {
-            const j = {
-                version: "2",
-                lastSync: "",
-                files: {
-                    "docs/a.md": { hash: "h", size: 1, syncedAt: "x", direction: "down" },
-                },
-                pulls: [],
-            };
-            const before = JSON.stringify(j);
-            const rewritten = normalizeJournalKeys(j);
-            expect(rewritten).toBe(0);
-            expect(JSON.stringify(j)).toBe(before);
-        });
-        it("prefers an existing POSIX twin and drops the malformed duplicate", () => {
-            // When both forms exist, the POSIX entry is authoritative (it round-
-            // tripped through an up-to-date client). The malformed dup is discarded.
-            const j = {
-                version: "2",
-                lastSync: "",
-                files: {
-                    "docs/a.md": {
-                        hash: "posix-wins",
-                        size: 1,
-                        syncedAt: "x",
-                        direction: "down",
-                    },
-                    "docs\\a.md": {
-                        hash: "backslash-loses",
-                        size: 2,
-                        syncedAt: "x",
-                        direction: "down",
-                    },
-                },
-                pulls: [],
-            };
-            normalizeJournalKeys(j);
-            expect(j.files["docs\\a.md"]).toBeUndefined();
-            expect(j.files["docs/a.md"]?.hash).toBe("posix-wins");
-        });
-        it("is idempotent — a second pass rewrites nothing", () => {
-            const j = {
-                version: "2",
-                lastSync: "",
-                files: {
-                    "a\\b\\c.txt": { hash: "h", size: 1, syncedAt: "x", direction: "down" },
-                },
-                pulls: [],
-            };
-            expect(normalizeJournalKeys(j)).toBe(1);
-            expect(normalizeJournalKeys(j)).toBe(0);
-            expect(j.files["a/b/c.txt"]).toBeDefined();
-        });
-    });
-    describe("generatePullId", () => {
-        it("produces a 26-char identifier", () => {
-            expect(generatePullId()).toHaveLength(26);
-        });
-        it("is time-prefixed and lexically sortable", () => {
-            const t0 = Date.parse("2026-01-01T00:00:00.000Z");
-            const t1 = Date.parse("2026-06-01T00:00:00.000Z");
-            const id0 = generatePullId(t0);
-            const id1 = generatePullId(t1);
-            expect(id0 < id1).toBe(true);
-        });
-        it("uses crockford base32 alphabet (no I, L, O, U)", () => {
-            const id = generatePullId();
-            expect(id).toMatch(/^[0-9A-HJKMNP-TV-Z]+$/);
-        });
-    });
-    describe("appendPullRecord + lastPullRecord", () => {
-        function pull(partial) {
-            return {
-                pullId: generatePullId(),
-                companyUid: "cmp_indigo",
-                startedAt: "2026-05-20T00:00:00.000Z",
-                completedAt: "2026-05-20T00:00:05.000Z",
-                syncMode: "all",
-                prefixSet: [],
-                scopeChangeDetected: false,
-                orphansRemoved: 0,
-                orphansBlocked: 0,
-                ...partial,
-            };
-        }
-        it("appends to pulls[] (auto-migrates v1)", () => {
-            const j = { version: "1", lastSync: "", files: {} };
-            appendPullRecord(j, pull({}));
-            expect(j.version).toBe("2");
-            expect(j.pulls).toHaveLength(1);
-        });
-        it("lastPullRecord returns undefined when no records exist", () => {
-            const j = {
-                version: "2",
-                lastSync: "",
-                files: {},
-                pulls: [],
-            };
-            expect(lastPullRecord(j, "cmp_indigo")).toBeUndefined();
-        });
-        it("lastPullRecord returns the most-recent by completedAt", () => {
-            const j = {
-                version: "2",
-                lastSync: "",
-                files: {},
-                pulls: [
-                    pull({ completedAt: "2026-05-19T00:00:00.000Z", syncMode: "all" }),
-                    pull({ completedAt: "2026-05-20T00:00:00.000Z", syncMode: "shared" }),
-                    pull({ completedAt: "2026-05-18T00:00:00.000Z", syncMode: "all" }),
-                ],
-            };
-            expect(lastPullRecord(j, "cmp_indigo")?.syncMode).toBe("shared");
-        });
-        it("lastPullRecord filters by companyUid", () => {
-            const j = {
-                version: "2",
-                lastSync: "",
-                files: {},
-                pulls: [
-                    pull({ companyUid: "cmp_a", completedAt: "2026-05-20T00:00:00.000Z" }),
-                    pull({ companyUid: "cmp_b", completedAt: "2026-05-21T00:00:00.000Z" }),
-                ],
-            };
-            expect(lastPullRecord(j, "cmp_a")?.completedAt).toBe("2026-05-20T00:00:00.000Z");
-        });
-        it("bounds pulls per company and preserves newest lastPullRecord", () => {
-            const j = {
-                version: "2",
-                lastSync: "",
-                files: {},
-                pulls: [],
-            };
-            const completedAt = (n) => `2026-05-20T00:00:${String(n).padStart(2, "0")}.000Z`;
-            for (let i = 0; i < MAX_PULLS_PER_COMPANY + 5; i++) {
-                appendPullRecord(j, pull({
-                    pullId: `pull-a-${String(i).padStart(2, "0")}`,
-                    companyUid: "cmp_a",
-                    completedAt: completedAt(i),
-                }));
-            }
-            for (let i = 0; i < 3; i++) {
-                appendPullRecord(j, pull({
-                    pullId: `pull-b-${i}`,
-                    companyUid: "cmp_b",
-                    completedAt: completedAt(i),
-                }));
-            }
-            const pulls = j.pulls ?? [];
-            const companyA = pulls.filter((p) => p.companyUid === "cmp_a");
-            const companyB = pulls.filter((p) => p.companyUid === "cmp_b");
-            expect(companyA).toHaveLength(MAX_PULLS_PER_COMPANY);
-            expect(companyB).toHaveLength(3);
-            expect(companyA[0].pullId).toBe("pull-a-05");
-            expect(companyA.at(-1)?.pullId).toBe("pull-a-54");
-            expect(companyA.some((p) => p.pullId === "pull-a-00")).toBe(false);
-            expect(lastPullRecord(j, "cmp_a")?.pullId).toBe("pull-a-54");
-            expect(lastPullRecord(j, "cmp_b")?.pullId).toBe("pull-b-2");
-        });
-    });
-    describe("tombstoneEntry + isTombstone", () => {
-        it("marks an entry with removedAt + removedReason", () => {
-            const j = {
-                version: "2",
-                lastSync: "",
-                files: {
-                    "a.md": {
-                        hash: "h",
-                        size: 1,
-                        syncedAt: "2026-05-01T00:00:00.000Z",
-                        direction: "down",
-                    },
-                },
-                pulls: [],
-            };
-            tombstoneEntry(j, "a.md", "scope_shrink", "2026-05-20T00:00:00.000Z");
-            expect(j.files["a.md"]?.removedAt).toBe("2026-05-20T00:00:00.000Z");
-            expect(j.files["a.md"]?.removedReason).toBe("scope_shrink");
-            expect(isTombstone(j.files["a.md"])).toBe(true);
-        });
-        it("is a no-op for missing entries", () => {
-            const j = {
-                version: "2",
-                lastSync: "",
-                files: {},
-                pulls: [],
-            };
-            expect(() => tombstoneEntry(j, "missing.md", "scope_shrink")).not.toThrow();
-        });
-        it("preserves the original hash/size/syncedAt (forensic trail)", () => {
-            const j = {
-                version: "2",
-                lastSync: "",
-                files: {
-                    "a.md": {
-                        hash: "old-hash",
-                        size: 42,
-                        syncedAt: "2026-05-01T00:00:00.000Z",
-                        direction: "down",
-                    },
-                },
-                pulls: [],
-            };
-            tombstoneEntry(j, "a.md", "scope_shrink");
-            expect(j.files["a.md"]?.hash).toBe("old-hash");
-            expect(j.files["a.md"]?.size).toBe(42);
-        });
-    });
-    describe("gcTombstones", () => {
-        it("removes tombstones older than TOMBSTONE_TTL_MS", () => {
-            const now = Date.parse("2026-06-01T00:00:00.000Z");
-            const old = new Date(now - TOMBSTONE_TTL_MS - 1000).toISOString();
-            const fresh = new Date(now - 1000).toISOString();
-            const j = {
-                version: "2",
-                lastSync: "",
-                files: {
-                    "old-tombstone.md": {
-                        hash: "h",
-                        size: 1,
-                        syncedAt: "2026-04-01T00:00:00.000Z",
-                        direction: "down",
-                        removedAt: old,
-                        removedReason: "scope_shrink",
-                    },
-                    "fresh-tombstone.md": {
-                        hash: "h",
-                        size: 1,
-                        syncedAt: "2026-05-01T00:00:00.000Z",
-                        direction: "down",
-                        removedAt: fresh,
-                        removedReason: "scope_shrink",
-                    },
-                    "live.md": {
-                        hash: "h",
-                        size: 1,
-                        syncedAt: "2026-05-01T00:00:00.000Z",
-                        direction: "down",
-                    },
-                },
-                pulls: [],
-            };
-            const removed = gcTombstones(j, now);
-            expect(removed).toBe(1);
-            expect(j.files["old-tombstone.md"]).toBeUndefined();
-            expect(j.files["fresh-tombstone.md"]).toBeDefined();
-            expect(j.files["live.md"]).toBeDefined();
-        });
-        it("never removes non-tombstone entries", () => {
-            const j = {
-                version: "2",
-                lastSync: "",
-                files: {
-                    "live.md": {
-                        hash: "h",
-                        size: 1,
-                        syncedAt: "1970-01-01T00:00:00.000Z",
-                        direction: "down",
-                    },
-                },
-                pulls: [],
-            };
-            expect(gcTombstones(j, Date.now())).toBe(0);
-            expect(j.files["live.md"]).toBeDefined();
-        });
-        it("ignores tombstones with un-parseable removedAt", () => {
-            const j = {
-                version: "2",
-                lastSync: "",
-                files: {
-                    "bogus.md": {
-                        hash: "h",
-                        size: 1,
-                        syncedAt: "",
-                        direction: "down",
-                        removedAt: "not-a-date",
-                        removedReason: "scope_shrink",
-                    },
-                },
-                pulls: [],
-            };
-            expect(gcTombstones(j, Date.now())).toBe(0);
-            expect(j.files["bogus.md"]).toBeDefined();
-        });
-    });
-    // ── Personal-vault journal-slug collision fix ──────────────────────────────
-    //
-    // Root cause: the --companies fanout's personal-vault slot journaled under
-    // the literal slug "personal", colliding with the companies/personal
-    // company (entity slug "personal"). The two targets have different sync
-    // roots, so the company's whole-tree delete-plan walked the shared
-    // sync-journal.personal.json, resolved the vault's hq-root keys against
-    // hqRoot/companies/personal (where they don't exist), tombstoned them as
-    // "remote already 404", and dropped them — only for the vault slot to
-    // re-upload them next cycle (~190 .claude/skills/* files of churn/sync).
-    describe("PERSONAL_VAULT_JOURNAL_SLUG", () => {
-        it("is decoupled from the 'personal' company slug", () => {
-            expect(PERSONAL_VAULT_JOURNAL_SLUG).not.toBe("personal");
-        });
-        it("survives sanitizeSlug unchanged (no path/dot/empty mangling)", () => {
-            // getJournalPath runs the slug through sanitizeSlug; the sentinel must
-            // pass through verbatim (it is all [a-zA-Z0-9_-] and not all [_-]).
-            expect(getJournalPath(PERSONAL_VAULT_JOURNAL_SLUG)).toBe(path.join(stateDir, `sync-journal.${PERSONAL_VAULT_JOURNAL_SLUG}.json`));
-        });
-        it("maps to a different journal file than 'personal'", () => {
-            expect(getJournalPath(PERSONAL_VAULT_JOURNAL_SLUG)).not.toBe(getJournalPath("personal"));
-        });
-    });
-    describe("migratePersonalVaultJournal", () => {
-        const legacyJournal = () => ({
-            version: "2",
-            lastSync: "2026-05-22T00:00:00.000Z",
-            files: {
-                ".claude/skills/deep-plan/SKILL.md": {
-                    hash: "abc123",
-                    size: 42,
-                    syncedAt: "2026-05-22T00:00:00.000Z",
-                    direction: "up",
-                },
-            },
-            pulls: [],
-        });
-        it("seeds the reserved slug from the legacy 'personal' journal when absent", () => {
-            writeJournal("personal", legacyJournal());
-            expect(fs.existsSync(getJournalPath(PERSONAL_VAULT_JOURNAL_SLUG))).toBe(false);
-            migratePersonalVaultJournal();
-            expect(fs.existsSync(getJournalPath(PERSONAL_VAULT_JOURNAL_SLUG))).toBe(true);
-            const seeded = readJournal(PERSONAL_VAULT_JOURNAL_SLUG);
-            // The hq-root-relative vault entry is preserved so it is NOT re-uploaded.
-            expect(seeded.files[".claude/skills/deep-plan/SKILL.md"]).toEqual(legacyJournal().files[".claude/skills/deep-plan/SKILL.md"]);
-            // Legacy journal is left intact (still used by the companies/personal company).
-            expect(fs.existsSync(getJournalPath("personal"))).toBe(true);
-        });
-        it("is idempotent — does not clobber an existing reserved-slug journal", () => {
-            // Pre-existing reserved-slug journal with distinct content.
-            const existing = {
-                version: "2",
-                lastSync: "2026-05-22T12:00:00.000Z",
-                files: {
-                    "core/keep-me.md": {
-                        hash: "keep",
-                        size: 7,
-                        syncedAt: "2026-05-22T12:00:00.000Z",
-                        direction: "up",
-                    },
-                },
-                pulls: [],
-            };
-            writeJournal(PERSONAL_VAULT_JOURNAL_SLUG, existing);
-            writeJournal("personal", legacyJournal());
-            migratePersonalVaultJournal();
-            const after = readJournal(PERSONAL_VAULT_JOURNAL_SLUG);
-            expect(after.files["core/keep-me.md"]).toBeDefined();
-            // The legacy entry was NOT copied over the existing reserved journal.
-            expect(after.files[".claude/skills/deep-plan/SKILL.md"]).toBeUndefined();
-        });
-        it("no-ops when the legacy 'personal' journal is absent", () => {
-            expect(fs.existsSync(getJournalPath("personal"))).toBe(false);
-            migratePersonalVaultJournal();
-            expect(fs.existsSync(getJournalPath(PERSONAL_VAULT_JOURNAL_SLUG))).toBe(false);
-        });
-    });
-    // Regression: `hq sync status` reported "No sync journal yet" right after a
-    // successful sync because it read one path keyed off the HQ-ROOT, while the
-    // engine writes slug-sharded journals (personal vault + per-company).
-    // `listJournals` is the all-shard enumeration the status surface now uses.
-    it("binds a local delete intent to the captured remote revision", () => {
-        const journal = {
-            version: "2",
-            lastSync: "",
-            pulls: [],
-            files: {
-                "docs/a.md": {
-                    hash: "local-hash",
-                    size: 1,
-                    syncedAt: new Date().toISOString(),
-                    direction: "down",
-                    kind: "file",
-                    remoteEtag: "new-etag",
-                },
-            },
-        };
-        expect(markLocalDeleteIntent(journal, "docs/a.md", "local-hash", "file", "old-etag")).toBe(false);
-        expect(journal.files["docs/a.md"]?.localDeleteIntent).toBeUndefined();
-        expect(markLocalDeleteIntent(journal, "docs/a.md", "local-hash", "file", "new-etag")).toBe(true);
-        expect(journal.files["docs/a.md"]?.localDeleteIntent).toMatchObject({
-            remoteEtag: "new-etag",
-            localHash: "local-hash",
-            localKind: "file",
-        });
-    });
-    describe("listJournals", () => {
-        function seed(slug, files) {
-            writeJournal(slug, {
-                version: "2",
-                lastSync: "",
-                files,
-                pulls: [],
-            });
-        }
-        it("returns [] when the state dir has no journals (truly-empty case)", () => {
-            expect(listJournals()).toEqual([]);
-        });
-        it("returns [] when the state dir does not exist at all", () => {
-            process.env.HQ_STATE_DIR = path.join(stateDir, "does-not-exist");
-            expect(listJournals()).toEqual([]);
-        });
-        it("enumerates the personal-vault shard written by a `--personal` sync", () => {
-            seed(PERSONAL_VAULT_JOURNAL_SLUG, {
-                ".claude/skills/x/SKILL.md": {
-                    hash: "a",
-                    size: 10,
-                    syncedAt: "2026-06-08T10:00:00.000Z",
-                    direction: "up",
-                },
-            });
-            const all = listJournals();
-            expect(all).toHaveLength(1);
-            expect(all[0].slug).toBe(PERSONAL_VAULT_JOURNAL_SLUG);
-            expect(all[0].path).toBe(getJournalPath(PERSONAL_VAULT_JOURNAL_SLUG));
-            expect(Object.keys(all[0].journal.files)).toContain(".claude/skills/x/SKILL.md");
-        });
-        it("enumerates a large shard without cloning its aggregate for a write baseline", () => {
-            // The runner's warm-up catch-up calls listJournals only to enumerate
-            // keys, yet listJournals went through readJournal, which memoizes a
-            // structuredClone of the whole aggregate as a delta baseline for a
-            // write that never comes. On a 100k-row vault that is a second copy of
-            // the journal on every runner start, for nothing.
-            const files = {};
-            for (let i = 0; i < 1_500; i++) {
-                files[`notes/${i}.md`] = {
-                    hash: `h${i}`,
-                    size: 1,
-                    syncedAt: "2026-06-08T10:00:00.000Z",
-                    direction: "up",
-                };
-            }
-            seed(PERSONAL_VAULT_JOURNAL_SLUG, files);
-            const clone = vi.spyOn(globalThis, "structuredClone");
-            try {
-                const all = listJournals();
-                expect(all).toHaveLength(1);
-                expect(Object.keys(all[0].journal.files)).toHaveLength(1_500);
-                for (const [value] of clone.mock.calls) {
-                    if (typeof value !== "object" || value === null)
-                        continue;
-                    const object = value;
-                    expect(Object.keys(object.files ?? object.journal?.files ?? {}).length).toBeLessThan(1_500);
-                }
-            }
-            finally {
-                clone.mockRestore();
-            }
-        });
-        it("enumerates a per-company shard written by a company sync", () => {
-            seed("marshalops", {
-                "knowledge/a.md": {
-                    hash: "b",
-                    size: 20,
-                    syncedAt: "2026-06-08T11:00:00.000Z",
-                    direction: "down",
-                },
-            });
-            const all = listJournals();
-            expect(all.map((j) => j.slug)).toEqual(["marshalops"]);
-        });
-        it("enumerates ALL shards together, sorted by slug", () => {
-            seed(PERSONAL_VAULT_JOURNAL_SLUG, {
-                ".claude/x": {
-                    hash: "a",
-                    size: 1,
-                    syncedAt: "2026-06-08T10:00:00.000Z",
-                    direction: "up",
-                },
-            });
-            seed("marshalops", {
-                "k/a": {
-                    hash: "b",
-                    size: 2,
-                    syncedAt: "2026-06-08T11:00:00.000Z",
-                    direction: "down",
-                },
-            });
-            seed("glazeymedia", {
-                "k/b": {
-                    hash: "c",
-                    size: 3,
-                    syncedAt: "2026-06-08T12:00:00.000Z",
-                    direction: "down",
-                },
-            });
-            const slugs = listJournals().map((j) => j.slug);
-            // Sorted: "__hq_personal_vault__" < "glazeymedia" < "marshalops".
-            expect(slugs).toEqual([
-                PERSONAL_VAULT_JOURNAL_SLUG,
-                "glazeymedia",
-                "marshalops",
-            ]);
-        });
-        it("skips a corrupt shard but still returns the healthy ones", () => {
-            seed("marshalops", {
-                "k/a": {
-                    hash: "b",
-                    size: 2,
-                    syncedAt: "2026-06-08T11:00:00.000Z",
-                    direction: "down",
-                },
-            });
-            fs.writeFileSync(path.join(stateDir, "sync-journal.broken.json"), "{ not valid json");
-            const all = listJournals();
-            expect(all.map((j) => j.slug)).toEqual(["marshalops"]);
-        });
-        it("R-F08: recovers a torn shard primary from .last-good in listJournals", () => {
-            seed("marshalops", {
-                "k/recovered.md": {
-                    hash: "last-good-hash",
-                    size: 2,
-                    syncedAt: "2026-06-19T11:00:00.000Z",
-                    direction: "down",
-                },
-            });
-            fs.writeFileSync(getJournalPath("marshalops"), "");
-            const all = listJournals();
-            expect(all).toHaveLength(1);
-            expect(all[0].slug).toBe("marshalops");
-            expect(all[0].journal.files["k/recovered.md"]?.hash).toBe("last-good-hash");
-        });
-        it("ignores unrelated files in the state dir", () => {
-            seed("marshalops", {});
-            fs.writeFileSync(path.join(stateDir, "config.json"), "{}");
-            fs.writeFileSync(path.join(stateDir, "sync-journal.json"), "{}"); // no slug
-            fs.writeFileSync(path.join(stateDir, "notes.txt"), "hi");
-            expect(listJournals().map((j) => j.slug)).toEqual(["marshalops"]);
-        });
-    });
-});
-//# sourceMappingURL=journal.test.js.map