skillrepo 3.2.0 → 4.1.0

package/src/lib/prompt-multiselect.mjs

@@ -0,0 +1,324 @@
+/**
+ * Multi-select prompt primitive (#1236, Phase 3 of #876).
+ *
+ * The two-row picker `init` step 4 uses to ask the user which targets
+ * to configure (Claude Code / Other agents / None). Designed as a
+ * general primitive so future commands can reuse it without copying
+ * keypress-handling code.
+ *
+ * Two modes:
+ *
+ *   - **TTY mode** (`process.stdout.isTTY`): renders a checkbox list
+ *     with a cursor highlight. Up/down arrows move the cursor, space
+ *     toggles the current item, `a` toggles all, enter confirms.
+ *     Uses `node:readline.emitKeypressEvents` + raw mode — the same
+ *     approach the existing `promptSecret` helper uses, so the
+ *     dependency surface stays node-builtins-only.
+ *
+ *   - **Non-TTY mode** (pipes, `--json` consumers, CI): prints the
+ *     numbered list with pre-checked markers, then reads a single line
+ *     of comma-separated keys from stdin. Empty line → returns the
+ *     pre-checked items.
+ *
+ * Cross-platform notes:
+ *
+ *   - Raw-mode keypress events are cross-platform on Node ≥ 18. CSI
+ *     escape sequences for arrow keys ("\x1b[A" etc.) are emitted
+ *     identically by the Windows console host and ConPTY in Windows
+ *     Terminal — verified against Node's `readline` source. We rely
+ *     on the parsed `key.name` ("up" / "down") rather than raw bytes
+ *     so any platform variance in the underlying bytes is absorbed
+ *     by Node's keypress parser.
+ *   - The renderer uses `\n` as line separator (not `\r\n`); Node's
+ *     line-buffered stdout converts to platform line endings on
+ *     Windows when stdout is a console.
+ *   - ANSI cursor-control codes ("\x1b[<N>A" / "\x1b[2K") are honored
+ *     by Windows Terminal, ConPTY, VS Code's integrated terminal,
+ *     and modern PowerShell hosts. Legacy cmd.exe without ANSI
+ *     interpretation will see the codes as visible noise — Node's
+ *     `process.stdout.isTTY` is true there too, so those users get a
+ *     functional but cosmetically degraded picker. Acceptable
+ *     tradeoff: the only fully-clean fallback would be redrawing
+ *     without cursor positioning, which adds complexity for a
+ *     vanishing population.
+ */
+
+import { emitKeypressEvents } from "node:readline";
+
+/**
+ * @typedef {Object} MultiSelectItem
+ * @property {string} key         - Returned in the result.
+ * @property {string} label       - Primary user-visible text.
+ * @property {string} [hint]      - Optional dim text after the label
+ *           (e.g. detection reason, target path).
+ * @property {boolean} preChecked - Initial checked state.
+ */
+
+/**
+ * @typedef {Object} MultiSelectIo
+ * @property {NodeJS.ReadableStream} [stdin=process.stdin]
+ * @property {NodeJS.WritableStream} [stdout=process.stdout]
+ * @property {boolean} [forceTty] - Override the stdout TTY check
+ *           (test-only). When undefined, falls back to
+ *           `stdout.isTTY`.
+ */
+
+const ANSI_CLEAR_LINE = "\x1b[2K";
+const ANSI_CURSOR_HIDE = "\x1b[?25l";
+const ANSI_CURSOR_SHOW = "\x1b[?25h";
+const DIM = (s) => `\x1b[2m${s}\x1b[0m`;
+const BOLD = (s) => `\x1b[1m${s}\x1b[0m`;
+
+function cursorUp(n) {
+  return n > 0 ? `\x1b[${n}A` : "";
+}
+
+/**
+ * Render the picker line for a single item.
+ * @param {MultiSelectItem} item
+ * @param {boolean} checked
+ * @param {boolean} active     - True if the cursor is on this row.
+ * @param {boolean} useColor
+ */
+function renderRow(item, checked, active, useColor) {
+  const cursor = active ? ">" : " ";
+  const box = checked ? "[x]" : "[ ]";
+  const hint = item.hint ? `  ${useColor ? DIM(item.hint) : item.hint}` : "";
+  const labelPiece = active && useColor ? BOLD(item.label) : item.label;
+  return `${cursor} ${box} ${labelPiece}${hint}`;
+}
+
+/**
+ * Render the full picker frame.
+ * @param {MultiSelectItem[]} items
+ * @param {Set<number>} checked  - Set of indices currently checked.
+ * @param {number} activeIdx     - Cursor row.
+ * @param {boolean} useColor
+ */
+function renderFrame(items, checked, activeIdx, useColor) {
+  const lines = items.map((item, i) =>
+    renderRow(item, checked.has(i), i === activeIdx, useColor),
+  );
+  return lines.join("\n");
+}
+
+/**
+ * Drive the TTY picker. Returns the final array of selected keys.
+ *
+ * @param {string} question
+ * @param {MultiSelectItem[]} items
+ * @param {NodeJS.ReadableStream} stdin
+ * @param {NodeJS.WritableStream} stdout
+ * @returns {Promise<string[]>}
+ */
+function runTtyPicker(question, items, stdin, stdout) {
+  return new Promise((resolve, reject) => {
+    const checked = new Set(
+      items.map((it, i) => (it.preChecked ? i : -1)).filter((i) => i >= 0),
+    );
+    let activeIdx = 0;
+
+    const useColor = !process.env.NO_COLOR;
+    const helpLine = useColor
+      ? DIM("  ↑/↓ move · space toggle · a toggle all · enter confirm")
+      : "  ↑/↓ move · space toggle · a toggle all · enter confirm";
+
+    stdout.write(`  ${question}\n`);
+    stdout.write(`${helpLine}\n`);
+    stdout.write(ANSI_CURSOR_HIDE);
+    let firstRender = true;
+
+    const draw = () => {
+      if (!firstRender) {
+        // Move back up over the previous frame and clear each line
+        // before redrawing. The frame is exactly `items.length` lines.
+        stdout.write(cursorUp(items.length));
+        for (let i = 0; i < items.length; i++) {
+          stdout.write(`${ANSI_CLEAR_LINE}\r`);
+          if (i < items.length - 1) stdout.write("\n");
+        }
+        stdout.write(cursorUp(items.length - 1));
+      }
+      stdout.write(`${renderFrame(items, checked, activeIdx, useColor)}\n`);
+      firstRender = false;
+    };
+
+    draw();
+
+    emitKeypressEvents(stdin);
+    const wasRaw = stdin.isTTY ? stdin.isRaw : false;
+    if (stdin.isTTY) stdin.setRawMode(true);
+    stdin.resume();
+
+    const cleanup = () => {
+      stdin.removeAllListeners("keypress");
+      if (stdin.isTTY) stdin.setRawMode(wasRaw);
+      stdin.pause();
+      stdout.write(ANSI_CURSOR_SHOW);
+    };
+
+    const onKeypress = (str, key) => {
+      if (!key) return;
+
+      // Ctrl-C / Ctrl-D / Esc → cancel. Resolve with reject so the
+      // calling command can exit non-zero rather than silently
+      // returning the pre-checked set. Ctrl-D in raw mode does not
+      // close the stream automatically, so we have to handle it here
+      // or the process hangs.
+      if (
+        (key.ctrl && (key.name === "c" || key.name === "d")) ||
+        key.name === "escape"
+      ) {
+        cleanup();
+        reject(new Error("Multi-select cancelled."));
+        return;
+      }
+
+      if (key.name === "up") {
+        activeIdx = (activeIdx - 1 + items.length) % items.length;
+        draw();
+        return;
+      }
+      if (key.name === "down") {
+        activeIdx = (activeIdx + 1) % items.length;
+        draw();
+        return;
+      }
+      if (key.name === "space" || str === " ") {
+        if (checked.has(activeIdx)) checked.delete(activeIdx);
+        else checked.add(activeIdx);
+        draw();
+        return;
+      }
+      if (key.name === "a") {
+        // Toggle all: if any unchecked, check all; otherwise clear all.
+        const allChecked = items.every((_, i) => checked.has(i));
+        checked.clear();
+        if (!allChecked) {
+          for (let i = 0; i < items.length; i++) checked.add(i);
+        }
+        draw();
+        return;
+      }
+      if (key.name === "return" || key.name === "enter") {
+        cleanup();
+        const picked = items
+          .map((it, i) => (checked.has(i) ? it.key : null))
+          .filter((k) => k !== null);
+        resolve(picked);
+        return;
+      }
+    };
+
+    stdin.on("keypress", onKeypress);
+  });
+}
+
+/**
+ * Drive the non-TTY picker. Renders the list once with check markers,
+ * then reads a single line from stdin. Empty input → pre-checked
+ * defaults; otherwise the input is parsed as a comma-separated list of
+ * keys. An unknown key throws.
+ *
+ * @param {string} question
+ * @param {MultiSelectItem[]} items
+ * @param {NodeJS.ReadableStream} stdin
+ * @param {NodeJS.WritableStream} stdout
+ * @returns {Promise<string[]>}
+ */
+function runNonTtyPicker(question, items, stdin, stdout) {
+  return new Promise((resolve, reject) => {
+    stdout.write(`  ${question}\n`);
+    for (const item of items) {
+      const box = item.preChecked ? "[x]" : "[ ]";
+      const hint = item.hint ? `  ${item.hint}` : "";
+      stdout.write(`  ${box} ${item.key.padEnd(12)} ${item.label}${hint}\n`);
+    }
+    stdout.write(
+      "  Enter comma-separated keys (or empty to accept the pre-checked defaults): ",
+    );
+
+    let buf = "";
+    const onData = (chunk) => {
+      buf += chunk.toString("utf-8");
+      const newlineIdx = buf.search(/\r?\n/);
+      if (newlineIdx === -1) return;
+      stdin.removeListener("data", onData);
+      stdin.removeListener("end", onEnd);
+      stdin.pause();
+      finish(buf.slice(0, newlineIdx));
+    };
+    const onEnd = () => {
+      stdin.removeListener("data", onData);
+      stdin.removeListener("end", onEnd);
+      finish(buf);
+    };
+
+    function finish(line) {
+      const trimmed = line.trim();
+      if (trimmed === "") {
+        resolve(
+          items.filter((it) => it.preChecked).map((it) => it.key),
+        );
+        return;
+      }
+      const requested = trimmed
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+      const validKeys = new Set(items.map((it) => it.key));
+      const unknown = requested.filter((r) => !validKeys.has(r));
+      if (unknown.length > 0) {
+        reject(
+          new Error(
+            `Unknown key(s): ${unknown.join(", ")}. Valid keys: ${
+              [...validKeys].join(", ")
+            }.`,
+          ),
+        );
+        return;
+      }
+      // Dedup while preserving order
+      const seen = new Set();
+      const result = [];
+      for (const key of requested) {
+        if (seen.has(key)) continue;
+        seen.add(key);
+        result.push(key);
+      }
+      resolve(result);
+    }
+
+    stdin.on("data", onData);
+    stdin.on("end", onEnd);
+    stdin.resume();
+  });
+}
+
+/**
+ * Multi-select prompt. TTY mode renders an interactive checkbox list;
+ * non-TTY mode prints the list and reads a comma-separated line.
+ *
+ * @param {object} options
+ * @param {string} options.question  - Prompt question (rendered above the list).
+ * @param {MultiSelectItem[]} options.items
+ * @param {MultiSelectIo} [io]
+ * @returns {Promise<string[]>}  - Selected keys, in declaration order.
+ */
+export async function promptMultiSelect(options, io = {}) {
+  if (!options || typeof options !== "object") {
+    throw new TypeError("promptMultiSelect: options is required");
+  }
+  if (!Array.isArray(options.items) || options.items.length === 0) {
+    throw new TypeError("promptMultiSelect: items must be a non-empty array");
+  }
+  const stdin = io.stdin ?? process.stdin;
+  const stdout = io.stdout ?? process.stdout;
+  const isTty =
+    typeof io.forceTty === "boolean" ? io.forceTty : Boolean(stdout.isTTY);
+
+  if (isTty) {
+    return runTtyPicker(options.question ?? "", options.items, stdin, stdout);
+  }
+  return runNonTtyPicker(options.question ?? "", options.items, stdin, stdout);
+}

