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

package/dist/personal-vault.test.js

@@ -1,1099 +0,0 @@
-/**
- * Unit tests for the personal-vault path-discovery helpers.
- *
- * These cover the column-anchored `cloud: true` exclusion-marker regex and
- * the `companies/{slug}/` enumeration filter — both are pure functions over
- * disk + caller-supplied option sets, so we exercise them against tmp
- * directories rather than mocking fs. Local (non-cloud) companies sync to
- * the personal vault by DEFAULT: a missing/markerless `company.yaml` is
- * INCLUDED; only an explicit `cloud: true` marker, membership via
- * `teamSyncedSlugs`, or a `cloud_uid: cmp_*` entry in
- * `companies/manifest.yaml` opts a company out.
- *
- * The sync-runner-level integration (team-synced slug derivation,
- * decommission of cloud-promoted companies, end-to-end share() invocation)
- * lives in `bin/sync-runner.test.ts` — tests G, H, I.
- */
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { computeContinuityPointerPaths, computePersonalCompanySubdirs, computePersonalVaultPaths, readCloudBackedSlugsFromManifest, CONTINUITY_POINTER_REL, computeAgencySyncPaths, AGENCY_SYNC_REL, computeSessionLogsSyncPaths, SESSION_LOGS_SYNC_REL, PERSONAL_VAULT_COMPANY_EXCLUDED_SLUGS, PERSONAL_VAULT_EXCLUDED_TOP_LEVEL, isPersonalVaultDeletionExcluded, purgeExcludedPersonalVaultJournalEntries, PURGE_IGNORED_PRESENT_BATCH, } from "./personal-vault.js";
-describe("personal-vault helpers", () => {
-    let hqRoot;
-    beforeEach(() => {
-        hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-pv-test-"));
-    });
-    afterEach(() => {
-        fs.rmSync(hqRoot, { recursive: true, force: true });
-    });
-    /** Helper: write `companies/{slug}/company.yaml` with arbitrary content. */
-    function writeCompany(slug, yaml) {
-        const dir = path.join(hqRoot, "companies", slug);
-        fs.mkdirSync(dir, { recursive: true });
-        if (yaml !== null)
-            fs.writeFileSync(path.join(dir, "company.yaml"), yaml);
-    }
-    /** Helper: relative-paths-sorted projection of an absolute-path list. */
-    function rel(abs) {
-        return abs.map((p) => path.relative(hqRoot, p)).sort();
-    }
-    // ── Exported constants ─────────────────────────────────────────────────
-    it("constants: PERSONAL_VAULT_EXCLUDED_TOP_LEVEL keeps the canonical four directories", () => {
-        // These four are the original directory exclusions and must never be lost.
-        for (const name of [".git", "companies", "repos", "workspace"]) {
-            expect(PERSONAL_VAULT_EXCLUDED_TOP_LEVEL).toContain(name);
-        }
-    });
-    it("constants: PERSONAL_VAULT_EXCLUDED_TOP_LEVEL also excludes Node project markers", () => {
-        // An HQ root is a DATA tree, never a Node project. When one of these files
-        // lands there — an accidental `npm init`, a stray `npm install` — syncing it
-        // makes every other machine's HQ root look like a Node project too, and the
-        // outpost hygiene guard that would otherwise clean the contamination stands
-        // down on every one of them. One stray file disables the fleet's defence.
-        for (const name of [
-            "package.json",
-            "package-lock.json",
-            "pnpm-lock.yaml",
-            "yarn.lock",
-            "pnpm-workspace.yaml",
-            "node_modules",
-        ]) {
-            expect(PERSONAL_VAULT_EXCLUDED_TOP_LEVEL).toContain(name);
-        }
-    });
-    it("constants: PERSONAL_VAULT_EXCLUDED_TOP_LEVEL excludes the global-install `bin/`", () => {
-        // `npm install -g` with its prefix resolved to the HQ root writes `bin/`
-        // (symlinks into ../lib/node_modules) alongside lib/node_modules. It is
-        // neither a node_modules nor a lockfile, so every other marker above can be
-        // excluded and this debris still rides the vault to every machine — which is
-        // exactly what reached two outposts as dangling symlinks and aborted the
-        // personal vault's journal checkpoint on each sync.
-        expect(PERSONAL_VAULT_EXCLUDED_TOP_LEVEL).toContain("bin");
-    });
-    it("constants: PERSONAL_VAULT_EXCLUDED_TOP_LEVEL does NOT exclude the HQ layout trees", () => {
-        // Guard against over-broad additions: `personal/` and `core/` carry real
-        // user data and were deliberately re-INCLUDED (user directive 2026-05-13).
-        // A future "just exclude the noisy top-level dir" edit must not take them.
-        for (const name of ["personal", "core", "data"]) {
-            expect(PERSONAL_VAULT_EXCLUDED_TOP_LEVEL).not.toContain(name);
-        }
-    });
-    it("constants: PERSONAL_VAULT_COMPANY_EXCLUDED_SLUGS hard-lists `_template`", () => {
-        expect(PERSONAL_VAULT_COMPANY_EXCLUDED_SLUGS).toContain("_template");
-    });
-    // ── computePersonalCompanySubdirs: default inclusion ───────────────────
-    // Local companies sync to the personal vault by default. A missing or
-    // markerless company.yaml is INCLUDED — only an explicit `cloud: true`
-    // marker (or membership) opts a company OUT.
-    it("default: includes a company with NO company.yaml", () => {
-        writeCompany("foo", null);
-        expect(rel(computePersonalCompanySubdirs(hqRoot))).toEqual([
-            path.join("companies", "foo"),
-        ]);
-    });
-    it("default: includes a company with an empty company.yaml", () => {
-        writeCompany("foo", "");
-        expect(rel(computePersonalCompanySubdirs(hqRoot))).toEqual([
-            path.join("companies", "foo"),
-        ]);
-    });
-    it("default: includes a company explicitly marked `cloud: false`", () => {
-        writeCompany("foo", "cloud: false\nname: Foo\n");
-        expect(rel(computePersonalCompanySubdirs(hqRoot))).toEqual([
-            path.join("companies", "foo"),
-        ]);
-    });
-    it("default: includes a company.yaml with no `cloud:` key at all", () => {
-        writeCompany("foo", "name: Foo\nslug: foo\n");
-        expect(rel(computePersonalCompanySubdirs(hqRoot))).toEqual([
-            path.join("companies", "foo"),
-        ]);
-    });
-    // ── computePersonalCompanySubdirs: `cloud: true` exclusion-marker ──────
-    it("marker: excludes canonical `cloud: true` at column 0", () => {
-        writeCompany("foo", "cloud: true\nname: Foo\n");
-        expect(computePersonalCompanySubdirs(hqRoot)).toEqual([]);
-    });
-    it("marker: excludes `cloud:true` (no space after colon)", () => {
-        writeCompany("foo", "cloud:true\n");
-        expect(computePersonalCompanySubdirs(hqRoot)).toEqual([]);
-    });
-    it("marker: excludes with a trailing comment after `cloud: true`", () => {
-        writeCompany("foo", "cloud: true   # cloud-backed, synced to team bucket\n");
-        expect(computePersonalCompanySubdirs(hqRoot)).toEqual([]);
-    });
-    it("marker: excludes with CRLF line endings", () => {
-        writeCompany("foo", "cloud: true\r\nname: Foo\r\n");
-        expect(computePersonalCompanySubdirs(hqRoot)).toEqual([]);
-    });
-    it("marker: excludes `cloud: true` even when it is NOT the first line", () => {
-        writeCompany("foo", "name: Foo\nslug: foo\ncloud: true\n");
-        expect(computePersonalCompanySubdirs(hqRoot)).toEqual([]);
-    });
-    // ── computePersonalCompanySubdirs: marker fails OPEN (still included) ───
-    // A marker that isn't the canonical column-0 lowercase `cloud: true`
-    // shape `/designate-team` emits does NOT exclude — the company stays in
-    // the personal vault, which is the safe default.
-    it("marker: nested `cloud: true` does NOT exclude (column-0 anchor)", () => {
-        writeCompany("foo", "meta:\n  cloud: true\n");
-        expect(rel(computePersonalCompanySubdirs(hqRoot))).toEqual([
-            path.join("companies", "foo"),
-        ]);
-    });
-    it("marker: list-item style `- cloud: true` does NOT exclude", () => {
-        writeCompany("foo", "tags:\n- cloud: true\n");
-        expect(rel(computePersonalCompanySubdirs(hqRoot))).toEqual([
-            path.join("companies", "foo"),
-        ]);
-    });
-    it("marker: flow-mapping `{ cloud: true }` does NOT exclude", () => {
-        writeCompany("foo", "{ cloud: true }\n");
-        expect(rel(computePersonalCompanySubdirs(hqRoot))).toEqual([
-            path.join("companies", "foo"),
-        ]);
-    });
-    it("marker: YAML-alt boolean spellings (True, TRUE, yes, on) do NOT exclude", () => {
-        for (const variant of ["cloud: True\n", "cloud: TRUE\n", "cloud: yes\n", "cloud: on\n"]) {
-            writeCompany("foo", variant);
-            expect(rel(computePersonalCompanySubdirs(hqRoot))).toEqual([
-                path.join("companies", "foo"),
-            ]);
-            fs.rmSync(path.join(hqRoot, "companies", "foo"), { recursive: true });
-        }
-    });
-    it("marker: quoted `cloud: \"true\"` does NOT exclude (quote breaks the literal-true match)", () => {
-        writeCompany("foo", 'cloud: "true"\n');
-        expect(rel(computePersonalCompanySubdirs(hqRoot))).toEqual([
-            path.join("companies", "foo"),
-        ]);
-    });
-    it("marker: `cloud: truthy` does NOT exclude (word-boundary guard)", () => {
-        writeCompany("foo", "cloud: truthy\n");
-        expect(rel(computePersonalCompanySubdirs(hqRoot))).toEqual([
-            path.join("companies", "foo"),
-        ]);
-    });
-    // ── Subdir-level filters ───────────────────────────────────────────────
-    it("filter: skips _template even when it would otherwise be included", () => {
-        writeCompany("_template", null);
-        writeCompany("real", null);
-        expect(rel(computePersonalCompanySubdirs(hqRoot))).toEqual([
-            path.join("companies", "real"),
-        ]);
-    });
-    it("filter: skips slugs in the teamSyncedSlugs set (cloud-backed)", () => {
-        writeCompany("free", null);
-        writeCompany("team-acme", null);
-        expect(rel(computePersonalCompanySubdirs(hqRoot, new Set(["team-acme"])))).toEqual([path.join("companies", "free")]);
-    });
-    // Manifest cloud_uid is the durable cloud-backed signal when the runner
-    // has no membership fanout (agent `--personal` ritual). Without this,
-    // multi-GB team trees re-enter the personal vault every cycle.
-    it("filter: skips slugs with cloud_uid in companies/manifest.yaml", () => {
-        writeCompany("local-only", null);
-        writeCompany("indigo", null); // no company.yaml cloud:true
-        fs.mkdirSync(path.join(hqRoot, "companies"), { recursive: true });
-        fs.writeFileSync(path.join(hqRoot, "companies", "manifest.yaml"), [
-            "companies:",
-            "  indigo:",
-            "    name: Indigo",
-            "    cloud_uid: cmp_01KQ2RYAHXHDPCTY9GPQPTH3DG",
-            "    bucket_name: hq-vault-cmp-01kq2ryahxhdpcty9gpqpth3dg",
-            "  local-only:",
-            "    name: Local Only",
-            "",
-        ].join("\n"));
-        expect(rel(computePersonalCompanySubdirs(hqRoot))).toEqual([
-            path.join("companies", "local-only"),
-        ]);
-        expect([...readCloudBackedSlugsFromManifest(hqRoot)].sort()).toEqual([
-            "indigo",
-        ]);
-    });
-    it("filter: missing/unreadable manifest fails open (local companies still included)", () => {
-        writeCompany("foo", null);
-        // no companies/manifest.yaml
-        expect(rel(computePersonalCompanySubdirs(hqRoot))).toEqual([
-            path.join("companies", "foo"),
-        ]);
-        expect(readCloudBackedSlugsFromManifest(hqRoot).size).toBe(0);
-    });
-    it("filter: skips stray files under companies/ (only directories considered)", () => {
-        // Hypothetical: someone drops a README.md at companies/. Should not
-        // crash, should not be enumerated as a company subdir.
-        fs.mkdirSync(path.join(hqRoot, "companies"), { recursive: true });
-        fs.writeFileSync(path.join(hqRoot, "companies", "README.md"), "# README");
-        writeCompany("real", null);
-        expect(rel(computePersonalCompanySubdirs(hqRoot))).toEqual([
-            path.join("companies", "real"),
-        ]);
-    });
-    it("filter: missing hqRoot/companies/ returns []", () => {
-        // No `companies/` dir at all (fresh install or atypical layout).
-        expect(computePersonalCompanySubdirs(hqRoot)).toEqual([]);
-    });
-    // ── computePersonalVaultPaths: top-level + company-subdir composition ──
-    it("composition: local company subdirs are included by default (no opt-in flag)", () => {
-        fs.mkdirSync(path.join(hqRoot, ".claude"));
-        fs.mkdirSync(path.join(hqRoot, "knowledge"));
-        writeCompany("foo", null);
-        writeCompany("bar", "cloud: true\n");
-        const out = rel(computePersonalVaultPaths(hqRoot));
-        // Top-level entries present.
-        expect(out).toContain(".claude");
-        expect(out).toContain("knowledge");
-        // Local (non-cloud) company included; cloud-marked one excluded.
-        expect(out).toContain(path.join("companies", "foo"));
-        expect(out).not.toContain(path.join("companies", "bar"));
-        // The companies/ top-level entry itself is never present — only specific
-        // eligible subdirs. Preserves the invariant that share() never walks
-        // the whole companies/ tree under personalMode.
-        expect(out).not.toContain("companies");
-    });
-    it("composition: a stray Node project in the HQ root never reaches the vault", () => {
-        // The exact contamination found on this fleet: an `npm init -y` stub, the
-        // lockfile a misdirected `npm install` left behind, and its node_modules.
-        fs.mkdirSync(path.join(hqRoot, "personal"));
-        fs.mkdirSync(path.join(hqRoot, "node_modules"));
-        fs.writeFileSync(path.join(hqRoot, "package.json"), '{"name":"hq"}');
-        fs.writeFileSync(path.join(hqRoot, "package-lock.json"), "{}");
-        fs.writeFileSync(path.join(hqRoot, "pnpm-lock.yaml"), "lockfileVersion: '9.0'");
-        fs.writeFileSync(path.join(hqRoot, "yarn.lock"), "");
-        fs.writeFileSync(path.join(hqRoot, "pnpm-workspace.yaml"), "packages: []");
-        const out = rel(computePersonalVaultPaths(hqRoot));
-        expect(out).toContain("personal");
-        for (const name of [
-            "package.json",
-            "package-lock.json",
-            "pnpm-lock.yaml",
-            "yarn.lock",
-            "pnpm-workspace.yaml",
-            "node_modules",
-        ]) {
-            expect(out).not.toContain(name);
-        }
-    });
-    it("composition: a misdirected global install's `bin/` never reaches the vault", () => {
-        // The exact shape found on outposts primary and 2 on 2026-09-07: `bin/`
-        // holding symlinks into ../lib/node_modules, still present (and dangling)
-        // after the CLI tree beside it had been removed. Once in the vault these
-        // keys mapped to no configured area and aborted the whole checkpoint, so
-        // deletes never persisted and every machine re-pulled them forever.
-        fs.mkdirSync(path.join(hqRoot, "personal"));
-        fs.mkdirSync(path.join(hqRoot, "bin"));
-        fs.symlinkSync("../lib/node_modules/@indigoai-us/hq-cli/dist/index.js", path.join(hqRoot, "bin", "hq"));
-        fs.symlinkSync("../lib/node_modules/@indigoai-us/hq-cli/dist/bin/hq-auth-refresh.js", path.join(hqRoot, "bin", "hq-auth-refresh"));
-        const out = rel(computePersonalVaultPaths(hqRoot));
-        expect(out).toContain("personal");
-        expect(out).not.toContain("bin");
-        expect(out).not.toContain(path.join("bin", "hq"));
-    });
-    it("composition: teamSyncedSlugs filter excludes cloud-backed companies", () => {
-        writeCompany("foo", null);
-        writeCompany("synced", null);
-        const out = rel(computePersonalVaultPaths(hqRoot, {
-            teamSyncedSlugs: new Set(["synced"]),
-        }));
-        expect(out).toContain(path.join("companies", "foo"));
-        expect(out).not.toContain(path.join("companies", "synced"));
-    });
-    it("composition: missing hqRoot returns []", () => {
-        fs.rmSync(hqRoot, { recursive: true });
-        expect(computePersonalVaultPaths(hqRoot)).toEqual([]);
-    });
-    // ── companies/manifest.yaml inclusion ─────────────────────────────────
-    //
-    // The manifest is the routing source-of-truth (which slugs exist, which
-    // are cloud-backed, what their company UIDs are). The vault needs a
-    // single canonical copy: without it, a fresh machine joining the
-    // personal vault has no way to enumerate which non-cloud companies it
-    // expects to pull. Special-cased because companies/ itself is in
-    // PERSONAL_VAULT_EXCLUDED_TOP_LEVEL.
-    it("manifest: includes companies/manifest.yaml when present (default opts)", () => {
-        fs.mkdirSync(path.join(hqRoot, "companies"));
-        fs.writeFileSync(path.join(hqRoot, "companies", "manifest.yaml"), "companies:\n  foo: {}\n");
-        fs.mkdirSync(path.join(hqRoot, ".claude"));
-        const out = rel(computePersonalVaultPaths(hqRoot));
-        expect(out).toContain(path.join("companies", "manifest.yaml"));
-        expect(out).toContain(".claude");
-    });
-    it("manifest: included even when there are no eligible company subdirs", () => {
-        fs.mkdirSync(path.join(hqRoot, "companies"));
-        fs.writeFileSync(path.join(hqRoot, "companies", "manifest.yaml"), "companies: {}\n");
-        const out = rel(computePersonalVaultPaths(hqRoot));
-        expect(out).toContain(path.join("companies", "manifest.yaml"));
-    });
-    it("manifest: absent file is not included (no crash, no phantom entry)", () => {
-        fs.mkdirSync(path.join(hqRoot, "companies"));
-        // No manifest.yaml written.
-        const out = rel(computePersonalVaultPaths(hqRoot));
-        expect(out).not.toContain(path.join("companies", "manifest.yaml"));
-    });
-    it("manifest: missing companies/ directory entirely is not an error", () => {
-        // Fresh install or atypical layout: no companies/ dir at all.
-        fs.mkdirSync(path.join(hqRoot, ".claude"));
-        expect(() => computePersonalVaultPaths(hqRoot)).not.toThrow();
-        const out = rel(computePersonalVaultPaths(hqRoot));
-        expect(out).toContain(".claude");
-        expect(out).not.toContain(path.join("companies", "manifest.yaml"));
-    });
-    it("manifest: ONLY manifest.yaml is special-cased — other companies/ root files stay excluded", () => {
-        // Anti-test: only manifest.yaml gets the bypass. A stray README.md at
-        // companies/ root or a directory called `_template` must still be
-        // filtered (the latter by company-eligibility, the former silently).
-        fs.mkdirSync(path.join(hqRoot, "companies"));
-        fs.writeFileSync(path.join(hqRoot, "companies", "manifest.yaml"), "companies: {}\n");
-        fs.writeFileSync(path.join(hqRoot, "companies", "README.md"), "# companies tree");
-        const out = rel(computePersonalVaultPaths(hqRoot));
-        expect(out).toContain(path.join("companies", "manifest.yaml"));
-        expect(out).not.toContain(path.join("companies", "README.md"));
-    });
-    it("manifest: composes with local company subdirs", () => {
-        fs.mkdirSync(path.join(hqRoot, "companies"));
-        fs.writeFileSync(path.join(hqRoot, "companies", "manifest.yaml"), "companies:\n  foo: {cloud_uid: null}\n  team-acme: {cloud_uid: cmp_01XYZ}\n");
-        writeCompany("foo", null);
-        writeCompany("team-acme", "cloud: true\n");
-        const out = rel(computePersonalVaultPaths(hqRoot, {
-            teamSyncedSlugs: new Set(["team-acme"]),
-        }));
-        // Manifest + non-cloud subdir, NOT team-acme.
-        expect(out).toContain(path.join("companies", "manifest.yaml"));
-        expect(out).toContain(path.join("companies", "foo"));
-        expect(out).not.toContain(path.join("companies", "team-acme"));
-    });
-    it("manifest: stray `manifest.yaml.conflict-*` litter is never enumerated as a company", () => {
-        // Regression guard for DEV-1719's secondary symptom: when the personal
-        // push accumulated `companies/manifest.yaml.conflict-<ts>.yaml` mirror
-        // files, those FILES must never be mis-counted as company subdirs (they
-        // are not directories) nor leak into the push set. The real manifest.yaml
-        // is still included; the conflict litter is not.
-        fs.mkdirSync(path.join(hqRoot, "companies"));
-        fs.writeFileSync(path.join(hqRoot, "companies", "manifest.yaml"), "companies: {}\n");
-        fs.writeFileSync(path.join(hqRoot, "companies", "manifest.yaml.conflict-2026-06-08T10-00-00Z-ab12cd.yaml"), "companies: {}\n");
-        // Not treated as a company subdir (only directories are eligible).
-        expect(computePersonalCompanySubdirs(hqRoot)).toEqual([]);
-        // Push set carries the real manifest, never the conflict litter.
-        const out = rel(computePersonalVaultPaths(hqRoot));
-        expect(out).toContain(path.join("companies", "manifest.yaml"));
-        expect(out.some((p) => p.includes("manifest.yaml.conflict-"))).toBe(false);
-    });
-});
-// ─────────────────────────────────────────────────────────────────────────
-// DEV-1778 — session-continuity pointer carve-out.
-//
-// `workspace/` is in PERSONAL_VAULT_EXCLUDED_TOP_LEVEL (machine-local by
-// design). The ONE exception is the session pointer
-// `workspace/threads/handoff.json` + the single thread file it references via
-// `thread_path`, so a `/handoff` on one machine reaches a second machine.
-// Mirrors the companies/manifest.yaml special-case: a narrow file-level
-// re-include that never broadens the rest of workspace/.
-// ─────────────────────────────────────────────────────────────────────────
-describe("personal-vault: continuity-pointer carve-out", () => {
-    let hqRoot;
-    beforeEach(() => {
-        hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-cont-test-"));
-    });
-    afterEach(() => {
-        fs.rmSync(hqRoot, { recursive: true, force: true });
-    });
-    /** Helper: relative-paths-sorted projection of an absolute-path list. */
-    function rel(abs) {
-        return abs.map((p) => path.relative(hqRoot, p)).sort();
-    }
-    const THREADS = path.join("workspace", "threads");
-    /** Write workspace/threads/handoff.json with the given object. */
-    function writeHandoff(obj, raw) {
-        const dir = path.join(hqRoot, THREADS);
-        fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(path.join(dir, "handoff.json"), raw !== undefined ? raw : JSON.stringify(obj));
-    }
-    /** Write a thread file under workspace/threads/ and return its rel path. */
-    function writeThread(name) {
-        const dir = path.join(hqRoot, THREADS);
-        fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(path.join(dir, name), "{}");
-        return path.join(THREADS, name).split(path.sep).join("/");
-    }
-    it("constant: CONTINUITY_POINTER_REL is the canonical pointer path", () => {
-        expect(CONTINUITY_POINTER_REL).toBe("workspace/threads/handoff.json");
-    });
-    it("includes handoff.json + the thread file it points to", () => {
-        const threadRel = writeThread("T-20260617-1200-demo.json");
-        writeHandoff({ thread_path: threadRel });
-        expect(rel(computeContinuityPointerPaths(hqRoot))).toEqual([
-            path.join(THREADS, "T-20260617-1200-demo.json"),
-            path.join(THREADS, "handoff.json"),
-        ].sort());
-    });
-    it("carve-out composes into computePersonalVaultPaths", () => {
-        const threadRel = writeThread("T-20260617-1200-demo.json");
-        writeHandoff({ thread_path: threadRel });
-        fs.mkdirSync(path.join(hqRoot, ".claude"));
-        const out = rel(computePersonalVaultPaths(hqRoot));
-        expect(out).toContain(path.join(THREADS, "handoff.json"));
-        expect(out).toContain(path.join(THREADS, "T-20260617-1200-demo.json"));
-        // Sibling top-level dirs still travel; the rest of workspace/ does not.
-        expect(out).toContain(".claude");
-    });
-    it("does NOT broaden the rest of workspace/ (siblings/other threads stay local)", () => {
-        const threadRel = writeThread("T-active.json");
-        writeThread("T-old.json"); // an inactive thread — must NOT sync
-        writeHandoff({ thread_path: threadRel });
-        // Unrelated workspace litter that must stay machine-local.
-        fs.mkdirSync(path.join(hqRoot, "workspace", "locks"), { recursive: true });
-        fs.writeFileSync(path.join(hqRoot, "workspace", "locks", "x.lock"), "1");
-        fs.writeFileSync(path.join(hqRoot, "workspace", "threads", "INDEX.md"), "#");
-        const out = rel(computePersonalVaultPaths(hqRoot));
-        expect(out).toContain(path.join(THREADS, "handoff.json"));
-        expect(out).toContain(path.join(THREADS, "T-active.json"));
-        expect(out).not.toContain(path.join(THREADS, "T-old.json"));
-        expect(out).not.toContain(path.join(THREADS, "INDEX.md"));
-        expect(out.some((p) => p.startsWith(path.join("workspace", "locks")))).toBe(false);
-    });
-    it("handoff.json present but thread_path absent → only the pointer", () => {
-        writeHandoff({ message: "no pointer field" });
-        expect(rel(computeContinuityPointerPaths(hqRoot))).toEqual([
-            path.join(THREADS, "handoff.json"),
-        ]);
-    });
-    it("handoff.json points to a non-existent thread file → only the pointer", () => {
-        writeHandoff({ thread_path: "workspace/threads/T-ghost.json" });
-        expect(rel(computeContinuityPointerPaths(hqRoot))).toEqual([
-            path.join(THREADS, "handoff.json"),
-        ]);
-    });
-    it("no handoff.json at all → empty (nothing to carry)", () => {
-        fs.mkdirSync(path.join(hqRoot, THREADS), { recursive: true });
-        expect(computeContinuityPointerPaths(hqRoot)).toEqual([]);
-    });
-    it("malformed handoff.json → fail-soft to pointer only (no throw)", () => {
-        writeHandoff(null, "{ this is : not json ]");
-        expect(() => computeContinuityPointerPaths(hqRoot)).not.toThrow();
-        expect(rel(computeContinuityPointerPaths(hqRoot))).toEqual([
-            path.join(THREADS, "handoff.json"),
-        ]);
-    });
-    // ── Security: thread_path must never escape workspace/threads/ ──────────
-    it("rejects an absolute thread_path (only the pointer is included)", () => {
-        // Put a real file at the absolute target so the ONLY thing rejecting it
-        // is the containment guard, not a missing-file fallthrough.
-        const evil = path.join(hqRoot, "secret.txt");
-        fs.writeFileSync(evil, "top secret");
-        writeHandoff({ thread_path: evil });
-        expect(rel(computeContinuityPointerPaths(hqRoot))).toEqual([
-            path.join(THREADS, "handoff.json"),
-        ]);
-    });
-    it("rejects a traversal thread_path (../../.env) — no smuggling out of threads/", () => {
-        fs.writeFileSync(path.join(hqRoot, ".env"), "SECRET=1");
-        writeHandoff({ thread_path: "workspace/threads/../../.env" });
-        const out = rel(computeContinuityPointerPaths(hqRoot));
-        expect(out).toEqual([path.join(THREADS, "handoff.json")]);
-        expect(out.some((p) => p.endsWith(".env"))).toBe(false);
-    });
-    it("rejects a thread_path under workspace/ but outside threads/", () => {
-        fs.mkdirSync(path.join(hqRoot, "workspace", "reports"), {
-            recursive: true,
-        });
-        fs.writeFileSync(path.join(hqRoot, "workspace", "reports", "secret.md"), "x");
-        writeHandoff({ thread_path: "workspace/reports/secret.md" });
-        expect(rel(computeContinuityPointerPaths(hqRoot))).toEqual([
-            path.join(THREADS, "handoff.json"),
-        ]);
-    });
-    it("rejects a symlink that escapes threads/ (realpath containment)", () => {
-        // A thread_path that names an in-threads symlink whose target is OUTSIDE
-        // threads/ must be rejected by the realpath re-check.
-        fs.writeFileSync(path.join(hqRoot, "outside.txt"), "secret");
-        fs.mkdirSync(path.join(hqRoot, THREADS), { recursive: true });
-        const link = path.join(hqRoot, THREADS, "escape.json");
-        try {
-            fs.symlinkSync(path.join(hqRoot, "outside.txt"), link);
-        }
-        catch {
-            // Platform without symlink support — skip the assertion gracefully.
-            return;
-        }
-        writeHandoff({ thread_path: "workspace/threads/escape.json" });
-        expect(rel(computeContinuityPointerPaths(hqRoot))).toEqual([
-            path.join(THREADS, "handoff.json"),
-        ]);
-    });
-    it("R-F35: rejects threads symlinks below hqRoot while allowing symlinked hqRoot ancestors", () => {
-        const privateThreads = path.join(hqRoot, "repos", "private");
-        fs.mkdirSync(privateThreads, { recursive: true });
-        fs.mkdirSync(path.join(hqRoot, "workspace"), { recursive: true });
-        fs.writeFileSync(path.join(privateThreads, "handoff.json"), JSON.stringify({
-            thread_path: "workspace/threads/T-private.json",
-        }));
-        fs.writeFileSync(path.join(privateThreads, "T-private.json"), "{}");
-        fs.symlinkSync(privateThreads, path.join(hqRoot, THREADS), "dir");
-        expect(rel(computeContinuityPointerPaths(hqRoot))).toEqual([
-            path.join(THREADS, "handoff.json"),
-        ]);
-        const realParent = fs.mkdtempSync(path.join(os.tmpdir(), "hq-cont-real-"));
-        const aliasParent = fs.mkdtempSync(path.join(os.tmpdir(), "hq-cont-alias-"));
-        const realRoot = path.join(realParent, "root");
-        const aliasRoot = path.join(aliasParent, "root-link");
-        try {
-            fs.mkdirSync(path.join(realRoot, THREADS), { recursive: true });
-            fs.writeFileSync(path.join(realRoot, THREADS, "handoff.json"), JSON.stringify({ thread_path: "workspace/threads/T-active.json" }));
-            fs.writeFileSync(path.join(realRoot, THREADS, "T-active.json"), "{}");
-            fs.symlinkSync(realRoot, aliasRoot, "dir");
-            const aliasRel = computeContinuityPointerPaths(aliasRoot)
-                .map((p) => path.relative(aliasRoot, p))
-                .sort();
-            expect(aliasRel).toEqual([
-                path.join(THREADS, "T-active.json"),
-                path.join(THREADS, "handoff.json"),
-            ].sort());
-        }
-        finally {
-            fs.rmSync(realParent, { recursive: true, force: true });
-            fs.rmSync(aliasParent, { recursive: true, force: true });
-        }
-    });
-});
-// ─────────────────────────────────────────────────────────────────────────
-// workspace/agency carve-out — sync the agency-team workspace across machines.
-//
-// Like the continuity pointer, this pierces the workspace/ top-level exclusion
-// for ONE subtree: workspace/agency/<company>/<team>/ (hq-pack-agency chat
-// inboxes + roster/state), so an agency team picked up on a second machine sees
-// the same conversation it had on the first. The rest of workspace/ stays local.
-// ─────────────────────────────────────────────────────────────────────────
-describe("personal-vault: agency-workspace carve-out", () => {
-    let hqRoot;
-    beforeEach(() => {
-        hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-agency-test-"));
-    });
-    afterEach(() => {
-        fs.rmSync(hqRoot, { recursive: true, force: true });
-    });
-    const relAll = (abs) => abs.map((p) => path.relative(hqRoot, p)).sort();
-    it("constant: AGENCY_SYNC_REL is workspace/agency", () => {
-        expect(AGENCY_SYNC_REL).toBe("workspace/agency");
-    });
-    it("includes workspace/agency when it exists", () => {
-        fs.mkdirSync(path.join(hqRoot, "workspace", "agency", "acme", "growth"), {
-            recursive: true,
-        });
-        expect(relAll(computeAgencySyncPaths(hqRoot))).toEqual([
-            path.join("workspace", "agency"),
-        ]);
-    });
-    it("empty when workspace/agency is absent (fail-soft)", () => {
-        fs.mkdirSync(path.join(hqRoot, "workspace"), { recursive: true });
-        expect(computeAgencySyncPaths(hqRoot)).toEqual([]);
-    });
-    it("composes into computePersonalVaultPaths without broadening workspace/", () => {
-        fs.mkdirSync(path.join(hqRoot, "workspace", "agency", "acme", "growth"), {
-            recursive: true,
-        });
-        fs.mkdirSync(path.join(hqRoot, "workspace", "locks"), { recursive: true });
-        fs.writeFileSync(path.join(hqRoot, "workspace", "locks", "x.lock"), "1");
-        fs.mkdirSync(path.join(hqRoot, ".claude"), { recursive: true });
-        const out = relAll(computePersonalVaultPaths(hqRoot));
-        expect(out).toContain(path.join("workspace", "agency"));
-        expect(out).toContain(".claude");
-        expect(out.some((p) => p.startsWith(path.join("workspace", "locks")))).toBe(false);
-    });
-});
-// ─────────────────────────────────────────────────────────────────────────
-// Session-logs carve-out (workspace/.session-logs) — reindex-captured Claude
-// Code transcripts pierce the workspace/ exclusion and round-trip to the vault.
-// ─────────────────────────────────────────────────────────────────────────
-describe("personal-vault: session-logs carve-out", () => {
-    let hqRoot;
-    beforeEach(() => {
-        hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-sesslog-test-"));
-    });
-    afterEach(() => {
-        fs.rmSync(hqRoot, { recursive: true, force: true });
-    });
-    const relAll = (abs) => abs.map((p) => path.relative(hqRoot, p)).sort();
-    it("constant: SESSION_LOGS_SYNC_REL is workspace/.session-logs", () => {
-        expect(SESSION_LOGS_SYNC_REL).toBe("workspace/.session-logs");
-    });
-    it("includes workspace/.session-logs when it exists", () => {
-        fs.mkdirSync(path.join(hqRoot, "workspace", ".session-logs", "tool-results"), {
-            recursive: true,
-        });
-        expect(relAll(computeSessionLogsSyncPaths(hqRoot))).toEqual([
-            path.join("workspace", ".session-logs"),
-        ]);
-    });
-    it("empty when workspace/.session-logs is absent (fail-soft)", () => {
-        fs.mkdirSync(path.join(hqRoot, "workspace"), { recursive: true });
-        expect(computeSessionLogsSyncPaths(hqRoot)).toEqual([]);
-    });
-    it("composes into computePersonalVaultPaths without broadening workspace/", () => {
-        fs.mkdirSync(path.join(hqRoot, "workspace", ".session-logs"), { recursive: true });
-        fs.writeFileSync(path.join(hqRoot, "workspace", ".session-logs", "session.jsonl"), "l\n");
-        // A sibling under workspace/ that must STAY local.
-        fs.mkdirSync(path.join(hqRoot, "workspace", "locks"), { recursive: true });
-        fs.writeFileSync(path.join(hqRoot, "workspace", "locks", "x.lock"), "1");
-        fs.mkdirSync(path.join(hqRoot, ".claude"), { recursive: true });
-        const out = relAll(computePersonalVaultPaths(hqRoot));
-        expect(out).toContain(path.join("workspace", ".session-logs"));
-        expect(out).toContain(".claude");
-        // The carve-out is exactly the .session-logs subtree — no other workspace/
-        // sibling is pulled in.
-        expect(out.some((p) => p.startsWith(path.join("workspace", "locks")))).toBe(false);
-    });
-});
-// ─────────────────────────────────────────────────────────────────────────
-describe("personal-vault: isPersonalVaultDeletionExcluded", () => {
-    it("protects release scaffold + reindex-generated skill wrappers", () => {
-        expect(isPersonalVaultDeletionExcluded("workspace/.session-logs")).toBe(true);
-        expect(isPersonalVaultDeletionExcluded("workspace/.session-logs/codex/session.jsonl")).toBe(true);
-        // Nested leftovers after a company is decommissioned from the personal
-        // bucket: VaultAccessRole's DeleteObject deny is unanchored (`hq-vault-*/workspace/.session-logs/*`).
-        expect(isPersonalVaultDeletionExcluded("companies/indigo/workspace/.session-logs/canary-noncurrent-v1.jsonl")).toBe(true);
-        expect(isPersonalVaultDeletionExcluded("companies/indigo/workspace/.session-logs")).toBe(true);
-        // An ancestor must remain ordinary so this guard never broadens into a
-        // workspace-wide delete-propagation exemption.
-        expect(isPersonalVaultDeletionExcluded("workspace")).toBe(false);
-        expect(isPersonalVaultDeletionExcluded("workspace/.session-logs-old/x")).toBe(false);
-        expect(isPersonalVaultDeletionExcluded("companies/indigo/workspace/.session-logs-old/x")).toBe(false);
-        expect(isPersonalVaultDeletionExcluded("companies/indigo/workspace/sessions/foo.json")).toBe(false);
-        expect(isPersonalVaultDeletionExcluded("a/b/workspace/.session-logs/nested.jsonl")).toBe(true);
-        expect(isPersonalVaultDeletionExcluded("workspace/.session-logsX/x")).toBe(false);
-        expect(isPersonalVaultDeletionExcluded("core")).toBe(true);
-        expect(isPersonalVaultDeletionExcluded("core/policies/x.md")).toBe(true);
-        expect(isPersonalVaultDeletionExcluded(".claude/skills")).toBe(true);
-        expect(isPersonalVaultDeletionExcluded(".claude/skills/core:demo/SKILL.md")).toBe(true);
-    });
-    it("protects reindex-generated command links from delete-propagation", () => {
-        // The generated <ns>:<cmd>.md links reindex surfaces — recreated locally by
-        // `hq reindex`, so a local absence is not user intent.
-        expect(isPersonalVaultDeletionExcluded(".claude/commands/core:demo.md")).toBe(true);
-        expect(isPersonalVaultDeletionExcluded(".claude/commands/indigo:signals.md")).toBe(true);
-        expect(isPersonalVaultDeletionExcluded(".claude/commands/hq-pack-demo:hello.md")).toBe(true);
-        // Win32-encoded colon form is protected too.
-        expect(isPersonalVaultDeletionExcluded(".claude/commands/indigo%3Asignals.md")).toBe(true);
-    });
-    it("does NOT protect hand-authored native commands (deletion IS user intent)", () => {
-        // A non-namespaced native slash command the user authored directly under
-        // .claude/commands/ must still delete-propagate, unlike the skill farm.
-        expect(isPersonalVaultDeletionExcluded(".claude/commands/deploy.md")).toBe(false);
-        expect(isPersonalVaultDeletionExcluded(".claude/commands")).toBe(false);
-        // And an ordinary user file is never protected.
-        expect(isPersonalVaultDeletionExcluded("knowledge/notes.md")).toBe(false);
-    });
-});
-// ─────────────────────────────────────────────────────────────────────────
-// Stale-journal convergence (never-completing personal-vault sync fix).
-//
-// The push WALK already prunes excluded trees, but journal rows written before
-// an exclusion rule existed were never removed and were re-diffed on every
-// push forever. `purgeExcludedPersonalVaultJournalEntries` drops them, using
-// the EXACT same exclusion mechanisms the push applies: the shared ignore
-// filter + personal-vault defaults (`shouldSync`), the `.conflict-*` ephemeral
-// basename pattern, and the `workspace/` top-level exclusion (which lives at
-// the walk-root level and is invisible to `shouldSync`).
-describe("personal-vault: purgeExcludedPersonalVaultJournalEntries", () => {
-    let hqRoot;
-    // Real push-side filter chain (mirrors createPushRunContext personalMode).
-    let shouldSync;
-    // Real vault-litter predicate the push delete-plan uses (`.conflict-*` /
-    // `.drift-*`) — the purge defers to it instead of dropping the row.
-    let isLitter;
-    beforeEach(async () => {
-        hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pv-purge-"));
-        const { createIgnoreFilter } = await import("./ignore.js");
-        const { wrapFilterWithPersonalVaultDefaults } = await import("./personal-vault-exclusions.js");
-        const { isVaultLitterArtifact } = await import("./cli/share.js");
-        isLitter = isVaultLitterArtifact;
-        shouldSync = wrapFilterWithPersonalVaultDefaults(createIgnoreFilter(hqRoot), hqRoot, () => { });
-        // Materialize the workspace carve-outs so the continuity / agency /
-        // session-log roots resolve to real paths (they are read from disk).
-        fs.mkdirSync(path.join(hqRoot, "workspace", "threads"), { recursive: true });
-        fs.writeFileSync(path.join(hqRoot, "workspace", "threads", "handoff.json"), JSON.stringify({ thread_path: "workspace/threads/T-active.md" }));
-        fs.writeFileSync(path.join(hqRoot, "workspace", "threads", "T-active.md"), "active");
-        fs.mkdirSync(path.join(hqRoot, "workspace", "agency", "co"), {
-            recursive: true,
-        });
-        fs.writeFileSync(path.join(hqRoot, "workspace", "agency", "co", "chat.jsonl"), "{}");
-        fs.mkdirSync(path.join(hqRoot, "workspace", ".session-logs"), {
-            recursive: true,
-        });
-        fs.writeFileSync(path.join(hqRoot, "workspace", ".session-logs", "s.jsonl"), "{}");
-    });
-    afterEach(() => {
-        fs.rmSync(hqRoot, { recursive: true, force: true });
-    });
-    const journalWith = (keys) => ({
-        version: "2",
-        lastSync: "",
-        pulls: [],
-        files: Object.fromEntries(keys.map((k) => [k, { hash: "h", size: 1, mtimeMs: 1, direction: "up" }])),
-    });
-    it("counts each 59,020-row purge population once while preserving its exact denominator", () => {
-        const rowCount = 59_020;
-        const files = {};
-        for (let index = 0; index < rowCount; index += 1) {
-            files[`personal/notes/entry-${index}.md`] = {
-                hash: "h",
-                size: index,
-                mtimeMs: index,
-                syncedAt: "2026-09-16T00:00:00.000Z",
-                direction: "up",
-            };
-        }
-        let keyEnumerations = 0;
-        const journal = {
-            version: "2",
-            lastSync: "",
-            pulls: [],
-            files: new Proxy(files, {
-                ownKeys(target) {
-                    keyEnumerations += 1;
-                    return Reflect.ownKeys(target);
-                },
-            }),
-        };
-        const purge = purgeExcludedPersonalVaultJournalEntries(journal, hqRoot, hqRoot, () => true, () => false);
-        expect(purge).toEqual({
-            removed: [],
-            byReason: {
-                "ignore-filtered": 0,
-                "ignore-filtered-present": 0,
-                "excluded-top-level": 0,
-            },
-        });
-        expect(keyEnumerations).toBe(1);
-    });
-    it("purges the orphaned excluded classes and keeps legit + carve-out + owned rows", () => {
-        const journal = journalWith([
-            // legit content — KEEP
-            "personal/notes.md",
-            "core/policies/x.md",
-            ".claude/skills/foo/SKILL.md",
-            "companies/manifest.yaml",
-            "companies/localco/knowledge/n.md",
-            // workspace carve-outs — KEEP
-            "workspace/threads/handoff.json",
-            "workspace/threads/T-active.md",
-            "workspace/agency/co/chat.jsonl",
-            "workspace/.session-logs/s.jsonl",
-            // owned by OTHER mechanisms — KEEP (deferred, not purged here)
-            ".conflict-2026-08-01T00-00-00Z-abcd1234.md", // vault-litter drain (remote delete)
-            "personal/.obsidian/x.json.drift-1779863862-42519", // rescue-drift litter
-            ".claude/skills/core:demo/SKILL.md", // reindex mirror, delete-excluded
-            // orphaned excluded classes with NO other owner — PURGE
-            ".claude/worktrees/wt1/a.ts",
-            ".claude/worktrees/wt1/deep/b.ts",
-            "personal/node_modules/pkg/index.js",
-            ".hq-conflicts/mirror.md",
-            "workspace/threads/T-old-2026-01-01.md",
-            "workspace/scratch/tmp.txt",
-            "workspace/worktrees/wt2/c.ts",
-        ]);
-        const { removed, byReason } = purgeExcludedPersonalVaultJournalEntries(journal, hqRoot, hqRoot, shouldSync, isLitter);
-        // Only the orphaned excluded rows were dropped.
-        expect(removed.sort()).toEqual([
-            ".claude/worktrees/wt1/a.ts",
-            ".claude/worktrees/wt1/deep/b.ts",
-            "personal/node_modules/pkg/index.js",
-            ".hq-conflicts/mirror.md",
-            "workspace/threads/T-old-2026-01-01.md",
-            "workspace/scratch/tmp.txt",
-            "workspace/worktrees/wt2/c.ts",
-        ].sort());
-        // Litter, reindex mirrors, carve-outs, and legit content all survive.
-        for (const kept of [
-            "personal/notes.md",
-            "core/policies/x.md",
-            ".claude/skills/foo/SKILL.md",
-            "companies/manifest.yaml",
-            "companies/localco/knowledge/n.md",
-            "workspace/threads/handoff.json",
-            "workspace/threads/T-active.md",
-            "workspace/agency/co/chat.jsonl",
-            "workspace/.session-logs/s.jsonl",
-            ".conflict-2026-08-01T00-00-00Z-abcd1234.md",
-            "personal/.obsidian/x.json.drift-1779863862-42519",
-            ".claude/skills/core:demo/SKILL.md",
-        ]) {
-            expect(journal.files[kept]).toBeDefined();
-        }
-        // Reason breakdown: shouldSync catches worktrees + node_modules +
-        // .hq-conflicts; the workspace top-level exclusion catches non-carve-outs.
-        //
-        // `workspace/worktrees/` moved buckets when it became a DEFAULT_IGNORES
-        // entry: it used to reach the purge only via this file's personal-vault
-        // `workspace` top-level rule, so it counted as `excluded-top-level`. The
-        // general sync filter now catches it first, so it counts as
-        // `ignore-filtered`. The set of removed rows asserted above is unchanged —
-        // this is an attribution shift, not a behaviour change. It also records the
-        // gap that motivated the DEFAULT_IGNORES entry: before it, worktrees were
-        // excluded from the PERSONAL vault only, so a company vault (and, because
-        // the same filter drives chokidar's descent, the file watcher) still walked
-        // them.
-        expect(byReason["ignore-filtered"]).toBe(5); // 2 .claude worktrees + workspace worktree + node_modules + .hq-conflicts
-        expect(byReason["excluded-top-level"]).toBe(2); // T-old + scratch
-    });
-    it("prunes ignore-filtered rows whether or not the file is present, but retains a pending in-scope delete", () => {
-        // An ignore-filtered row is inert bookkeeping either way: the push walk
-        // never descends into the ignored tree and the pull leg refuses the key, so
-        // nothing ever reads the row again — it is only re-serialized and re-lstat'd
-        // on every pass. A PRESENT ignored file is therefore purged too (reason
-        // `ignore-filtered-present`, kept distinct for the event summary). An
-        // in-scope missing file is ambiguous user intent and must remain available
-        // to the ordinary delete/tombstone planner.
-        fs.mkdirSync(path.join(hqRoot, ".claude", "worktrees", "live"), {
-            recursive: true,
-        });
-        fs.writeFileSync(path.join(hqRoot, ".claude", "worktrees", "live", "present.ts"), "live");
-        const journal = journalWith([
-            ".claude/worktrees/gone/stranded.ts",
-            ".claude/worktrees/live/present.ts",
-            "personal/pending-user-delete.md",
-        ]);
-        const { removed, byReason } = purgeExcludedPersonalVaultJournalEntries(journal, hqRoot, hqRoot, shouldSync, isLitter);
-        expect(removed.sort()).toEqual([".claude/worktrees/gone/stranded.ts", ".claude/worktrees/live/present.ts"].sort());
-        expect(byReason).toEqual({
-            "ignore-filtered": 1,
-            "ignore-filtered-present": 1,
-            "excluded-top-level": 0,
-        });
-        expect(journal.files["personal/pending-user-delete.md"]).toBeDefined();
-    });
-    // Regression: the 2026-09-05 sync-runner CPU/RAM drain. `workspace/agency/`
-    // and `workspace/.session-logs/` are synced carve-outs, so ~460k rows for
-    // agency workflow logs and session transcripts were journaled before the
-    // operator added `.hqignore` rules for them. The files stayed on disk, so the
-    // missing-only purge never touched the rows: the 206MB journal was
-    // structuredClone'd and re-serialized on every pass (3–4GB heap, ~50% CPU,
-    // repeated OOM kills). A row under a LATER ignore rule must drain even when
-    // its file is still present.
-    it("drains present carve-out rows once a later .hqignore rule excludes them", async () => {
-        fs.mkdirSync(path.join(hqRoot, "workspace", "agency", "workflows", "feedback"), {
-            recursive: true,
-        });
-        fs.writeFileSync(path.join(hqRoot, "workspace", "agency", "workflows", "feedback", "run.jsonl"), "{}");
-        fs.mkdirSync(path.join(hqRoot, "workspace", ".session-logs", "claude"), {
-            recursive: true,
-        });
-        fs.writeFileSync(path.join(hqRoot, "workspace", ".session-logs", "claude", "t.jsonl"), "{}");
-        const journal = journalWith([
-            "workspace/agency/workflows/feedback/run.jsonl",
-            "workspace/.session-logs/claude/t.jsonl",
-            "workspace/.session-logs/s.jsonl",
-            "workspace/agency/co/chat.jsonl", // still in scope — KEEP
-            "personal/notes.md", // in scope — KEEP
-        ]);
-        // Baseline: no ignore rule yet, every present carve-out row is retained.
-        expect(purgeExcludedPersonalVaultJournalEntries(journal, hqRoot, hqRoot, shouldSync, isLitter).removed).toEqual([]);
-        // The operator adds the rules AFTER the rows were journaled.
-        fs.writeFileSync(path.join(hqRoot, ".hqignore"), ["workspace/agency/workflows/", "/workspace/.session-logs/", ""].join("\n"));
-        const { createIgnoreFilter } = await import("./ignore.js");
-        const { wrapFilterWithPersonalVaultDefaults } = await import("./personal-vault-exclusions.js");
-        const laterShouldSync = wrapFilterWithPersonalVaultDefaults(createIgnoreFilter(hqRoot), hqRoot, () => { });
-        const { removed, byReason } = purgeExcludedPersonalVaultJournalEntries(journal, hqRoot, hqRoot, laterShouldSync, isLitter);
-        expect(removed.sort()).toEqual([
-            "workspace/agency/workflows/feedback/run.jsonl",
-            "workspace/.session-logs/claude/t.jsonl",
-            "workspace/.session-logs/s.jsonl",
-        ].sort());
-        expect(byReason["ignore-filtered-present"]).toBe(3);
-        expect(journal.files["workspace/agency/co/chat.jsonl"]).toBeDefined();
-        expect(journal.files["personal/notes.md"]).toBeDefined();
-    });
-    it("retains a row whose lstat fails with anything other than ENOENT (never treats an error as presence)", () => {
-        // A regular file where the journal expects a directory makes lstat fail
-        // with ENOTDIR. That is neither "missing" nor "present": the row must be
-        // left alone rather than classified as a present ignored file and purged.
-        fs.mkdirSync(path.join(hqRoot, ".claude", "worktrees"), { recursive: true });
-        fs.writeFileSync(path.join(hqRoot, ".claude", "worktrees", "blob"), "x");
-        const journal = journalWith([".claude/worktrees/blob/inner.ts"]);
-        const { removed } = purgeExcludedPersonalVaultJournalEntries(journal, hqRoot, hqRoot, shouldSync, isLitter);
-        expect(removed).toEqual([]);
-        expect(journal.files[".claude/worktrees/blob/inner.ts"]).toBeDefined();
-    });
-    it("circuit breaker: present ignored rows are exempt, so a 90% ignore-filtered-present drain proceeds", () => {
-        // The breaker exists for the 2026-08-18 class of fault: a transient
-        // enumeration/stat failure reclassifying MISSING rows. Whether a PRESENT
-        // file is ignored is a deterministic function of the ignore configuration
-        // (and a failed `.hqignore` read yields FEWER ignores, never more), so those
-        // rows must not be counted against the fraction — otherwise the exact
-        // situation this drain exists for (hundreds of thousands of rows under a
-        // later ignore rule) is vetoed forever.
-        const dir = path.join(hqRoot, ".claude", "worktrees", "wt");
-        fs.mkdirSync(dir, { recursive: true });
-        const ignoredPresent = Array.from({ length: 1100 }, (_i, n) => {
-            fs.writeFileSync(path.join(dir, `f${n}.ts`), "x");
-            return `.claude/worktrees/wt/f${n}.ts`;
-        });
-        const kept = Array.from({ length: 100 }, (_i, n) => `.claude/skills/s${n}/SKILL.md`);
-        const journal = journalWith([...ignoredPresent, ...kept]);
-        const purge = purgeExcludedPersonalVaultJournalEntries(journal, hqRoot, hqRoot, shouldSync, isLitter);
-        expect(purge.guardTripped).toBeUndefined();
-        expect(purge.removed).toHaveLength(1100);
-        expect(purge.byReason["ignore-filtered-present"]).toBe(1100);
-        expect(Object.keys(journal.files)).toHaveLength(100);
-    });
-    it("circuit breaker: a vetoed pass still drops nothing, including present ignored rows", () => {
-        // When the missing-row fraction trips the breaker the pass is treated as
-        // untrustworthy wholesale — the present-ignored drain waits for the next
-        // healthy pass too, and `attempted` reports only the vetoed missing rows.
-        const dir = path.join(hqRoot, ".claude", "worktrees", "wt");
-        fs.mkdirSync(dir, { recursive: true });
-        const ignoredPresent = Array.from({ length: 50 }, (_i, n) => {
-            fs.writeFileSync(path.join(dir, `f${n}.ts`), "x");
-            return `.claude/worktrees/wt/f${n}.ts`;
-        });
-        const excludedMissing = Array.from({ length: 1000 }, (_i, n) => `workspace/scratch/f${n}.txt`);
-        const kept = Array.from({ length: 200 }, (_i, n) => `.claude/skills/s${n}/SKILL.md`);
-        const journal = journalWith([...ignoredPresent, ...excludedMissing, ...kept]);
-        const purge = purgeExcludedPersonalVaultJournalEntries(journal, hqRoot, hqRoot, shouldSync, isLitter);
-        expect(purge.removed).toEqual([]);
-        expect(purge.guardTripped).toEqual({ attempted: 1000, totalRows: 1250 });
-        expect(Object.keys(journal.files)).toHaveLength(1250);
-    });
-    it("drains present ignored rows in bounded batches per pass (missing rows are unaffected)", () => {
-        // Because present ignored rows bypass the fraction breaker, an accidental
-        // blanket ignore rule must not be able to empty the journal in a single
-        // pass. The drain is capped per pass so the pruned event surfaces the
-        // scope shrink while most rows are still recoverable by fixing the rule.
-        const dir = path.join(hqRoot, ".claude", "worktrees", "wt");
-        fs.mkdirSync(dir, { recursive: true });
-        const ignoredPresent = Array.from({ length: 5 }, (_i, n) => {
-            fs.writeFileSync(path.join(dir, `f${n}.ts`), "x");
-            return `.claude/worktrees/wt/f${n}.ts`;
-        });
-        const journal = journalWith([
-            ...ignoredPresent,
-            ".claude/worktrees/gone/a.ts", // missing + ignored — not subject to the cap
-            ".claude/worktrees/gone/b.ts",
-            "personal/keep.md",
-        ]);
-        const first = purgeExcludedPersonalVaultJournalEntries(journal, hqRoot, hqRoot, shouldSync, isLitter, { ignoredPresentBatch: 3 });
-        expect(first.guardTripped).toBeUndefined();
-        expect(first.byReason["ignore-filtered"]).toBe(2);
-        expect(first.byReason["ignore-filtered-present"]).toBe(3);
-        expect(first.removed).toHaveLength(5);
-        expect(Object.keys(journal.files)).toHaveLength(3); // 2 present ignored + keep
-        const second = purgeExcludedPersonalVaultJournalEntries(journal, hqRoot, hqRoot, shouldSync, isLitter, { ignoredPresentBatch: 3 });
-        expect(second.byReason["ignore-filtered-present"]).toBe(2);
-        expect(Object.keys(journal.files)).toEqual(["personal/keep.md"]);
-    });
-    it("exposes a default present-ignored batch large enough to drain a 500k-row backlog in a few passes", () => {
-        // ~460k stale rows at 25k/pass drains in ~19 passes (well under an hour at
-        // the watcher's cadence) while an accidental blanket rule still needs many
-        // passes to do real damage.
-        expect(PURGE_IGNORED_PRESENT_BATCH).toBe(25_000);
-    });
-    // Regression: the 2026-08-18 personal-vault journal wipe. A transient
-    // fs.statSync failure on the carve-out dirs (EMFILE under a large 64-way
-    // pass, or an FS hiccup during a network storm) made computeAgencySyncPaths /
-    // computeSessionLogsSyncPaths fail-soft to [], so `isSyncedWorkspaceCarveKey`
-    // no longer recognized their rows and the purge reclassified ~400k
-    // workspace/.session-logs + workspace/agency entries as excluded-top-level
-    // and dropped them — wiping the journal and stalling sync until a manual
-    // restart. Whether a workspace/ KEY belongs to a carve-out is a static fact
-    // of its path, so it must survive the carve-out dir being momentarily
-    // unstattable. We simulate that by removing the dirs while their rows remain.
-    it("keeps workspace carve-out rows when the carve-out dirs are momentarily unstattable", () => {
-        fs.rmSync(path.join(hqRoot, "workspace", ".session-logs"), {
-            recursive: true,
-            force: true,
-        });
-        fs.rmSync(path.join(hqRoot, "workspace", "agency"), {
-            recursive: true,
-            force: true,
-        });
-        const journal = journalWith([
-            "workspace/.session-logs/s.jsonl",
-            "workspace/.session-logs/deep/t.jsonl",
-            "workspace/agency/co/chat.jsonl",
-            "workspace/scratch/tmp.txt", // genuinely excluded — still PURGE
-            ".claude/skills/foo/SKILL.md", // base — KEEP
-        ]);
-        const { removed } = purgeExcludedPersonalVaultJournalEntries(journal, hqRoot, hqRoot, shouldSync, isLitter);
-        // Carve-out rows survive the filesystem hiccup...
-        expect(journal.files["workspace/.session-logs/s.jsonl"]).toBeDefined();
-        expect(journal.files["workspace/.session-logs/deep/t.jsonl"]).toBeDefined();
-        expect(journal.files["workspace/agency/co/chat.jsonl"]).toBeDefined();
-        expect(journal.files[".claude/skills/foo/SKILL.md"]).toBeDefined();
-        // ...while genuinely-excluded workspace/ rows are still pruned.
-        expect(removed).toContain("workspace/scratch/tmp.txt");
-        expect(removed).not.toContain("workspace/.session-logs/s.jsonl");
-        expect(removed).not.toContain("workspace/agency/co/chat.jsonl");
-    });
-    it("circuit breaker: refuses a mass purge (>50% of a large journal) and keeps every row", () => {
-        // 1000 genuinely-excluded workspace/ rows + 200 kept base rows = 1200 total;
-        // 83% would be dropped, well over the guard fraction on a >=1000-row journal.
-        const excluded = Array.from({ length: 1000 }, (_i, n) => `workspace/scratch/f${n}.txt`);
-        const kept = Array.from({ length: 200 }, (_i, n) => `.claude/skills/s${n}/SKILL.md`);
-        const journal = journalWith([...excluded, ...kept]);
-        const purge = purgeExcludedPersonalVaultJournalEntries(journal, hqRoot, hqRoot, shouldSync, isLitter);
-        expect(purge.removed).toEqual([]);
-        expect(purge.guardTripped).toEqual({ attempted: 1000, totalRows: 1200 });
-        // Nothing was actually dropped — the journal survives intact for resume.
-        expect(Object.keys(journal.files)).toHaveLength(1200);
-        for (const k of excluded)
-            expect(journal.files[k]).toBeDefined();
-    });
-    it("circuit breaker: allows a purge of exactly half the journal (guard is strictly >50%)", () => {
-        // 600 excluded of 1200 total = exactly 50%. The contract is "more than
-        // half", so this must NOT trip — otherwise these rows stay candidates every
-        // pass and the journal never converges at the boundary.
-        const excluded = Array.from({ length: 600 }, (_i, n) => `workspace/scratch/f${n}.txt`);
-        const kept = Array.from({ length: 600 }, (_i, n) => `.claude/skills/s${n}/SKILL.md`);
-        const journal = journalWith([...excluded, ...kept]);
-        const purge = purgeExcludedPersonalVaultJournalEntries(journal, hqRoot, hqRoot, shouldSync, isLitter);
-        expect(purge.guardTripped).toBeUndefined();
-        expect(purge.removed).toHaveLength(600);
-        expect(Object.keys(journal.files)).toHaveLength(600);
-    });
-    it("circuit breaker: does NOT guard a small journal, so early-baseline cleanup still applies", () => {
-        // Below PURGE_GUARD_MIN_JOURNAL a high purge fraction is normal baseline
-        // convergence, so the guard must stay out of the way.
-        const journal = journalWith([
-            "workspace/scratch/a.txt",
-            "workspace/scratch/b.txt",
-            ".claude/skills/foo/SKILL.md",
-        ]);
-        const purge = purgeExcludedPersonalVaultJournalEntries(journal, hqRoot, hqRoot, shouldSync, isLitter);
-        expect(purge.guardTripped).toBeUndefined();
-        expect(purge.removed.sort()).toEqual(["workspace/scratch/a.txt", "workspace/scratch/b.txt"].sort());
-        expect(journal.files[".claude/skills/foo/SKILL.md"]).toBeDefined();
-    });
-    it("defers `.conflict-*` / `.drift-*` litter to the vault-litter drain (remote delete)", () => {
-        // The delete-plan litter drain remotely DELETES these when the local file
-        // is gone — stronger than forgetting the row — so the purge must not touch
-        // them or it would strand the vault object.
-        const journal = journalWith([
-            "CLAUDE.md.conflict-2026-05-13T19-40-40Z-e5797a.md",
-            "personal/.obsidian/graph.json.drift-1779863862-42519",
-        ]);
-        const { removed } = purgeExcludedPersonalVaultJournalEntries(journal, hqRoot, hqRoot, shouldSync, isLitter);
-        expect(removed).toEqual([]);
-    });
-    it("does NOT purge cloud-company keys (owned by the decommission plan)", () => {
-        // A cloud company's stale keys are drained by computeDecommissionPlan,
-        // which deletes them remotely against their journal rows — purging them
-        // here would rob that plan of the rows. `companies/` is never top-level
-        // purged even though it is in PERSONAL_VAULT_EXCLUDED_TOP_LEVEL.
-        const journal = journalWith(["companies/cloudco/knowledge/a.md"]);
-        const { removed } = purgeExcludedPersonalVaultJournalEntries(journal, hqRoot, hqRoot, shouldSync, isLitter);
-        expect(removed).toEqual([]);
-        expect(Object.keys(journal.files)).toEqual([
-            "companies/cloudco/knowledge/a.md",
-        ]);
-    });
-    it("is a no-op on an already-clean journal", () => {
-        const journal = journalWith(["personal/a.md", "core/b.md"]);
-        const { removed, byReason } = purgeExcludedPersonalVaultJournalEntries(journal, hqRoot, hqRoot, shouldSync, isLitter);
-        expect(removed).toEqual([]);
-        expect(byReason).toEqual({
-            "ignore-filtered": 0,
-            "ignore-filtered-present": 0,
-            "excluded-top-level": 0,
-        });
-    });
-});
-//# sourceMappingURL=personal-vault.test.js.map