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

package/dist/cli/reindex.test.js

@@ -1,811 +0,0 @@
-/**
- * Unit tests for `hq reindex` (the formerly-bash hq-core hook, now shipped
- * in this package and invoked via the CLI).
- *
- * The logic is implemented natively in TypeScript in ./reindex.ts; these tests
- * exercise reindex() directly against a temp HQ tree, asserting the observable
- * filesystem outcomes (skill wrappers, retired personal-overlay mirror cleanup)
- * rather than re-deriving the implementation internals.
- */
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import { reindex } from "./reindex.js";
-import { lockPathFor, OPERATION_LOCKED_EXIT } from "../operation-lock.js";
-// HQ-B0: simulate the Windows filesystem rejecting a ':' in a path segment.
-// The flag is off by default, so every other test sees the real `mkdirSync`;
-// the regression test below flips it on only for its own run.
-const hoisted = vi.hoisted(() => ({
-    failNamespacedMkdir: false,
-    // When set, any mkdir whose path contains this substring throws ENOENT —
-    // lets a test simulate a mkdir failure at a NON-wrapper site (e.g. the
-    // `.claude/skills` parent or a `core/<type>` mirror dir).
-    failMkdirContaining: "",
-    // HQ-CLI-4: when set, any symlink whose LINK path contains this substring
-    // throws EPERM — simulates Windows WITHOUT Developer Mode, where symlink
-    // creation is a privileged operation. Off by default so other tests see the
-    // real `symlinkSync`.
-    failSymlinkContaining: "",
-}));
-vi.mock("fs", async (importOriginal) => {
-    const actual = await importOriginal();
-    const mkdirSync = ((p, opts) => {
-        if (typeof p === "string" &&
-            ((hoisted.failNamespacedMkdir && /[:][^/\\]*$/.test(p)) || // colon in final segment
-                (hoisted.failMkdirContaining !== "" && p.includes(hoisted.failMkdirContaining)))) {
-            throw Object.assign(new Error(`ENOENT: no such file or directory, mkdir '${p}'`), { code: "ENOENT" });
-        }
-        return actual.mkdirSync(p, opts);
-    });
-    const symlinkSync = ((target, linkPath, type) => {
-        if (hoisted.failSymlinkContaining !== "" &&
-            typeof linkPath === "string" &&
-            linkPath.includes(hoisted.failSymlinkContaining)) {
-            throw Object.assign(new Error(`EPERM: operation not permitted, symlink '${target}' -> '${linkPath}'`), { code: "EPERM" });
-        }
-        return actual.symlinkSync(target, linkPath, type);
-    });
-    const patched = { ...actual, mkdirSync, symlinkSync };
-    return { ...patched, default: patched };
-});
-describe("reindex", () => {
-    let root;
-    let stateDir;
-    beforeEach(() => {
-        root = fs.mkdtempSync(path.join(os.tmpdir(), "ms-test-"));
-        // Redirect the operation lock into a throwaway dir so reindex's default
-        // locking never touches the real ~/.hq during tests.
-        stateDir = fs.mkdtempSync(path.join(os.tmpdir(), "ms-state-"));
-        process.env.HQ_STATE_DIR = stateDir;
-    });
-    afterEach(() => {
-        fs.rmSync(root, { recursive: true, force: true });
-        fs.rmSync(stateDir, { recursive: true, force: true });
-        delete process.env.HQ_STATE_DIR;
-    });
-    function writeSkill(rel) {
-        const dir = path.join(root, rel);
-        fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(path.join(dir, "SKILL.md"), "skill\n");
-    }
-    // Write a namespaced slash-command source file, e.g.
-    // writeCommand("core/commands/demo.md") → root/core/commands/demo.md.
-    function writeCommand(rel, body = "command\n") {
-        const abs = path.join(root, rel);
-        fs.mkdirSync(path.dirname(abs), { recursive: true });
-        fs.writeFileSync(abs, body);
-    }
-    it("surfaces namespaced skills as .claude/skills/<ns>:<skill>/ wrappers", () => {
-        writeSkill("core/skills/demo");
-        fs.writeFileSync(path.join(root, "core/skills/demo/helper.md"), "h\n");
-        writeSkill("companies/acme/skills/widget");
-        const { status } = reindex({ repoRoot: root });
-        expect(status).toBe(0);
-        const coreWrapper = path.join(root, ".claude/skills/core:demo");
-        expect(fs.lstatSync(path.join(coreWrapper, "SKILL.md")).isSymbolicLink()).toBe(true);
-        expect(fs.readlinkSync(path.join(coreWrapper, "SKILL.md"))).toBe("../../../core/skills/demo/SKILL.md");
-        // Every source file is mirrored, not just SKILL.md.
-        expect(fs.existsSync(path.join(coreWrapper, "helper.md"))).toBe(true);
-        const acmeWrapper = path.join(root, ".claude/skills/acme:widget");
-        expect(fs.readlinkSync(path.join(acmeWrapper, "SKILL.md"))).toBe("../../../companies/acme/skills/widget/SKILL.md");
-    });
-    // ── namespaced slash-command surfacing (parallel to skills) ─────────────
-    // reindex mirrors <ns>/commands/<cmd>.md into .claude/commands/<ns>:<cmd>.md
-    // as a single symlink per source file, using the same <ns>:<name> naming as
-    // skills so a company/core/personal/pack command shows up as /<ns>:<cmd>.
-    it("surfaces namespaced commands as .claude/commands/<ns>:<cmd>.md symlinks", () => {
-        writeCommand("core/commands/demo.md");
-        writeCommand("companies/acme/commands/widget.md");
-        writeCommand("personal/commands/note.md");
-        writeCommand("core/packages/hq-pack-demo/commands/hello.md");
-        const { status } = reindex({ repoRoot: root });
-        expect(status).toBe(0);
-        const link = (name) => path.join(root, ".claude/commands", name);
-        expect(fs.lstatSync(link("core:demo.md")).isSymbolicLink()).toBe(true);
-        expect(fs.readlinkSync(link("core:demo.md"))).toBe("../../core/commands/demo.md");
-        expect(fs.readlinkSync(link("acme:widget.md"))).toBe("../../companies/acme/commands/widget.md");
-        expect(fs.readlinkSync(link("personal:note.md"))).toBe("../../personal/commands/note.md");
-        expect(fs.readlinkSync(link("hq-pack-demo:hello.md"))).toBe("../../core/packages/hq-pack-demo/commands/hello.md");
-    });
-    it("skips `_`-prefixed, dotfile, and non-.md command files", () => {
-        writeCommand("core/commands/_partial.md");
-        writeCommand("core/commands/.hidden.md");
-        writeCommand("core/commands/notes.txt");
-        writeCommand("core/commands/real.md");
-        reindex({ repoRoot: root });
-        const cmds = path.join(root, ".claude/commands");
-        expect(fs.existsSync(path.join(cmds, "core:real.md"))).toBe(true);
-        expect(fs.existsSync(path.join(cmds, "core:_partial.md"))).toBe(false);
-        expect(fs.existsSync(path.join(cmds, "core:.hidden.md"))).toBe(false);
-        expect(fs.existsSync(path.join(cmds, "core:notes.txt"))).toBe(false);
-    });
-    it("prunes orphan managed command links when the source command disappears", () => {
-        writeCommand("core/commands/demo.md");
-        reindex({ repoRoot: root });
-        expect(fs.existsSync(path.join(root, ".claude/commands/core:demo.md"))).toBe(true);
-        fs.rmSync(path.join(root, "core/commands/demo.md"));
-        reindex({ repoRoot: root });
-        expect(fs.existsSync(path.join(root, ".claude/commands/core:demo.md"))).toBe(false);
-    });
-    it("is idempotent for commands — a second run keeps the same link", () => {
-        writeCommand("core/commands/demo.md");
-        expect(reindex({ repoRoot: root }).status).toBe(0);
-        expect(reindex({ repoRoot: root }).status).toBe(0);
-        expect(fs.readlinkSync(path.join(root, ".claude/commands/core:demo.md"))).toBe("../../core/commands/demo.md");
-    });
-    it("falls back to a hardlink when a command-wrapper symlink fails with EPERM", () => {
-        writeCommand("core/commands/demo.md", "run me\n");
-        hoisted.failSymlinkContaining = path.join(".claude", "commands");
-        try {
-            expect(reindex({ repoRoot: root }).status).toBe(0);
-        }
-        finally {
-            hoisted.failSymlinkContaining = "";
-        }
-        const link = path.join(root, ".claude/commands/core:demo.md");
-        expect(fs.existsSync(link)).toBe(true);
-        // Bridged as a hardlink to the source, not skipped or left as a broken link.
-        expect(fs.lstatSync(link).isSymbolicLink()).toBe(false);
-        expect(fs.readFileSync(link, "utf8")).toBe("run me\n");
-        expect(fs.lstatSync(link).ino).toBe(fs.statSync(path.join(root, "core/commands/demo.md")).ino);
-    });
-    it("leaves hand-authored / non-managed command files alone", () => {
-        const cmds = path.join(root, ".claude/commands");
-        fs.mkdirSync(cmds, { recursive: true });
-        // A real file with no namespace colon → preserved.
-        fs.writeFileSync(path.join(cmds, "manual.md"), "manual\n");
-        // A real (non-symlink) file that happens to use a managed namespace prefix
-        // → still preserved; reindex only ever prunes symlinks it created.
-        fs.writeFileSync(path.join(cmds, "core:hand.md"), "hand\n");
-        // A composite symlink under an UNMANAGED namespace → preserved.
-        writeCommand("core/commands/other.md");
-        fs.symlinkSync("../../core/commands/other.md", path.join(cmds, "vendor:tool.md"));
-        reindex({ repoRoot: root });
-        expect(fs.existsSync(path.join(cmds, "manual.md"))).toBe(true);
-        expect(fs.existsSync(path.join(cmds, "core:hand.md"))).toBe(true);
-        expect(fs.lstatSync(path.join(cmds, "vendor:tool.md")).isSymbolicLink()).toBe(true);
-    });
-    it("preserves a hand-authored alias under a managed namespace (target basename differs)", () => {
-        // A live source command...
-        writeCommand("core/commands/demo.md");
-        // ...plus a hand-authored alias in the SAME (managed) namespace pointing at
-        // it under a different command name, with NO core/commands/alias.md source.
-        // A prefix-only ownership test would wrongly treat this as a reindex link
-        // and delete it; the exact-target cross-check must keep it.
-        const cmds = path.join(root, ".claude/commands");
-        fs.mkdirSync(cmds, { recursive: true });
-        fs.symlinkSync("../../core/commands/demo.md", path.join(cmds, "core:alias.md"));
-        reindex({ repoRoot: root });
-        // The alias survives, and the real managed link is still created.
-        expect(fs.lstatSync(path.join(cmds, "core:alias.md")).isSymbolicLink()).toBe(true);
-        expect(fs.readlinkSync(path.join(cmds, "core:alias.md"))).toBe("../../core/commands/demo.md");
-        expect(fs.existsSync(path.join(cmds, "core:demo.md"))).toBe(true);
-    });
-    it("does not create an empty .claude/commands when there are no command sources", () => {
-        writeSkill("core/skills/demo");
-        reindex({ repoRoot: root });
-        expect(fs.existsSync(path.join(root, ".claude/commands"))).toBe(false);
-    });
-    it("does NOT mirror the personal overlay into core/<type>/ (read directly now)", () => {
-        fs.mkdirSync(path.join(root, "personal/policies"), { recursive: true });
-        fs.writeFileSync(path.join(root, "personal/policies/myrule.md"), "rule\n");
-        const { status } = reindex({ repoRoot: root });
-        expect(status).toBe(0);
-        // personal is the sole read source — reindex must NOT create a mirror
-        // symlink in core/policies. The HQ tooling reads personal/policies directly,
-        // so a mirror would only double-surface every entry.
-        expect(fs.existsSync(path.join(root, "core/policies/myrule.md"))).toBe(false);
-    });
-    it("collapses per-file wrapper-skip spam into ONE summary line (HQ-SYNC-2)", () => {
-        // A REAL file sits where a managed skill-wrapper symlink would go — the
-        // legitimate no-op that used to spam one stderr line per entry and flood the
-        // Sentry breadcrumb ring, evicting the real per-company sync error.
-        writeSkill("core/skills/demo");
-        reindex({ repoRoot: root });
-        // Replace the managed per-file symlink with a real (non-symlink) file.
-        const slot = path.join(root, ".claude/skills/core:demo/SKILL.md");
-        fs.rmSync(slot);
-        fs.writeFileSync(slot, "REAL file, not a link\n");
-        const writes = [];
-        const spy = vi
-            .spyOn(process.stderr, "write")
-            .mockImplementation(((chunk) => {
-            writes.push(String(chunk));
-            return true;
-        }));
-        let status;
-        try {
-            status = reindex({ repoRoot: root }).status;
-        }
-        finally {
-            spy.mockRestore();
-        }
-        const stderr = writes.join("");
-        expect(status).toBe(0);
-        // The pre-existing real file is left untouched (never overwritten).
-        expect(fs.lstatSync(slot).isSymbolicLink()).toBe(false);
-        // No per-file spam…
-        expect(stderr).not.toContain("already exists and is not a symlink; skipping");
-        // …just ONE collapsed summary naming the count.
-        expect(stderr).toMatch(/left 1 pre-existing non-symlink entry untouched/);
-        expect(stderr).toContain("HQ_REINDEX_VERBOSE=1");
-    });
-    it("keeps per-file wrapper-skip detail under HQ_REINDEX_VERBOSE=1", () => {
-        writeSkill("core/skills/demo");
-        reindex({ repoRoot: root });
-        const slot = path.join(root, ".claude/skills/core:demo/SKILL.md");
-        fs.rmSync(slot);
-        fs.writeFileSync(slot, "REAL\n");
-        const writes = [];
-        const spy = vi
-            .spyOn(process.stderr, "write")
-            .mockImplementation(((chunk) => {
-            writes.push(String(chunk));
-            return true;
-        }));
-        process.env.HQ_REINDEX_VERBOSE = "1";
-        try {
-            reindex({ repoRoot: root });
-        }
-        finally {
-            spy.mockRestore();
-            delete process.env.HQ_REINDEX_VERBOSE;
-        }
-        const stderr = writes.join("");
-        expect(stderr).toContain(".claude/skills/core:demo/SKILL.md already exists and is not a symlink; skipping");
-    });
-    it("prunes orphan managed wrappers when the source skill disappears", () => {
-        writeSkill("core/skills/demo");
-        reindex({ repoRoot: root });
-        expect(fs.existsSync(path.join(root, ".claude/skills/core:demo"))).toBe(true);
-        fs.rmSync(path.join(root, "core/skills/demo"), { recursive: true, force: true });
-        reindex({ repoRoot: root });
-        expect(fs.existsSync(path.join(root, ".claude/skills/core:demo"))).toBe(false);
-    });
-    it("is idempotent — a second run is a no-op", () => {
-        writeSkill("core/skills/demo");
-        expect(reindex({ repoRoot: root }).status).toBe(0);
-        expect(reindex({ repoRoot: root }).status).toBe(0);
-        expect(fs.readlinkSync(path.join(root, ".claude/skills/core:demo/SKILL.md"))).toBe("../../../core/skills/demo/SKILL.md");
-    });
-    // ── Migration cleanup: retired personal-overlay mirror symlinks ──────────
-    // reindex no longer CREATES core/<type>/<entry> -> ../../personal/<type>/<entry>
-    // mirror symlinks — personal is read directly. A managed mirror symlink a
-    // PRIOR release left behind must be pruned on the next reindex, WHETHER OR NOT
-    // its personal source still exists, so it can never double-surface alongside
-    // the direct read.
-    // Forge a legacy managed mirror symlink exactly as the old reindex would have.
-    function legacyMirror(type, entry) {
-        const coreDir = path.join(root, "core", type);
-        fs.mkdirSync(coreDir, { recursive: true });
-        const link = path.join(coreDir, entry);
-        fs.symlinkSync(`../../personal/${type}/${entry}`, link);
-        return link;
-    }
-    it("prunes a legacy mirror symlink even when its personal source still exists", () => {
-        fs.mkdirSync(path.join(root, "personal/policies"), { recursive: true });
-        fs.writeFileSync(path.join(root, "personal/policies/myrule.md"), "rule\n");
-        const link = legacyMirror("policies", "myrule.md");
-        expect(fs.lstatSync(link).isSymbolicLink()).toBe(true);
-        expect(reindex({ repoRoot: root }).status).toBe(0);
-        // Pruned — personal/policies/myrule.md is read directly now, no mirror.
-        expect(fs.existsSync(link)).toBe(false);
-        expect(() => fs.lstatSync(link)).toThrow();
-        // The personal source itself is untouched.
-        expect(fs.existsSync(path.join(root, "personal/policies/myrule.md"))).toBe(true);
-    });
-    it("prunes a legacy mirror symlink whose personal source was deleted", () => {
-        const link = legacyMirror("policies", "gone.md"); // dangling: no source
-        expect(fs.lstatSync(link).isSymbolicLink()).toBe(true);
-        expect(reindex({ repoRoot: root }).status).toBe(0);
-        expect(fs.existsSync(link)).toBe(false);
-    });
-    it("prunes a legacy mirror DIRECTORY symlink without recursing into the source (DEV-1767 shape)", () => {
-        fs.mkdirSync(path.join(root, "personal/knowledge/my-kb"), { recursive: true });
-        fs.writeFileSync(path.join(root, "personal/knowledge/my-kb/note.md"), "n\n");
-        const link = legacyMirror("knowledge", "my-kb"); // directory-shaped symlink
-        expect(fs.lstatSync(link).isSymbolicLink()).toBe(true);
-        expect(reindex({ repoRoot: root }).status).toBe(0);
-        expect(fs.existsSync(link)).toBe(false);
-        // rmSync on the symlink must NOT recurse into the resolved directory.
-        expect(fs.existsSync(path.join(root, "personal/knowledge/my-kb/note.md"))).toBe(true);
-    });
-    it("leaves a real core file and a foreign symlink in core/<type>/ untouched (cross-check invariant)", () => {
-        fs.mkdirSync(path.join(root, "core/policies"), { recursive: true });
-        // (a) a real release-shipped core file — not a symlink, never ours.
-        fs.writeFileSync(path.join(root, "core/policies/shipped.md"), "shipped\n");
-        // (b) a human-authored symlink in core/policies pointing SOMEWHERE ELSE
-        //     (not the managed ../../personal/policies/<name> shape) — even though
-        //     it is dangling, its target doesn't match, so it must survive.
-        fs.symlinkSync("../../somewhere/else.md", path.join(root, "core/policies/foreign.md"));
-        // (c) a symlink whose target's basename disagrees with its own name — the
-        //     exact cross-check catches this: name 'mismatch.md' but target points
-        //     at personal/policies/other.md → NOT managed, left alone.
-        fs.symlinkSync("../../personal/policies/other.md", path.join(root, "core/policies/mismatch.md"));
-        expect(reindex({ repoRoot: root }).status).toBe(0);
-        expect(fs.lstatSync(path.join(root, "core/policies/shipped.md")).isSymbolicLink()).toBe(false);
-        expect(fs.existsSync(path.join(root, "core/policies/shipped.md"))).toBe(true);
-        expect(fs.lstatSync(path.join(root, "core/policies/foreign.md")).isSymbolicLink()).toBe(true);
-        expect(fs.lstatSync(path.join(root, "core/policies/mismatch.md")).isSymbolicLink()).toBe(true);
-    });
-    it("skips `_`-prefixed and dotfile skill folders", () => {
-        writeSkill("core/skills/_template");
-        fs.mkdirSync(path.join(root, "core/skills/.hidden"), { recursive: true });
-        fs.writeFileSync(path.join(root, "core/skills/.hidden/SKILL.md"), "x\n");
-        writeSkill("core/skills/real");
-        reindex({ repoRoot: root });
-        expect(fs.existsSync(path.join(root, ".claude/skills/core:real"))).toBe(true);
-        expect(fs.existsSync(path.join(root, ".claude/skills/core:_template"))).toBe(false);
-        expect(fs.existsSync(path.join(root, ".claude/skills/core:.hidden"))).toBe(false);
-    });
-    it("removes legacy .claude/commands/<ns>/<skill>.md bridge symlinks", () => {
-        const cmdDir = path.join(root, ".claude/commands/core");
-        fs.mkdirSync(cmdDir, { recursive: true });
-        // Legacy bridge symlink (matches the cleanup pattern) → removed.
-        fs.symlinkSync("../../../core/skills/demo/SKILL.md", path.join(cmdDir, "demo.md"));
-        // A real file (non-symlink) → preserved.
-        fs.writeFileSync(path.join(cmdDir, "keep.md"), "manual\n");
-        reindex({ repoRoot: root });
-        expect(fs.existsSync(path.join(cmdDir, "demo.md"))).toBe(false);
-        expect(fs.existsSync(path.join(cmdDir, "keep.md"))).toBe(true);
-    });
-    it("leaves hand-authored composite wrappers (unmanaged namespace) alone", () => {
-        // A wrapper whose namespace ('vendor') is not a managed namespace and
-        // whose target points into core/skills/<other> — must not be pruned.
-        const wrapper = path.join(root, ".claude/skills/vendor:tool");
-        fs.mkdirSync(wrapper, { recursive: true });
-        writeSkill("core/skills/helper");
-        fs.symlinkSync("../../../core/skills/helper/SKILL.md", path.join(wrapper, "SKILL.md"));
-        reindex({ repoRoot: root });
-        expect(fs.existsSync(wrapper)).toBe(true);
-        expect(fs.lstatSync(path.join(wrapper, "SKILL.md")).isSymbolicLink()).toBe(true);
-    });
-    // ── symlink-to-directory reindex links (feedback_731b88d9) ──────────────
-    // reindex emits two kinds of link whose TARGET is a directory:
-    //   (a) a skill folder that contains a sub-directory (e.g. `agents/`) → the
-    //       wrapper gets a per-entry symlink that resolves to a directory;
-    //   (b) a personal/<type>/<entry> that is itself a directory → mirrored into
-    //       core/<type>/<entry> as a directory symlink (the DEV-1767 shape:
-    //       `core/knowledge/<kb> -> ../../personal/knowledge/<kb>`).
-    // The bash-era reindex followed these into the directory and aborted with
-    // ERR_FS_EISDIR, dropping the link. These lock that they are created,
-    // resolve to the directory, survive an idempotent re-run, and never crash.
-    it("creates a symlink-to-DIR wrapper entry for a skill sub-directory and preserves it", () => {
-        writeSkill("core/skills/demo");
-        // A sub-directory inside the skill folder → its wrapper link targets a dir.
-        fs.mkdirSync(path.join(root, "core/skills/demo/agents"), { recursive: true });
-        fs.writeFileSync(path.join(root, "core/skills/demo/agents/helper.md"), "h\n");
-        expect(reindex({ repoRoot: root }).status).toBe(0);
-        const agentsLink = path.join(root, ".claude/skills/core:demo/agents");
-        expect(fs.lstatSync(agentsLink).isSymbolicLink()).toBe(true);
-        expect(fs.readlinkSync(agentsLink)).toBe("../../../core/skills/demo/agents");
-        // The link resolves to the directory (the EISDIR-prone dereference path).
-        expect(fs.statSync(agentsLink).isDirectory()).toBe(true);
-        expect(fs.readFileSync(path.join(agentsLink, "helper.md"), "utf-8")).toBe("h\n");
-        // Idempotent re-run: the prune pass walks the symlink-to-dir and must not
-        // follow it / drop it / throw EISDIR.
-        expect(reindex({ repoRoot: root }).status).toBe(0);
-        expect(fs.lstatSync(agentsLink).isSymbolicLink()).toBe(true);
-        expect(fs.readlinkSync(agentsLink)).toBe("../../../core/skills/demo/agents");
-    });
-    it("does NOT mirror a personal/<type> DIRECTORY entry into core/ (read directly now)", () => {
-        // personal/knowledge/<kb>/ is a directory of notes. It used to mirror as a
-        // core/ directory symlink (the DEV-1767 shape rescue/update-hq choked on).
-        // The mirror is retired: qmd indexes personal/knowledge directly, so reindex
-        // must leave core/knowledge alone — nothing to choke on anymore.
-        fs.mkdirSync(path.join(root, "personal/knowledge/my-kb"), { recursive: true });
-        fs.writeFileSync(path.join(root, "personal/knowledge/my-kb/note.md"), "owned by personal\n");
-        expect(reindex({ repoRoot: root }).status).toBe(0);
-        expect(fs.existsSync(path.join(root, "core/knowledge/my-kb"))).toBe(false);
-        // The personal source is untouched.
-        expect(fs.readFileSync(path.join(root, "personal/knowledge/my-kb/note.md"), "utf-8")).toBe("owned by personal\n");
-    });
-    // ── operation lock: reindex uses a SEPARATE scope from sync/rescue ──────
-    // Regression for feedback_ed98d810 (the "hq reindex indefinite hang"): when
-    // a watch-mode hq-sync-runner holds the per-root "operation" lock for its
-    // whole lifetime, a shared lock starved `hq reindex` forever. reindex now
-    // takes its own "reindex" scope, so it must run to completion even while the
-    // sync/watch "operation" lock is held by a LIVE holder.
-    it("completes while the sync/watch operation lock is held (no starvation)", () => {
-        // Simulate the long-lived watch runner holding the "operation"-scope lock.
-        // pid = this process → the lock probes it as ALIVE (a live same-PID holder
-        // is treated as busy, never reclaimed), so it is a genuine live holder.
-        const syncLock = lockPathFor(root); // default "operation" scope
-        fs.mkdirSync(path.dirname(syncLock), { recursive: true });
-        fs.writeFileSync(syncLock, JSON.stringify({
-            pid: process.pid,
-            command: "sync",
-            startedAt: new Date(0).toISOString(),
-            hqRoot: root,
-        }));
-        // Even with a zero-wait bound (never block), reindex acquires its OWN scope
-        // and finishes — proving the operation lock no longer gates it.
-        const { status } = reindex({ repoRoot: root, lockTimeoutSec: 0 });
-        expect(status).toBe(0);
-        expect(fs.existsSync(path.join(root, ".claude/skills"))).toBe(true);
-        // The sync/watch holder is untouched.
-        expect(fs.existsSync(syncLock)).toBe(true);
-    });
-    it("refuses (OPERATION_LOCKED_EXIT) when another reindex holds the reindex-scope lock (lockTimeoutSec:0)", () => {
-        // reindex-vs-reindex is still mutually exclusive. A live holder on the
-        // "reindex" scope → with lockTimeoutSec:0 reindex refuses immediately and
-        // does no work. (The wait-then-acquire path is in operation-lock.test.ts.)
-        const lp = lockPathFor(root, "reindex");
-        fs.mkdirSync(path.dirname(lp), { recursive: true });
-        fs.writeFileSync(lp, JSON.stringify({ pid: 1, command: "reindex", startedAt: new Date(0).toISOString(), hqRoot: root }));
-        const before = fs.existsSync(path.join(root, ".claude/skills"));
-        const { status } = reindex({ repoRoot: root, lockTimeoutSec: 0 });
-        expect(status).toBe(OPERATION_LOCKED_EXIT);
-        // It refused before doing any work (didn't create .claude/skills).
-        expect(fs.existsSync(path.join(root, ".claude/skills"))).toBe(before);
-    });
-    it("skipLock bypasses the reindex lock (internal sync/rescue caller path)", () => {
-        const lp = lockPathFor(root, "reindex");
-        fs.mkdirSync(path.dirname(lp), { recursive: true });
-        fs.writeFileSync(lp, JSON.stringify({ pid: 1, command: "reindex", startedAt: new Date(0).toISOString(), hqRoot: root }));
-        // Even with a live reindex holder on record, the internal caller (which
-        // serializes reindex itself at the tail of a pass) runs to completion.
-        const { status } = reindex({ repoRoot: root, skipLock: true });
-        expect(status).toBe(0);
-        expect(fs.existsSync(path.join(root, ".claude/skills"))).toBe(true);
-    });
-    it("releases the reindex-scope lock after a normal run (no leftover lock file)", () => {
-        reindex({ repoRoot: root });
-        expect(fs.existsSync(lockPathFor(root, "reindex"))).toBe(false);
-        // ...and never created the sync/rescue "operation" lock.
-        expect(fs.existsSync(lockPathFor(root))).toBe(false);
-    });
-    // ── HQ-B0: wrapper dir name uses ':' which is illegal on Windows ─────────
-    // `<ns>:<skill>` wrapper dirs contain a colon — fine on macOS/Linux, but a
-    // reserved drive/ADS separator on Windows, where mkdirSync throws ENOENT.
-    // A single un-creatable wrapper must not abort the entire reindex run.
-    it("does not abort reindex when a namespaced wrapper dir cannot be created (':' illegal on Windows)", () => {
-        writeSkill("core/skills/demo");
-        writeSkill("companies/acme/skills/widget");
-        hoisted.failNamespacedMkdir = true;
-        try {
-            // Without the guard the wrapper mkdir throws ENOENT and aborts the whole
-            // command; with it, the run completes and the bad wrappers are skipped.
-            expect(reindex({ repoRoot: root }).status).toBe(0);
-        }
-        finally {
-            hoisted.failNamespacedMkdir = false;
-        }
-        // The un-creatable wrappers are skipped (not half-written).
-        expect(fs.existsSync(path.join(root, ".claude/skills/core:demo"))).toBe(false);
-        expect(fs.existsSync(path.join(root, ".claude/skills/acme:widget"))).toBe(false);
-    });
-    // ── HQ-B0 (residual): PR #98 guarded only the wrapper mkdir, leaving the
-    //    `.claude/skills` parent and the `core/<type>` mirror mkdirs unguarded.
-    //    A failure at EITHER must also degrade gracefully, not abort reindex.
-    it("does not abort reindex when the .claude/skills parent mkdir fails", () => {
-        writeSkill("core/skills/demo");
-        hoisted.failMkdirContaining = path.join(".claude", "skills");
-        try {
-            // The parent mkdir fails AND every recursive wrapper mkdir under it fails,
-            // so nothing is surfaced — but reindex must still complete cleanly.
-            expect(reindex({ repoRoot: root }).status).toBe(0);
-        }
-        finally {
-            hoisted.failMkdirContaining = "";
-        }
-    });
-    // ── HQ-CLI-4: symlink creation is privileged on Windows. Without Developer
-    //    Mode, fs.symlinkSync throws EPERM. The HQ-B0 work guarded every mkdir
-    //    site but left the symlink sites unguarded, so `hq reindex` aborted on
-    //    Windows. safeBridgeLink must degrade gracefully like safeMkdir.
-    it("does not abort reindex when a skill-wrapper symlink fails with EPERM (Windows no Developer Mode)", () => {
-        writeSkill("core/skills/demo");
-        hoisted.failSymlinkContaining = path.join(".claude", "skills");
-        try {
-            // Every per-file wrapper symlink throws EPERM, but reindex must still
-            // complete cleanly (exit 0) rather than crash + flood Sentry.
-            expect(reindex({ repoRoot: root }).status).toBe(0);
-        }
-        finally {
-            hoisted.failSymlinkContaining = "";
-        }
-        // The wrapper DIR was still created.
-        expect(fs.existsSync(path.join(root, ".claude/skills/core:demo"))).toBe(true);
-    });
-    // ── Windows symlink fallback: when symlink creation fails with EPERM, the
-    //    bridge must NOT be left empty (that made bridged skills silently never
-    //    surface as slash commands). Fall back to a hardlink so the wrapper still
-    //    contains a working, in-sync copy of every source entry.
-    it("falls back to a hardlink when a skill-wrapper symlink fails with EPERM", () => {
-        writeSkill("core/skills/demo");
-        fs.writeFileSync(path.join(root, "core/skills/demo/helper.md"), "help\n");
-        hoisted.failSymlinkContaining = path.join(".claude", "skills");
-        try {
-            expect(reindex({ repoRoot: root }).status).toBe(0);
-        }
-        finally {
-            hoisted.failSymlinkContaining = "";
-        }
-        const wrapper = path.join(root, ".claude/skills/core:demo");
-        const skillLink = path.join(wrapper, "SKILL.md");
-        const helperLink = path.join(wrapper, "helper.md");
-        // Every source entry is bridged (not skipped), so the skill surfaces.
-        expect(fs.existsSync(skillLink)).toBe(true);
-        expect(fs.existsSync(helperLink)).toBe(true);
-        // It is a hardlink, not a symlink: same content, same inode as the source,
-        // and readable without the symlink privilege the platform denied.
-        const st = fs.lstatSync(skillLink);
-        expect(st.isSymbolicLink()).toBe(false);
-        expect(fs.readFileSync(skillLink, "utf8")).toBe("skill\n");
-        expect(st.ino).toBe(fs.statSync(path.join(root, "core/skills/demo/SKILL.md")).ino);
-    });
-    // ── Repair: an older build left an EMPTY wrapper dir (mkdir succeeded, every
-    //    symlink was skipped). A later reindex — even one still unable to symlink —
-    //    must repair it by bridging the missing entries via the fallback.
-    it("repairs a pre-existing empty bridge directory on the next run", () => {
-        writeSkill("core/skills/demo");
-        // Simulate the stale state: the wrapper dir exists but is empty.
-        const wrapper = path.join(root, ".claude/skills/core:demo");
-        fs.mkdirSync(wrapper, { recursive: true });
-        expect(fs.readdirSync(wrapper)).toHaveLength(0);
-        hoisted.failSymlinkContaining = path.join(".claude", "skills");
-        try {
-            expect(reindex({ repoRoot: root }).status).toBe(0);
-        }
-        finally {
-            hoisted.failSymlinkContaining = "";
-        }
-        // The empty bridge is now populated with a working entry.
-        expect(fs.existsSync(path.join(wrapper, "SKILL.md"))).toBe(true);
-        expect(fs.readFileSync(path.join(wrapper, "SKILL.md"), "utf8")).toBe("skill\n");
-    });
-    // --- multi-harness session-log capture into workspace/.session-logs/<harness>/
-    describe("session-log capture", () => {
-        let claudeDir; // CLAUDE_CONFIG_DIR
-        let codexHome; // CODEX_HOME
-        let grokHome; // GROK_HOME
-        // Per-harness cwd encodings the harnesses actually use.
-        const claudeSlug = (p) => p.replace(/[^a-zA-Z0-9]/g, "-");
-        const grokKey = (p) => encodeURIComponent(p);
-        const dest = (reindexRoot = root) => path.join(reindexRoot, "workspace", ".session-logs");
-        beforeEach(() => {
-            claudeDir = fs.mkdtempSync(path.join(os.tmpdir(), "ms-claude-"));
-            codexHome = fs.mkdtempSync(path.join(os.tmpdir(), "ms-codex-"));
-            grokHome = fs.mkdtempSync(path.join(os.tmpdir(), "ms-grok-"));
-            process.env.CLAUDE_CONFIG_DIR = claudeDir;
-            process.env.CODEX_HOME = codexHome;
-            process.env.GROK_HOME = grokHome;
-        });
-        afterEach(() => {
-            for (const d of [claudeDir, codexHome, grokHome]) {
-                fs.rmSync(d, { recursive: true, force: true });
-            }
-            delete process.env.CLAUDE_CONFIG_DIR;
-            delete process.env.CODEX_HOME;
-            delete process.env.GROK_HOME;
-        });
-        // Seed a Claude project folder for cwd `cwdPath`, return its dest dir name.
-        function seedClaude(cwdPath, body = "claude\n") {
-            const name = claudeSlug(cwdPath);
-            const projDir = path.join(claudeDir, "projects", name);
-            fs.mkdirSync(path.join(projDir, "tool-results"), { recursive: true });
-            fs.writeFileSync(path.join(projDir, "session.jsonl"), body);
-            fs.writeFileSync(path.join(projDir, "tool-results", "r.txt"), "res\n");
-            return name;
-        }
-        // Seed a Grok session folder for cwd `cwdPath`, return its dest dir name.
-        function seedGrok(cwdPath, body = "grok\n") {
-            const name = grokKey(cwdPath);
-            const sess = path.join(grokHome, "sessions", name, "uuid-1");
-            fs.mkdirSync(sess, { recursive: true });
-            fs.writeFileSync(path.join(sess, "chat_history.jsonl"), body);
-            return name;
-        }
-        // Seed a Codex rollout at YYYY/MM/DD/<file> whose session_meta records `cwd`.
-        function seedCodex(cwd, date, file) {
-            const [y, m, d] = date;
-            const dir = path.join(codexHome, "sessions", y, m, d);
-            fs.mkdirSync(dir, { recursive: true });
-            const meta = JSON.stringify({ type: "session_meta", payload: { cwd } });
-            const event = JSON.stringify({ type: "event_msg", payload: { text: "hi" } });
-            const abs = path.join(dir, file);
-            fs.writeFileSync(abs, `${meta}\n${event}\n`);
-            return abs;
-        }
-        // Build the real root under a canonical tmp path so this fixture remains
-        // stable even when the platform itself exposes its temp directory via a
-        // symlink (for example, /tmp -> /private/tmp on macOS).
-        function makeSymlinkRoot() {
-            const fixtureDir = fs.mkdtempSync(path.join(fs.realpathSync.native(os.tmpdir()), "ms-session-log-alias-"));
-            const realRoot = path.join(fixtureDir, "real-hq");
-            const linkRoot = path.join(fixtureDir, "hq-alias");
-            fs.mkdirSync(realRoot);
-            try {
-                fs.symlinkSync(realRoot, linkRoot, "dir");
-            }
-            catch (err) {
-                fs.rmSync(fixtureDir, { recursive: true, force: true });
-                if (err.code === "EPERM")
-                    return null;
-                throw err;
-            }
-            return {
-                realRoot,
-                linkRoot,
-                cleanup: () => fs.rmSync(fixtureDir, { recursive: true, force: true }),
-            };
-        }
-        // ── Claude ──────────────────────────────────────────────────────────────
-        it("claude: captures the HQ-root project AND descendant projects under claude/", () => {
-            const rootName = seedClaude(root);
-            const subName = seedClaude(path.join(root, "workspace", "worktrees", "x"));
-            // An unrelated project (different root) must NOT be captured.
-            seedClaude("/some/other/place");
-            expect(reindex({ repoRoot: root }).status).toBe(0);
-            const c = path.join(dest(), "claude");
-            expect(fs.readFileSync(path.join(c, rootName, "session.jsonl"), "utf8")).toBe("claude\n");
-            expect(fs.existsSync(path.join(c, subName, "session.jsonl"))).toBe(true);
-            expect(fs.existsSync(path.join(c, claudeSlug("/some/other/place")))).toBe(false);
-            // Namespaced: claude logs are NOT dumped at the .session-logs root anymore.
-            expect(fs.existsSync(path.join(dest(), "session.jsonl"))).toBe(false);
-        });
-        it("claude: refreshes a changed dest file but never prunes dest-only entries", () => {
-            const rootName = seedClaude(root, "fresh source\n");
-            const c = path.join(dest(), "claude");
-            fs.mkdirSync(path.join(c, rootName), { recursive: true });
-            fs.writeFileSync(path.join(c, rootName, "session.jsonl"), "STALE\n");
-            fs.writeFileSync(path.join(dest(), "orphan.txt"), "keep\n");
-            expect(reindex({ repoRoot: root }).status).toBe(0);
-            expect(fs.readFileSync(path.join(c, rootName, "session.jsonl"), "utf8")).toBe("fresh source\n");
-            expect(fs.readFileSync(path.join(dest(), "orphan.txt"), "utf8")).toBe("keep\n");
-        });
-        it("claude and grok: skip unchanged overlay files and refresh changed files", () => {
-            const claudeName = seedClaude(root, "claude first\n");
-            const grokName = seedGrok(root, "grok first\n");
-            const files = [
-                {
-                    initial: "claude first\n",
-                    source: path.join(claudeDir, "projects", claudeName, "session.jsonl"),
-                    destination: path.join(dest(), "claude", claudeName, "session.jsonl"),
-                    appended: "claude second\n",
-                },
-                {
-                    initial: "grok first\n",
-                    source: path.join(grokHome, "sessions", grokName, "uuid-1", "chat_history.jsonl"),
-                    destination: path.join(dest(), "grok", grokName, "uuid-1", "chat_history.jsonl"),
-                    appended: "grok second\n",
-                },
-            ];
-            expect(reindex({ repoRoot: root }).status).toBe(0);
-            const copiedMtimes = files.map(({ destination }) => fs.statSync(destination).mtimeMs);
-            expect(reindex({ repoRoot: root }).status).toBe(0);
-            expect(files.map(({ destination }) => fs.statSync(destination).mtimeMs)).toEqual(copiedMtimes);
-            const newerThanCopies = (Math.max(...copiedMtimes) + 2_000) / 1_000;
-            for (const file of files) {
-                fs.appendFileSync(file.source, file.appended);
-                fs.utimesSync(file.source, newerThanCopies, newerThanCopies);
-            }
-            expect(reindex({ repoRoot: root }).status).toBe(0);
-            for (const file of files) {
-                expect(fs.readFileSync(file.destination, "utf8")).toBe(file.initial + file.appended);
-            }
-        });
-        it("claude: captures a realpath-keyed project when reindex uses a symlink alias", () => {
-            const fixture = makeSymlinkRoot();
-            if (!fixture)
-                return; // Symlink-restricted host (for example, Windows without Developer Mode).
-            try {
-                const realName = seedClaude(fixture.realRoot);
-                const aliasName = claudeSlug(fixture.linkRoot);
-                expect(reindex({ repoRoot: fixture.linkRoot }).status).toBe(0);
-                const c = path.join(dest(fixture.realRoot), "claude");
-                expect(fs.readFileSync(path.join(c, realName, "session.jsonl"), "utf8")).toBe("claude\n");
-                expect(fs.existsSync(path.join(c, aliasName))).toBe(false);
-            }
-            finally {
-                fixture.cleanup();
-            }
-        });
-        // ── Grok ────────────────────────────────────────────────────────────────
-        it("grok: captures the HQ-root and descendant cwd folders under grok/, excludes others", () => {
-            const rootName = seedGrok(root);
-            const subName = seedGrok(path.join(root, "repos", "private", "x"));
-            seedGrok("/tmp/benchmark"); // unrelated cwd → excluded
-            expect(reindex({ repoRoot: root }).status).toBe(0);
-            const g = path.join(dest(), "grok");
-            expect(fs.readFileSync(path.join(g, rootName, "uuid-1", "chat_history.jsonl"), "utf8")).toBe("grok\n");
-            expect(fs.existsSync(path.join(g, subName, "uuid-1", "chat_history.jsonl"))).toBe(true);
-            expect(fs.existsSync(path.join(g, grokKey("/tmp/benchmark")))).toBe(false);
-        });
-        it("grok: captures a realpath-keyed session when reindex uses a symlink alias", () => {
-            const fixture = makeSymlinkRoot();
-            if (!fixture)
-                return; // Symlink-restricted host (for example, Windows without Developer Mode).
-            try {
-                const realName = seedGrok(fixture.realRoot);
-                expect(reindex({ repoRoot: fixture.linkRoot }).status).toBe(0);
-                expect(fs.readFileSync(path.join(dest(fixture.realRoot), "grok", realName, "uuid-1", "chat_history.jsonl"), "utf8")).toBe("grok\n");
-            }
-            finally {
-                fixture.cleanup();
-            }
-        });
-        // ── Codex ───────────────────────────────────────────────────────────────
-        it("codex: captures rollouts whose recorded cwd is the HQ tree, mirroring the date path", () => {
-            seedCodex(root, ["2026", "07", "13"], "rollout-root.jsonl");
-            seedCodex(path.join(root, "workspace", "worktrees", "y"), ["2026", "07", "13"], "rollout-sub.jsonl");
-            seedCodex("/elsewhere/repo", ["2026", "07", "13"], "rollout-other.jsonl");
-            expect(reindex({ repoRoot: root }).status).toBe(0);
-            const cx = path.join(dest(), "codex", "2026", "07", "13");
-            expect(fs.existsSync(path.join(cx, "rollout-root.jsonl"))).toBe(true);
-            expect(fs.existsSync(path.join(cx, "rollout-sub.jsonl"))).toBe(true);
-            // A rollout run from outside the HQ tree is never captured (tenant scope).
-            expect(fs.existsSync(path.join(cx, "rollout-other.jsonl"))).toBe(false);
-        });
-        it("codex: captures a realpath-keyed rollout when reindex uses a symlink alias", () => {
-            const fixture = makeSymlinkRoot();
-            if (!fixture)
-                return; // Symlink-restricted host (for example, Windows without Developer Mode).
-            try {
-                seedCodex(path.join(fixture.realRoot, "workspace", "worktrees", "x"), ["2026", "07", "13"], "rollout-real.jsonl");
-                expect(reindex({ repoRoot: fixture.linkRoot }).status).toBe(0);
-                expect(fs.existsSync(path.join(dest(fixture.realRoot), "codex", "2026", "07", "13", "rollout-real.jsonl"))).toBe(true);
-            }
-            finally {
-                fixture.cleanup();
-            }
-        });
-        it("codex: skips a rollout already captured and unchanged (mtime guard)", () => {
-            const src = seedCodex(root, ["2026", "07", "13"], "rollout-a.jsonl");
-            expect(reindex({ repoRoot: root }).status).toBe(0);
-            // Tamper the dest copy with same-sized content and push its mtime into
-            // the future; an unchanged src must be skipped, leaving it in place.
-            const destFile = path.join(dest(), "codex", "2026", "07", "13", "rollout-a.jsonl");
-            const sentinel = "X".repeat(fs.statSync(src).size);
-            fs.writeFileSync(destFile, sentinel);
-            const future = Date.now() / 1000 + 3600;
-            fs.utimesSync(destFile, future, future);
-            expect(reindex({ repoRoot: root }).status).toBe(0);
-            expect(fs.readFileSync(destFile, "utf8")).toBe(sentinel);
-            // But when the src is newer, it IS re-copied (overwriting the sentinel).
-            fs.writeFileSync(src, `${JSON.stringify({ type: "session_meta", payload: { cwd: root } })}\nNEW\n`);
-            const soon = Date.now() / 1000 + 7200;
-            fs.utimesSync(src, soon, soon);
-            expect(reindex({ repoRoot: root }).status).toBe(0);
-            expect(fs.readFileSync(destFile, "utf8")).toContain("NEW");
-        });
-        it("captures exact-root and descendant entries once when the root is already canonical", () => {
-            const canonicalRoot = fs.realpathSync.native(root);
-            const claudeNames = [
-                seedClaude(canonicalRoot),
-                seedClaude(path.join(canonicalRoot, "workspace", "worktrees", "x")),
-            ];
-            const grokNames = [
-                seedGrok(canonicalRoot),
-                seedGrok(path.join(canonicalRoot, "repos", "private", "x")),
-            ];
-            seedCodex(canonicalRoot, ["2026", "07", "15"], "rollout-root.jsonl");
-            seedCodex(path.join(canonicalRoot, "workspace", "worktrees", "x"), ["2026", "07", "15"], "rollout-sub.jsonl");
-            expect(reindex({ repoRoot: canonicalRoot }).status).toBe(0);
-            expect(fs.readdirSync(path.join(dest(canonicalRoot), "claude")).sort()).toEqual(claudeNames.sort());
-            expect(fs.readdirSync(path.join(dest(canonicalRoot), "grok")).sort()).toEqual(grokNames.sort());
-            expect(fs.readdirSync(path.join(dest(canonicalRoot), "codex", "2026", "07", "15")).sort()).toEqual([
-                "rollout-root.jsonl",
-                "rollout-sub.jsonl",
-            ]);
-        });
-        // ── Cross-harness ─────────────────────────────────────────────────────────
-        it("all three harnesses land side-by-side under their own subfolders", () => {
-            seedClaude(root);
-            seedGrok(root);
-            seedCodex(root, ["2026", "07", "14"], "rollout-z.jsonl");
-            expect(reindex({ repoRoot: root }).status).toBe(0);
-            expect(fs.existsSync(path.join(dest(), "claude", claudeSlug(root), "session.jsonl"))).toBe(true);
-            expect(fs.existsSync(path.join(dest(), "grok", grokKey(root), "uuid-1", "chat_history.jsonl"))).toBe(true);
-            expect(fs.existsSync(path.join(dest(), "codex", "2026", "07", "14", "rollout-z.jsonl"))).toBe(true);
-        });
-        it("no-ops (still exit 0) when no harness has logs for this root", () => {
-            // Home dirs exist but are empty → nothing to capture, no dest created.
-            expect(reindex({ repoRoot: root }).status).toBe(0);
-            expect(fs.existsSync(path.join(root, "workspace", ".session-logs"))).toBe(false);
-        });
-    });
-});
-//# sourceMappingURL=reindex.test.js.map