@indigoai-us/hq-cloud 6.14.50 → 6.15.1

package/src/cli/reindex.test.ts

@@ -1,957 +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: "" as string,
-  // 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: "" as string,
-}));
-vi.mock("fs", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("fs")>();
-  const mkdirSync = ((p: unknown, opts: unknown) => {
-    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 as (p: unknown, opts: unknown) => unknown)(p, opts);
-  }) as typeof actual.mkdirSync;
-  const symlinkSync = ((target: unknown, linkPath: unknown, type?: unknown) => {
-    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 as (t: unknown, l: unknown, ty?: unknown) => unknown)(
-      target,
-      linkPath,
-      type,
-    );
-  }) as typeof actual.symlinkSync;
-  const patched = { ...actual, mkdirSync, symlinkSync };
-  return { ...patched, default: patched };
-});
-
-describe("reindex", () => {
-  let root: string;
-  let stateDir: string;
-
-  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: string): void {
-    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: string, body = "command\n"): void {
-    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: string) => 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: string[] = [];
-    const spy = vi
-      .spyOn(process.stderr, "write")
-      .mockImplementation(((chunk: unknown) => {
-        writes.push(String(chunk));
-        return true;
-      }) as typeof process.stderr.write);
-    let status: number;
-    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: string[] = [];
-    const spy = vi
-      .spyOn(process.stderr, "write")
-      .mockImplementation(((chunk: unknown) => {
-        writes.push(String(chunk));
-        return true;
-      }) as typeof process.stderr.write);
-    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: string, entry: string): string {
-    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: string; // CLAUDE_CONFIG_DIR
-    let codexHome: string; // CODEX_HOME
-    let grokHome: string; // GROK_HOME
-
-    // Per-harness cwd encodings the harnesses actually use.
-    const claudeSlug = (p: string): string => p.replace(/[^a-zA-Z0-9]/g, "-");
-    const grokKey = (p: string): string => encodeURIComponent(p);
-
-    const dest = (reindexRoot = root): string =>
-      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: string, body = "claude\n"): string {
-      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: string, body = "grok\n"): string {
-      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: string, date: [string, string, string], file: string): string {
-      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(): { realRoot: string; linkRoot: string; cleanup: () => void } | null {
-      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 as NodeJS.ErrnoException).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: overwrites an existing dest file but never prunes dest-only entries", () => {
-      const rootName = seedClaude(root, "fresh\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\n");
-      expect(fs.readFileSync(path.join(dest(), "orphan.txt"), "utf8")).toBe("keep\n");
-    });
-
-    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 and push its mtime into the future; an unchanged
-      // src must be skipped, leaving the sentinel in place.
-      const destFile = path.join(dest(), "codex", "2026", "07", "13", "rollout-a.jsonl");
-      fs.writeFileSync(destFile, "SENTINEL\n");
-      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\n");
-
-      // 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);
-    });
-  });
-});