skillrepo 3.0.0 → 3.1.1

package/src/test/commands/uninstall.test.mjs

@@ -0,0 +1,774 @@
+/**
+ * Unit/integration tests for src/commands/uninstall.mjs (#885).
+ *
+ * HOME-ISOLATION SAFETY CONTRACT (architect tightening #2):
+ *
+ *   Every test sets `process.env.HOME` to a `mkdtempSync` sandbox
+ *   inside `os.tmpdir()` BEFORE running any code that could touch the
+ *   filesystem. The `beforeEach` hook asserts that contract loudly —
+ *   if a future test copy-pastes setup() and forgets the HOME
+ *   override, the assertion fails before any `rmSync` can run against
+ *   the developer's real `~/.claude/skillrepo/` directory.
+ *
+ *   This matters especially for `--global` tests: uninstall --global
+ *   does `rmSync(join(homedir(), ".claude", "skillrepo"), { recursive
+ *   true })`. Without the HOME override, a test run would nuke real
+ *   user state. The architect-flagged incident from the prior v3.0.0
+ *   session (a debug script that forgot HOME and wrote a localhost
+ *   URL into the user's real config) is the failure mode this
+ *   contract exists to prevent.
+ *
+ *   NEVER remove the `ASSERT_HOME_ISOLATED` check. If it breaks, fix
+ *   the test's setup — do not silence the assertion.
+ */
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdtempSync,
+  mkdirSync,
+  rmSync,
+  readFileSync,
+  writeFileSync,
+  existsSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { runUninstall } from "../../commands/uninstall.mjs";
+import { SESSION_HOOK_FINGERPRINT } from "../../lib/artifact-registry.mjs";
+import { createCaptureStream } from "../helpers/capture-stream.mjs";
+import {
+  captureHome,
+  setSandboxHome,
+  restoreHome,
+  assertHomeIsolated,
+} from "../helpers/sandbox-home.mjs";
+
+let sandbox;
+let projectDir;
+let homeDir;
+let originalCwd;
+/** @type {import("../helpers/sandbox-home.mjs").HomeEnvSnapshot} */
+let originalHomeEnv;
+let stdout;
+let stderr;
+
+/**
+ * Sanity guard: before any remover code can run, assert that
+ * `process.env.HOME` points inside `os.tmpdir()`. If a test forgets
+ * to override HOME, this check fails loudly BEFORE any destructive
+ * operation touches the real home directory. This is the safety net
+ * architect tightening #2 asked for.
+ */
+function ASSERT_HOME_ISOLATED() {
+  // Thin wrapper around the shared helper. Checks BOTH HOME and
+  // USERPROFILE so Windows is actually guarded — `os.homedir()`
+  // reads USERPROFILE on Windows, and an assertion that checked
+  // only HOME would pass while real user state was at risk.
+  assertHomeIsolated(tmpdir(), "uninstall tests");
+}
+
+function setup() {
+  sandbox = mkdtempSync(join(tmpdir(), "cli-cmd-uninstall-"));
+  projectDir = join(sandbox, "project");
+  homeDir = join(sandbox, "home");
+  mkdirSync(projectDir, { recursive: true });
+  mkdirSync(homeDir, { recursive: true });
+
+  originalCwd = process.cwd();
+  originalHomeEnv = captureHome();
+  process.chdir(projectDir);
+  setSandboxHome(homeDir);
+
+  ASSERT_HOME_ISOLATED();
+
+  stdout = createCaptureStream();
+  stderr = createCaptureStream();
+}
+
+function teardown() {
+  process.chdir(originalCwd);
+  restoreHome(originalHomeEnv);
+  if (sandbox) rmSync(sandbox, { recursive: true, force: true });
+}
+
+/**
+ * Seed a project directory with every v3.0.0 artifact `skillrepo init`
+ * would write. Each test starts from a clean sandbox and calls this
+ * to get a realistic "installed" state to uninstall from.
+ *
+ * Note: we do NOT call runInit to seed — that would require a running
+ * mock server, serial test execution, and couples the uninstall tests
+ * to the init flow. Writing the artifacts directly is faster and
+ * makes each test's assumed starting state explicit.
+ */
+function seedInstalledProject({
+  mcpSkillrepo = true,
+  mcpOtherTool = false,
+  envLocalHasKey = true,
+  envLocalHasOther = false,
+  gitignoreHasSection = true,
+  gitignoreHasOther = false,
+  skillsDir = true,
+  settingsSessionHook = false,
+  settingsUserHook = false,
+} = {}) {
+  // .mcp.json
+  const mcpConfig = { mcpServers: {} };
+  if (mcpSkillrepo) {
+    mcpConfig.mcpServers.skillrepo = {
+      type: "http",
+      url: "https://skillrepo.dev/api/mcp",
+      headers: { Authorization: "Bearer ${SKILLREPO_ACCESS_KEY}" },
+    };
+  }
+  if (mcpOtherTool) {
+    mcpConfig.mcpServers.otherTool = {
+      type: "http",
+      url: "https://example.com/mcp",
+    };
+  }
+  writeFileSync(
+    join(projectDir, ".mcp.json"),
+    JSON.stringify(mcpConfig, null, 2),
+  );
+
+  // .env.local
+  const envLines = [];
+  if (envLocalHasOther) envLines.push("DATABASE_URL=postgres://localhost");
+  if (envLocalHasKey) envLines.push("SKILLREPO_ACCESS_KEY=sk_live_testkey");
+  if (envLines.length > 0) {
+    writeFileSync(join(projectDir, ".env.local"), envLines.join("\n") + "\n");
+  }
+
+  // .gitignore
+  const giLines = [];
+  if (gitignoreHasOther) giLines.push("node_modules/", "");
+  if (gitignoreHasSection) {
+    giLines.push(
+      "# SkillRepo CLI (added by `skillrepo init`)",
+      ".env.local",
+      ".claude/skills/",
+      ".claude/settings.local.json",
+      "",
+    );
+  }
+  if (giLines.length > 0) {
+    writeFileSync(join(projectDir, ".gitignore"), giLines.join("\n"));
+  }
+
+  // .claude/skills/ directory with one fake skill for child-count detail
+  if (skillsDir) {
+    mkdirSync(join(projectDir, ".claude", "skills", "fake-skill"), {
+      recursive: true,
+    });
+    writeFileSync(
+      join(projectDir, ".claude", "skills", "fake-skill", "SKILL.md"),
+      "---\nname: fake-skill\n---\nbody",
+    );
+  }
+
+  // .claude/settings.local.json with a SkillRepo SessionStart hook
+  // (forward-declaration for #884 integration; the remover already
+  // handles this artifact today).
+  if (settingsSessionHook || settingsUserHook) {
+    const hooks = [];
+    if (settingsUserHook) {
+      hooks.push({
+        hooks: [{ type: "command", command: "echo user-owned-hook" }],
+      });
+    }
+    if (settingsSessionHook) {
+      hooks.push({
+        hooks: [
+          {
+            type: "command",
+            command: `/usr/local/bin/skillrepo update --session-hook 2>&1 || true`,
+          },
+        ],
+      });
+    }
+    mkdirSync(join(projectDir, ".claude"), { recursive: true });
+    writeFileSync(
+      join(projectDir, ".claude", "settings.local.json"),
+      JSON.stringify({ hooks: { SessionStart: hooks } }, null, 2),
+    );
+  }
+}
+
+/**
+ * Seed global state that `skillrepo init` would write with --global.
+ */
+function seedInstalledGlobal() {
+  // ~/.claude/skillrepo/config.json + .last-sync
+  mkdirSync(join(homeDir, ".claude", "skillrepo"), { recursive: true });
+  writeFileSync(
+    join(homeDir, ".claude", "skillrepo", "config.json"),
+    JSON.stringify(
+      {
+        schemaVersion: 1,
+        apiKey: "sk_live_testkey",
+        serverUrl: "https://skillrepo.dev",
+      },
+      null,
+      2,
+    ),
+  );
+  writeFileSync(
+    join(homeDir, ".claude", "skillrepo", ".last-sync"),
+    JSON.stringify({ schemaVersion: 1, etag: null, syncedAt: new Date().toISOString() }),
+  );
+
+  // ~/.claude/skills/ global skill cache
+  mkdirSync(join(homeDir, ".claude", "skills", "global-skill"), {
+    recursive: true,
+  });
+  writeFileSync(
+    join(homeDir, ".claude", "skills", "global-skill", "SKILL.md"),
+    "---\nname: global-skill\n---\nbody",
+  );
+
+  // ~/.codeium/windsurf/mcp_config.json
+  mkdirSync(join(homeDir, ".codeium", "windsurf"), { recursive: true });
+  writeFileSync(
+    join(homeDir, ".codeium", "windsurf", "mcp_config.json"),
+    JSON.stringify(
+      {
+        mcpServers: {
+          skillrepo: {
+            serverUrl: "https://skillrepo.dev/api/mcp",
+            headers: { Authorization: "Bearer ${env:SKILLREPO_ACCESS_KEY}" },
+          },
+        },
+      },
+      null,
+      2,
+    ),
+  );
+}
+
+// ──────────────────────────────────────────────────────────────────
+
+describe("runUninstall — nothing-to-remove", () => {
+  beforeEach(setup);
+  afterEach(teardown);
+
+  it("reports Nothing to remove and exits 0 when no artifacts exist", async () => {
+    ASSERT_HOME_ISOLATED();
+    await runUninstall(["--yes"], { stdout, stderr });
+    assert.match(stdout.text(), /Nothing to remove/);
+  });
+
+  it("is idempotent after a prior uninstall", async () => {
+    ASSERT_HOME_ISOLATED();
+    seedInstalledProject();
+    await runUninstall(["--yes"], { stdout, stderr });
+    stdout.clear();
+
+    await runUninstall(["--yes"], { stdout, stderr });
+    assert.match(stdout.text(), /Nothing to remove/);
+  });
+});
+
+describe("runUninstall — project happy path", () => {
+  beforeEach(setup);
+  afterEach(teardown);
+
+  it("removes every SkillRepo-owned artifact with --yes", async () => {
+    ASSERT_HOME_ISOLATED();
+    seedInstalledProject();
+
+    await runUninstall(["--yes"], { stdout, stderr });
+
+    // Skill directory gone
+    assert.ok(!existsSync(join(projectDir, ".claude", "skills")));
+    // .mcp.json still exists but no longer has the skillrepo entry
+    const mcp = JSON.parse(
+      readFileSync(join(projectDir, ".mcp.json"), "utf-8"),
+    );
+    assert.equal(mcp.mcpServers.skillrepo, undefined);
+    // .env.local no longer has the key (file may or may not exist
+    // depending on whether it had other content)
+    const envPath = join(projectDir, ".env.local");
+    if (existsSync(envPath)) {
+      const env = readFileSync(envPath, "utf-8");
+      assert.doesNotMatch(env, /SKILLREPO_ACCESS_KEY=/);
+    }
+    // .gitignore no longer has the section
+    const gi = readFileSync(join(projectDir, ".gitignore"), "utf-8");
+    assert.doesNotMatch(gi, /SkillRepo/);
+  });
+
+  it("preserves non-SkillRepo content in shared files", async () => {
+    ASSERT_HOME_ISOLATED();
+    seedInstalledProject({
+      mcpOtherTool: true,
+      envLocalHasOther: true,
+      gitignoreHasOther: true,
+    });
+
+    await runUninstall(["--yes"], { stdout, stderr });
+
+    // Sibling MCP server survives
+    const mcp = JSON.parse(
+      readFileSync(join(projectDir, ".mcp.json"), "utf-8"),
+    );
+    assert.ok(mcp.mcpServers.otherTool, "sibling MCP server must survive");
+    // Sibling env var survives
+    const env = readFileSync(join(projectDir, ".env.local"), "utf-8");
+    assert.match(env, /DATABASE_URL=postgres:\/\/localhost/);
+    assert.doesNotMatch(env, /SKILLREPO_ACCESS_KEY=/);
+    // User's gitignore lines survive
+    const gi = readFileSync(join(projectDir, ".gitignore"), "utf-8");
+    assert.match(gi, /node_modules\//);
+    assert.doesNotMatch(gi, /SkillRepo/);
+  });
+
+  it("does NOT touch global state by default", async () => {
+    ASSERT_HOME_ISOLATED();
+    seedInstalledProject();
+    seedInstalledGlobal();
+
+    await runUninstall(["--yes"], { stdout, stderr });
+
+    // Global config still exists — user's credential survives a
+    // project-only uninstall so other projects on the same machine
+    // keep working.
+    assert.ok(existsSync(join(homeDir, ".claude", "skillrepo", "config.json")));
+    assert.ok(existsSync(join(homeDir, ".claude", "skills")));
+  });
+});
+
+describe("runUninstall — --global", () => {
+  beforeEach(setup);
+  afterEach(teardown);
+
+  it("removes global state when --global is passed", async () => {
+    ASSERT_HOME_ISOLATED();
+    seedInstalledProject();
+    seedInstalledGlobal();
+
+    await runUninstall(["--yes", "--global"], { stdout, stderr });
+
+    // Global artifacts gone
+    assert.ok(
+      !existsSync(join(homeDir, ".claude", "skillrepo")),
+      "~/.claude/skillrepo/ must be removed with --global",
+    );
+    assert.ok(
+      !existsSync(join(homeDir, ".claude", "skills")),
+      "~/.claude/skills/ must be removed with --global",
+    );
+    // Windsurf entry removed but file preserved (it may contain
+    // other MCP servers — we only delete our key)
+    const ws = JSON.parse(
+      readFileSync(
+        join(homeDir, ".codeium", "windsurf", "mcp_config.json"),
+        "utf-8",
+      ),
+    );
+    assert.equal(ws.mcpServers.skillrepo, undefined);
+    // Project artifacts also gone (project + global = both passes)
+    assert.ok(!existsSync(join(projectDir, ".claude", "skills")));
+  });
+
+  it("removes a SkillRepo SessionStart hook end-to-end (covers settings-session-hook descriptor)", async () => {
+    // Command-level integration for the settings remover — closes
+    // a coverage gap the code-reviewer flagged in round 1. The
+    // remover has its own unit tests, but the orchestrator's
+    // handling of this descriptor (scan → execute → JSON output)
+    // is only tested here.
+    ASSERT_HOME_ISOLATED();
+    seedInstalledProject({
+      settingsSessionHook: true,
+      settingsUserHook: true,
+    });
+
+    await runUninstall(["--yes", "--json"], { stdout, stderr });
+
+    const json = JSON.parse(stdout.text());
+    assert.equal(json.action, "uninstalled");
+    const settingsRemoval = json.removed.find(
+      (r) => r.id === "settings-session-hook",
+    );
+    assert.ok(
+      settingsRemoval,
+      "settings-session-hook must appear in the removed list",
+    );
+
+    const settings = JSON.parse(
+      readFileSync(
+        join(projectDir, ".claude", "settings.local.json"),
+        "utf-8",
+      ),
+    );
+    // User's hook survives — SkillRepo's entry filtered out.
+    const allCommands = (settings.hooks?.SessionStart ?? [])
+      .flatMap((group) => group.hooks ?? [])
+      .map((h) => h.command);
+    assert.ok(
+      allCommands.some((c) => c.includes("user-owned-hook")),
+      "user-authored hook must survive uninstall",
+    );
+    assert.ok(
+      !allCommands.some((c) => c.includes(SESSION_HOOK_FINGERPRINT)),
+      "SkillRepo hook must be gone",
+    );
+  });
+
+  it("round-trip: real installer writes global hook → real uninstall --global strips it (closes #884 gap)", async () => {
+    // Regression guard for the gap the user flagged during #884
+    // review. CRITICAL: this test uses the REAL installer
+    // (`mergeSessionHook({ global: true })`) to seed the hook, NOT a
+    // manual writeFileSync. A manual seed would pass even if the
+    // installer's output format drifted away from what the
+    // uninstaller expects — false-negative territory. Calling the
+    // real installer locks the end-to-end contract: what the
+    // installer writes, the uninstaller (via the registry-driven
+    // orchestrator) must find and strip.
+    //
+    // Before #884's uninstall fix, `skillrepo init --global` (which
+    // calls mergeSessionHook({ global: true })) would install the
+    // hook at `~/.claude/settings.local.json` but `skillrepo
+    // uninstall --global` had no registry descriptor for that path
+    // — the hook was unreachable. The `settings-session-hook-global`
+    // descriptor closes the gap.
+    ASSERT_HOME_ISOLATED();
+
+    // Pre-seed user-authored content in the global settings file
+    // so we can verify it survives uninstall.
+    mkdirSync(join(homeDir, ".claude"), { recursive: true });
+    writeFileSync(
+      join(homeDir, ".claude", "settings.local.json"),
+      JSON.stringify({ env: { USER_KEPT: "yes" } }, null, 2),
+    );
+
+    // Now use the REAL installer to write the hook. Pass an
+    // explicit binaryPath so `which skillrepo` doesn't leak through
+    // to the developer's real PATH.
+    const { mergeSessionHook } = await import(
+      "../../lib/mergers/session-hook.mjs"
+    );
+    const installResult = mergeSessionHook({
+      binaryPath: "/usr/local/bin/skillrepo",
+      global: true,
+    });
+    assert.equal(
+      installResult.action,
+      "installed",
+      "installer must write the hook before uninstall runs",
+    );
+
+    // Sanity check the installer actually wrote to the global path,
+    // NOT the project path.
+    assert.ok(
+      existsSync(join(homeDir, ".claude", "settings.local.json")),
+      "installer must target ~/.claude/settings.local.json with global: true",
+    );
+    assert.ok(
+      !existsSync(join(projectDir, ".claude", "settings.local.json")),
+      "installer must NOT have written to project-local path",
+    );
+
+    // Now invoke uninstall via the real command path.
+    await runUninstall(["--yes", "--global", "--json"], { stdout, stderr });
+
+    const json = JSON.parse(stdout.text());
+    const globalRemoval = json.removed.find(
+      (r) => r.id === "settings-session-hook-global",
+    );
+    assert.ok(
+      globalRemoval,
+      "settings-session-hook-global must appear in removed[] (registry → remover round-trip)",
+    );
+    assert.equal(globalRemoval.path, "~/.claude/settings.local.json");
+
+    // Hook gone; user-authored content preserved.
+    const settings = JSON.parse(
+      readFileSync(
+        join(homeDir, ".claude", "settings.local.json"),
+        "utf-8",
+      ),
+    );
+    const allCommands = (settings.hooks?.SessionStart ?? [])
+      .flatMap((group) => group?.hooks ?? [])
+      .map((h) => h?.command);
+    assert.ok(
+      !allCommands.some((c) => c?.includes(SESSION_HOOK_FINGERPRINT)),
+      "global SkillRepo hook must be gone after uninstall --global",
+    );
+    assert.deepEqual(
+      settings.env,
+      { USER_KEPT: "yes" },
+      "user-authored env must survive the global uninstall",
+    );
+  });
+
+  it("does NOT touch the global settings file without --global (scope isolation)", async () => {
+    // Mirror-test: project-only uninstall must never touch the
+    // user-wide settings file, even if it has a SkillRepo hook.
+    // This protects users on multi-project machines — uninstalling
+    // from project A shouldn't remove session-sync for projects
+    // B, C, D.
+    ASSERT_HOME_ISOLATED();
+    mkdirSync(join(homeDir, ".claude"), { recursive: true });
+    const originalGlobal = JSON.stringify(
+      {
+        hooks: {
+          SessionStart: [
+            {
+              hooks: [
+                {
+                  type: "command",
+                  command:
+                    "/usr/local/bin/skillrepo update --session-hook 2>&1 || true",
+                },
+              ],
+            },
+          ],
+        },
+      },
+      null,
+      2,
+    );
+    writeFileSync(
+      join(homeDir, ".claude", "settings.local.json"),
+      originalGlobal,
+    );
+    seedInstalledProject({ settingsSessionHook: true });
+
+    await runUninstall(["--yes"], { stdout, stderr });
+
+    // Global settings file byte-for-byte unchanged.
+    assert.equal(
+      readFileSync(
+        join(homeDir, ".claude", "settings.local.json"),
+        "utf-8",
+      ),
+      originalGlobal,
+      "global settings file must be untouched by project-only uninstall",
+    );
+    // But project-local hook IS gone (happy path continues to work).
+    const projectSettings = JSON.parse(
+      readFileSync(
+        join(projectDir, ".claude", "settings.local.json"),
+        "utf-8",
+      ),
+    );
+    const projectCommands = (projectSettings.hooks?.SessionStart ?? [])
+      .flatMap((g) => g?.hooks ?? [])
+      .map((h) => h?.command);
+    assert.ok(
+      !projectCommands.some((c) => c?.includes(SESSION_HOOK_FINGERPRINT)),
+      "project-local hook still gets cleaned up",
+    );
+  });
+
+  it("does NOT touch the Windsurf config without --global", async () => {
+    // Multi-tenant correctness: a project-only uninstall must leave
+    // Windsurf's global MCP config untouched. A user with several
+    // projects on one machine expects running uninstall in project
+    // A to keep project B's Windsurf integration working.
+    ASSERT_HOME_ISOLATED();
+    seedInstalledProject();
+    seedInstalledGlobal();
+
+    const wsBefore = readFileSync(
+      join(homeDir, ".codeium", "windsurf", "mcp_config.json"),
+      "utf-8",
+    );
+
+    await runUninstall(["--yes"], { stdout, stderr });
+
+    const wsAfter = readFileSync(
+      join(homeDir, ".codeium", "windsurf", "mcp_config.json"),
+      "utf-8",
+    );
+    assert.equal(wsAfter, wsBefore, "Windsurf config is untouched without --global");
+    // And ~/.claude/skillrepo/config.json survives — the user's
+    // credential for other projects stays valid.
+    assert.ok(existsSync(join(homeDir, ".claude", "skillrepo", "config.json")));
+  });
+});
+
+describe("runUninstall — --dry-run", () => {
+  beforeEach(setup);
+  afterEach(teardown);
+
+  it("does not modify any file", async () => {
+    ASSERT_HOME_ISOLATED();
+    seedInstalledProject();
+
+    const mcpBefore = readFileSync(join(projectDir, ".mcp.json"), "utf-8");
+    const envBefore = readFileSync(join(projectDir, ".env.local"), "utf-8");
+    const giBefore = readFileSync(join(projectDir, ".gitignore"), "utf-8");
+
+    await runUninstall(["--dry-run"], { stdout, stderr });
+
+    // All files byte-for-byte unchanged
+    assert.equal(
+      readFileSync(join(projectDir, ".mcp.json"), "utf-8"),
+      mcpBefore,
+    );
+    assert.equal(
+      readFileSync(join(projectDir, ".env.local"), "utf-8"),
+      envBefore,
+    );
+    assert.equal(
+      readFileSync(join(projectDir, ".gitignore"), "utf-8"),
+      giBefore,
+    );
+    // Skill directory still exists
+    assert.ok(existsSync(join(projectDir, ".claude", "skills", "fake-skill")));
+  });
+
+  it("lists what would be removed", async () => {
+    ASSERT_HOME_ISOLATED();
+    seedInstalledProject();
+
+    await runUninstall(["--dry-run"], { stdout, stderr });
+
+    assert.match(stdout.text(), /Would remove/);
+    assert.match(stdout.text(), /\.mcp\.json/);
+    assert.match(stdout.text(), /\.env\.local/);
+    assert.match(stdout.text(), /\.gitignore/);
+    assert.match(stdout.text(), /\.claude\/skills\//);
+  });
+});
+
+describe("runUninstall — --json", () => {
+  beforeEach(setup);
+  afterEach(teardown);
+
+  it("outputs valid JSON with removed entries for the happy path", async () => {
+    ASSERT_HOME_ISOLATED();
+    seedInstalledProject();
+
+    await runUninstall(["--yes", "--json"], { stdout, stderr });
+
+    const json = JSON.parse(stdout.text());
+    assert.equal(json.action, "uninstalled");
+    assert.equal(json.scope, "project");
+    assert.ok(Array.isArray(json.removed));
+    assert.ok(json.removed.length > 0);
+    // Each removed entry has id and path
+    for (const r of json.removed) {
+      assert.ok(typeof r.id === "string");
+      assert.ok(typeof r.path === "string");
+    }
+  });
+
+  it("outputs valid JSON for --dry-run with would-remove entries", async () => {
+    ASSERT_HOME_ISOLATED();
+    seedInstalledProject();
+
+    await runUninstall(["--dry-run", "--json"], { stdout, stderr });
+
+    const json = JSON.parse(stdout.text());
+    assert.equal(json.action, "dry-run");
+    assert.ok(Array.isArray(json["would-remove"]));
+    assert.ok(json["would-remove"].length > 0);
+  });
+
+  it("outputs valid JSON for the nothing-to-remove path", async () => {
+    ASSERT_HOME_ISOLATED();
+
+    await runUninstall(["--yes", "--json"], { stdout, stderr });
+
+    const json = JSON.parse(stdout.text());
+    assert.equal(json.action, "nothing-to-remove");
+    assert.deepEqual(json.removed, []);
+  });
+
+  it("--json implicitly bypasses the interactive prompt (no --yes needed)", async () => {
+    // Architect review round 1 flagged this as a contract gap: the
+    // `if (!yes && !json)` gate is intentional (CI scripts use
+    // --json and shouldn't hang on stdin), but the behavior was
+    // only tested transitively via passing tests that already had
+    // --yes. This test locks the "--json means no prompt" contract
+    // so a future refactor that accidentally re-introduces prompt
+    // gating under --json breaks loudly.
+    ASSERT_HOME_ISOLATED();
+    seedInstalledProject();
+
+    // No --yes. --json alone. If the prompt were to fire, readline
+    // would block on stdin and this test would hang — node:test's
+    // default timeout would then fail it. A clean return-with-
+    // uninstalled-action is the proof.
+    await runUninstall(["--json"], { stdout, stderr });
+
+    const json = JSON.parse(stdout.text());
+    assert.equal(json.action, "uninstalled");
+    assert.ok(json.removed.length > 0);
+  });
+});
+
+describe("runUninstall — error handling", () => {
+  beforeEach(setup);
+  afterEach(teardown);
+
+  it("refuses to recursively remove a directory with a non-skills/skillrepo basename", async () => {
+    // Defense-in-depth for a path-resolution bug: if a future
+    // refactor changes `claudeSkillsProjectRoot()` to point somewhere
+    // dangerous, the inline remover's basename guard must refuse
+    // rmSync rather than propagating the bad path. We can't easily
+    // induce that kind of bug from the test surface, but we can
+    // verify the guard EXISTS by pointing at the code path: if the
+    // code below ever accepts a path with basename other than
+    // "skills" or "skillrepo", this test fails.
+    //
+    // We test this by reading the source of removeDirectoryArtifact
+    // — imperfect, but catches a refactor that removes the assertion
+    // without updating this test. Structural guard, not a runtime
+    // invariant exerciser.
+    const { readFileSync: rfs } = await import("node:fs");
+    const { fileURLToPath } = await import("node:url");
+    const src = rfs(
+      fileURLToPath(new URL("../../commands/uninstall.mjs", import.meta.url)),
+      "utf-8",
+    );
+    assert.match(
+      src,
+      /basename[^"]+"skills"[^"]+"skillrepo"/,
+      "removeDirectoryArtifact must assert basename in {skills, skillrepo} before rmSync",
+    );
+    assert.match(
+      src,
+      /Refusing to recursively remove/,
+      "the refusal path must surface a recognizable error message",
+    );
+  });
+
+  it("continues processing when a single file has unparseable JSON", async () => {
+    ASSERT_HOME_ISOLATED();
+    seedInstalledProject();
+    // Corrupt the .mcp.json — the skill directory and .gitignore
+    // should still be processed despite this failure.
+    writeFileSync(join(projectDir, ".mcp.json"), "{ corrupt json");
+
+    // runUninstall throws a diskError (EXIT_DISK) when any artifact
+    // fails so the dispatcher exits with code 3. The JSON summary is
+    // still written to stdout BEFORE the throw — we capture both.
+    let thrownError;
+    try {
+      await runUninstall(["--yes", "--json"], { stdout, stderr });
+    } catch (err) {
+      thrownError = err;
+    }
+    assert.ok(thrownError, "uninstall must throw when any artifact fails");
+    assert.equal(thrownError.exitCode, 3, "thrown error must carry EXIT_DISK");
+
+    const json = JSON.parse(stdout.text());
+    // The corrupt MCP file shows up in errors
+    const mcpError = json.errors.find((e) => e.path === ".mcp.json");
+    assert.ok(mcpError, ".mcp.json parse error must be surfaced");
+    assert.match(mcpError.error, /parse/i);
+    // But the skill directory and gitignore were still processed —
+    // continue-with-errors semantics preserved even though the
+    // command ultimately exits non-zero.
+    assert.ok(!existsSync(join(projectDir, ".claude", "skills")));
+    const giSurvivors = readFileSync(join(projectDir, ".gitignore"), "utf-8");
+    assert.doesNotMatch(giSurvivors, /SkillRepo/);
+  });
+});