@indigoai-us/hq-cli 5.77.13 → 5.78.0

package/src/utils/pack-contributions.test.ts

@@ -1,603 +0,0 @@
-/**
- * pack-contributions tests — pins the content-pack lifecycle helpers that
- * commands/packs.ts (list / update / uninstall) depends on.
- *
- * The load-bearing invariant is the contributes->host-path mapping: it MUST
- * agree byte-for-byte with core/scripts/scan-packages.sh (the wiring
- * authority) and pack-install.ts:validateManifest. A drift there means
- * uninstall would miss symlinks (dangling links) or delete the wrong path.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { fileURLToPath } from 'node:url';
-import {
-  contributionLinks,
-  linkStatus,
-  listInstalledPacks,
-  findDependentPacks,
-  unwirePack,
-  unwirePackMcp,
-  packagesDir,
-  readHqVersion,
-  type WiredLink,
-  type InstalledPack,
-} from './pack-contributions.js';
-import { parse as parseToml } from 'smol-toml';
-import {
-  registerClaudeServer,
-  registerServer,
-  claudeConfigPath,
-  codexConfigPath,
-  codexHome,
-} from '../commands/mcp-registration.js';
-import {
-  CONTRIBUTION_TABLE,
-  CONTRIBUTION_KEYS,
-  SYMLINK_KEYS,
-  payloadFor,
-  type ContributionKey,
-} from './contribution-table.js';
-import type { PackContributeKey } from '../types.js';
-
-// The canonical mapping is DERIVED from the single-source CONTRIBUTION_TABLE
-// (US-003) -- the oracle is no longer a hand-restated copy. For each SYMLINK
-// key, src = the payload expanded for item "X"; dst = <host-dir>/<basename>.
-const EXPECTED: Record<ContributionKey, { src: string; dst: string }> =
-  Object.fromEntries(
-    SYMLINK_KEYS.map((k) => {
-      const src = payloadFor(k, 'X');
-      const dst = `${CONTRIBUTION_TABLE[k].host}/${src.split('/').pop()}`;
-      return [k, { src, dst }];
-    }),
-  ) as Record<ContributionKey, { src: string; dst: string }>;
-
-function mkTmp(prefix: string): string {
-  // realpathSync so macOS /tmp -> /private/tmp doesn't break path equality.
-  return fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), prefix)));
-}
-
-describe('contributionLinks: mapping', () => {
-  it('maps every SYMLINK contributes key to the canonical src/dst', () => {
-    const hqRoot = '/hq';
-    const packDir = '/hq/core/packages/hq-pack-x';
-    for (const key of SYMLINK_KEYS) {
-      const [link] = contributionLinks(hqRoot, packDir, { [key]: ['X'] });
-      expect(link.key).toBe(key);
-      expect(link.src).toBe(path.join(packDir, EXPECTED[key].src));
-      expect(link.dst).toBe(path.join(hqRoot, EXPECTED[key].dst));
-    }
-  });
-
-  it('produces NO symlink for wire:merge keys (mcp)', () => {
-    // The mcp row is wire:merge — declared as data (US-003) but never wired as a
-    // symlink here; its host effect is a config merge (US-004/US-005).
-    const mergeKeys = CONTRIBUTION_KEYS.filter(
-      (k) => CONTRIBUTION_TABLE[k].wire === 'merge',
-    );
-    expect(mergeKeys).toContain('mcp'); // guards the row exists
-    for (const key of mergeKeys) {
-      const links = contributionLinks('/hq', '/p', { [key]: ['X'] });
-      expect(links).toEqual([]);
-    }
-  });
-
-  it('ignores empty / non-array contributes subfields', () => {
-    const links = contributionLinks('/hq', '/p', {
-      skills: [],
-      workers: ['a', 'b'],
-      // @ts-expect-error — defensive: non-array should be skipped
-      hooks: 'nope',
-    });
-    expect(links.map((l) => l.item)).toEqual(['a', 'b']);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// US-003 single-source parity: FULL key-set + payload-suffix + wire-mode
-// equivalence across every surface (table, derived union, validateManifest's
-// payload reader, and the generated scan-packages.sh block). Replaces the old
-// substring-only `toContain` check, which passed even if a key was MISSING, had
-// the WRONG payload suffix, or the WRONG wire mode.
-// ---------------------------------------------------------------------------
-describe('US-003 parity: contribution table is the single source', () => {
-  // The bash block that `core/scripts/scan-packages.sh` reads is GENERATED from
-  // the contribution table (scripts/generate-scan-packages-table.mjs) and lives
-  // in hq-core — a separately-versioned repo this package never contains. We
-  // vendor that generated block as a committed golden fixture and compare the
-  // table against it, so this guard runs DETERMINISTICALLY in CI and from any
-  // checkout. Regenerate after any table change: `pnpm gen:scan-golden`
-  // (hq-core's own scan-packages.sh must be regenerated from the same table —
-  // that cross-repo leg is enforced in the monorepo that holds both).
-  //
-  // Anchored to THIS module via import.meta.url — never process.cwd().
-  // REGRESSION (do NOT reintroduce): the old resolver did
-  //   path.resolve(process.cwd(), '../../../core/scripts/scan-packages.sh')
-  // which, from a checkout sitting 3 levels below an installed HQ (e.g.
-  // HQ/workspace/worktrees/<name>), bound to that unrelated, differently-
-  // versioned hq-core script and false-failed; from anywhere else it resolved
-  // outside the repo and silently skipped, so the guard NEVER ran — not even in
-  // CI. See the module-anchor regression test below.
-  const goldenBlockPath = path.resolve(
-    path.dirname(fileURLToPath(import.meta.url)),
-    '__fixtures__',
-    'scan-packages.generated-block.sh',
-  );
-
-  // Parse the generated `contrib_row` case arms back into {key:{payload,host,wire}}.
-  function parseBashTable(bash: string): Record<
-    string,
-    { payload: string; host: string; wire: string }
-  > {
-    const out: Record<string, { payload: string; host: string; wire: string }> = {};
-    const re =
-      /^\s*([a-z]+)\)\s*printf\s+'%s'\s+'([^|]+)\|([^|]+)\|([^']+)'\s*;;/gm;
-    let m;
-    while ((m = re.exec(bash)) !== null) {
-      out[m[1]] = { payload: m[2], host: m[3], wire: m[4] };
-    }
-    return out;
-  }
-
-  it('the derived PackContributeKey union == the table keys (8 keys incl. mcp)', () => {
-    // CONTRIBUTION_KEYS IS PackContributeKey's source (types.ts derives the
-    // union from it). Assert the full expected set is present, no more, no less.
-    expect([...CONTRIBUTION_KEYS].sort()).toEqual(
-      [
-        'commands',
-        'hooks',
-        'knowledge',
-        'mcp',
-        'policies',
-        'scripts',
-        'skills',
-        'workers',
-      ].sort(),
-    );
-    // Type-level: every key is assignable to PackContributeKey.
-    const asUnion: PackContributeKey[] = [...CONTRIBUTION_KEYS];
-    expect(asUnion.length).toBe(8);
-  });
-
-  it('every key has a wire mode of exactly symlink|merge, mcp is the merge row', () => {
-    for (const k of CONTRIBUTION_KEYS) {
-      expect(['symlink', 'merge']).toContain(CONTRIBUTION_TABLE[k].wire);
-    }
-    expect(CONTRIBUTION_TABLE.mcp.wire).toBe('merge');
-    expect(CONTRIBUTION_TABLE.mcp.payload).toBe('mcp/{item}.json');
-    expect(CONTRIBUTION_TABLE.mcp.host).toBe('merge:claude+codex');
-    // All non-mcp rows are symlink in this milestone.
-    for (const k of CONTRIBUTION_KEYS) {
-      if (k !== 'mcp') expect(CONTRIBUTION_TABLE[k].wire).toBe('symlink');
-    }
-  });
-
-  it('payload suffixes are pinned per key (suffix is load-bearing)', () => {
-    const suffix = (p: string) => {
-      const base = p.split('/').pop() as string;
-      const dot = base.indexOf('.', base.indexOf('}'));
-      return dot >= 0 ? base.slice(dot) : '';
-    };
-    expect(suffix(CONTRIBUTION_TABLE.commands.payload)).toBe('.md');
-    expect(suffix(CONTRIBUTION_TABLE.policies.payload)).toBe('.md');
-    expect(suffix(CONTRIBUTION_TABLE.hooks.payload)).toBe('.sh');
-    expect(suffix(CONTRIBUTION_TABLE.mcp.payload)).toBe('.json');
-    expect(suffix(CONTRIBUTION_TABLE.workers.payload)).toBe('');
-    expect(suffix(CONTRIBUTION_TABLE.knowledge.payload)).toBe('');
-    expect(suffix(CONTRIBUTION_TABLE.skills.payload)).toBe('');
-    expect(suffix(CONTRIBUTION_TABLE.scripts.payload)).toBe('');
-  });
-
-  it('generated block (vendored golden) matches the table on key-set + payload + host + wire', () => {
-    const bash = fs.readFileSync(goldenBlockPath, 'utf-8');
-    const bashTable = parseBashTable(bash);
-
-    // FULL key-set equivalence (fails if the golden is MISSING a key or has an
-    // EXTRA one — not just a substring presence check). This doubles as the
-    // drift guard: if the table changed but the golden wasn't regenerated, one
-    // of these assertions fails with the exact key/field that diverged.
-    expect(Object.keys(bashTable).sort()).toEqual([...CONTRIBUTION_KEYS].sort());
-
-    // Per-key payload + host + wire-mode equivalence.
-    for (const k of CONTRIBUTION_KEYS) {
-      expect(
-        bashTable[k],
-        `golden block missing row for "${k}" — run \`pnpm gen:scan-golden\``,
-      ).toBeDefined();
-      expect(bashTable[k].payload).toBe(CONTRIBUTION_TABLE[k].payload);
-      expect(bashTable[k].host).toBe(CONTRIBUTION_TABLE[k].host);
-      expect(bashTable[k].wire).toBe(CONTRIBUTION_TABLE[k].wire);
-    }
-
-    // The CONTRIB_KEYS array in the block also lists every key.
-    const keysLine = bash.match(/CONTRIB_KEYS=\(([^)]*)\)/);
-    expect(keysLine).not.toBeNull();
-    const bashKeys = (keysLine as RegExpMatchArray)[1].trim().split(/\s+/).sort();
-    expect(bashKeys).toEqual([...CONTRIBUTION_KEYS].sort());
-  });
-
-  it('resolves the golden from the module, never from process.cwd() (regression: a co-located HQ must not bind)', () => {
-    // Rebuild the exact historical trap: an installed-HQ-shaped dir carrying a
-    // DIFFERENT scan-packages.sh, with a checkout nested 3 levels below it
-    // (the HQ/workspace/worktrees/<name> layout that first surfaced this bug).
-    const fakeHq = mkTmp('fake-hq-');
-    fs.mkdirSync(path.join(fakeHq, 'core', 'scripts'), { recursive: true });
-    fs.writeFileSync(
-      path.join(fakeHq, 'core', 'scripts', 'scan-packages.sh'),
-      '# unrelated, differently-versioned hq-core script\n',
-    );
-    const nested = path.join(fakeHq, 'workspace', 'worktrees', 'hq-cli-x');
-    fs.mkdirSync(nested, { recursive: true });
-
-    const orig = process.cwd();
-    try {
-      process.chdir(nested);
-      // Module-anchored resolution is unaffected by cwd and points at the repo
-      // golden — which really exists and is what the parity test reads.
-      expect(fs.existsSync(goldenBlockPath)).toBe(true);
-      expect(
-        goldenBlockPath.endsWith(
-          path.join('src', 'utils', '__fixtures__', 'scan-packages.generated-block.sh'),
-        ),
-      ).toBe(true);
-      // The OLD cwd-relative resolver WOULD have latched onto the fake file.
-      // Prove the trap is real, and that we no longer resolve to it.
-      const oldCwdRelative = path.resolve(
-        process.cwd(),
-        '../../../core/scripts/scan-packages.sh',
-      );
-      expect(oldCwdRelative).toBe(
-        path.join(fakeHq, 'core', 'scripts', 'scan-packages.sh'),
-      );
-      expect(oldCwdRelative).not.toBe(goldenBlockPath);
-    } finally {
-      process.chdir(orig);
-      fs.rmSync(fakeHq, { recursive: true, force: true });
-    }
-  });
-
-  it('validateManifest payload reader (payloadFor) agrees with the table for every key', () => {
-    for (const k of CONTRIBUTION_KEYS) {
-      // payloadFor is exactly what validateManifest now uses for the
-      // payload-existence check, so this pins that surface to the table.
-      expect(payloadFor(k, 'demo')).toBe(
-        CONTRIBUTION_TABLE[k].payload.replace('{item}', 'demo'),
-      );
-    }
-  });
-});
-
-describe('linkStatus + unwirePack', () => {
-  let hqRoot: string;
-  let packDir: string;
-
-  beforeEach(() => {
-    hqRoot = mkTmp('hq-pc-root-');
-    packDir = path.join(packagesDir(hqRoot), 'hq-pack-demo');
-    // A pack that contributes one skill and one command.
-    fs.mkdirSync(path.join(packDir, 'skills', 'demo-skill'), { recursive: true });
-    fs.writeFileSync(path.join(packDir, 'skills', 'demo-skill', 'SKILL.md'), '# demo');
-    fs.mkdirSync(path.join(packDir, 'commands'), { recursive: true });
-    fs.writeFileSync(path.join(packDir, 'commands', 'demo-cmd.md'), '# cmd');
-  });
-
-  afterEach(() => {
-    fs.rmSync(hqRoot, { recursive: true, force: true });
-  });
-
-  const contributes = { skills: ['demo-skill'], commands: ['demo-cmd'] };
-
-  function wire(link: WiredLink): void {
-    fs.mkdirSync(path.dirname(link.dst), { recursive: true });
-    fs.symlinkSync(link.src, link.dst);
-  }
-
-  it('reports missing before wiring, live after wiring', () => {
-    const links = contributionLinks(hqRoot, packDir, contributes);
-    for (const l of links) expect(linkStatus(l)).toBe('missing');
-    for (const l of links) wire(l);
-    for (const l of links) expect(linkStatus(l)).toBe('live');
-  });
-
-  it('reports broken when the pack payload is gone', () => {
-    const links = contributionLinks(hqRoot, packDir, contributes);
-    links.forEach(wire);
-    fs.rmSync(packDir, { recursive: true, force: true });
-    for (const l of links) expect(linkStatus(l)).toBe('broken');
-  });
-
-  it('reports foreign when the dst points elsewhere or is a real file', () => {
-    const [skillLink, cmdLink] = contributionLinks(hqRoot, packDir, contributes);
-    // foreign symlink: points at some other path
-    fs.mkdirSync(path.dirname(skillLink.dst), { recursive: true });
-    const other = path.join(hqRoot, 'somewhere-else');
-    fs.mkdirSync(other, { recursive: true });
-    fs.symlinkSync(other, skillLink.dst);
-    expect(linkStatus(skillLink)).toBe('foreign');
-    // foreign real file
-    fs.mkdirSync(path.dirname(cmdLink.dst), { recursive: true });
-    fs.writeFileSync(cmdLink.dst, 'host-owned content');
-    expect(linkStatus(cmdLink)).toBe('foreign');
-  });
-
-  it('unwirePack removes ONLY our symlinks, leaving foreign ones', () => {
-    const [skillLink, cmdLink] = contributionLinks(hqRoot, packDir, contributes);
-    wire(skillLink); // our link
-    // cmd slot occupied by a foreign symlink (another pack / host content)
-    fs.mkdirSync(path.dirname(cmdLink.dst), { recursive: true });
-    const other = path.join(hqRoot, 'foreign-target.md');
-    fs.writeFileSync(other, 'x');
-    fs.symlinkSync(other, cmdLink.dst);
-
-    const result = unwirePack(hqRoot, packDir, contributes);
-
-    expect(fs.existsSync(skillLink.dst)).toBe(false); // ours removed
-    expect(fs.lstatSync(cmdLink.dst).isSymbolicLink()).toBe(true); // foreign kept
-    expect(result.unlinked.map((u) => u.item)).toEqual(['demo-skill']);
-    expect(result.skipped.map((s) => s.item)).toEqual(['demo-cmd']);
-  });
-
-  it('unwirePack removes broken (dangling) links that point into our pack', () => {
-    const links = contributionLinks(hqRoot, packDir, contributes);
-    links.forEach(wire);
-    fs.rmSync(packDir, { recursive: true, force: true }); // now all broken
-    const result = unwirePack(hqRoot, packDir, contributes);
-    expect(result.unlinked).toHaveLength(2);
-    for (const l of links) expect(fs.existsSync(l.dst)).toBe(false);
-    for (const l of links) expect(() => fs.lstatSync(l.dst)).toThrow(); // gone
-  });
-});
-
-describe('listInstalledPacks', () => {
-  let hqRoot: string;
-
-  beforeEach(() => {
-    hqRoot = mkTmp('hq-pc-list-');
-  });
-  afterEach(() => {
-    fs.rmSync(hqRoot, { recursive: true, force: true });
-  });
-
-  it('returns [] when core/packages is absent', () => {
-    expect(listInstalledPacks(hqRoot)).toEqual([]);
-  });
-
-  it('walks packs, skips README + .archive, and parses the stamped source', () => {
-    const dir = packagesDir(hqRoot);
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(path.join(dir, 'README.md'), '# packages');
-    fs.mkdirSync(path.join(dir, '.archive', 'old-pack-2026'), { recursive: true });
-
-    const p = path.join(dir, 'hq-pack-one');
-    fs.mkdirSync(p, { recursive: true });
-    fs.writeFileSync(
-      path.join(p, 'package.yaml'),
-      'source: "github:acme/repo#packages/hq-pack-one"\nname: hq-pack-one\nversion: 2.1.0\ncontributes:\n  skills:\n    - foo\n',
-    );
-
-    const packs = listInstalledPacks(hqRoot);
-    expect(packs.map((x) => x.name)).toEqual(['hq-pack-one']);
-    expect(packs[0].manifest?.version).toBe('2.1.0');
-    expect(packs[0].manifest?.source).toBe('github:acme/repo#packages/hq-pack-one');
-  });
-
-  it('surfaces an unreadable manifest as error, not a throw', () => {
-    const dir = packagesDir(hqRoot);
-    const p = path.join(dir, 'hq-pack-bad');
-    fs.mkdirSync(p, { recursive: true });
-    fs.writeFileSync(path.join(p, 'package.yaml'), 'name: [unclosed\n');
-    const packs = listInstalledPacks(hqRoot);
-    expect(packs).toHaveLength(1);
-    expect(packs[0].manifest).toBeNull();
-    expect(packs[0].error).toMatch(/invalid/i);
-  });
-});
-
-describe('readHqVersion: v15 layout awareness (feedback_57d7edcf, symptom b)', () => {
-  let hqRoot: string;
-
-  beforeEach(() => {
-    hqRoot = mkTmp('hq-readhqversion-');
-  });
-
-  afterEach(() => {
-    fs.rmSync(hqRoot, { recursive: true, force: true });
-  });
-
-  it('reads the CANONICAL core/core.yaml on a v14+/v15 layout', () => {
-    fs.mkdirSync(path.join(hqRoot, 'core'), { recursive: true });
-    fs.writeFileSync(
-      path.join(hqRoot, 'core', 'core.yaml'),
-      'version: 1\nhqVersion: "15.0.11"\n',
-    );
-    expect(readHqVersion(hqRoot)).toBe('15.0.11');
-  });
-
-  it('PREFERS canonical core/core.yaml over a STALE leftover root core.yaml', () => {
-    // The exact reported failure: post-v12→v15 reshape moved core.yaml under
-    // core/, but a stale root copy (hqVersion 12.1.0) lingered. The version
-    // read MUST report the canonical 15.x, not the stale root 12.1.0 — else
-    // `hq install` wrongly rejects packs requiring hqCore >=15.
-    fs.mkdirSync(path.join(hqRoot, 'core'), { recursive: true });
-    fs.writeFileSync(
-      path.join(hqRoot, 'core', 'core.yaml'),
-      'version: 1\nhqVersion: "15.0.11"\n',
-    );
-    fs.writeFileSync(
-      path.join(hqRoot, 'core.yaml'),
-      'version: 1\nhqVersion: "12.1.0"\n',
-    );
-    expect(readHqVersion(hqRoot)).toBe('15.0.11');
-  });
-
-  it('falls back to the legacy root core.yaml when no nested core/core.yaml exists', () => {
-    fs.writeFileSync(
-      path.join(hqRoot, 'core.yaml'),
-      'version: 1\nhqVersion: "13.4.0"\n',
-    );
-    expect(readHqVersion(hqRoot)).toBe('13.4.0');
-  });
-
-  it('returns null when neither core/core.yaml nor root core.yaml exists', () => {
-    expect(readHqVersion(hqRoot)).toBeNull();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// US-009: unwirePackMcp — the wire:merge (MCP) un-registration parallel to the
-// symlink unwirePack. Runs against an ISOLATED tmpdir home (env.home) so the
-// developer's real ~/.claude.json / ~/.codex are NEVER touched.
-// ---------------------------------------------------------------------------
-
-describe('US-009: unwirePackMcp (mcp un-registration parallel to symlink unwire)', () => {
-  let mcpHome: string;
-
-  beforeEach(() => {
-    mcpHome = mkTmp('hq-unwire-mcp-');
-  });
-  afterEach(() => {
-    fs.rmSync(mcpHome, { recursive: true, force: true });
-  });
-
-  it('un-registers ONLY this pack\'s provenance-stamped mcp servers from ~/.claude.json', () => {
-    const env = { home: mcpHome };
-    // The user owns `figma`; our pack installs `vyg`.
-    fs.writeFileSync(
-      claudeConfigPath(env),
-      JSON.stringify({ mcpServers: { figma: { type: 'http', url: 'https://figma' } } }, null, 2) + '\n',
-    );
-    registerClaudeServer({ name: 'vyg', manifest: { type: 'http', url: 'https://vyg' }, pack: 'hq-pack-vyg', env });
-
-    const result = unwirePackMcp('hq-pack-vyg', { mcp: ['vyg'] }, { env });
-    expect(result.servers).toHaveLength(1);
-    expect(result.servers[0]!.claude.outcome).toBe('removed');
-
-    const after = JSON.parse(fs.readFileSync(claudeConfigPath(env), 'utf-8'));
-    expect(after.mcpServers.vyg).toBeUndefined(); // ours removed
-    expect(after.mcpServers.figma.url).toBe('https://figma'); // user sibling preserved
-  });
-
-  it('no-ops cleanly when the pack declares no mcp (merge) keys', () => {
-    const result = unwirePackMcp('hq-pack-x', { commands: ['foo'], skills: ['bar'] }, { env: { home: mcpHome } });
-    expect(result.servers).toEqual([]);
-  });
-
-  it('skip-and-warns (does not delete) a foreign/unstamped same-named entry', () => {
-    const env = { home: mcpHome };
-    // The user has their OWN `vyg` (no _hqPack stamp).
-    fs.writeFileSync(
-      claudeConfigPath(env),
-      JSON.stringify({ mcpServers: { vyg: { type: 'http', url: 'https://user-vyg' } } }, null, 2) + '\n',
-    );
-    const before = fs.readFileSync(claudeConfigPath(env), 'utf-8');
-
-    const result = unwirePackMcp('hq-pack-vyg', { mcp: ['vyg'] }, { env });
-    expect(result.servers[0]!.claude.outcome).toBe('skipped-foreign');
-    // The user's server is left byte-for-byte intact.
-    expect(fs.readFileSync(claudeConfigPath(env), 'utf-8')).toBe(before);
-  });
-
-  it('is a clean no-op on a Codex-less host with no ~/.claude.json (never fabricates)', () => {
-    const env = { home: mcpHome };
-    const result = unwirePackMcp('hq-pack-vyg', { mcp: ['vyg'] }, { env });
-    expect(result.servers[0]!.claude.outcome).toBe('absent');
-    expect('skipped' in result.servers[0]!.codex && (result.servers[0]!.codex as any).skipped).toBe(true);
-    expect(fs.existsSync(path.join(mcpHome, '.claude.json'))).toBe(false);
-    expect(fs.existsSync(path.join(mcpHome, '.codex'))).toBe(false);
-  });
-
-  it('delegates to unregisterMcpServers across BOTH surfaces when ~/.codex exists', () => {
-    // The unwire-hook must un-register from Claude AND Codex (not just Claude) — i.e.
-    // it really delegates to unregisterMcpServers, which fans out over both surfaces.
-    const env = { home: mcpHome };
-    fs.mkdirSync(codexHome(env), { recursive: true }); // make Codex a real runtime
-    // Install our vyg into BOTH surfaces, alongside a user-owned figma on Claude.
-    fs.writeFileSync(
-      claudeConfigPath(env),
-      JSON.stringify({ mcpServers: { figma: { type: 'http', url: 'https://figma' } } }, null, 2) + '\n',
-    );
-    registerServer({ name: 'vyg', manifest: { type: 'http', url: 'https://vyg' }, pack: 'hq-pack-vyg', env });
-    // Both surfaces carry vyg before uninstall.
-    expect(JSON.parse(fs.readFileSync(claudeConfigPath(env), 'utf-8')).mcpServers.vyg).toBeDefined();
-    expect((parseToml(fs.readFileSync(codexConfigPath(env), 'utf-8')) as any).mcp_servers.vyg).toBeDefined();
-
-    const result = unwirePackMcp('hq-pack-vyg', { mcp: ['vyg'] }, { env });
-    expect(result.servers).toHaveLength(1);
-    expect(result.servers[0]!.claude.outcome).toBe('removed');
-    expect('skipped' in result.servers[0]!.codex).toBe(false);
-    expect((result.servers[0]!.codex as any).outcome).toBe('removed');
-
-    // Both surfaces no longer carry vyg; the user's Claude figma sibling survives.
-    expect(JSON.parse(fs.readFileSync(claudeConfigPath(env), 'utf-8')).mcpServers.vyg).toBeUndefined();
-    expect(JSON.parse(fs.readFileSync(claudeConfigPath(env), 'utf-8')).mcpServers.figma).toBeDefined();
-    expect((parseToml(fs.readFileSync(codexConfigPath(env), 'utf-8')) as any).mcp_servers.vyg).toBeUndefined();
-  });
-
-  it('skip-and-warns a foreign Codex table too (does not delete another pack\'s server)', () => {
-    // The Codex parallel of the foreign skip: a vyg table stamped by ANOTHER pack must
-    // be left in place when uninstalling OUR pack — provenance scope, not name match.
-    const env = { home: mcpHome };
-    fs.mkdirSync(codexHome(env), { recursive: true });
-    const original =
-      '# keep me\n[mcp_servers.vyg]\ntype = "http"\nurl = "https://vyg"\n_hqPack = "hq-pack-OTHER"\n';
-    fs.writeFileSync(codexConfigPath(env), original);
-
-    const result = unwirePackMcp('hq-pack-vyg', { mcp: ['vyg'] }, { env });
-    expect((result.servers[0]!.codex as any).outcome).toBe('skipped-foreign');
-    // Byte-for-byte preserved (comment intact — no write on a foreign skip).
-    expect(fs.readFileSync(codexConfigPath(env), 'utf-8')).toBe(original);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// findDependentPacks — uninstall dependents guard (M0)
-// ---------------------------------------------------------------------------
-
-describe('findDependentPacks (M0)', () => {
-  function ip(
-    name: string,
-    requiresPacks?: Array<{ name: string; version?: string }>,
-  ): InstalledPack {
-    return {
-      name,
-      dir: `/tmp/nope/${name}`,
-      manifest: {
-        name,
-        version: '1.0.0',
-        publisher: '@indigoai-us',
-        access: 'public',
-        requires: { hqCore: '>=15.0.0', packs: requiresPacks },
-        contributes: { skills: ['x'] },
-      },
-    } as InstalledPack;
-  }
-
-  it('returns the packs that require the named pack', () => {
-    const installed = [
-      ip('hq-pack-crm'),
-      ip('hq-pack-accounting', [{ name: 'hq-pack-crm', version: '>=1.0.0' }]),
-      ip('hq-pack-unrelated'),
-    ];
-    const deps = findDependentPacks(installed, 'hq-pack-crm');
-    expect(deps.map((p) => p.name)).toEqual(['hq-pack-accounting']);
-  });
-
-  it('returns empty when no installed pack requires it', () => {
-    const installed = [ip('hq-pack-crm'), ip('hq-pack-unrelated')];
-    expect(findDependentPacks(installed, 'hq-pack-crm')).toEqual([]);
-  });
-
-  it('never counts a pack that lists itself as its own dependent', () => {
-    // Defensive: a self-referencing manifest (rejected at install) must not make
-    // a pack un-removable.
-    const installed = [ip('hq-pack-weird', [{ name: 'hq-pack-weird' }])];
-    expect(findDependentPacks(installed, 'hq-pack-weird')).toEqual([]);
-  });
-
-  it('tolerates an unreadable manifest (manifest === null)', () => {
-    const broken: InstalledPack = { name: 'hq-pack-broken', dir: '/tmp/nope', manifest: null };
-    expect(findDependentPacks([broken], 'hq-pack-crm')).toEqual([]);
-  });
-});