@indigoai-us/hq-cli 5.77.13 → 5.78.0

package/src/commands/skill.test.ts

@@ -1,770 +0,0 @@
-/**
- * Unit + story tests for `hq skill` (skill.ts) — US-017.
- *
- * Story tests (PRD):
- *   - Given local edits to a skill, `hq skill suggest --diff` creates a
- *     suggestion the owner's inbox renders WITH a diff.
- *   - Given a pending suggestion, `hq skill review --accept` merges and closes it.
- *
- * Plus AC coverage: the CLI reuses the SAME wired hq-pro routes (exact paths
- * asserted, AC2); a suggest never runs a client-side lock/permission pre-check
- * (AC3); an author note rides as `authorNote` and attribution is the server-
- * derived identity (AC4); the base-changed accept conflict is surfaced with
- * acknowledgement guidance (US-009).
- *
- * The network is exercised through the REAL `vaultApiFetch` over a spied global
- * `fetch` (so the actual route URLs are asserted). The git-diff base is an
- * injected seam so no real repo is needed.
- */
-
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import {
-  afterEach,
-  beforeAll,
-  beforeEach,
-  describe,
-  expect,
-  it,
-  vi,
-  type MockInstance,
-} from "vitest";
-
-// Stub the Cognito token so the action runs without keychain/disk I/O.
-vi.mock("../utils/cognito-session.js", async (importOriginal) => {
-  const original = (await importOriginal()) as Record<string, unknown>;
-  return {
-    ...original,
-    ensureCognitoToken: vi.fn(async () => "test-token"),
-  };
-});
-
-import { Command } from "commander";
-import chalk from "chalk";
-import {
-  registerSkillCommand,
-  parseSkillUid,
-  sha256Hex,
-  buildSuggestionCreateBody,
-  mapSkillError,
-  resolveCompanySlug,
-  resolveSkillTarget,
-  findSkillFileByUid,
-  formatSuggestionsList,
-  type GitBaseReader,
-  type SuggestionRow,
-} from "./skill.js";
-
-// Plain (un-coloured) rendered text so assertions read the literal output.
-beforeAll(() => {
-  chalk.level = 0;
-});
-
-function jsonResponse(body: unknown, status = 200): Response {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: { "Content-Type": "application/json" },
-  });
-}
-
-let fetchSpy: MockInstance<typeof fetch>;
-let exitSpy: MockInstance<typeof process.exit>;
-let logSpy: MockInstance<typeof console.log>;
-let errSpy: MockInstance<typeof console.error>;
-const tmpDirs: string[] = [];
-
-beforeEach(() => {
-  fetchSpy = vi.spyOn(globalThis, "fetch");
-  exitSpy = vi.spyOn(process, "exit").mockImplementation(((code?: number) => {
-    throw new Error(`__EXIT__:${code ?? 0}`);
-  }) as never);
-  logSpy = vi.spyOn(console, "log").mockImplementation(() => undefined);
-  errSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
-});
-
-afterEach(() => {
-  vi.restoreAllMocks();
-  while (tmpDirs.length > 0) {
-    const dir = tmpDirs.pop()!;
-    try {
-      fs.rmSync(dir, { recursive: true, force: true });
-    } catch {
-      /* best effort */
-    }
-  }
-});
-
-/** A commander program with the skill command registered + a git-base seam. */
-function buildProgram(deps: { gitBase?: GitBaseReader } = {}): Command {
-  const program = new Command();
-  program.configureOutput({ writeOut: () => undefined, writeErr: () => undefined });
-  registerSkillCommand(program, deps);
-  return program;
-}
-
-/** Make a temp dir holding a SKILL.md with `skill_uid` frontmatter + body. */
-function makeSkillDir(uid: string, body: string): string {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-skill-"));
-  tmpDirs.push(dir);
-  fs.writeFileSync(
-    path.join(dir, "SKILL.md"),
-    `---\nskill_uid: ${uid}\nname: Test Skill\n---\n${body}`,
-  );
-  return dir;
-}
-
-function joinedLog(): string {
-  return logSpy.mock.calls.map((c) => String(c[0])).join("\n");
-}
-function joinedErr(): string {
-  // Join every arg of each call — some error paths log `console.error("Error:", msg)`.
-  return errSpy.mock.calls.map((c) => c.map((a) => String(a)).join(" ")).join("\n");
-}
-
-const UID = "skl_01ABCDEFGHJKMNPQRSTVWXYZ00";
-
-// ===========================================================================
-// Story tests
-// ===========================================================================
-
-describe("story: suggest --diff → suggestion in the owner's inbox with a diff", () => {
-  it("posts proposed + base to the CREATE route and the inbox renders the diff", async () => {
-    const dir = makeSkillDir(UID, "# Title\n\nfixed line\n");
-    const proposed = fs.readFileSync(path.join(dir, "SKILL.md"), "utf-8");
-    const base = proposed.replace("fixed line", "old line");
-    const gitBase: GitBaseReader = vi.fn(async () => base);
-
-    // CREATE response (server derived the diff from baseContent).
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse({
-        ok: true,
-        created: true,
-        company: "acme",
-        skillUid: UID,
-        suggestionId: "sgn_1",
-        status: "open",
-        authorPersonUid: "prs_me",
-        payloadFormat: "diff",
-        baseContentHash: "hhh",
-        authorNote: "fix the thing",
-      }),
-    );
-
-    await buildProgram({ gitBase }).parseAsync(
-      ["skill", "--company", "acme", "suggest", dir, "--diff", "--note", "fix the thing"],
-      { from: "user" },
-    );
-
-    // AC2: the exact wired CREATE route + a diff-capable body (proposed + base).
-    const createCall = fetchSpy.mock.calls[0];
-    expect(String(createCall[0])).toMatch(
-      /\/v1\/files\/skills\/company\/acme\/skl_01ABCDEFGHJKMNPQRSTVWXYZ00\/suggestions$/,
-    );
-    expect(createCall[1]?.method).toBe("POST");
-    const body = JSON.parse((createCall[1]?.body as string) ?? "{}");
-    expect(body.proposedContent).toBe(proposed);
-    expect(body.baseContent).toBe(base);
-    expect(body.authorNote).toBe("fix the thing"); // AC4 author note
-    expect(body.baseContentHash).toBeUndefined(); // server derives it from baseContent
-
-    // AC4: attribution is the server-derived identity, surfaced to the user.
-    expect(joinedLog()).toContain("prs_me");
-    expect(joinedLog()).toContain("sgn_1");
-
-    // Now the owner's inbox lists it WITH a diff.
-    logSpy.mockClear();
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse({
-        suggestions: [
-          {
-            suggestionId: "sgn_1",
-            skillUid: UID,
-            authorPersonUid: "prs_me",
-            status: "open",
-            baseChanged: false,
-            presentation: "diff",
-            unifiedDiff:
-              "--- a/SKILL.md\n+++ b/SKILL.md\n@@ -3 +3 @@\n-old line\n+fixed line\n",
-            fullContent: proposed,
-            authorNote: "fix the thing",
-            createdAt: "2026-07-09T00:00:00Z",
-            path: "skills/test-skill/SKILL.md",
-          },
-        ],
-        count: 1,
-      }),
-    );
-
-    await buildProgram().parseAsync(
-      ["skill", "--company", "acme", "list-suggestions", "--show-diff"],
-      { from: "user" },
-    );
-
-    const inbox = joinedLog();
-    expect(inbox).toContain("sgn_1");
-    expect(inbox).toContain("-old line");
-    expect(inbox).toContain("+fixed line");
-    expect(exitSpy).not.toHaveBeenCalled();
-  });
-});
-
-describe("story: review --accept merges and closes a pending suggestion", () => {
-  it("resolves the row via LIST then POSTs {path} to the ACCEPT route", async () => {
-    // 1) LIST (status all) → the row carrying skillUid + live path.
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse({
-        suggestions: [
-          {
-            suggestionId: "sgn_9",
-            skillUid: "skl_yyy",
-            authorPersonUid: "prs_author",
-            status: "open",
-            baseChanged: false,
-            path: "skills/foo/SKILL.md",
-            createdAt: "2026-07-09",
-          },
-        ],
-        count: 1,
-      }),
-    );
-    // 2) ACCEPT → merged + closed.
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse({
-        ok: true,
-        accepted: true,
-        liveSkill: true,
-        skillUid: "skl_yyy",
-        suggestionId: "sgn_9",
-        authorPersonUid: "prs_author",
-        acceptedBy: "prs_me",
-        baseChanged: false,
-        reindex: true,
-        message: "Suggestion accepted — the skill was updated to the proposed version.",
-      }),
-    );
-
-    await buildProgram().parseAsync(
-      ["skill", "--company", "acme", "review", "sgn_9", "--accept"],
-      { from: "user" },
-    );
-
-    // First call is the LIST lookup...
-    expect(String(fetchSpy.mock.calls[0][0])).toMatch(
-      /\/v1\/files\/skills\/company\/acme\/suggestions\/list$/,
-    );
-    // ...second is the wired ACCEPT route with the authoritative path.
-    const acceptCall = fetchSpy.mock.calls[1];
-    expect(String(acceptCall[0])).toMatch(
-      /\/v1\/files\/skills\/company\/acme\/skl_yyy\/suggestions\/sgn_9\/accept$/,
-    );
-    expect(JSON.parse((acceptCall[1]?.body as string) ?? "{}")).toEqual({
-      path: "skills/foo/SKILL.md",
-    });
-
-    expect(joinedLog()).toMatch(/merged and closed/);
-    expect(joinedLog()).toContain("prs_me");
-    expect(exitSpy).not.toHaveBeenCalled();
-  });
-});
-
-// ===========================================================================
-// AC3 — lock-safe suggest (no client-side gate)
-// ===========================================================================
-
-describe("AC3: suggest never runs a client-side lock/permission pre-check", () => {
-  it("issues exactly one network call — the CREATE POST — with no pre-flight lookup", async () => {
-    const dir = makeSkillDir("skl_locked000000000000000000", "body\n");
-    const gitBase: GitBaseReader = vi.fn(async () => null); // no base → full-file proposal
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse({
-        suggestionId: "sgn_x",
-        skillUid: "skl_locked000000000000000000",
-        status: "open",
-        authorPersonUid: "prs_me",
-        payloadFormat: "full-file",
-        baseContentHash: "h",
-      }),
-    );
-
-    await buildProgram({ gitBase }).parseAsync(
-      ["skill", "--company", "acme", "suggest", dir],
-      { from: "user" },
-    );
-
-    // A lock check would be a SEPARATE GET before the POST — there is none.
-    expect(fetchSpy).toHaveBeenCalledTimes(1);
-    expect(String(fetchSpy.mock.calls[0][0])).toContain("/suggestions");
-    expect(fetchSpy.mock.calls[0][1]?.method).toBe("POST");
-    // A full-file proposal carries a baseContentHash the server requires.
-    const body = JSON.parse((fetchSpy.mock.calls[0][1]?.body as string) ?? "{}");
-    expect(body.proposedContent).toContain("body");
-    expect(typeof body.baseContentHash).toBe("string");
-    expect(body.baseContent).toBeUndefined();
-  });
-});
-
-// ===========================================================================
-// suggest — base resolution + guardrails
-// ===========================================================================
-
-describe("hq skill suggest — base + guardrails", () => {
-  it("errors (no fetch) when the working tree matches its base", async () => {
-    const dir = makeSkillDir(UID, "same\n");
-    const same = fs.readFileSync(path.join(dir, "SKILL.md"), "utf-8");
-    const gitBase: GitBaseReader = vi.fn(async () => same);
-
-    await expect(
-      buildProgram({ gitBase }).parseAsync(
-        ["skill", "--company", "acme", "suggest", dir, "--diff"],
-        { from: "user" },
-      ),
-    ).rejects.toThrow(/__EXIT__:1/);
-
-    expect(joinedErr()).toMatch(/No changes to propose/);
-    expect(fetchSpy).not.toHaveBeenCalled();
-  });
-
-  it("--diff errors when no base can be resolved", async () => {
-    const dir = makeSkillDir(UID, "body\n");
-    const gitBase: GitBaseReader = vi.fn(async () => null);
-
-    await expect(
-      buildProgram({ gitBase }).parseAsync(
-        ["skill", "--company", "acme", "suggest", dir, "--diff"],
-        { from: "user" },
-      ),
-    ).rejects.toThrow(/__EXIT__:1/);
-
-    expect(joinedErr()).toMatch(/--diff needs a base/);
-    expect(fetchSpy).not.toHaveBeenCalled();
-  });
-
-  it("uses an explicit --base file as the diff base", async () => {
-    const dir = makeSkillDir(UID, "new content\n");
-    const baseFile = path.join(dir, "base.md");
-    fs.writeFileSync(baseFile, `---\nskill_uid: ${UID}\n---\nold content\n`);
-    const gitBase: GitBaseReader = vi.fn(async () => "SHOULD_NOT_BE_USED");
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse({
-        suggestionId: "sgn_b",
-        skillUid: UID,
-        status: "open",
-        authorPersonUid: "prs_me",
-        payloadFormat: "diff",
-      }),
-    );
-
-    await buildProgram({ gitBase }).parseAsync(
-      ["skill", "--company", "acme", "suggest", dir, "--base", baseFile],
-      { from: "user" },
-    );
-
-    expect(gitBase).not.toHaveBeenCalled(); // --base wins over git HEAD
-    const body = JSON.parse((fetchSpy.mock.calls[0][1]?.body as string) ?? "{}");
-    expect(body.baseContent).toContain("old content");
-    expect(body.proposedContent).toContain("new content");
-  });
-
-  it("errors when the SKILL.md has no skill_uid", async () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-skill-"));
-    tmpDirs.push(dir);
-    fs.writeFileSync(path.join(dir, "SKILL.md"), "# no frontmatter uid\n");
-    const gitBase: GitBaseReader = vi.fn(async () => null);
-
-    await expect(
-      buildProgram({ gitBase }).parseAsync(
-        ["skill", "--company", "acme", "suggest", dir],
-        { from: "user" },
-      ),
-    ).rejects.toThrow(/__EXIT__:1/);
-
-    expect(joinedErr()).toMatch(/no skill_uid/);
-    expect(fetchSpy).not.toHaveBeenCalled();
-  });
-
-  it("maps a 403 non-membership error from the CREATE route", async () => {
-    const dir = makeSkillDir(UID, "body\n");
-    const gitBase: GitBaseReader = vi.fn(async () => null);
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse({ error: "Caller is not a member", code: "WRITE_NOT_MEMBER" }, 403),
-    );
-
-    await expect(
-      buildProgram({ gitBase }).parseAsync(
-        ["skill", "--company", "acme", "suggest", dir],
-        { from: "user" },
-      ),
-    ).rejects.toThrow(/__EXIT__:1/);
-
-    expect(joinedErr()).toMatch(/not a member/);
-  });
-});
-
-// ===========================================================================
-// list-suggestions
-// ===========================================================================
-
-describe("hq skill list-suggestions", () => {
-  it("POSTs {status} (+ skillUid when scoped) to the LIST route", async () => {
-    fetchSpy.mockResolvedValueOnce(jsonResponse({ suggestions: [], count: 0 }));
-
-    await buildProgram().parseAsync(
-      ["skill", "--company", "acme", "list-suggestions", "--skill", "skl_yyy", "--status", "all"],
-      { from: "user" },
-    );
-
-    const call = fetchSpy.mock.calls[0];
-    expect(String(call[0])).toMatch(
-      /\/v1\/files\/skills\/company\/acme\/suggestions\/list$/,
-    );
-    expect(JSON.parse((call[1]?.body as string) ?? "{}")).toEqual({
-      status: "all",
-      skillUid: "skl_yyy",
-    });
-    expect(joinedLog()).toMatch(/review inbox is empty/);
-  });
-
-  it("defaults status to open and emits raw JSON with --json", async () => {
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse({ suggestions: [], count: 0 }),
-    );
-    await buildProgram().parseAsync(
-      ["skill", "--company", "acme", "list-suggestions", "--json"],
-      { from: "user" },
-    );
-    expect(JSON.parse((fetchSpy.mock.calls[0][1]?.body as string) ?? "{}")).toEqual({
-      status: "open",
-    });
-    expect(joinedLog()).toContain('"count": 0');
-  });
-
-  it("rejects an invalid --status without a network call", async () => {
-    await expect(
-      buildProgram().parseAsync(
-        ["skill", "--company", "acme", "list-suggestions", "--status", "bogus"],
-        { from: "user" },
-      ),
-    ).rejects.toThrow(/__EXIT__:1/);
-    expect(fetchSpy).not.toHaveBeenCalled();
-  });
-});
-
-// ===========================================================================
-// review — decline, conflicts, validation
-// ===========================================================================
-
-describe("hq skill review", () => {
-  const openRow = {
-    suggestions: [
-      {
-        suggestionId: "sgn_9",
-        skillUid: "skl_yyy",
-        authorPersonUid: "prs_author",
-        status: "open",
-        baseChanged: false,
-        path: "skills/foo/SKILL.md",
-        createdAt: "2026-07-09",
-      },
-    ],
-    count: 1,
-  };
-
-  it("--decline posts the reason and leaves the skill unchanged", async () => {
-    fetchSpy.mockResolvedValueOnce(jsonResponse(openRow));
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse({
-        ok: true,
-        declined: true,
-        skillUid: "skl_yyy",
-        suggestionId: "sgn_9",
-        declinedBy: "prs_me",
-        status: "declined",
-        reason: "not now",
-      }),
-    );
-
-    await buildProgram().parseAsync(
-      ["skill", "--company", "acme", "review", "sgn_9", "--decline", "--reason", "not now"],
-      { from: "user" },
-    );
-
-    const declineCall = fetchSpy.mock.calls[1];
-    expect(String(declineCall[0])).toMatch(
-      /\/skl_yyy\/suggestions\/sgn_9\/decline$/,
-    );
-    expect(JSON.parse((declineCall[1]?.body as string) ?? "{}")).toEqual({
-      reason: "not now",
-    });
-    expect(joinedLog()).toMatch(/declined/);
-    expect(joinedLog()).toContain("not now");
-  });
-
-  it("--accept surfaces a base-changed conflict with acknowledge guidance", async () => {
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse({
-        suggestions: [{ ...openRow.suggestions[0], baseChanged: true }],
-        count: 1,
-      }),
-    );
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse(
-        {
-          error: "The skill changed since this suggestion was written.",
-          code: "WRITE_SKILL_SUGGESTION_BASE_CHANGED",
-          baseChanged: true,
-        },
-        409,
-      ),
-    );
-
-    await expect(
-      buildProgram().parseAsync(
-        ["skill", "--company", "acme", "review", "sgn_9", "--accept"],
-        { from: "user" },
-      ),
-    ).rejects.toThrow(/__EXIT__:1/);
-
-    expect(joinedErr()).toMatch(/--acknowledge-base-changed/);
-  });
-
-  it("--accept --acknowledge-base-changed forwards the flag in the body", async () => {
-    fetchSpy.mockResolvedValueOnce(jsonResponse(openRow));
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse({
-        ok: true,
-        accepted: true,
-        skillUid: "skl_yyy",
-        suggestionId: "sgn_9",
-        acceptedBy: "prs_me",
-        baseChanged: true,
-        reindex: true,
-      }),
-    );
-
-    await buildProgram().parseAsync(
-      ["skill", "--company", "acme", "review", "sgn_9", "--accept", "--acknowledge-base-changed"],
-      { from: "user" },
-    );
-
-    expect(JSON.parse((fetchSpy.mock.calls[1][1]?.body as string) ?? "{}")).toEqual({
-      path: "skills/foo/SKILL.md",
-      acknowledgeBaseChanged: true,
-    });
-    expect(joinedLog()).toMatch(/merged and closed/);
-  });
-
-  it("requires exactly one of --accept / --decline", async () => {
-    await expect(
-      buildProgram().parseAsync(
-        ["skill", "--company", "acme", "review", "sgn_9"],
-        { from: "user" },
-      ),
-    ).rejects.toThrow(/__EXIT__:1/);
-    expect(joinedErr()).toMatch(/exactly one of --accept or --decline/);
-    expect(fetchSpy).not.toHaveBeenCalled();
-  });
-
-  it("errors when the suggestion is not in the inbox", async () => {
-    fetchSpy.mockResolvedValueOnce(jsonResponse({ suggestions: [], count: 0 }));
-    await expect(
-      buildProgram().parseAsync(
-        ["skill", "--company", "acme", "review", "sgn_missing", "--accept"],
-        { from: "user" },
-      ),
-    ).rejects.toThrow(/__EXIT__:1/);
-    expect(joinedErr()).toMatch(/not in your review inbox/);
-  });
-
-  it("rejects a malformed suggestion id before any network call", async () => {
-    await expect(
-      buildProgram().parseAsync(
-        ["skill", "--company", "acme", "review", "not-an-id", "--accept"],
-        { from: "user" },
-      ),
-    ).rejects.toThrow(/__EXIT__:1/);
-    expect(fetchSpy).not.toHaveBeenCalled();
-  });
-});
-
-// ===========================================================================
-// Pure helpers
-// ===========================================================================
-
-describe("parseSkillUid", () => {
-  it("reads a top-level skl_ uid from frontmatter", () => {
-    expect(parseSkillUid(`---\nskill_uid: ${UID}\nname: x\n---\nbody`)).toBe(UID);
-  });
-  it("returns undefined with no frontmatter", () => {
-    expect(parseSkillUid("# just a heading\n")).toBeUndefined();
-  });
-  it("returns undefined for a non-skl_ value", () => {
-    expect(parseSkillUid("---\nskill_uid: nope\n---\n")).toBeUndefined();
-  });
-  it("returns undefined for a non-string uid", () => {
-    expect(parseSkillUid("---\nskill_uid: 123\n---\n")).toBeUndefined();
-  });
-});
-
-describe("buildSuggestionCreateBody", () => {
-  it("sends baseContent (diff path) and drops a derived hash", () => {
-    const body = buildSuggestionCreateBody({
-      proposedContent: "new",
-      baseContent: "old",
-      note: "  ctx  ",
-    });
-    expect(body).toEqual({ proposedContent: "new", baseContent: "old", authorNote: "ctx" });
-  });
-  it("sends baseContentHash (full-file path) when there is no base", () => {
-    const body = buildSuggestionCreateBody({ proposedContent: "solo" });
-    expect(body).toEqual({
-      proposedContent: "solo",
-      baseContentHash: sha256Hex("solo"),
-    });
-  });
-  it("drops an empty note", () => {
-    const body = buildSuggestionCreateBody({ proposedContent: "x", note: "   " });
-    expect(body.authorNote).toBeUndefined();
-  });
-  it("throws on a no-op (base === proposed)", () => {
-    expect(() =>
-      buildSuggestionCreateBody({ proposedContent: "same", baseContent: "same" }),
-    ).toThrow(/No changes to propose/);
-  });
-});
-
-describe("mapSkillError", () => {
-  it("maps auth + prefers the server message", () => {
-    expect(mapSkillError(401, {})).toMatch(/hq login/);
-    expect(mapSkillError(403, { error: "You need write access" })).toBe(
-      "You need write access",
-    );
-    expect(mapSkillError(404, { error: "Skill not found" })).toBe("Skill not found");
-    expect(mapSkillError(409, { message: "already accepted" })).toBe("already accepted");
-    expect(mapSkillError(500, {})).toMatch(/Server error/);
-  });
-});
-
-describe("resolveCompanySlug", () => {
-  it("prefers the explicit flag", () => {
-    expect(resolveCompanySlug("acme", "/nonexistent")).toBe("acme");
-  });
-  it("falls back to .hq/config.json activeCompany", () => {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "hq-root-"));
-    tmpDirs.push(root);
-    fs.mkdirSync(path.join(root, ".hq"));
-    fs.writeFileSync(
-      path.join(root, ".hq", "config.json"),
-      JSON.stringify({ activeCompany: "beta" }),
-    );
-    expect(resolveCompanySlug(undefined, root)).toBe("beta");
-  });
-  it("throws when neither is available", () => {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "hq-root-"));
-    tmpDirs.push(root);
-    expect(() => resolveCompanySlug(undefined, root)).toThrow(/No company specified/);
-  });
-});
-
-describe("resolveSkillTarget", () => {
-  it("resolves a directory to its SKILL.md and reads the uid", () => {
-    const dir = makeSkillDir(UID, "hello\n");
-    const r = resolveSkillTarget(dir, { cwd: dir, hqRoot: "/x", companySlug: "acme" });
-    expect(r.skillUid).toBe(UID);
-    expect(r.content).toContain("hello");
-    expect(r.filePath.endsWith("SKILL.md")).toBe(true);
-  });
-
-  it("resolves a direct SKILL.md file path", () => {
-    const dir = makeSkillDir(UID, "hi\n");
-    const file = path.join(dir, "SKILL.md");
-    const r = resolveSkillTarget(file, { cwd: "/x", hqRoot: "/x", companySlug: "acme" });
-    expect(r.skillUid).toBe(UID);
-  });
-
-  it("resolves a skl_ uid by scanning the company skills dir", () => {
-    const hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-root-"));
-    tmpDirs.push(hqRoot);
-    const skillDir = path.join(hqRoot, "companies", "acme", "skills", "foo");
-    fs.mkdirSync(skillDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(skillDir, "SKILL.md"),
-      `---\nskill_uid: ${UID}\n---\ncontent\n`,
-    );
-    const emptyCwd = fs.mkdtempSync(path.join(os.tmpdir(), "hq-cwd-"));
-    tmpDirs.push(emptyCwd);
-
-    const r = resolveSkillTarget(UID, { cwd: emptyCwd, hqRoot, companySlug: "acme" });
-    expect(r.skillUid).toBe(UID);
-    expect(r.filePath).toBe(path.join(skillDir, "SKILL.md"));
-  });
-
-  it("throws for a missing path", () => {
-    expect(() =>
-      resolveSkillTarget("/no/such/dir", { cwd: "/x", hqRoot: "/x", companySlug: "acme" }),
-    ).toThrow(/No SKILL.md found/);
-  });
-
-  it("throws when the resolved SKILL.md has no uid", () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-skill-"));
-    tmpDirs.push(dir);
-    fs.writeFileSync(path.join(dir, "SKILL.md"), "# no uid\n");
-    expect(() =>
-      resolveSkillTarget(dir, { cwd: dir, hqRoot: "/x", companySlug: "acme" }),
-    ).toThrow(/no skill_uid/);
-  });
-});
-
-describe("findSkillFileByUid", () => {
-  it("returns null when no skill matches", () => {
-    const dir = makeSkillDir(UID, "x\n");
-    expect(findSkillFileByUid([dir], "skl_other")).toBeNull();
-  });
-  it("skips ignored dirs and finds a nested match", () => {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "hq-root-"));
-    tmpDirs.push(root);
-    const nested = path.join(root, "a", "b", "skill");
-    fs.mkdirSync(nested, { recursive: true });
-    fs.writeFileSync(path.join(nested, "SKILL.md"), `---\nskill_uid: ${UID}\n---\n`);
-    expect(findSkillFileByUid([root], UID)).toBe(path.join(nested, "SKILL.md"));
-  });
-});
-
-describe("formatSuggestionsList", () => {
-  const row: SuggestionRow = {
-    suggestionId: "sgn_1",
-    skillUid: "skl_a",
-    authorPersonUid: "prs_x",
-    status: "open",
-    baseChanged: false,
-    presentation: "diff",
-    unifiedDiff: "--- a\n+++ b\n@@ -1 +1 @@\n-a\n+b\n",
-    authorNote: "why",
-    createdAt: "2026-07-09T00:00:00Z",
-    path: "skills/a/SKILL.md",
-  };
-
-  it("renders an empty-inbox line", () => {
-    expect(formatSuggestionsList([])).toMatch(/review inbox is empty/);
-  });
-  it("renders a header + row + note", () => {
-    const out = formatSuggestionsList([row]);
-    expect(out).toContain("SUGGESTION_ID");
-    expect(out).toContain("sgn_1");
-    expect(out).toContain("note: why");
-    expect(out).not.toContain("+b"); // no diff without --show-diff
-  });
-  it("includes the diff with showDiff", () => {
-    const out = formatSuggestionsList([row], { showDiff: true });
-    expect(out).toContain("-a");
-    expect(out).toContain("+b");
-  });
-  it("shows full file when the base changed", () => {
-    const out = formatSuggestionsList(
-      [{ ...row, presentation: "full-file", unifiedDiff: undefined, fullContent: "WHOLE", baseChanged: true }],
-      { showDiff: true },
-    );
-    expect(out).toContain("full file");
-    expect(out).toContain("WHOLE");
-  });
-});