@indigoai-us/hq-cli 5.77.13 → 5.78.0

package/src/commands/people.test.ts

@@ -1,807 +0,0 @@
-/**
- * Unit tests for the `hq people` capability:
- *   - utils/people.ts — parse, list, search, resolve (pure + filesystem)
- *   - people.ts       — active-company resolution + wired list/search/resolve
- */
-
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { Command } from "commander";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import {
-  assertSafeCompanySlug,
-  companyPeopleDir,
-  parsePersonMeta,
-  listCompanyPeople,
-  searchPeople,
-  resolveNameToEmail,
-  type PersonRecord,
-} from "../utils/people.js";
-import { isExpectedUserError } from "../utils/expected-cli-error.js";
-import {
-  activeMemberToPersonRecord,
-  mergePeople,
-  registerPeopleCommand,
-  resolveCompanySlug,
-  type FetchPeopleRoster,
-} from "./people.js";
-import type { ActiveMember } from "./members.js";
-
-// ---------------------------------------------------------------------------
-// Filesystem fixture helpers
-// ---------------------------------------------------------------------------
-
-let tmpRoot: string;
-
-function makePerson(
-  company: string,
-  slug: string,
-  meta: Record<string, unknown> | string,
-): void {
-  const dir = path.join(tmpRoot, "companies", company, "people", slug);
-  fs.mkdirSync(dir, { recursive: true });
-  const body =
-    typeof meta === "string"
-      ? meta
-      : Object.entries(meta)
-          .map(([k, v]) =>
-            Array.isArray(v)
-              ? `${k}: [${v.join(", ")}]`
-              : `${k}: ${JSON.stringify(v)}`,
-          )
-          .join("\n");
-  fs.writeFileSync(path.join(dir, "meta.yaml"), body + "\n");
-}
-
-function writeCompaniesManifest(
-  companies: Record<string, Record<string, unknown> | null>,
-): void {
-  const dir = path.join(tmpRoot, "companies");
-  fs.mkdirSync(dir, { recursive: true });
-  const yamlBody =
-    "companies:\n" +
-    Object.entries(companies)
-      .map(([slug, entry]) => {
-        if (!entry) return `  ${slug}:`;
-        const fields = Object.entries(entry)
-          .map(([k, v]) => `    ${k}: ${JSON.stringify(v)}`)
-          .join("\n");
-        return `  ${slug}:\n${fields}`;
-      })
-      .join("\n") +
-    "\n";
-  fs.writeFileSync(path.join(dir, "manifest.yaml"), yamlBody);
-}
-
-beforeEach(() => {
-  tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-people-"));
-});
-
-afterEach(() => {
-  fs.rmSync(tmpRoot, { recursive: true, force: true });
-  vi.restoreAllMocks();
-});
-
-// ---------------------------------------------------------------------------
-// assertSafeCompanySlug
-// ---------------------------------------------------------------------------
-
-describe("assertSafeCompanySlug", () => {
-  it("accepts ordinary slugs", () => {
-    expect(() => assertSafeCompanySlug("indigo")).not.toThrow();
-    expect(() => assertSafeCompanySlug("acme-co_1.2")).not.toThrow();
-  });
-
-  it("rejects path-traversal and separators", () => {
-    expect(() => assertSafeCompanySlug("..")).toThrow();
-    expect(() => assertSafeCompanySlug("a/b")).toThrow();
-    expect(() => assertSafeCompanySlug("../etc")).toThrow();
-    expect(() => assertSafeCompanySlug("")).toThrow();
-  });
-
-  it("rejects reserved slugs", () => {
-    expect(() => assertSafeCompanySlug("personal")).toThrow(/reserved/);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// parsePersonMeta
-// ---------------------------------------------------------------------------
-
-describe("parsePersonMeta", () => {
-  it("parses a full record and trims fields", () => {
-    const rec = parsePersonMeta(
-      "name: Jane Smith\nemail: jane@example.com\ntype: internal\nrole: Head of Eng\ntags: [eng, lead]\n",
-      "jane-smith",
-      "/x/meta.yaml",
-    );
-    expect(rec).toEqual({
-      slug: "jane-smith",
-      name: "Jane Smith",
-      email: "jane@example.com",
-      type: "internal",
-      role: "Head of Eng",
-      tags: ["eng", "lead"],
-      source: "/x/meta.yaml",
-    });
-  });
-
-  it("returns null when name is missing or blank", () => {
-    expect(parsePersonMeta("email: a@b.com\n", "x", "/x")).toBeNull();
-    expect(parsePersonMeta("name: '   '\n", "x", "/x")).toBeNull();
-  });
-
-  it("returns null for empty / non-object docs", () => {
-    expect(parsePersonMeta("", "x", "/x")).toBeNull();
-    expect(parsePersonMeta("- a\n- b\n", "x", "/x")).toBeNull();
-  });
-
-  it("throws on unparseable yaml", () => {
-    const error = (() => {
-      try {
-        parsePersonMeta("name: [unterminated\n", "x", "/x");
-      } catch (err) {
-        return err;
-      }
-      throw new Error("expected malformed YAML to throw");
-    })();
-
-    expect(isExpectedUserError(error)).toBe(true);
-    expect((error as Error).message).toContain("Invalid YAML in /x:2:1");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// listCompanyPeople
-// ---------------------------------------------------------------------------
-
-describe("listCompanyPeople", () => {
-  it("returns [] when the company has no people directory", () => {
-    writeCompaniesManifest({ acme: { status: "active" } });
-    expect(listCompanyPeople(tmpRoot, "acme")).toEqual([]);
-  });
-
-  it("reads people, skips _scaffolding, nameless, and meta-less folders, sorted by name", () => {
-    makePerson("acme", "zed", { name: "Zed Zebra", email: "zed@acme.com" });
-    makePerson("acme", "ann", { name: "Ann Apple", email: "ann@acme.com" });
-    makePerson("acme", "_example", { name: "Template Person" });
-    makePerson("acme", "nameless", { email: "noone@acme.com" });
-    // folder with no meta.yaml
-    fs.mkdirSync(path.join(tmpRoot, "companies", "acme", "people", "empty"), {
-      recursive: true,
-    });
-
-    const people = listCompanyPeople(tmpRoot, "acme");
-    expect(people.map((p) => p.name)).toEqual(["Ann Apple", "Zed Zebra"]);
-  });
-
-  it("never reads outside the named company (tenancy)", () => {
-    makePerson("acme", "ann", { name: "Ann Apple", email: "ann@acme.com" });
-    makePerson("other", "bob", { name: "Bob Other", email: "bob@other.com" });
-    const people = listCompanyPeople(tmpRoot, "acme");
-    expect(people.map((p) => p.name)).toEqual(["Ann Apple"]);
-  });
-
-  it("rejects an unsafe company slug", () => {
-    expect(() => listCompanyPeople(tmpRoot, "../other")).toThrow();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// searchPeople
-// ---------------------------------------------------------------------------
-
-const SAMPLE: PersonRecord[] = [
-  { slug: "jane-smith", name: "Jane Smith", email: "jane@example.com", source: "a" },
-  { slug: "john-doe", name: "John Doe", email: "john@acme.com", source: "b" },
-  { slug: "janet-lee", name: "Janet Lee", source: "c" },
-];
-
-describe("searchPeople", () => {
-  it("matches on name (case-insensitive)", () => {
-    // "jane" is a substring of both "Jane Smith" and "Janet Lee".
-    expect(searchPeople(SAMPLE, "jane").map((p) => p.slug)).toEqual([
-      "jane-smith",
-      "janet-lee",
-    ]);
-    expect(searchPeople(SAMPLE, "smith").map((p) => p.slug)).toEqual([
-      "jane-smith",
-    ]);
-    expect(searchPeople(SAMPLE, "JAN").map((p) => p.slug)).toEqual([
-      "jane-smith",
-      "janet-lee",
-    ]);
-  });
-
-  it("matches on email", () => {
-    expect(searchPeople(SAMPLE, "acme.com").map((p) => p.slug)).toEqual([
-      "john-doe",
-    ]);
-  });
-
-  it("matches on slug", () => {
-    expect(searchPeople(SAMPLE, "janet-lee").map((p) => p.slug)).toEqual([
-      "janet-lee",
-    ]);
-  });
-
-  it("returns nothing for an empty/whitespace keyword", () => {
-    expect(searchPeople(SAMPLE, "")).toEqual([]);
-    expect(searchPeople(SAMPLE, "   ")).toEqual([]);
-  });
-
-  it("returns nothing when no one matches", () => {
-    expect(searchPeople(SAMPLE, "zzz")).toEqual([]);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// resolveNameToEmail
-// ---------------------------------------------------------------------------
-
-describe("resolveNameToEmail", () => {
-  it("resolves an exact name to its email", () => {
-    expect(resolveNameToEmail(SAMPLE, "Jane Smith")).toEqual({
-      status: "found",
-      email: "jane@example.com",
-      person: SAMPLE[0],
-    });
-  });
-
-  it("is case-insensitive on exact name", () => {
-    const r = resolveNameToEmail(SAMPLE, "jane smith");
-    expect(r.status).toBe("found");
-  });
-
-  it("prefers an exact name over looser substring matches", () => {
-    const people: PersonRecord[] = [
-      { slug: "jan", name: "Jan", email: "jan@x.com", source: "a" },
-      { slug: "jana", name: "Janabc", email: "jana@x.com", source: "b" },
-    ];
-    expect(resolveNameToEmail(people, "Jan")).toMatchObject({
-      status: "found",
-      email: "jan@x.com",
-    });
-  });
-
-  it("resolves via slug when name doesn't match exactly", () => {
-    expect(resolveNameToEmail(SAMPLE, "john-doe")).toMatchObject({
-      status: "found",
-      email: "john@acme.com",
-    });
-  });
-
-  it("reports ambiguity when a substring matches several", () => {
-    const r = resolveNameToEmail(SAMPLE, "jan");
-    expect(r.status).toBe("ambiguous");
-    if (r.status === "ambiguous") {
-      expect(r.matches.map((m) => m.slug)).toEqual(["jane-smith", "janet-lee"]);
-    }
-  });
-
-  it("reports no_email when the sole match has no email", () => {
-    expect(resolveNameToEmail(SAMPLE, "Janet Lee")).toMatchObject({
-      status: "no_email",
-    });
-  });
-
-  it("reports not_found when nothing matches", () => {
-    expect(resolveNameToEmail(SAMPLE, "Nobody")).toEqual({
-      status: "not_found",
-    });
-    expect(resolveNameToEmail(SAMPLE, "   ")).toEqual({ status: "not_found" });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// resolveCompanySlug
-// ---------------------------------------------------------------------------
-
-describe("resolveCompanySlug", () => {
-  it("passes through an explicit, valid slug", () => {
-    expect(resolveCompanySlug(tmpRoot, "indigo")).toBe("indigo");
-  });
-
-  it("rejects an explicit unsafe slug", () => {
-    expect(() => resolveCompanySlug(tmpRoot, "../escape")).toThrow();
-  });
-
-  it("defaults to the sole company in the manifest", () => {
-    writeCompaniesManifest({ indigo: { status: "active" } });
-    expect(resolveCompanySlug(tmpRoot, undefined)).toBe("indigo");
-  });
-
-  it("ignores archived companies when defaulting", () => {
-    writeCompaniesManifest({
-      indigo: { status: "active" },
-      old: { status: "archived" },
-    });
-    expect(resolveCompanySlug(tmpRoot, undefined)).toBe("indigo");
-  });
-
-  it("requires --company when several companies exist", () => {
-    writeCompaniesManifest({ a: { status: "active" }, b: { status: "active" } });
-    expect(() => resolveCompanySlug(tmpRoot, undefined)).toThrow(
-      /Multiple companies/,
-    );
-  });
-
-  it("errors clearly when the manifest is absent", () => {
-    expect(() => resolveCompanySlug(tmpRoot, undefined)).toThrow(
-      /manifest\.yaml not found/,
-    );
-  });
-});
-
-// ---------------------------------------------------------------------------
-// companyPeopleDir
-// ---------------------------------------------------------------------------
-
-describe("companyPeopleDir", () => {
-  it("builds the scoped path", () => {
-    expect(companyPeopleDir("/hq", "indigo")).toBe(
-      path.join("/hq", "companies", "indigo", "people"),
-    );
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Membership roster fallback helpers
-// ---------------------------------------------------------------------------
-
-function rosterPerson(overrides: Partial<PersonRecord>): PersonRecord {
-  return {
-    slug: "ada-lovelace",
-    name: "Ada Lovelace",
-    email: "ada@acme.com",
-    type: "internal",
-    source: "test roster",
-    ...overrides,
-  };
-}
-
-describe("activeMemberToPersonRecord", () => {
-  const base: ActiveMember = {
-    membershipKey: "m_1",
-    personUid: "prs_123",
-    companyUid: "co_123",
-    role: "admin",
-    status: "active",
-  };
-
-  it("maps membership person fields into an internal person record", () => {
-    expect(
-      activeMemberToPersonRecord({
-        ...base,
-        personName: " Ada Lovelace ",
-        personEmail: " ada@acme.com ",
-        personSlug: " ada ",
-      }),
-    ).toEqual({
-      slug: "ada",
-      name: "Ada Lovelace",
-      email: "ada@acme.com",
-      role: "admin",
-      type: "internal",
-      source: "hq-pro membership: /membership/company/co_123",
-    });
-  });
-
-  it("falls back from name to email to slug, and slugifies names", () => {
-    expect(
-      activeMemberToPersonRecord({
-        ...base,
-        personName: "Grace Hopper",
-        personEmail: "grace@acme.com",
-      }),
-    ).toMatchObject({ name: "Grace Hopper", slug: "grace-hopper" });
-
-    expect(
-      activeMemberToPersonRecord({
-        ...base,
-        personEmail: "only-email@acme.com",
-      }),
-    ).toMatchObject({ name: "only-email@acme.com", slug: "only-email-acme-com" });
-
-    expect(
-      activeMemberToPersonRecord({
-        ...base,
-        personSlug: "only-slug",
-      }),
-    ).toMatchObject({ name: "only-slug", slug: "only-slug" });
-  });
-
-  it("returns null when all name-like fields are empty", () => {
-    expect(
-      activeMemberToPersonRecord({
-        ...base,
-        personName: " ",
-        personEmail: "",
-        personSlug: "   ",
-      }),
-    ).toBeNull();
-  });
-});
-
-describe("mergePeople", () => {
-  it("deduplicates by email, slug, then name with primary records winning", () => {
-    const primary = [
-      rosterPerson({
-        slug: "local-email",
-        name: "Local Email",
-        email: "same@acme.com",
-        role: "CEO",
-      }),
-      rosterPerson({ slug: "same-slug", name: "Local Slug", email: undefined }),
-      rosterPerson({ slug: "", name: "Same Name", email: undefined }),
-    ];
-    const extra = [
-      rosterPerson({
-        slug: "remote-email",
-        name: "Remote Email",
-        email: "SAME@acme.com",
-      }),
-      rosterPerson({ slug: "SAME-SLUG", name: "Remote Slug", email: undefined }),
-      rosterPerson({ slug: "", name: "same name", email: undefined }),
-      rosterPerson({ slug: "new-person", name: "New Person", email: undefined }),
-    ];
-
-    expect(mergePeople(primary, extra)).toEqual([
-      ...primary,
-      rosterPerson({ slug: "new-person", name: "New Person", email: undefined }),
-    ]);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Wired CLI surface (list / search / resolve)
-// ---------------------------------------------------------------------------
-
-function buildProgram(deps?: { fetchRoster?: FetchPeopleRoster }): Command {
-  const program = new Command();
-  program.exitOverride(); // throw instead of process.exit on commander errors
-  registerPeopleCommand(program, deps);
-  return program;
-}
-
-async function run(
-  args: string[],
-  deps: { fetchRoster?: FetchPeopleRoster } = {
-    fetchRoster: async () => [],
-  },
-): Promise<void> {
-  await buildProgram(deps).parseAsync(["node", "hq", ...args]);
-}
-
-describe("hq people (wired)", () => {
-  let logSpy: ReturnType<typeof vi.spyOn>;
-  let errSpy: ReturnType<typeof vi.spyOn>;
-  let exitSpy: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    writeCompaniesManifest({ acme: { status: "active" } });
-    makePerson("acme", "jane-smith", {
-      name: "Jane Smith",
-      email: "jane@acme.com",
-      role: "CEO",
-      type: "internal",
-    });
-    makePerson("acme", "john-doe", {
-      name: "John Doe",
-      email: "john@acme.com",
-      type: "internal",
-    });
-    logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
-    errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-    exitSpy = vi.spyOn(process, "exit").mockImplementation(((): never => {
-      throw new Error("__exit__");
-    }) as never);
-  });
-
-  it("list --json emits both people", async () => {
-    await run(["people", "list", "--company", "acme", "--hq-root", tmpRoot, "--json"]);
-    const out = JSON.parse(logSpy.mock.calls[0][0] as string);
-    expect(out.map((p: PersonRecord) => p.name).sort()).toEqual([
-      "Jane Smith",
-      "John Doe",
-    ]);
-  });
-
-  it("list includes roster people, sorts them, and deduplicates with local winning", async () => {
-    const fetchRoster = vi.fn<FetchPeopleRoster>(async () => [
-      rosterPerson({
-        slug: "remote-jane",
-        name: "Remote Jane",
-        email: "JANE@acme.com",
-        role: "member",
-      }),
-      rosterPerson({
-        slug: "ada-lovelace",
-        name: "Ada Lovelace",
-        email: "ada@acme.com",
-        role: "admin",
-      }),
-    ]);
-
-    await run(
-      ["people", "list", "--company", "acme", "--hq-root", tmpRoot, "--json"],
-      { fetchRoster },
-    );
-
-    expect(fetchRoster).toHaveBeenCalledTimes(1);
-    expect(fetchRoster).toHaveBeenCalledWith(tmpRoot, "acme");
-    const out = JSON.parse(logSpy.mock.calls[0][0] as string);
-    expect(out.map((p: PersonRecord) => p.name)).toEqual([
-      "Ada Lovelace",
-      "Jane Smith",
-      "John Doe",
-    ]);
-    expect(out.find((p: PersonRecord) => p.email === "jane@acme.com")).toMatchObject({
-      name: "Jane Smith",
-      role: "CEO",
-    });
-  });
-
-  it("list --local-only skips roster fetch", async () => {
-    const fetchRoster = vi.fn<FetchPeopleRoster>(async () => [
-      rosterPerson({ slug: "ada-lovelace", name: "Ada Lovelace" }),
-    ]);
-
-    await run(
-      [
-        "people",
-        "list",
-        "--company",
-        "acme",
-        "--hq-root",
-        tmpRoot,
-        "--json",
-        "--local-only",
-      ],
-      { fetchRoster },
-    );
-
-    expect(fetchRoster).not.toHaveBeenCalled();
-    const out = JSON.parse(logSpy.mock.calls[0][0] as string);
-    expect(out.map((p: PersonRecord) => p.name).sort()).toEqual([
-      "Jane Smith",
-      "John Doe",
-    ]);
-  });
-
-  it("search narrows to the matching person", async () => {
-    await run([
-      "people",
-      "search",
-      "jane",
-      "--company",
-      "acme",
-      "--hq-root",
-      tmpRoot,
-      "--json",
-    ]);
-    const out = JSON.parse(logSpy.mock.calls[0][0] as string);
-    expect(out).toHaveLength(1);
-    expect(out[0].email).toBe("jane@acme.com");
-  });
-
-  it("search local hit does not fetch the roster", async () => {
-    const fetchRoster = vi.fn<FetchPeopleRoster>();
-    await run(
-      [
-        "people",
-        "search",
-        "jane",
-        "--company",
-        "acme",
-        "--hq-root",
-        tmpRoot,
-        "--json",
-      ],
-      { fetchRoster },
-    );
-    expect(fetchRoster).not.toHaveBeenCalled();
-  });
-
-  it("search finds a teammate from the roster on a local miss", async () => {
-    const fetchRoster = vi.fn<FetchPeopleRoster>(async () => [
-      rosterPerson({ slug: "ada-lovelace", name: "Ada Lovelace" }),
-    ]);
-
-    await run(
-      [
-        "people",
-        "search",
-        "ada",
-        "--company",
-        "acme",
-        "--hq-root",
-        tmpRoot,
-        "--json",
-      ],
-      { fetchRoster },
-    );
-
-    expect(fetchRoster).toHaveBeenCalledTimes(1);
-    expect(fetchRoster).toHaveBeenCalledWith(tmpRoot, "acme");
-    const out = JSON.parse(logSpy.mock.calls[0][0] as string);
-    expect(out).toHaveLength(1);
-    expect(out[0]).toMatchObject({
-      name: "Ada Lovelace",
-      email: "ada@acme.com",
-    });
-  });
-
-  it("search local miss with fetch failure reports the original empty JSON and logs a note", async () => {
-    const fetchRoster = vi.fn<FetchPeopleRoster>(async () => {
-      throw new Error("offline");
-    });
-
-    await run(
-      [
-        "people",
-        "search",
-        "ada",
-        "--company",
-        "acme",
-        "--hq-root",
-        tmpRoot,
-        "--json",
-      ],
-      { fetchRoster },
-    );
-
-    expect(fetchRoster).toHaveBeenCalledTimes(1);
-    expect(JSON.parse(logSpy.mock.calls[0][0] as string)).toEqual([]);
-    expect(errSpy).toHaveBeenCalledWith(
-      expect.stringContaining("Could not fetch people roster"),
-    );
-  });
-
-  it("search --local-only skips fetch on a miss", async () => {
-    const fetchRoster = vi.fn<FetchPeopleRoster>();
-    await run(
-      [
-        "people",
-        "search",
-        "ada",
-        "--company",
-        "acme",
-        "--hq-root",
-        tmpRoot,
-        "--json",
-        "--local-only",
-      ],
-      { fetchRoster },
-    );
-
-    expect(fetchRoster).not.toHaveBeenCalled();
-    expect(JSON.parse(logSpy.mock.calls[0][0] as string)).toEqual([]);
-  });
-
-  it("resolve prints the bare email on stdout", async () => {
-    await run([
-      "people",
-      "resolve",
-      "Jane Smith",
-      "--company",
-      "acme",
-      "--hq-root",
-      tmpRoot,
-    ]);
-    expect(logSpy).toHaveBeenCalledWith("jane@acme.com");
-  });
-
-  it("resolve local hit does not fetch the roster", async () => {
-    const fetchRoster = vi.fn<FetchPeopleRoster>();
-    await run(
-      [
-        "people",
-        "resolve",
-        "Jane Smith",
-        "--company",
-        "acme",
-        "--hq-root",
-        tmpRoot,
-      ],
-      { fetchRoster },
-    );
-    expect(fetchRoster).not.toHaveBeenCalled();
-  });
-
-  it("resolve finds a teammate that exists only in the fetched roster", async () => {
-    const fetchRoster = vi.fn<FetchPeopleRoster>(async () => [
-      rosterPerson({ slug: "ada-lovelace", name: "Ada Lovelace" }),
-    ]);
-
-    await run(
-      [
-        "people",
-        "resolve",
-        "Ada Lovelace",
-        "--company",
-        "acme",
-        "--hq-root",
-        tmpRoot,
-      ],
-      { fetchRoster },
-    );
-
-    expect(fetchRoster).toHaveBeenCalledTimes(1);
-    expect(fetchRoster).toHaveBeenCalledWith(tmpRoot, "acme");
-    expect(logSpy).toHaveBeenCalledWith("ada@acme.com");
-  });
-
-  it("resolve local miss with fetch failure reports unchanged not_found JSON and logs a note", async () => {
-    const fetchRoster = vi.fn<FetchPeopleRoster>(async () => {
-      throw new Error("not signed in");
-    });
-
-    await expect(
-      run(
-        [
-          "people",
-          "resolve",
-          "Ada Lovelace",
-          "--company",
-          "acme",
-          "--hq-root",
-          tmpRoot,
-          "--json",
-        ],
-        { fetchRoster },
-      ),
-    ).rejects.toThrow("__exit__");
-
-    expect(fetchRoster).toHaveBeenCalledTimes(1);
-    expect(JSON.parse(logSpy.mock.calls[0][0] as string)).toEqual({
-      status: "not_found",
-    });
-    expect(errSpy).toHaveBeenCalledWith(
-      expect.stringContaining("Could not fetch people roster"),
-    );
-    expect(exitSpy).toHaveBeenCalledWith(1);
-  });
-
-  it("resolve --local-only skips fetch on a miss", async () => {
-    const fetchRoster = vi.fn<FetchPeopleRoster>();
-    await expect(
-      run(
-        [
-          "people",
-          "resolve",
-          "Ada Lovelace",
-          "--company",
-          "acme",
-          "--hq-root",
-          tmpRoot,
-          "--json",
-          "--local-only",
-        ],
-        { fetchRoster },
-      ),
-    ).rejects.toThrow("__exit__");
-
-    expect(fetchRoster).not.toHaveBeenCalled();
-    expect(JSON.parse(logSpy.mock.calls[0][0] as string)).toEqual({
-      status: "not_found",
-    });
-  });
-
-  it("resolve exits non-zero when not found", async () => {
-    await expect(
-      run([
-        "people",
-        "resolve",
-        "Nobody",
-        "--company",
-        "acme",
-        "--hq-root",
-        tmpRoot,
-      ]),
-    ).rejects.toThrow("__exit__");
-    expect(exitSpy).toHaveBeenCalledWith(1);
-  });
-});