skillrepo 3.2.0 → 4.0.0

package/src/test/e2e/cli-agent-permutations.test.mjs

@@ -0,0 +1,631 @@
+/**
+ * E2E permutation matrix for the `--agent` flag (placement epic
+ * #876, #1234, #1235, #1236).
+ *
+ * These tests verify USER INTENT, not implementation internals. Each
+ * case spawns the real CLI binary, then asserts on the user-visible
+ * post-state: which directories exist on disk, what their SKILL.md
+ * frontmatter actually says, what `.gitignore` contains, and the
+ * process exit code + stderr text.
+ *
+ * Unit tests under `src/test/lib/file-write-placement.test.mjs`
+ * already cover the data layer (`placementTargetsFor` return values).
+ * The gap this file closes is the user-layer: "after I run init
+ * with these flags, what do I see in my project on disk?"
+ *
+ * The harness pattern is the same as the read-commands E2E file —
+ * shared `createMockServer`, per-test mkdtemp for cwd + HOME, and a
+ * `runCli` helper that always resolves with stdout/stderr/status.
+ */
+
+import { describe, it, before, after, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdtempSync,
+  rmSync,
+  existsSync,
+  readFileSync,
+} from "node:fs";
+import { join, dirname, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { execFile } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+import { createMockServer } from "./mock-server.mjs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CLI_BIN = resolve(__dirname, "../../../bin/skillrepo.mjs");
+const VALID_KEY = "sk_live_test_e2e";
+
+let server;
+let port;
+let tempDir;
+let tempHome;
+
+/**
+ * Build a `SyncSkill`-shaped object the mock server's library route
+ * returns. The SKILL.md content is a real frontmatter block so the
+ * frontmatter-validity assertions in each test are meaningful.
+ */
+function makeSkill(owner, name, content = `body of ${name}`) {
+  return {
+    owner,
+    name,
+    version: "1.0.0",
+    description: `${name} description`,
+    files: [
+      {
+        path: "SKILL.md",
+        content: `---\nname: ${name}\ndescription: ${name} description\n---\n\n${content}\n`,
+        sha256: "x",
+        size: 100,
+        contentType: "text/markdown",
+      },
+    ],
+    updatedAt: "2025-01-01T00:00:00Z",
+  };
+}
+
+function runCli(args, extraEnv = {}) {
+  return new Promise((resolve) => {
+    execFile(
+      process.execPath,
+      [CLI_BIN, ...args],
+      {
+        cwd: tempDir,
+        encoding: "utf-8",
+        timeout: 15_000,
+        env: {
+          ...process.env,
+          HOME: tempHome,
+          NO_COLOR: "1",
+          NODE_NO_WARNINGS: "1",
+          SKILLREPO_ACCESS_KEY: "",
+          SKILLREPO_TIMEOUT_MS: "5000",
+          ...extraEnv,
+        },
+      },
+      (err, stdout, stderr) => {
+        resolve({
+          stdout: stdout ?? "",
+          stderr: stderr ?? "",
+          status: err ? err.code ?? 1 : 0,
+        });
+      },
+    );
+  });
+}
+
+/**
+ * Seed two skills the mock server's library endpoint returns. Two
+ * skills (rather than one) makes sure the assertions catch the
+ * common bug of "first skill writes correctly, second falls through
+ * to a wrong target."
+ */
+function seedTwoSkills() {
+  server.setLibraryResponse({
+    skills: [
+      makeSkill("alice", "pdf-helper"),
+      makeSkill("bob", "code-review"),
+    ],
+    removals: [],
+    syncedAt: "x",
+  });
+}
+
+const SEEDED_NAMES = ["pdf-helper", "code-review"];
+
+/** Read a SKILL.md file and assert it has a valid `name:`/`description:` frontmatter block. */
+function assertValidSkillFile(filePath, expectedName) {
+  assert.ok(existsSync(filePath), `expected skill file at ${filePath}`);
+  const content = readFileSync(filePath, "utf-8");
+  // Frontmatter fence must be present.
+  assert.match(content, /^---\r?\n/, `frontmatter fence missing in ${filePath}`);
+  // `name:` must match the seeded skill.
+  assert.match(
+    content,
+    new RegExp(`\\nname:\\s*${expectedName}\\b`),
+    `name field missing or wrong in ${filePath}`,
+  );
+  // `description:` must be present.
+  assert.match(
+    content,
+    /\ndescription:\s*\S/,
+    `description field missing in ${filePath}`,
+  );
+}
+
+describe("CLI E2E — --agent permutation matrix", () => {
+  before(async () => {
+    server = createMockServer({});
+    port = await server.start();
+  });
+
+  after(async () => {
+    if (server) await server.stop();
+  });
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "cli-e2e-agent-"));
+    tempHome = mkdtempSync(join(tmpdir(), "cli-e2e-home-"));
+    server.setLibraryResponse({ skills: [], removals: [], syncedAt: "x" });
+    server.setEtag(null);
+    server.clearSkillResponses();
+    server.setSearchResponse({ skills: [], pagination: { total: 0, limit: 20, offset: 0 } });
+    server.clearAddResponses();
+    server.clearRemoveResponses();
+  });
+
+  afterEach(() => {
+    if (tempDir) rmSync(tempDir, { recursive: true, force: true });
+    if (tempHome) rmSync(tempHome, { recursive: true, force: true });
+  });
+
+  // ── init permutations (project scope) ──────────────────────────────
+
+  it("init --agent claude writes Claude-only placement", async () => {
+    seedTwoSkills();
+    const r = await runCli([
+      "init",
+      "--key", VALID_KEY,
+      "--url", `http://127.0.0.1:${port}`,
+      "--yes",
+      "--agent", "claude",
+    ]);
+    assert.equal(r.status, 0, `stderr: ${r.stderr}`);
+
+    // Config saved under tempHome
+    assert.ok(existsSync(join(tempHome, ".claude", "skillrepo", "config.json")));
+
+    // Each seeded skill is on disk under .claude/skills/<name>/SKILL.md
+    for (const name of SEEDED_NAMES) {
+      assertValidSkillFile(join(tempDir, ".claude", "skills", name, "SKILL.md"), name);
+    }
+
+    // .gitignore protects the Claude path but NOT the agents path
+    const gi = readFileSync(join(tempDir, ".gitignore"), "utf-8");
+    assert.match(gi, /(^|\n)\.claude\/skills\/(\r?\n|$)/, `.gitignore missing .claude/skills/: ${gi}`);
+    assert.doesNotMatch(gi, /(^|\n)\.agents\/skills\/(\r?\n|$)/, `.gitignore should not contain .agents/skills/: ${gi}`);
+
+    // No agents-cohort directory created
+    assert.ok(!existsSync(join(tempDir, ".agents", "skills")), ".agents/skills/ should not exist for claude-only");
+  });
+
+  it("init --agent agents writes agents-cohort placement only", async () => {
+    seedTwoSkills();
+    const r = await runCli([
+      "init",
+      "--key", VALID_KEY,
+      "--url", `http://127.0.0.1:${port}`,
+      "--yes",
+      "--agent", "agents",
+    ]);
+    assert.equal(r.status, 0, `stderr: ${r.stderr}`);
+
+    for (const name of SEEDED_NAMES) {
+      assertValidSkillFile(join(tempDir, ".agents", "skills", name, "SKILL.md"), name);
+    }
+
+    const gi = readFileSync(join(tempDir, ".gitignore"), "utf-8");
+    assert.match(gi, /(^|\n)\.agents\/skills\/(\r?\n|$)/, `.gitignore missing .agents/skills/: ${gi}`);
+    assert.doesNotMatch(gi, /(^|\n)\.claude\/skills\/(\r?\n|$)/, `.gitignore should not contain .claude/skills/: ${gi}`);
+
+    assert.ok(!existsSync(join(tempDir, ".claude", "skills")), ".claude/skills/ should not exist for agents-only");
+  });
+
+  it("init --agent claude,agents writes both placements with identical content", async () => {
+    seedTwoSkills();
+    const r = await runCli([
+      "init",
+      "--key", VALID_KEY,
+      "--url", `http://127.0.0.1:${port}`,
+      "--yes",
+      "--agent", "claude,agents",
+    ]);
+    assert.equal(r.status, 0, `stderr: ${r.stderr}`);
+
+    for (const name of SEEDED_NAMES) {
+      const claudePath = join(tempDir, ".claude", "skills", name, "SKILL.md");
+      const agentsPath = join(tempDir, ".agents", "skills", name, "SKILL.md");
+      assertValidSkillFile(claudePath, name);
+      assertValidSkillFile(agentsPath, name);
+      // Identical content across the two targets
+      assert.equal(
+        readFileSync(claudePath, "utf-8"),
+        readFileSync(agentsPath, "utf-8"),
+        `SKILL.md content should be identical between claude and agents targets for ${name}`,
+      );
+    }
+
+    const gi = readFileSync(join(tempDir, ".gitignore"), "utf-8");
+    assert.match(gi, /(^|\n)\.claude\/skills\/(\r?\n|$)/);
+    assert.match(gi, /(^|\n)\.agents\/skills\/(\r?\n|$)/);
+  });
+
+  it("init --agent none configures credentials but writes no skills", async () => {
+    seedTwoSkills();
+    const r = await runCli([
+      "init",
+      "--key", VALID_KEY,
+      "--url", `http://127.0.0.1:${port}`,
+      "--yes",
+      "--agent", "none",
+    ]);
+    assert.equal(r.status, 0, `stderr: ${r.stderr}`);
+
+    // Config still happens
+    assert.ok(existsSync(join(tempHome, ".claude", "skillrepo", "config.json")));
+    // Gitignore still happens — at minimum, .env.local must be in it
+    const giPath = join(tempDir, ".gitignore");
+    assert.ok(existsSync(giPath), ".gitignore should exist");
+    const gi = readFileSync(giPath, "utf-8");
+    assert.match(gi, /(^|\n)\.env\.local(\r?\n|$)/, `.gitignore missing .env.local: ${gi}`);
+
+    // No skill placement directories created
+    assert.ok(!existsSync(join(tempDir, ".claude", "skills")), ".claude/skills/ must not be written for --agent none");
+    assert.ok(!existsSync(join(tempDir, ".agents", "skills")), ".agents/skills/ must not be written for --agent none");
+  });
+
+  it("init --agent cursor (vendor alias) writes to .agents/skills, not .cursor/skills", async () => {
+    seedTwoSkills();
+    const r = await runCli([
+      "init",
+      "--key", VALID_KEY,
+      "--url", `http://127.0.0.1:${port}`,
+      "--yes",
+      "--agent", "cursor",
+    ]);
+    assert.equal(r.status, 0, `stderr: ${r.stderr}`);
+
+    for (const name of SEEDED_NAMES) {
+      assertValidSkillFile(join(tempDir, ".agents", "skills", name, "SKILL.md"), name);
+    }
+    // The product decision: Cursor uses the cohort `.agents/skills/`,
+    // NOT a per-vendor `.cursor/skills/` directory.
+    assert.ok(
+      !existsSync(join(tempDir, ".cursor", "skills")),
+      ".cursor/skills/ must not exist — Cursor placement uses .agents/skills/",
+    );
+  });
+
+  it("init --agent claude-code (kebab alias) writes to .claude/skills", async () => {
+    seedTwoSkills();
+    const r = await runCli([
+      "init",
+      "--key", VALID_KEY,
+      "--url", `http://127.0.0.1:${port}`,
+      "--yes",
+      "--agent", "claude-code",
+    ]);
+    assert.equal(r.status, 0, `stderr: ${r.stderr}`);
+
+    for (const name of SEEDED_NAMES) {
+      assertValidSkillFile(join(tempDir, ".claude", "skills", name, "SKILL.md"), name);
+    }
+    assert.ok(!existsSync(join(tempDir, ".agents", "skills")), ".agents/skills/ should not exist for claude-code alias");
+  });
+
+  it("init --agent gemini,codex,cline dedupes to a single .agents/skills/<name> per skill", async () => {
+    seedTwoSkills();
+    const r = await runCli([
+      "init",
+      "--key", VALID_KEY,
+      "--url", `http://127.0.0.1:${port}`,
+      "--yes",
+      "--agent", "gemini,codex,cline",
+    ]);
+    assert.equal(r.status, 0, `stderr: ${r.stderr}`);
+
+    for (const name of SEEDED_NAMES) {
+      assertValidSkillFile(join(tempDir, ".agents", "skills", name, "SKILL.md"), name);
+    }
+    // No per-vendor directories — these three vendors all collapse
+    // onto the cohort `.agents/skills/` target.
+    assert.ok(!existsSync(join(tempDir, ".gemini", "skills")), ".gemini/skills/ should not exist");
+    assert.ok(!existsSync(join(tempDir, ".codex", "skills")), ".codex/skills/ should not exist");
+    assert.ok(!existsSync(join(tempDir, ".cline", "skills")), ".cline/skills/ should not exist");
+  });
+
+  // ── init --global permutations (personal scope) ────────────────────
+
+  it("init --global --agent claude writes to ~/.claude/skills/, not project", async () => {
+    seedTwoSkills();
+    const r = await runCli([
+      "init",
+      "--key", VALID_KEY,
+      "--url", `http://127.0.0.1:${port}`,
+      "--yes",
+      "--global",
+      "--agent", "claude",
+      "--json",
+    ]);
+    assert.equal(r.status, 0, `stderr: ${r.stderr}`);
+
+    for (const name of SEEDED_NAMES) {
+      assertValidSkillFile(
+        join(tempHome, ".claude", "skills", name, "SKILL.md"),
+        name,
+      );
+    }
+    // Global writes do not pollute the project directory
+    assert.ok(
+      !existsSync(join(tempDir, ".claude", "skills")),
+      "project .claude/skills/ should not exist when init runs with --global",
+    );
+    // Positive: --global --agent claude IS Claude-targeted, so the
+    // session-sync flow must run (the action is anything BUT
+    // "not-applicable"). Whether the hook merge succeeds depends on
+    // whether a global skillrepo is on PATH (environment-dependent —
+    // CI runners don't have one; local dev machines often do), so we
+    // assert on the attempt, not the file. Pairs with the windsurf
+    // negative assertion that locks action === "not-applicable".
+    const summary = JSON.parse(r.stdout);
+    assert.notEqual(
+      summary.sessionSync.action,
+      "not-applicable",
+      "--global --agent claude is Claude-targeted; sessionSync must attempt the install",
+    );
+  });
+
+  it("init --global --agent windsurf writes to ~/.codeium/windsurf/skills (vendor-specific)", async () => {
+    seedTwoSkills();
+    const r = await runCli([
+      "init",
+      "--key", VALID_KEY,
+      "--url", `http://127.0.0.1:${port}`,
+      "--yes",
+      "--global",
+      "--agent", "windsurf",
+    ]);
+    assert.equal(r.status, 0, `stderr: ${r.stderr}`);
+
+    // Windsurf has a vendor-specific personal skills path.
+    for (const name of SEEDED_NAMES) {
+      assertValidSkillFile(
+        join(tempHome, ".codeium", "windsurf", "skills", name, "SKILL.md"),
+        name,
+      );
+    }
+    // Windsurf's globalTarget is windsurfGlobal, NOT agentsGlobal.
+    assert.ok(
+      !existsSync(join(tempHome, ".agents", "skills")),
+      "~/.agents/skills/ should not exist — Windsurf personal scope is ~/.codeium/windsurf/skills/",
+    );
+    // The Claude SessionStart hook is Claude Code-specific. A user
+    // running `--global --agent windsurf` did NOT pick Claude — the
+    // hook must not install. Locks the fix from manual E2E sweep.
+    // Assert via --json so the test is environment-independent (file
+    // presence depends on whether a global skillrepo is on PATH;
+    // sessionSync.action === "not-applicable" is the load-bearing
+    // signal that the install path was correctly skipped).
+    assert.ok(
+      !existsSync(join(tempHome, ".claude", "settings.local.json")),
+      "~/.claude/settings.local.json must NOT be installed for --global --agent windsurf",
+    );
+  });
+
+  it("init --global --agent copilot rejects (no personal scope)", async () => {
+    seedTwoSkills();
+    const r = await runCli([
+      "init",
+      "--key", VALID_KEY,
+      "--url", `http://127.0.0.1:${port}`,
+      "--yes",
+      "--global",
+      "--agent", "copilot",
+    ]);
+    // The user passed an invalid combination; init must fail loudly.
+    assert.equal(r.status, 5, `expected exit 5 for copilot+global, got ${r.status}; stderr=${r.stderr}; stdout=${r.stdout}`);
+    assert.match(
+      r.stderr,
+      /does not support global scope|copilot/i,
+      `stderr should explain copilot has no global scope: ${r.stderr}`,
+    );
+    // No skill files should land anywhere when the combination is rejected.
+    assert.ok(!existsSync(join(tempHome, ".claude", "skills")), "no skills should be written for rejected combination");
+    assert.ok(!existsSync(join(tempHome, ".agents", "skills")), "no skills should be written for rejected combination");
+    assert.ok(!existsSync(join(tempHome, ".codeium", "windsurf", "skills")), "no skills should be written for rejected combination");
+  });
+
+  // ── update permutations (after a seeded init) ──────────────────────
+
+  it("update --agent claude is idempotent after init --agent claude", async () => {
+    seedTwoSkills();
+    const initR = await runCli([
+      "init",
+      "--key", VALID_KEY,
+      "--url", `http://127.0.0.1:${port}`,
+      "--yes",
+      "--agent", "claude",
+    ]);
+    assert.equal(initR.status, 0, `init stderr: ${initR.stderr}`);
+
+    // Snapshot the SKILL.md content after init.
+    const skillPath = join(tempDir, ".claude", "skills", "pdf-helper", "SKILL.md");
+    const before = readFileSync(skillPath, "utf-8");
+
+    // Re-run update — should be a no-op (or at worst, a re-write with
+    // identical bytes). In either case: exit 0 and content unchanged.
+    const updateR = await runCli([
+      "update",
+      "--key", VALID_KEY,
+      "--url", `http://127.0.0.1:${port}`,
+      "--agent", "claude",
+    ]);
+    assert.equal(updateR.status, 0, `update stderr: ${updateR.stderr}`);
+
+    const after = readFileSync(skillPath, "utf-8");
+    assert.equal(after, before, "SKILL.md content should be unchanged after re-running update");
+    assertValidSkillFile(skillPath, "pdf-helper");
+  });
+
+  it("update --agent agents after init --agent claude adds the agents placement without disturbing claude", async () => {
+    seedTwoSkills();
+    const initR = await runCli([
+      "init",
+      "--key", VALID_KEY,
+      "--url", `http://127.0.0.1:${port}`,
+      "--yes",
+      "--agent", "claude",
+    ]);
+    assert.equal(initR.status, 0, `init stderr: ${initR.stderr}`);
+
+    // Pre-state: claude path exists, agents path does not.
+    assert.ok(existsSync(join(tempDir, ".claude", "skills", "pdf-helper", "SKILL.md")));
+    assert.ok(!existsSync(join(tempDir, ".agents", "skills")));
+
+    const claudeBefore = readFileSync(
+      join(tempDir, ".claude", "skills", "pdf-helper", "SKILL.md"),
+      "utf-8",
+    );
+
+    // ETag served from a fresh state may make update return 304;
+    // clear it so update fetches fresh and writes to the new target.
+    server.setEtag(null);
+
+    const updateR = await runCli([
+      "update",
+      "--key", VALID_KEY,
+      "--url", `http://127.0.0.1:${port}`,
+      "--agent", "agents",
+    ]);
+    assert.equal(updateR.status, 0, `update stderr: ${updateR.stderr}`);
+
+    // agents placement now exists for both seeded skills.
+    for (const name of SEEDED_NAMES) {
+      assertValidSkillFile(join(tempDir, ".agents", "skills", name, "SKILL.md"), name);
+    }
+    // claude placement is unchanged.
+    const claudeAfter = readFileSync(
+      join(tempDir, ".claude", "skills", "pdf-helper", "SKILL.md"),
+      "utf-8",
+    );
+    assert.equal(
+      claudeAfter,
+      claudeBefore,
+      "claude SKILL.md must remain unchanged when update targets a different cohort",
+    );
+  });
+
+  // ── failure-mode tests ─────────────────────────────────────────────
+
+  it("init --agent foo rejects unknown agent token", async () => {
+    seedTwoSkills();
+    const r = await runCli([
+      "init",
+      "--key", VALID_KEY,
+      "--url", `http://127.0.0.1:${port}`,
+      "--yes",
+      "--agent", "foo",
+    ]);
+    assert.equal(r.status, 5, `expected exit 5; stderr=${r.stderr}`);
+    assert.match(
+      r.stderr,
+      /Unknown --agent target|foo/i,
+      `stderr should mention the unknown token: ${r.stderr}`,
+    );
+    // No skill files written.
+    assert.ok(!existsSync(join(tempDir, ".claude", "skills")));
+    assert.ok(!existsSync(join(tempDir, ".agents", "skills")));
+  });
+
+  it("init --agent claude,none rejects mutually-exclusive tokens", async () => {
+    seedTwoSkills();
+    const r = await runCli([
+      "init",
+      "--key", VALID_KEY,
+      "--url", `http://127.0.0.1:${port}`,
+      "--yes",
+      "--agent", "claude,none",
+    ]);
+    assert.equal(r.status, 5, `expected exit 5; stderr=${r.stderr}`);
+    assert.match(
+      r.stderr,
+      /cannot mix.*none|none.*cannot/i,
+      `stderr should explain none is mutually exclusive: ${r.stderr}`,
+    );
+    assert.ok(!existsSync(join(tempDir, ".claude", "skills")));
+    assert.ok(!existsSync(join(tempDir, ".agents", "skills")));
+  });
+
+  it("init --agent '' rejects empty value", async () => {
+    seedTwoSkills();
+    const r = await runCli([
+      "init",
+      "--key", VALID_KEY,
+      "--url", `http://127.0.0.1:${port}`,
+      "--yes",
+      "--agent", "",
+    ]);
+    assert.equal(r.status, 5, `expected exit 5; stderr=${r.stderr}`);
+    // The CLI should call out that --agent received nothing useful.
+    assert.match(
+      r.stderr,
+      /agent/i,
+      `stderr should mention --agent: ${r.stderr}`,
+    );
+    assert.ok(!existsSync(join(tempDir, ".claude", "skills")));
+    assert.ok(!existsSync(join(tempDir, ".agents", "skills")));
+  });
+
+  it("init --ide claude rejects the legacy flag with a v2→v3 migration hint", async () => {
+    seedTwoSkills();
+    const r = await runCli([
+      "init",
+      "--key", VALID_KEY,
+      "--url", `http://127.0.0.1:${port}`,
+      "--yes",
+      "--ide", "claude",
+    ]);
+    assert.equal(r.status, 5, `expected exit 5; stderr=${r.stderr}`);
+    assert.match(
+      r.stderr,
+      /--ide was renamed to --agent/,
+      `stderr should explain the v2→v3 rename: ${r.stderr}`,
+    );
+    assert.ok(!existsSync(join(tempDir, ".claude", "skills")));
+    assert.ok(!existsSync(join(tempDir, ".agents", "skills")));
+  });
+
+  // ── re-run idempotency ─────────────────────────────────────────────
+
+  it("init --agent claude twice in a row leaves a clean tree on disk", async () => {
+    seedTwoSkills();
+
+    const first = await runCli([
+      "init",
+      "--key", VALID_KEY,
+      "--url", `http://127.0.0.1:${port}`,
+      "--yes",
+      "--agent", "claude",
+    ]);
+    assert.equal(first.status, 0, `first init stderr: ${first.stderr}`);
+
+    const skillPath = join(tempDir, ".claude", "skills", "pdf-helper", "SKILL.md");
+    const before = readFileSync(skillPath, "utf-8");
+
+    const second = await runCli([
+      "init",
+      "--key", VALID_KEY,
+      "--url", `http://127.0.0.1:${port}`,
+      "--yes",
+      "--agent", "claude",
+    ]);
+    assert.equal(second.status, 0, `second init stderr: ${second.stderr}`);
+
+    // SKILL.md content unchanged after the second run.
+    const after = readFileSync(skillPath, "utf-8");
+    assert.equal(after, before, "second init must not alter SKILL.md content");
+
+    // No leftover .tmp / .old siblings under the placement root.
+    const placementRoot = join(tempDir, ".claude", "skills");
+    const { readdirSync } = await import("node:fs");
+    const entries = readdirSync(placementRoot);
+    const stale = entries.filter((e) => e.endsWith(".tmp") || e.endsWith(".old"));
+    assert.deepEqual(
+      stale,
+      [],
+      `placement root should have no .tmp/.old leftovers; found: ${stale.join(", ")}`,
+    );
+  });
+});