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

package/dist/ignore.test.js

@@ -1,926 +0,0 @@
-/**
- * Unit tests for createIgnoreFilter.
- *
- * Covers both modes: legacy permissive (no .hqinclude) and allowlist mode
- * (.hqinclude present). The allowlist tests guard against accidentally
- * leaking sensitive subtrees like data/ or workers/ to S3 — a regression
- * here would silently push private content on the next sync.
- */
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { createIgnoreFilter, createIgnoreFilterReference, isExpectedIgnore, } from "./ignore.js";
-import { wrapFilterWithIgnoreVisibility } from "./cli/share.js";
-describe("isExpectedIgnore", () => {
-    it("treats root .tmp-* build caches as expected, but not company data with that name", () => {
-        expect(isExpectedIgnore(".tmp-c180-base")).toBe(true);
-        expect(isExpectedIgnore(".tmp-c180-base/")).toBe(true);
-        expect(isExpectedIgnore(".tmp-c180-base/chunk/a.json")).toBe(true);
-        expect(isExpectedIgnore("companies/indigo/knowledge/.tmp-c180-base")).toBe(false);
-        expect(isExpectedIgnore("companies/indigo/knowledge/.tmp-c180-base/notes.md")).toBe(false);
-    });
-    it("classifies top-level HQ-managed roots as expected", () => {
-        expect(isExpectedIgnore("repos")).toBe(true);
-        expect(isExpectedIgnore("repos/private/x.ts")).toBe(true);
-        expect(isExpectedIgnore("workspace/tmp/file.md")).toBe(true);
-    });
-    it("classifies build, VCS, cache, and known basename noise as expected", () => {
-        expect(isExpectedIgnore("node_modules/react/index.js")).toBe(true);
-        expect(isExpectedIgnore("apps/web/node_modules/react/index.js")).toBe(true);
-        expect(isExpectedIgnore(".git/config")).toBe(true);
-        expect(isExpectedIgnore(".DS_Store")).toBe(true);
-        expect(isExpectedIgnore("x/.env")).toBe(true);
-        expect(isExpectedIgnore("a/b/.hq-sync.pid")).toBe(true);
-        expect(isExpectedIgnore("y/foo.pyc")).toBe(true);
-        // Cloud-only skill hero images (US-014) are an expected by-design exclusion.
-        expect(isExpectedIgnore(".claude/skills/foo/.skill-media/hero.png")).toBe(true);
-    });
-    it("classifies macOS Finder Icon\\r files as expected noise", () => {
-        // Finder scatters one into every directory it renders a custom icon for,
-        // and a folder-level cloud-sync agent propagates them tree-wide. Treated
-        // exactly like .DS_Store so a seeded tree stays silent rather than firing
-        // the "EXCLUDED from sync — review in case this is unintended" warning
-        // once per file.
-        expect(isExpectedIgnore("Icon\r")).toBe(true);
-        expect(isExpectedIgnore("companies/indigo/Icon\r")).toBe(true);
-    });
-    it("classifies AppleDouble files as expected noise", () => {
-        expect(isExpectedIgnore("core/._README.md")).toBe(true);
-        expect(isExpectedIgnore("core/connectors/apple-mail/._connector.sh")).toBe(true);
-        expect(isExpectedIgnore("core/README.md")).toBe(false);
-    });
-    it("classifies restore staging paths as expected noise", () => {
-        expect(isExpectedIgnore("core/packages.hq-restore-9980")).toBe(true);
-        expect(isExpectedIgnore("core/packages.hq-restore-9980/connectors/README.md")).toBe(true);
-        expect(isExpectedIgnore("core/README.md.hq-restore-probe-9980-m6bx")).toBe(true);
-    });
-    it("keeps a real file named Icons noteworthy (no `Icon?` over-match)", () => {
-        // The `Icon?` gitignore workaround would swallow these. Dropping real
-        // user content is a worse failure than the cruft being excluded.
-        expect(isExpectedIgnore("companies/indigo/Icons")).toBe(false);
-        expect(isExpectedIgnore("companies/indigo/Icon")).toBe(false);
-        expect(isExpectedIgnore("companies/indigo/Icons.md")).toBe(false);
-    });
-    it("keeps nested repos/workspace and ordinary content noteworthy", () => {
-        expect(isExpectedIgnore("companies/indigo/knowledge/repos/foo/notes.md")).toBe(false);
-        expect(isExpectedIgnore("companies/indigo/knowledge/overview.md")).toBe(false);
-    });
-    it("classifies secret/credential defaults as expected (no false 'unexpectedly excluded' warning)", () => {
-        // These are mandatory, by-design exclusions (DEFAULT_IGNORES). If they were
-        // not recognized here, every push touching a secret would fire the
-        // "EXCLUDED from sync — review in case unintended" warning.
-        expect(isExpectedIgnore("credentials.json")).toBe(true);
-        expect(isExpectedIgnore("companies/acme/credentials.json")).toBe(true);
-        expect(isExpectedIgnore("companies/acme/service.credentials.json")).toBe(true);
-        expect(isExpectedIgnore("personal/db.secret.yaml")).toBe(true);
-        expect(isExpectedIgnore("personal/.netrc")).toBe(true);
-        // Ordinary content that merely mentions "credentials"/"secret" stays noteworthy.
-        expect(isExpectedIgnore("docs/credentials-guide.md")).toBe(false);
-        expect(isExpectedIgnore("companies/acme/secrets-policy.md")).toBe(false);
-    });
-});
-describe("createIgnoreFilter", () => {
-    let hqRoot;
-    beforeEach(() => {
-        hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-ignore-test-"));
-    });
-    afterEach(() => {
-        fs.rmSync(hqRoot, { recursive: true, force: true });
-    });
-    it("permissive mode excludes AppleDouble files", () => {
-        const shouldSync = createIgnoreFilter(hqRoot);
-        const paths = [
-            "._README.md",
-            "core/._README.md",
-            "core/connectors/apple-mail/._connector.sh",
-        ];
-        for (const relative of paths) {
-            expect(shouldSync(path.join(hqRoot, relative)), relative).toBe(false);
-        }
-        expect(shouldSync(path.join(hqRoot, "core/README.md"))).toBe(true);
-    });
-    it("re-includes only the root MCP file for the personal-target flag", () => {
-        const shouldSync = createIgnoreFilter(hqRoot, { allowRootMcpConfig: true });
-        expect(shouldSync(path.join(hqRoot, ".mcp.json"))).toBe(true);
-        expect(shouldSync(path.join(hqRoot, "personal", ".mcp.json"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "companies", "acme", ".mcp.json"))).toBe(false);
-        expect(createIgnoreFilter(hqRoot)(path.join(hqRoot, ".mcp.json"))).toBe(false);
-    });
-    it("permissive mode excludes every restore staging segment", () => {
-        const shouldSync = createIgnoreFilter(hqRoot);
-        const paths = [
-            "core/packages.hq-restore-9980",
-            "core/packages.hq-restore-9980/connectors/README.md",
-            "core/README.md.hq-restore-probe-9980-m6bx",
-        ];
-        for (const relative of paths) {
-            expect(shouldSync(path.join(hqRoot, relative)), relative).toBe(false);
-        }
-        expect(shouldSync(path.join(hqRoot, "core/README.md"))).toBe(true);
-    });
-    it("memoized filter is observationally identical to the reference across ignore/include edge cases", () => {
-        // This combines the shapes that make a directory cache unsafe: ordered
-        // negations that re-include deep agency files, directory-only patterns,
-        // and allowlist ancestor descent. Every candidate is checked as both a
-        // file and a directory probe so the trailing-slash distinction is covered.
-        fs.writeFileSync(path.join(hqRoot, ".hqignore"), [
-            "plain-ignored.txt",
-            "dir-only/",
-            "workspace/agency/**",
-            "!workspace/agency/",
-            "!workspace/agency/*/",
-            "!workspace/agency/*/*/",
-            "!workspace/agency/*/*/status.json",
-            "!workspace/agency/*/*/team.json",
-            "!workspace/agency/*/*/chat.jsonl",
-        ].join("\n"));
-        fs.writeFileSync(path.join(hqRoot, ".hqinclude"), ["allow/leaf.txt", "projects/*/docs/"].join("\n"));
-        const candidates = [
-            "plain-ignored.txt",
-            "plain-kept.txt",
-            "dir-only",
-            "dir-only/child.txt",
-            "workspace",
-            "workspace/agency",
-            "workspace/agency/acme",
-            "workspace/agency/acme/team-a",
-            "workspace/agency/acme/team-a/status.json",
-            "workspace/agency/acme/team-a/team.json",
-            "workspace/agency/acme/team-a/chat.jsonl",
-            "workspace/agency/acme/team-a/other.txt",
-            "allow",
-            "allow/leaf.txt",
-            "projects",
-            "projects/acme",
-            "projects/acme/docs",
-            "projects/acme/docs/readme.md",
-            "Icon\r",
-        ];
-        const reference = createIgnoreFilterReference(hqRoot);
-        const memoized = createIgnoreFilter(hqRoot);
-        for (const relative of candidates) {
-            const absolute = path.join(hqRoot, relative);
-            for (const isDir of [false, true]) {
-                expect(memoized(absolute, isDir), `${relative} (isDir=${isDir})`).toBe(reference(absolute, isDir));
-            }
-        }
-        // Outside-root checks are part of the historical contract too.
-        const outside = path.join(path.dirname(hqRoot), "outside.md");
-        expect(memoized(outside)).toBe(reference(outside));
-    });
-    it("memoizes the parent-directory verdict, never the file's", () => {
-        const stats = {
-            cacheHits: 0,
-            cacheMisses: 0,
-            matcherInvocations: 0,
-        };
-        const filter = createIgnoreFilter(hqRoot, { memoLimit: 1_000, stats });
-        const paths = Array.from({ length: 500 }, (_value, index) => path.join(hqRoot, "workspace", "agency", "acme", `f-${index}.json`));
-        for (let pass = 0; pass < 4; pass += 1) {
-            for (const candidate of paths)
-                expect(filter(candidate)).toBe(true);
-        }
-        // 2,000 probes of one folder cost one memo entry and one memo miss. The
-        // old per-file memo held 500 entries here and ~1.5M on a real HQ walk,
-        // where it rolled over ~30 times per walk and so never stayed warm.
-        expect(stats.cacheEntries).toBe(1);
-        expect(filter.censusSize()).toBe(1);
-        expect(stats.cacheMisses).toBe(1);
-        expect(stats.cacheHits).toBe(paths.length * 4 - 1);
-        // Files inside an included folder still reach the matcher on every probe:
-        // that is the trade — matcher time per file for memory per directory.
-        expect(stats.matcherInvocations).toBe(paths.length * 4 + 1);
-        const cappedStats = {
-            cacheHits: 0,
-            cacheMisses: 0,
-            matcherInvocations: 0,
-        };
-        const capped = createIgnoreFilter(hqRoot, { memoLimit: 0, stats: cappedStats });
-        for (const candidate of paths)
-            expect(capped(candidate)).toBe(true);
-        for (const candidate of paths)
-            expect(capped(candidate)).toBe(true);
-        // With no memo at all every probe evaluates its parent and then itself.
-        // Correctness comes from exact re-evaluation, not from cache admission.
-        expect(cappedStats.cacheHits).toBe(0);
-        expect(cappedStats.cacheEntries).toBe(0);
-        expect(cappedStats.matcherInvocations).toBe(paths.length * 2 * 2);
-    });
-    it("short-circuits every file under an excluded folder without consulting the matcher", () => {
-        fs.writeFileSync(path.join(hqRoot, ".hqignore"), "private/\n");
-        const stats = {
-            cacheHits: 0,
-            cacheMisses: 0,
-            matcherInvocations: 0,
-        };
-        const filter = createIgnoreFilter(hqRoot, { memoLimit: 1_000, stats });
-        const dirs = Array.from({ length: 10 }, (_value, index) => `private/team-${index}/notes`);
-        for (const dir of dirs) {
-            for (let index = 0; index < 100; index += 1) {
-                expect(filter(path.join(hqRoot, dir, `${index}.md`))).toBe(false);
-            }
-        }
-        // gitignore semantics: nothing under an excluded directory can be
-        // re-included, so an excluded parent settles its children with a Map
-        // lookup. The matcher ran once per distinct folder and never per file.
-        expect(stats.matcherInvocations).toBe(dirs.length);
-        expect(stats.cacheMisses).toBe(dirs.length);
-        expect(stats.cacheHits).toBe(dirs.length * 100 - dirs.length);
-        expect(stats.cacheEntries).toBe(dirs.length);
-    });
-    it("keeps memo entries proportional to directories, not files", () => {
-        const filter = createIgnoreFilter(hqRoot, { memoLimit: 1_000 });
-        for (let dir = 0; dir < 50; dir += 1) {
-            for (let file = 0; file < 200; file += 1) {
-                filter(path.join(hqRoot, "personal", `d-${dir}`, `f-${file}.md`));
-            }
-        }
-        expect(filter.censusSize()).toBe(50);
-    });
-    it("treats root-level files and directories as having no cacheable parent", () => {
-        fs.writeFileSync(path.join(hqRoot, ".hqignore"), "top-secret/\n*.log\n");
-        const stats = {
-            cacheHits: 0,
-            cacheMisses: 0,
-            matcherInvocations: 0,
-        };
-        const filter = createIgnoreFilter(hqRoot, { memoLimit: 1_000, stats });
-        expect(filter(path.join(hqRoot, "README.md"))).toBe(true);
-        expect(filter(path.join(hqRoot, "debug.log"))).toBe(false);
-        expect(filter(path.join(hqRoot, "top-secret"), true)).toBe(false);
-        expect(filter(path.join(hqRoot, "top-secret"), false)).toBe(true);
-        expect(filter(path.join(hqRoot, "top-secret", "x.md"))).toBe(false);
-        // Root probes never consult the memo. The one DIRECTORY probe seeded its
-        // own verdict (a walker probes a folder before descending into it), so the
-        // child's lookup was already warm.
-        expect(stats.cacheEntries).toBe(1);
-        expect(stats.cacheMisses).toBe(0);
-        expect(stats.cacheHits).toBe(1);
-    });
-    it("rolls the directory memo over at its bound and re-evaluates evicted folders", () => {
-        const stats = {
-            cacheHits: 0,
-            cacheMisses: 0,
-            matcherInvocations: 0,
-        };
-        fs.writeFileSync(path.join(hqRoot, ".hqignore"), "private/\n");
-        const filter = createIgnoreFilter(hqRoot, {
-            memoLimit: 3,
-            matcherRebuildInterval: 3,
-            stats,
-        });
-        for (let cycle = 0; cycle < 20; cycle += 1) {
-            for (let index = 0; index < 5; index += 1) {
-                expect(filter(path.join(hqRoot, "public", `${cycle}-${index}`, "note.md"))).toBe(true);
-            }
-            // This folder has necessarily fallen out of the small memo. A miss must
-            // consult the real matcher and preserve the privacy exclusion.
-            expect(filter(path.join(hqRoot, "private", `${cycle}`, "note.md"), false)).toBe(false);
-        }
-        expect(stats.cacheEntries).toBeLessThanOrEqual(3);
-        expect(stats.matcherGenerations).toBeGreaterThan(1);
-    });
-    it("bounds the matcher's private cache by rebuilding it after a fixed number of evaluations", () => {
-        const stats = {
-            cacheHits: 0,
-            cacheMisses: 0,
-            matcherInvocations: 0,
-        };
-        const filter = createIgnoreFilter(hqRoot, {
-            memoLimit: 1_000,
-            matcherRebuildInterval: 100,
-            stats,
-        });
-        // One folder, one memo entry — but the `ignore` package caches every path
-        // it is handed internally, so 1,000 distinct files would still grow its
-        // private cache without bound. Rebuilding on an evaluation count keeps it
-        // bounded independently of how many directories the memo retains.
-        for (let index = 0; index < 1_000; index += 1) {
-            filter(path.join(hqRoot, "personal", "notes", `${index}.md`));
-        }
-        expect(stats.cacheEntries).toBe(1);
-        expect(stats.matcherGenerations).toBeGreaterThanOrEqual(10);
-    });
-    it("captures ignore configuration once even when both caches roll over repeatedly", () => {
-        const coreYaml = path.join(hqRoot, "core", "core.yaml");
-        const hqignore = path.join(hqRoot, ".hqignore");
-        const hqsyncignore = path.join(hqRoot, ".hqsyncignore");
-        const hqinclude = path.join(hqRoot, ".hqinclude");
-        const contents = new Map([
-            [hqignore, "ignored/\n"],
-            [hqsyncignore, "legacy-ignored/\n"],
-            [hqinclude, "included/\n"],
-        ]);
-        const snapshotReader = {
-            existsSync: vi.fn((filePath) => filePath === coreYaml || contents.has(filePath)),
-            readFileSync: vi.fn((filePath) => {
-                const content = contents.get(filePath);
-                if (content === undefined)
-                    throw new Error(`unexpected read of ${filePath}`);
-                return content;
-            }),
-        };
-        const filter = createIgnoreFilter(hqRoot, {
-            memoLimit: 1,
-            matcherRebuildInterval: 1,
-            snapshotReader,
-        });
-        for (let index = 0; index < 10; index += 1) {
-            filter(path.join(hqRoot, "included", `${index}`, "note.md"));
-        }
-        const callsFor = (calls, filePath) => calls.filter(([candidate]) => candidate === filePath).length;
-        expect(callsFor(snapshotReader.existsSync.mock.calls, coreYaml)).toBe(1);
-        expect(callsFor(snapshotReader.existsSync.mock.calls, hqignore)).toBe(1);
-        expect(callsFor(snapshotReader.existsSync.mock.calls, hqsyncignore)).toBe(1);
-        expect(callsFor(snapshotReader.existsSync.mock.calls, hqinclude)).toBe(1);
-        expect(callsFor(snapshotReader.readFileSync.mock.calls, hqignore)).toBe(1);
-        expect(callsFor(snapshotReader.readFileSync.mock.calls, hqsyncignore)).toBe(1);
-        expect(callsFor(snapshotReader.readFileSync.mock.calls, hqinclude)).toBe(1);
-    });
-    describe("folder memo is observationally identical to the reference over a generated tree", () => {
-        // A deterministic tree that exercises every shape the folder memo must
-        // not get wrong: excluded directories with files that a later negation
-        // tries (and must fail) to re-include, directory-only patterns, deep
-        // negation ladders under workspace/agency, root-anchored globs, an
-        // excluded name that is itself re-included, and — in the second variant —
-        // allowlist mode with ancestor descent.
-        const IGNORE_RULES = [
-            "build/",
-            "*.log",
-            "!important.log",
-            "/workspace/agency/**/*.tmp",
-            "workspace/agency/**",
-            "!workspace/agency/",
-            "!workspace/agency/*/",
-            "!workspace/agency/*/*/",
-            "!workspace/agency/*/*/status.json",
-            "docs/*/drafts/",
-            "secret-*",
-            "!secret-public",
-        ];
-        const DIRS = [
-            "build",
-            "build/sub",
-            "logs",
-            "workspace",
-            "workspace/agency",
-            "workspace/agency/acme",
-            "workspace/agency/acme/team",
-            "workspace/agency/acme/team/deep",
-            "docs",
-            "docs/a",
-            "docs/a/drafts",
-            "docs/a/drafts/x",
-            "secret-1",
-            "secret-1/inner",
-            "secret-public",
-            "secret-public/inner",
-            "plain",
-            "plain/nested",
-        ];
-        const LEAVES = ["file.txt", "file.log", "important.log", "status.json", "note.tmp", "Icon\r"];
-        const candidates = () => {
-            const all = [...LEAVES];
-            for (const dir of DIRS) {
-                all.push(dir);
-                for (const leaf of LEAVES)
-                    all.push(`${dir}/${leaf}`);
-            }
-            return all;
-        };
-        /** Small deterministic PRNG so a failure is reproducible from the seed. */
-        const shuffled = (items, seed) => {
-            const out = [...items];
-            let state = seed >>> 0;
-            for (let index = out.length - 1; index > 0; index -= 1) {
-                state = (Math.imul(state, 1664525) + 1013904223) >>> 0;
-                const swap = state % (index + 1);
-                [out[index], out[swap]] = [out[swap], out[index]];
-            }
-            return out;
-        };
-        const assertParity = (order, label) => {
-            const reference = createIgnoreFilterReference(hqRoot);
-            // Tiny bounds force memo rollovers and matcher rebuilds mid-walk, so the
-            // comparison covers warm hits, cold misses, and post-rollover state.
-            const memoized = createIgnoreFilter(hqRoot, { memoLimit: 2, matcherRebuildInterval: 3 });
-            for (let pass = 0; pass < 2; pass += 1) {
-                for (const relative of order) {
-                    const absolute = path.join(hqRoot, relative);
-                    for (const isDir of [false, true]) {
-                        expect(memoized(absolute, isDir), `${label} pass=${pass} ${JSON.stringify(relative)} (isDir=${isDir})`).toBe(reference(absolute, isDir));
-                    }
-                }
-            }
-        };
-        for (const allowlist of [false, true]) {
-            it(`${allowlist ? "allowlist" : "permissive"} mode: parents-first, children-first, and shuffled probe orders agree`, () => {
-                fs.writeFileSync(path.join(hqRoot, ".hqignore"), IGNORE_RULES.join("\n"));
-                if (allowlist) {
-                    fs.writeFileSync(path.join(hqRoot, ".hqinclude"), ["docs/*/", "plain/file.txt", "secret-public/", "workspace/agency/*/*/"].join("\n"));
-                }
-                const all = candidates();
-                assertParity(all, "parents-first");
-                assertParity([...all].reverse(), "children-first");
-                for (const seed of [1, 7, 42])
-                    assertParity(shuffled(all, seed), `seed=${seed}`);
-            });
-        }
-    });
-    it("keeps allowlist mode active after .hqinclude is deleted during a rollover", () => {
-        const hqinclude = path.join(hqRoot, ".hqinclude");
-        fs.writeFileSync(hqinclude, "included/allowed.md\n");
-        const filter = createIgnoreFilter(hqRoot, { memoLimit: 1, matcherRebuildInterval: 1 });
-        expect(filter(path.join(hqRoot, "included", "allowed.md"))).toBe(true);
-        fs.rmSync(hqinclude);
-        // This unique folder rolls the memo and the matcher rebuilds. Neither was
-        // captured in the first generation, so it proves the new generation
-        // retained allowlist mode.
-        expect(filter(path.join(hqRoot, "not-included", "private.md"))).toBe(false);
-    });
-    it("keeps .hqignore exclusions after its contents are truncated during a rollover", () => {
-        const hqignore = path.join(hqRoot, ".hqignore");
-        fs.writeFileSync(hqignore, "private/\n");
-        const filter = createIgnoreFilter(hqRoot, { memoLimit: 1, matcherRebuildInterval: 1 });
-        expect(filter(path.join(hqRoot, "public", "seed.md"))).toBe(true);
-        fs.writeFileSync(hqignore, "");
-        // This unique folder rolls the memo and the matcher rebuilds. Its
-        // exclusion must come from the construction-time snapshot, not the later
-        // on-disk file contents.
-        expect(filter(path.join(hqRoot, "private", "secret.md"))).toBe(false);
-    });
-    // Sync exclusions are governed ONLY by hq-cloud's own config (.hqignore /
-    // .hqinclude) plus the built-in defaults — never by the repo's .gitignore.
-    // .gitignore describes what the git-mirror should not COMMIT, which is a
-    // different question from what sync should not UPLOAD; coupling them meant
-    // excluding a subtree from the git-mirror silently stopped syncing it too
-    // (the 2026-08 personal-vault carve-out incident). Root cause of the split.
-    describe("ignores .gitignore entirely (only .hqignore/.hqinclude govern sync)", () => {
-        it("a .gitignore pattern does NOT exclude a file from sync", () => {
-            fs.writeFileSync(path.join(hqRoot, ".gitignore"), "workspace/\nsecret-dir/\n*.bigfile\n");
-            const shouldSync = createIgnoreFilter(hqRoot);
-            expect(shouldSync(path.join(hqRoot, "workspace/.session-logs/s.jsonl"))).toBe(true);
-            expect(shouldSync(path.join(hqRoot, "secret-dir/x.md"))).toBe(true);
-            expect(shouldSync(path.join(hqRoot, "notes.bigfile"))).toBe(true);
-        });
-        it("the same pattern in .hqignore DOES exclude it (the supported channel)", () => {
-            fs.writeFileSync(path.join(hqRoot, ".hqignore"), "secret-dir/\n*.bigfile\n");
-            const shouldSync = createIgnoreFilter(hqRoot);
-            expect(shouldSync(path.join(hqRoot, "secret-dir/x.md"))).toBe(false);
-            expect(shouldSync(path.join(hqRoot, "notes.bigfile"))).toBe(false);
-            expect(shouldSync(path.join(hqRoot, "notes.md"))).toBe(true);
-        });
-        // Secrets used to be kept out of the vault only because most HQ roots'
-        // .gitignore listed them. Now that .gitignore is not consulted, the built-in
-        // defaults must guarantee it for every user, independent of any config file.
-        it("secret files are excluded by the built-in defaults, with no ignore file at all", () => {
-            const shouldSync = createIgnoreFilter(hqRoot);
-            for (const p of [
-                ".env",
-                ".env.local",
-                ".env.production.local",
-                ".env.staging-token",
-                "companies/acme/.env",
-                "companies/acme/service.credentials.json",
-                "credentials.json", // bare basename, not just *.credentials.json
-                "companies/acme/knowledge/credentials.json",
-                "personal/db.secret.yaml",
-                ".mcp.json",
-                "companies/acme/.mcp.json",
-                "personal/.netrc",
-            ]) {
-                expect(shouldSync(path.join(hqRoot, p)), `${p} must be excluded by default`).toBe(false);
-            }
-            // A near-miss that must NOT be swallowed: an ordinary env-adjacent doc.
-            expect(shouldSync(path.join(hqRoot, "docs/env-setup.md"))).toBe(true);
-            // Packaged .mcp.json templates under core/packages/*/ are release-shipped
-            // config, not a user secret; the .gitignore used to re-include them and
-            // the defaults must preserve that carve-out.
-            expect(shouldSync(path.join(hqRoot, "core/packages/hq-pack-gemini/.mcp.json"))).toBe(true);
-        });
-    });
-    it("permissive mode: regular files sync, defaults are ignored", () => {
-        const shouldSync = createIgnoreFilter(hqRoot);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/notes.md"))).toBe(true);
-        expect(shouldSync(path.join(hqRoot, "node_modules/foo/x.js"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, ".env"))).toBe(false);
-    });
-    it("permissive mode: project-local .qmd index is ignored by default", () => {
-        // feedback_332c7ccc / sqlite-vec#297 — never round-trip a project-local
-        // qmd index through the vault.
-        const shouldSync = createIgnoreFilter(hqRoot);
-        expect(shouldSync(path.join(hqRoot, ".qmd"), true)).toBe(false);
-        expect(shouldSync(path.join(hqRoot, ".qmd/index.sqlite"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, ".qmd/index.sqlite-wal"))).toBe(false);
-        expect(isExpectedIgnore(".qmd/index.sqlite")).toBe(true);
-    });
-    it("permissive mode: pnpm content-addressed store is ignored by default", () => {
-        // .pnpm-store/ is pnpm's content-addressed package store. Like
-        // node_modules/ it is large and machine-local and must never sync — a
-        // synced store writes a `.conflict-` copy of every blob each cycle, which
-        // then re-syncs and amplifies into tens of thousands of files. Regression
-        // guard for that storm.
-        const shouldSync = createIgnoreFilter(hqRoot);
-        // The store directory and everything beneath it is excluded.
-        expect(shouldSync(path.join(hqRoot, ".pnpm-store"), true)).toBe(false);
-        expect(shouldSync(path.join(hqRoot, ".pnpm-store/v10/files/00/abc123"))).toBe(false);
-        // Caught at any depth — a project store nested under a synced subtree.
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/repos/x/.pnpm-store/v10/blob"))).toBe(false);
-        // node_modules/ is already covered; asserted here so the pair travels together.
-        expect(shouldSync(path.join(hqRoot, "node_modules/react/index.js"))).toBe(false);
-    });
-    it("permissive mode: macOS Finder Icon\\r files never enter the walk", () => {
-        // A CR is a control character, so the vault key validator rejects the key
-        // (INVALID_KEY_CONTROL_CHARS) and the upload can only ever throw. Dropping
-        // them during the walk is what keeps them off the upload path entirely.
-        const shouldSync = createIgnoreFilter(hqRoot);
-        expect(shouldSync(path.join(hqRoot, "Icon\r"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/Icon\r"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, ".agents/Icon\r"))).toBe(false);
-        // Caught at any depth, like the other OS-cruft exclusions.
-        expect(shouldSync(path.join(hqRoot, "a/b/c/d/Icon\r"))).toBe(false);
-    });
-    it("permissive mode: a real file named Icons still syncs", () => {
-        // Regression guard for the `Icon?` gitignore workaround, whose `?`
-        // single-char wildcard also matches Icons / Icon1 / IconX. This exclusion
-        // matches the exact Finder byte sequence instead, so real content survives.
-        const shouldSync = createIgnoreFilter(hqRoot);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/Icons"))).toBe(true);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/Icon"))).toBe(true);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/Icon1"))).toBe(true);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/Icons.md"))).toBe(true);
-    });
-    it("a literal Icon+CR line in .hqignore does NOT reach the ignore lib", () => {
-        // This is why the exclusion is a predicate and not a DEFAULT_IGNORES
-        // entry. ignore@5 strips a trailing CR from a pattern line, so the
-        // spelling git itself requires silently never matches. Pinning the
-        // upstream behavior here means a future ignore-lib bump that changes it
-        // surfaces as a failing test rather than a silent double-exclusion.
-        // (.hqignore is the sync-config channel; .gitignore is not consulted.)
-        fs.writeFileSync(path.join(hqRoot, ".hqignore"), "Icon\r\n");
-        const shouldSync = createIgnoreFilter(hqRoot);
-        // Still excluded — by the predicate, not by the pattern.
-        expect(shouldSync(path.join(hqRoot, "Icon\r"))).toBe(false);
-        // Proof the pattern itself is inert: it did not take `Icons` with it.
-        expect(shouldSync(path.join(hqRoot, "Icons"))).toBe(true);
-    });
-    it("repos/ exclusion is root-anchored to hqRoot (DEV-1791)", () => {
-        const shouldSync = createIgnoreFilter(hqRoot);
-        expect(shouldSync(path.join(hqRoot, "repos/private/hq-cloud/src/x.ts"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "repos/public/hq-core/README.md"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "companies/lutiq/knowledge/repos/dev-docs-mcp/overview.md"))).toBe(true);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/knowledge/repos/foo/notes.md"))).toBe(true);
-        expect(shouldSync(path.join(hqRoot, "companies/lutiq/knowledge/repos"), true)).toBe(true);
-    });
-    it("excludes only repositories directly under a company root", () => {
-        const shouldSync = createIgnoreFilter(hqRoot);
-        expect(shouldSync(path.join(hqRoot, "companies", "acme", "repos", "x", "a.md"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "companies", "acme", "repos"), true)).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "companies", "acme", "knowledge", "repos", "a.md"))).toBe(true);
-        expect(shouldSync(path.join(hqRoot, "companies", "acme", "knowledge", "repos"), true)).toBe(true);
-    });
-    it("permissive mode: .hqignore patterns are honored", () => {
-        fs.writeFileSync(path.join(hqRoot, ".hqignore"), "companies/*/data/\n");
-        const shouldSync = createIgnoreFilter(hqRoot);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/data/x.csv"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/notes.md"))).toBe(true);
-    });
-    it("visibility fires on an OVER-BROAD exclusion (real filter + recorder, DEV-1791)", () => {
-        // Simulate the regressed over-broad bug: an un-anchored `repos/` in
-        // .hqignore that matches ANY nested repos segment — exactly what
-        // silently ate /discover knowledge under companies/*/knowledge/repos/
-        // before the root-anchor fix. The visibility recorder must surface the
-        // dropped knowledge as NOTEWORTHY while staying quiet on build noise.
-        fs.writeFileSync(path.join(hqRoot, ".hqignore"), "repos/\n");
-        const ignoreFilter = createIgnoreFilter(hqRoot);
-        const noteworthy = [];
-        let total = 0;
-        const recorded = wrapFilterWithIgnoreVisibility(ignoreFilter, hqRoot, (rel) => { noteworthy.push(rel); }, () => { total++; });
-        // Knowledge under a nested repos/ is dropped by the over-broad rule and
-        // is genuine content → captured as noteworthy.
-        expect(recorded(path.join(hqRoot, "companies/indigo/knowledge/repos/foo/notes.md"))).toBe(false);
-        // Build noise is also excluded but is EXPECTED → counted, not noteworthy.
-        expect(recorded(path.join(hqRoot, "node_modules/react/index.js"))).toBe(false);
-        // Ordinary knowledge that the filter ALLOWS fires nothing.
-        expect(recorded(path.join(hqRoot, "companies/indigo/knowledge/overview.md"))).toBe(true);
-        expect(noteworthy).toEqual(["companies/indigo/knowledge/repos/foo/notes.md"]);
-        expect(total).toBe(2); // both exclusions counted; only one is noteworthy
-    });
-    it("v15+ layout (core/core.yaml present): root core.yaml is ignored, nested core/core.yaml syncs", () => {
-        // On v15+ the scaffold/version manifest lives at `core/core.yaml` (a real
-        // project file that DOES sync). Any root-level `core.yaml` here is a stale
-        // per-machine duplicate that must never round-trip — pulling another
-        // machine's marker would corrupt root discovery. The exclusion is anchored
-        // (`/core.yaml`) so it never touches `core/core.yaml`.
-        fs.mkdirSync(path.join(hqRoot, "core"), { recursive: true });
-        fs.writeFileSync(path.join(hqRoot, "core/core.yaml"), 'version: 1\nhqVersion: "15.0.12"\n');
-        fs.writeFileSync(path.join(hqRoot, "core.yaml"), 'version: 1\nhqVersion: "15.0.12"\n');
-        const shouldSync = createIgnoreFilter(hqRoot);
-        expect(shouldSync(path.join(hqRoot, "core.yaml"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "core/core.yaml"))).toBe(true);
-    });
-    it("v12–v14 layout (no core/core.yaml): root core.yaml IS the manifest and MUST sync", () => {
-        // Regression for DEV-1729 / the ~98 "no core.yaml in vault, version
-        // undetectable" sync users. On v12–v14 roots there is NO `core/core.yaml`
-        // — the ROOT `core.yaml` is the scaffold/version manifest. The old
-        // unconditional `/core.yaml` exclusion silently dropped it (while
-        // computePersonalVaultPaths still enumerated it), so the vault never
-        // received a version marker. With no `core/core.yaml` on disk, the root
-        // `core.yaml` must round-trip like any other top-level file.
-        fs.writeFileSync(path.join(hqRoot, "core.yaml"), 'version: 1\nhqVersion: "14.0.0"\n');
-        const shouldSync = createIgnoreFilter(hqRoot);
-        expect(shouldSync(path.join(hqRoot, "core.yaml"))).toBe(true);
-    });
-    it("permissive mode: modules/modules.yaml manifest is ignored", () => {
-        // modules.yaml is the local modules-resolution manifest. Per-machine
-        // state, never synced.
-        const shouldSync = createIgnoreFilter(hqRoot);
-        expect(shouldSync(path.join(hqRoot, "modules/modules.yaml"))).toBe(false);
-    });
-    it("permissive mode: per-company company.yaml is ignored", () => {
-        // company.yaml is written locally on first sync from the entity context.
-        // Round-tripping it would let one machine's identity overwrite another's.
-        const shouldSync = createIgnoreFilter(hqRoot);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/company.yaml"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "company.yaml"))).toBe(false);
-    });
-    it("permissive mode: root INDEX.md, tools INDEX.md, and policies/_digest.md are ignored", () => {
-        // Root INDEX.md and companies/*/tools/INDEX.md are regenerated locally.
-        // policies/_digest.md is the policies digest builder output.
-        const shouldSync = createIgnoreFilter(hqRoot);
-        expect(shouldSync(path.join(hqRoot, "INDEX.md"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "companies/ghq/tools/INDEX.md"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "policies/_digest.md"))).toBe(false);
-    });
-    it("syncs hand-authored INDEX.md under company knowledge (feedback 2292)", () => {
-        // Unanchored INDEX.md used to drop every file of that name at any depth.
-        // Crayads lost 14 hand-written knowledge maps (101 KB) that way: sync
-        // reported success and only an ignore-excluded ndjson event named one
-        // lowercase index.md. These are user content, not the tools indexer.
-        const knowledgeDir = path.join(hqRoot, "companies/crayads/knowledge/librarys/visual-formats/anleitungen");
-        fs.mkdirSync(knowledgeDir, { recursive: true });
-        const handWrittenUpper = path.join(hqRoot, "companies/crayads/knowledge/librarys/personas/INDEX.md");
-        const handWrittenLower = path.join(knowledgeDir, "index.md");
-        fs.mkdirSync(path.dirname(handWrittenUpper), { recursive: true });
-        fs.writeFileSync(handWrittenUpper, "# Personas\n\nHand-authored navigation.\n");
-        fs.writeFileSync(handWrittenLower, "# Anleitungen\n\nHand-authored navigation.\n");
-        const generated = path.join(hqRoot, "companies/crayads/knowledge/INDEX.md");
-        fs.writeFileSync(generated, "# Knowledge\n\n> Auto-generated. Updated: 2026-09-16\n\n| Name | Description |\n|------|-------------|\n");
-        const shouldSync = createIgnoreFilter(hqRoot);
-        const reference = createIgnoreFilterReference(hqRoot);
-        expect(shouldSync(handWrittenUpper)).toBe(true);
-        expect(shouldSync(handWrittenLower)).toBe(true);
-        expect(shouldSync(generated)).toBe(false);
-        expect(reference(handWrittenUpper)).toBe(true);
-        expect(reference(handWrittenLower)).toBe(true);
-        expect(reference(generated)).toBe(false);
-        // Visibility: generated copies stay expected (no false "review this"
-        // warning). Hand-authored files are allowed, so they never hit it.
-        expect(isExpectedIgnore("companies/crayads/knowledge/INDEX.md")).toBe(true);
-        expect(isExpectedIgnore("companies/crayads/knowledge/librarys/visual-formats/anleitungen/index.md")).toBe(true);
-    });
-    it("permissive mode: .claude/worktrees/ is ignored", () => {
-        const shouldSync = createIgnoreFilter(hqRoot);
-        expect(shouldSync(path.join(hqRoot, ".claude/worktrees/foo/file.ts"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/.claude/worktrees/bar/x.md"))).toBe(false);
-        // The .claude/ dir itself (commands, skills, hooks) still syncs.
-        expect(shouldSync(path.join(hqRoot, ".claude/skills/foo/SKILL.md"))).toBe(true);
-    });
-    it("permissive mode: workspace/worktrees/ is ignored without an .hqignore entry", () => {
-        // Regression: this was excluded ONLY when an operator remembered to list it
-        // in .hqignore. On Outpost 2 (2026-09-04) it was absent, so the sync runner
-        // descended into 23 live fleet worktrees — 289,141 files / 4.2 GB — and,
-        // because this same filter drives chokidar's descent predicate, held
-        // 113,389 inotify watches and 3.65 GB RSS over a tree the hq-sentry fleet
-        // creates and deletes continuously. Same lifecycle as .claude/worktrees/,
-        // so it belongs in DEFAULT_IGNORES, not in an operator's config.
-        const shouldSync = createIgnoreFilter(hqRoot);
-        expect(shouldSync(path.join(hqRoot, "workspace/worktrees/hq-pro/task-1/src/a.ts"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "workspace/worktrees/wf-hq-sentry-abc/node_modules/x/y.js"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "workspace/worktrees"), true)).toBe(false);
-        // Root-anchored, following the /repos/ precedent (DEV-1791): a nested dir
-        // legitimately named workspace/worktrees inside synced knowledge must NOT
-        // be dropped.
-        expect(shouldSync(path.join(hqRoot, "personal/knowledge/repo-x/workspace/worktrees/notes.md"))).toBe(true);
-        // The rule must not broaden to workspace/ — the rest of workspace still syncs.
-        expect(shouldSync(path.join(hqRoot, "workspace/reports/outpost2.md"))).toBe(true);
-        expect(shouldSync(path.join(hqRoot, "workspace/threads/handoff.json"))).toBe(true);
-    });
-    it("permissive mode: workspace/locks/ is ignored, and the SYNCED carve-outs are not", () => {
-        // Lock files are per-host mutexes held by a running process: another machine
-        // can neither hold nor release one.
-        const shouldSync = createIgnoreFilter(hqRoot);
-        expect(shouldSync(path.join(hqRoot, "workspace/locks/run-project.lock"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "workspace/locks"), true)).toBe(false);
-        // Root-anchored (the DEV-1791 lesson, as with /workspace/worktrees/): a
-        // nested `workspace/locks` inside synced knowledge is real content.
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/knowledge/workspace/locks/notes.md"))).toBe(true);
-        // ⚠️ These two were the audit's two LARGEST finding classes and are the
-        // obvious things to ignore — and they must NOT be. `.session-logs/` is the
-        // cross-machine session-capture carve-out and `workspace/threads/` carries
-        // the DEV-1778 continuity pointer that makes a `/handoff` resume on another
-        // machine. Their audit noise is a REPORTING problem, suppressed server-side.
-        expect(shouldSync(path.join(hqRoot, "workspace/.session-logs/2026-09-07/s.jsonl"))).toBe(true);
-        expect(shouldSync(path.join(hqRoot, "workspace/threads/handoff.json"))).toBe(true);
-    });
-    it("permissive mode: client-written conflict copies are ignored", () => {
-        // The client writes `<name>.conflict-<ts>-<id>` itself when it cannot merge.
-        // 874 audit findings, 732 of them verdict-flipping `local_untracked`.
-        const shouldSync = createIgnoreFilter(hqRoot);
-        expect(shouldSync(path.join(hqRoot, "plan.conflict-20260907T101112Z-a1b2c3.md"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/knowledge/n.conflict-2026-09-07-9f2a.md"))).toBe(false);
-        // Must NOT swallow a user file that merely contains the word: the digit
-        // class after `conflict-` and the required second hyphen are what keep
-        // `notes.conflict-resolution.md` syncing.
-        expect(shouldSync(path.join(hqRoot, "notes.conflict-resolution.md"))).toBe(true);
-    });
-    it("permissive mode: .skill-media/ (cloud-only skill images) is ignored (US-014)", () => {
-        const shouldSync = createIgnoreFilter(hqRoot);
-        // Skill hero images are cloud-only — excluded from push AND pull at any depth.
-        expect(shouldSync(path.join(hqRoot, ".claude/skills/lead-qualifier/.skill-media/hero.png"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/skills/foo/.skill-media/cover.jpg"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "skills/bar/.skill-media"), true)).toBe(false);
-        // The skill's SKILL.md and other content still sync — the rule is scoped to
-        // the media dir only, never the skill.
-        expect(shouldSync(path.join(hqRoot, ".claude/skills/lead-qualifier/SKILL.md"))).toBe(true);
-    });
-    it("permissive mode: .hq-* internal state is ignored, .hqignore family still sync", () => {
-        const shouldSync = createIgnoreFilter(hqRoot);
-        // Internal state files that must never round-trip through the bucket.
-        expect(shouldSync(path.join(hqRoot, ".hq-sync.pid"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, ".hq-sync-journal.json"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, ".hq-sync-state.json"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, ".hq-embeddings-pending.json"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/.hq-foo.json"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, ".hq-cache/blob.bin"))).toBe(false);
-        // Sync-config files still sync (no hyphen, doesn't match `.hq-*`).
-        expect(shouldSync(path.join(hqRoot, ".hqignore"))).toBe(true);
-        expect(shouldSync(path.join(hqRoot, ".hqsyncignore"))).toBe(true);
-        expect(shouldSync(path.join(hqRoot, ".hqinclude"))).toBe(true);
-    });
-    it("permissive mode: .claude/state/ and .claude/audit/ are per-host, never synced", () => {
-        // 5.34.0 live cross-machine sync test (macOS ↔ Lightsail) wrote
-        // ~25 of the 30 conflict mirrors directly to these paths. They're
-        // session-/host-scoped by design:
-        //   - .claude/state/active-session-project: the active project
-        //     pointer for the currently-foregrounded Claude Code session.
-        //   - .claude/state/auto-session-project-<sessionUuid>: one
-        //     marker per spawned session; entirely host-local.
-        //   - .claude/audit/: hook-decision audit log + suppressions
-        //     config; host-specific by nature.
-        // Syncing produces guaranteed conflicts per machine per session.
-        const shouldSync = createIgnoreFilter(hqRoot);
-        expect(shouldSync(path.join(hqRoot, ".claude/state/active-session-project"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, ".claude/state/auto-session-project-571177ff-59bb-4728-8670-0bf66a6410a5"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, ".claude/audit/instructions.md"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, ".claude/audit/suppressions.yaml"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, ".claude/state"), true)).toBe(false);
-        expect(shouldSync(path.join(hqRoot, ".claude/audit"), true)).toBe(false);
-        // Nested .claude/ inside a company also stays local — same anchor
-        // shape as the .claude/worktrees/ rule directly above.
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/.claude/state/active-session-project"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/.claude/audit/instructions.md"))).toBe(false);
-        // The .claude/ dir's other contents (commands, skills, hooks) still
-        // sync — the rule MUST NOT broaden to .claude/.
-        expect(shouldSync(path.join(hqRoot, ".claude/skills/foo/SKILL.md"))).toBe(true);
-        expect(shouldSync(path.join(hqRoot, ".claude/hooks/foo.sh"))).toBe(true);
-    });
-    it("permissive mode: .claude/settings*.json is machine-local, never synced (qmd PATH regression)", () => {
-        // 2026-07-01 e2e-mac report (20260701-qmd-path): cloud sync pulled the
-        // operator's .claude/settings.json over a fresh install's copy ~40s
-        // after install, byte-identical to the source machine — reverting the
-        // installer's day-one env.PATH fix and propagating one host's PATH
-        // snapshot to every machine/teammate. This is the recurrence mechanism
-        // behind the recurring "qmd: command not found" reports. Settings are
-        // machine-local (PATH snapshot, model prefs) and must never round-trip
-        // in EITHER direction — the pull planner consults this same filter, so
-        // an existing vault copy is also never applied locally.
-        const shouldSync = createIgnoreFilter(hqRoot);
-        expect(shouldSync(path.join(hqRoot, ".claude/settings.json"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, ".claude/settings.local.json"))).toBe(false);
-        // Nested .claude/ inside a company stays local too — same anchor shape
-        // as the state/audit rules above.
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/.claude/settings.json"))).toBe(false);
-        // Siblings still sync — the rule must not broaden past settings files.
-        expect(shouldSync(path.join(hqRoot, ".claude/skills/foo/SKILL.md"))).toBe(true);
-        expect(shouldSync(path.join(hqRoot, ".claude/hooks/foo.sh"))).toBe(true);
-        expect(shouldSync(path.join(hqRoot, ".claude/CLAUDE.md"))).toBe(true);
-    });
-    it("permissive mode: .hq/ directory is per-host state, never synced (Bug #1/#6/#8)", () => {
-        // Bug catalog: `.hq/install-manifest.json`, `.hq/machine-id`, and
-        // `.hq/machine.json` are per-host source-of-truth files. The original
-        // `DEFAULT_IGNORES` only covered the `.hq-*` wildcard (with hyphen) and
-        // explicitly left the `.hq/` directory unaffected — so the install
-        // manifest and machine-id round-tripped through S3 between hosts,
-        // breaking the per-machine identity contract that the 5.33.0
-        // machine-id fix relies on.
-        const shouldSync = createIgnoreFilter(hqRoot);
-        expect(shouldSync(path.join(hqRoot, ".hq/install-manifest.json"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, ".hq/machine-id"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, ".hq/machine.json"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, ".hq/config.json"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, ".hq"), true)).toBe(false);
-        // Nested .hq/ inside a company also stays local (per-host scoping).
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/.hq/config.json"))).toBe(false);
-    });
-    it("excludes root .tmp-* build caches without excluding nested user content", () => {
-        const shouldSync = createIgnoreFilter(hqRoot);
-        const rootCache = path.join(hqRoot, ".tmp-c180-base");
-        expect(shouldSync(rootCache, true)).toBe(false);
-        expect(shouldSync(path.join(rootCache, "node-compile-cache", "entry"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/knowledge/.tmp-c180-base"), true)).toBe(true);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/knowledge/.tmp-c180-base/notes.md"))).toBe(true);
-    });
-    it("allowlist mode: presence of .hqinclude switches to opt-in", () => {
-        fs.writeFileSync(path.join(hqRoot, ".hqinclude"), "companies/*/knowledge/\ncompanies/*/projects/\n");
-        const shouldSync = createIgnoreFilter(hqRoot);
-        // Allowlisted paths sync.
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/knowledge/foo.md"))).toBe(true);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/projects/p1/prd.json"))).toBe(true);
-        // Anything else stays local — this is the privacy guarantee.
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/data/leads.csv"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/workers/cmo/skill.md"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/settings/aws.json"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "personal/journal/2026-04-26.md"))).toBe(false);
-    });
-    it("allowlist mode: directory entries match dir-suffix include patterns (walker descent)", () => {
-        // Regression: walkDir tests directory entries when deciding whether to
-        // descend. The `ignore` lib only matches dir-only patterns like
-        // `companies/*/knowledge/` against paths that end with `/`. The filter
-        // accepts an `isDir` hint and appends the trailing slash before probing,
-        // mirroring how git itself decides (it knows from the index whether
-        // each entry is a tree or a blob). Without the hint the walker would
-        // see `companies/indigo/knowledge` -> not allowed -> never descend ->
-        // entire subtree silently lost. Files inside still work because
-        // `ignore` walks ancestors internally; the bug only bites the descent
-        // decision for directory entries.
-        fs.writeFileSync(path.join(hqRoot, ".hqinclude"), "companies/*/knowledge/\ncompanies/*/projects/\n.claude/\n");
-        const shouldSync = createIgnoreFilter(hqRoot);
-        // Directory entries must be allowed when the caller hints isDir=true.
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/knowledge"), true)).toBe(true);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/projects"), true)).toBe(true);
-        expect(shouldSync(path.join(hqRoot, ".claude"), true)).toBe(true);
-        // Files inside still resolve correctly without the hint.
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/knowledge/x.md"))).toBe(true);
-        expect(shouldSync(path.join(hqRoot, ".claude/skills/foo/SKILL.md"))).toBe(true);
-        // Machine-local settings stay excluded even inside an allowlisted
-        // subtree — exclusion layers subtract on top of the allowlist.
-        expect(shouldSync(path.join(hqRoot, ".claude/settings.json"))).toBe(false);
-        // Non-allowlisted siblings stay excluded — privacy guarantee intact.
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/data"), true)).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/workers"), true)).toBe(false);
-    });
-    it("allowlist mode: walker descends through intermediate ancestor dirs", () => {
-        // Full gitignore semantics: a walker starting at hqRoot must be able to
-        // descend through `companies/` and `companies/indigo/` to reach the
-        // allowlisted leaf `companies/*/knowledge/`. The ancestor matcher
-        // permits this for dir-mode queries while keeping files directly inside
-        // those intermediate dirs excluded — privacy invariant intact.
-        fs.writeFileSync(path.join(hqRoot, ".hqinclude"), "companies/*/knowledge/\n");
-        const shouldSync = createIgnoreFilter(hqRoot);
-        // Intermediate directories along the path to the leaf are descent-allowed.
-        expect(shouldSync(path.join(hqRoot, "companies"), true)).toBe(true);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo"), true)).toBe(true);
-        // The leaf itself is allowed.
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/knowledge"), true)).toBe(true);
-        // Files directly inside intermediate dirs are still excluded — only the
-        // dir is descent-allowed, the dir's loose files are not.
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/notes.md"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "companies/README.md"))).toBe(false);
-        // Files inside the allowlisted leaf still sync.
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/knowledge/x.md"))).toBe(true);
-    });
-    it("dir-only ignore patterns honor the isDir hint symmetrically", () => {
-        // Gitignore semantics: a trailing-slash pattern (`foo/`) matches only
-        // directories, never files of the same name. The filter applies this
-        // on BOTH layers — exclude and include — by appending `/` to the probe
-        // when the caller passes isDir=true, and leaving it as-is otherwise.
-        // This guarantees:
-        //   - a directory `node_modules` is excluded (descent skipped),
-        //   - but a regular file literally named `node_modules` is NOT
-        //     mistakenly excluded by the dir-only pattern.
-        fs.writeFileSync(path.join(hqRoot, ".hqignore"), "build/\n");
-        const shouldSync = createIgnoreFilter(hqRoot);
-        // Directory `build` matches the dir-only exclusion.
-        expect(shouldSync(path.join(hqRoot, "build"), true)).toBe(false);
-        // A file literally named `build` (not a dir) does NOT match `build/`.
-        // This is the asymmetry that previous PR comments warned about and
-        // that the isDir hint resolves cleanly.
-        expect(shouldSync(path.join(hqRoot, "build"), false)).toBe(true);
-        // Default-call (no hint) is treated as "not a directory" — matches
-        // gitignore's blob-default and preserves the file-side guarantee.
-        expect(shouldSync(path.join(hqRoot, "build"))).toBe(true);
-    });
-    it("allowlist mode: exclusion layers still subtract on top", () => {
-        // Even when a subtree is allowlisted, default ignores like node_modules/
-        // and .env must still apply. Otherwise an allowlisted subdir would sync
-        // gigabytes of dependency junk or leak secret env files.
-        fs.writeFileSync(path.join(hqRoot, ".hqinclude"), "companies/*/projects/\n");
-        const shouldSync = createIgnoreFilter(hqRoot);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/projects/p1/prd.json"))).toBe(true);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/projects/p1/node_modules/react/index.js"))).toBe(false);
-        expect(shouldSync(path.join(hqRoot, "companies/indigo/projects/p1/.env"))).toBe(false);
-    });
-});
-//# sourceMappingURL=ignore.test.js.map