@indigoai-us/hq-cloud 6.14.50 → 6.15.1

package/src/journal.test.ts

@@ -1,968 +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 } 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,
-  listJournals,
-  markLocalDeleteIntent,
-} from "./journal.js";
-import type { SyncJournal, PullRecord } from "./types.js";
-
-describe("journal", () => {
-  let stateDir: string;
-
-  beforeEach(() => {
-    stateDir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-journal-test-"));
-    process.env.HQ_STATE_DIR = stateDir;
-  });
-
-  afterEach(() => {
-    fs.rmSync(stateDir, { recursive: true, force: true });
-    delete process.env.HQ_STATE_DIR;
-  });
-
-  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("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("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: SyncJournal = {
-        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: SyncJournal = {
-        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("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 refreshes the compatibility mirror", () => {
-      const initial: SyncJournal = { version: "2", lastSync: "one", files: {}, pulls: [] };
-      writeJournal("indigo", initial);
-      const locator = fs.readFileSync(getJournalPath("indigo"));
-
-      writeJournal("indigo", { version: "2", lastSync: "two", files: {}, pulls: [] });
-
-      expect(fs.readFileSync(getJournalPath("indigo"))).not.toEqual(locator);
-      expect(
-        JSON.parse(fs.readFileSync(getJournalPath("indigo"), "utf8")) as SyncJournal,
-      ).toMatchObject({ version: "2", lastSync: "two" });
-      expect(readJournal("indigo").lastSync).toBe("two");
-    });
-  });
-
-  describe("updateEntry", () => {
-    it("stamps lastSync and the per-file syncedAt", () => {
-      const j: SyncJournal = { 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: SyncJournal = { 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: SyncJournal = { 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: SyncJournal = { 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: SyncJournal = { version: "1", lastSync: "", files: {} };
-      migrateToV2(j);
-      expect(j.version).toBe("2");
-      expect(j.pulls).toEqual([]);
-    });
-
-    it("is idempotent on a v2 journal", () => {
-      const j: SyncJournal = {
-        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: SyncJournal = {
-        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: {} });
-      const raw = JSON.parse(
-        fs.readFileSync(getJournalPath("indigo"), "utf-8"),
-      ) as SyncJournal;
-      expect(raw.version).toBe("2");
-      expect(raw.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: SyncJournal = {
-        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();
-    });
-  });
-
-  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: SyncJournal = {
-        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: SyncJournal = {
-        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: SyncJournal = {
-        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: SyncJournal = {
-        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: Partial<PullRecord>): PullRecord {
-      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: SyncJournal = { 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: SyncJournal = {
-        version: "2",
-        lastSync: "",
-        files: {},
-        pulls: [],
-      };
-      expect(lastPullRecord(j, "cmp_indigo")).toBeUndefined();
-    });
-
-    it("lastPullRecord returns the most-recent by completedAt", () => {
-      const j: SyncJournal = {
-        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: SyncJournal = {
-        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: SyncJournal = {
-        version: "2",
-        lastSync: "",
-        files: {},
-        pulls: [],
-      };
-      const completedAt = (n: number) =>
-        `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: SyncJournal = {
-        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: SyncJournal = {
-        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: SyncJournal = {
-        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: SyncJournal = {
-        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: SyncJournal = {
-        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: SyncJournal = {
-        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 = (): SyncJournal => ({
-      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: SyncJournal = {
-        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: SyncJournal = {
-      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: string, files: SyncJournal["files"]): void {
-      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 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"]);
-    });
-  });
-});