package/src/lib/removers/agent-hooks.mjs

@@ -0,0 +1,83 @@
+/**
+ * Cohort SessionStart-hook batch remover (#1240). Pairs with the two
+ * cohort installer mergers under `mergers/agent-hook-{claude,cursor}-shape.mjs`
+ * to satisfy the artifact-registry drift-protection test
+ * (`src/test/lib/artifact-registry.test.mjs`), which requires every
+ * descriptor to map to a remover.
+ *
+ * One file rather than per-vendor removers because:
+ *
+ *   1. The four cohort vendors share a single fingerprint
+ *      (`AGENT_HOOK_FINGERPRINT`), so all per-vendor removers would
+ *      delegate to identical logic.
+ *   2. The dispatch by `agentHook.shape` is already encoded in
+ *      `agent-hook-merge.mjs`; reusing it here keeps the two-shape
+ *      walk in exactly one place.
+ *   3. The uninstall command iterates the registry's
+ *      `kind: "agent-hook"` descriptors and calls this module once per
+ *      descriptor — the file count would otherwise grow with every
+ *      cohort vendor added.
+ *
+ * The artifact-registry CI test maps `removers/agent-hooks.mjs` to the
+ * four `agent-hook-<vendorKey>` descriptor ids via `REMOVER_EXPECTED`;
+ * any drift in that mapping fails CI before the user can run.
+ */
+
+import { uninstallAgentHookFor } from "../agent-hook-merge.mjs";
+import { ARTIFACT_REGISTRY } from "../artifact-registry.mjs";
+
+/**
+ * Remove the cohort hook for a single artifact descriptor. Used by
+ * `commands/uninstall.mjs`'s dispatch loop, which routes any
+ * `kind: "agent-hook"` descriptor here.
+ *
+ * @param {object} descriptor - One entry from `ARTIFACT_REGISTRY` with
+ *        `kind: "agent-hook"`. Must carry `vendorKey`.
+ * @param {object} [options]
+ * @param {boolean} [options.dryRun=false]
+ * @returns {{ path: string; action: "removed" | "would-remove" | "skipped" | "unchanged"; error?: string }}
+ */
+export function removeAgentHookArtifact(descriptor, { dryRun = false } = {}) {
+  if (!descriptor || descriptor.kind !== "agent-hook") {
+    throw new Error(
+      `removeAgentHookArtifact: expected kind="agent-hook", got "${descriptor?.kind}".`,
+    );
+  }
+  if (!descriptor.vendorKey) {
+    throw new Error(
+      `removeAgentHookArtifact: descriptor "${descriptor.id}" missing vendorKey.`,
+    );
+  }
+  return uninstallAgentHookFor(descriptor.vendorKey, { dryRun });
+}
+
+/**
+ * Remove every cohort hook in one call. Convenience wrapper for
+ * `skillrepo uninstall --global` and the standalone session-sync
+ * "disable all" workflow. Iterates all `kind: "agent-hook"` descriptors
+ * in the artifact registry — i.e. every cohort vendor that has an
+ * `agentHook` spec. Idempotent: vendors with no installed hook return
+ * `"skipped"` or `"unchanged"`, never failing.
+ *
+ * @param {object} [options]
+ * @param {boolean} [options.dryRun=false]
+ * @returns {Array<{ id: string; path: string; action: string; error?: string }>}
+ */
+export function removeAllAgentHooks({ dryRun = false } = {}) {
+  const results = [];
+  for (const descriptor of ARTIFACT_REGISTRY) {
+    if (descriptor.kind !== "agent-hook") continue;
+    try {
+      const r = removeAgentHookArtifact(descriptor, { dryRun });
+      results.push({ id: descriptor.id, ...r });
+    } catch (err) {
+      results.push({
+        id: descriptor.id,
+        path: descriptor.displayPath,
+        action: "failed",
+        error: err?.message ?? String(err),
+      });
+    }
+  }
+  return results;
+}

package/src/lib/sync.mjs

@@ -55,13 +55,14 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 
 import { getLibrary } from "./http.mjs";
-import { writeSkillDir, removeSkillDir, cleanupOrphans } from "./file-write.mjs";
 import {
-  globalLastSyncPath,
-  claudeSkillsProject,
-  claudeSkillsGlobal,
-  projectSkillsFallback,
-} from "./paths.mjs";
+  writeSkillDir,
+  removeSkillDir,
+  cleanupOrphans,
+  placementTargetsFor,
+  resolvePlacementDir,
+} from "./file-write.mjs";
+import { globalLastSyncPath } from "./paths.mjs";
 import { diskError, validationError } from "./errors.mjs";
 
 /**
@@ -311,21 +312,19 @@ export async function runSync(options) {
  * per target.
  */
 function isAnyTargetPresent(skillName, options) {
-  if (options.global) {
-    return existsSync(claudeSkillsGlobal(skillName));
-  }
   if (!Array.isArray(options.vendors) || options.vendors.length === 0) {
     return false;
   }
-  if (options.vendors.includes("claudeCode")) {
-    if (existsSync(claudeSkillsProject(skillName))) return true;
-  }
-  if (
-    options.vendors.includes("cursor") ||
-    options.vendors.includes("windsurf") ||
-    options.vendors.includes("vscode")
-  ) {
-    if (existsSync(projectSkillsFallback(skillName))) return true;
+  let targets;
+  try {
+    targets = placementTargetsFor({
+      vendors: options.vendors,
+      global: !!options.global,
+    });
+  } catch {
+    return false;
   }
-  return false;
+  return targets.some((target) =>
+    existsSync(resolvePlacementDir(target, skillName)),
+  );
 }

package/src/test/commands/add.test.mjs

@@ -152,15 +152,30 @@ describe("runAdd — happy path", () => {
     assert.ok(dir.startsWith(process.env.HOME));
   });
 
-  it("--ide cursor writes to the project /skills/ fallback", async () => {
+  it("--agent cursor writes to .agents/skills/", async () => {
     server.setSkillResponse("alice", "pdf-helper", makeSkill("alice", "pdf-helper"));
     await runAdd(
-      ["--key", VALID_KEY, "--url", serverUrl, "--ide", "cursor", "@alice/pdf-helper"],
+      ["--key", VALID_KEY, "--url", serverUrl, "--agent", "cursor", "@alice/pdf-helper"],
       { stdout },
     );
-    const dir = resolvePlacementDir("projectFallback", "pdf-helper");
+    const dir = resolvePlacementDir("agentsProject", "pdf-helper");
     assert.ok(existsSync(dir));
   });
+
+  it("rejects --agent none with a validation error (no targets to write)", async () => {
+    server.setSkillResponse("alice", "pdf-helper", makeSkill("alice", "pdf-helper"));
+    await assert.rejects(
+      () =>
+        runAdd(
+          ["--key", VALID_KEY, "--url", serverUrl, "--agent", "none", "@alice/pdf-helper"],
+          { stdout },
+        ),
+      (err) =>
+        err instanceof CliError &&
+        err.exitCode === EXIT_VALIDATION &&
+        /--agent none has no effect on `skillrepo add`/.test(err.message),
+    );
+  });
 });
 
 describe("runAdd — error paths", () => {

package/src/test/commands/init-picker.test.mjs

@@ -0,0 +1,144 @@
+/**
+ * Unit tests for init.mjs's picker-row helpers (#1252 QA round —
+ * coverage gap: "(already configured — re-checking will refresh)"
+ * annotation).
+ *
+ * Why a separate file: init.test.mjs is the integration test for
+ * `runInit` — it spins up a mock server and the full credential +
+ * detection + picker + sync pipeline. The annotation lives in two
+ * pure helpers (`formatHint`, `directoryHasContent`) that don't need
+ * any of that — direct unit tests are cheaper and lock the exact
+ * string and state semantics the picker renders.
+ *
+ * Coverage goals:
+ *   1. The annotation string is the literal phrase the picker shows
+ *      to the user. A future refactor that paraphrases it (e.g.
+ *      "(re-running will refresh)") must fail this test.
+ *   2. The "(not detected — leave checked if you use one)" fallback
+ *      is the wording change the v3.1.x copy review settled on,
+ *      replacing the older "(no signal — opt in if you use one)".
+ *      Pinning the current wording keeps that decision visible.
+ *   3. directoryHasContent treats missing, empty, and populated
+ *      directories with the three states the picker layer assumes.
+ */
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { directoryHasContent, formatHint } from "../../commands/init.mjs";
+
+let sandbox;
+
+function setupSandbox() {
+  sandbox = mkdtempSync(join(tmpdir(), "cli-init-picker-"));
+}
+
+function teardownSandbox() {
+  if (sandbox) rmSync(sandbox, { recursive: true, force: true });
+  sandbox = undefined;
+}
+
+// ── formatHint ──────────────────────────────────────────────────────────
+
+describe("formatHint — already-configured annotation", () => {
+  it("includes the annotation when alreadyConfigured is true and a detection reason fired", () => {
+    const hint = formatHint({
+      detectionReason: "CLAUDECODE=1",
+      pathLabel: ".claude/skills/",
+      alreadyConfigured: true,
+    });
+    // The annotation is the load-bearing string here — the QA round
+    // flagged that init.mjs:846 had this phrase and zero coverage.
+    // Match the literal so a copy edit forces an explicit test
+    // update.
+    assert.match(
+      hint,
+      /\(already configured — re-checking will refresh\)/,
+    );
+    // The detection reason still renders alongside the annotation.
+    assert.match(hint, /\(detected: CLAUDECODE=1\)/);
+    // Path label leads the hint (rendering invariant the picker UI
+    // depends on for column alignment).
+    assert.ok(hint.startsWith(".claude/skills/"), `hint should start with path label, got "${hint}"`);
+  });
+
+  it("does NOT include the annotation when alreadyConfigured is false but a detection reason fired", () => {
+    const hint = formatHint({
+      detectionReason: ".cursor/",
+      pathLabel: ".agents/skills/",
+      alreadyConfigured: false,
+    });
+    assert.match(hint, /\(detected: \.cursor\/\)/);
+    // Negative assertion: the annotation must not appear.
+    assert.doesNotMatch(hint, /already configured/);
+  });
+
+  it("returns the no-signal fallback when alreadyConfigured is false and no detection reason fired", () => {
+    const hint = formatHint({
+      detectionReason: null,
+      pathLabel: ".claude/skills/",
+      alreadyConfigured: false,
+    });
+    // The fallback was reworded in the v3.1.x copy review from
+    // "(no signal — opt in if you use one)" to the current text.
+    // Match the live wording so a future revert is caught here.
+    assert.match(
+      hint,
+      /\(not detected — leave checked if you use one\)/,
+    );
+    assert.doesNotMatch(hint, /already configured/);
+  });
+
+  it("returns the no-signal fallback PLUS the annotation when alreadyConfigured is true and no detection fired", () => {
+    // This is the genuine "user already has skills written here from
+    // a prior run, but no live detection signal" case. The picker
+    // should still annotate the row so the user understands a
+    // re-check refreshes the existing target.
+    const hint = formatHint({
+      detectionReason: null,
+      pathLabel: ".agents/skills/",
+      alreadyConfigured: true,
+    });
+    assert.match(hint, /\(not detected — leave checked if you use one\)/);
+    assert.match(hint, /\(already configured — re-checking will refresh\)/);
+  });
+});
+
+// ── directoryHasContent ─────────────────────────────────────────────────
+
+describe("directoryHasContent", () => {
+  beforeEach(setupSandbox);
+  afterEach(teardownSandbox);
+
+  it("returns false for a path that does not exist", () => {
+    // Use join() so the absent path is platform-correct (Windows
+    // forward-slashes are tolerated by node:fs but not idiomatic).
+    const missing = join(sandbox, "does-not-exist", "ghost");
+    assert.equal(directoryHasContent(missing), false);
+  });
+
+  it("returns false for an existing but empty directory", () => {
+    const emptyDir = join(sandbox, "empty");
+    mkdirSync(emptyDir, { recursive: true });
+    assert.equal(directoryHasContent(emptyDir), false);
+  });
+
+  it("returns true for a directory containing a file", () => {
+    const dir = join(sandbox, "has-file");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "marker.txt"), "x");
+    assert.equal(directoryHasContent(dir), true);
+  });
+
+  it("returns true for a directory containing a subdirectory", () => {
+    // A previous init writes <root>/<skill-name>/SKILL.md, so the
+    // typical "already configured" signal is a child directory, not
+    // a child file at the root.
+    const dir = join(sandbox, "has-subdir");
+    mkdirSync(join(dir, "pdf-helper"), { recursive: true });
+    assert.equal(directoryHasContent(dir), true);
+  });
+});