@lifeaitools/rdc-skills 0.35.14 → 0.35.16

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "rdc",
-  "version": "0.35.14",
+  "version": "0.35.16",
   "description": "RDC typed-agent dispatch skill suite for Claude Code — plan, build, review, overnight unattended builds with work-item tracking and TDD enforcement.",
   "author": {
     "name": "LIFEAI",

package/hooks/foreground-process-gate.js

@@ -25,6 +25,33 @@
  */
 const hookLog = require('./hook-logger');
 
+/**
+ * The mitigator — OPTIONAL, because this hook crosses a repo boundary.
+ *
+ * EVERY BLOCK ROUTES THROUGH THE MITIGATOR (operator: "any block"). Audited
+ * 2026-08-30: 9 PreToolUse hooks wired, only the two guard dispatchers called
+ * mitigate(), so seven families refused with no repeat count and no
+ * classification — the signal that caught rtp-steering-grep being wrong in
+ * BOTH directions.
+ *
+ * This file ships in rdc-skills and installs to ~/.claude/hooks. The mitigator
+ * lives in lifeai-env, which is a SEPARATE repo that a consumer of this package
+ * may not have. So the import is best-effort and its absence is not an error:
+ * the block still lands, it simply arrives unannotated. A refusal that depended
+ * on a sibling repo being installed would be worse than no annotation at all.
+ */
+let mitigator = null;
+async function loadMitigator() {
+  try {
+    const path = require('node:path');
+    const fs = require('node:fs');
+    const envRoot = process.env.LIFEAI_ENV || 'C:/Dev/lifeai-env';
+    const file = path.join(envRoot, 'hooks', 'lib', 'guard-mitigator.mjs');
+    if (!fs.existsSync(file)) return;          // no lifeai-env here — that is fine
+    mitigator = await import(require('node:url').pathToFileURL(file).href);
+  } catch { /* annotation is never load-bearing */ }
+}
+
 function readStdin() {
   return new Promise((resolve) => {
     let input = '';
@@ -37,8 +64,28 @@ function readStdin() {
 
 function block(message, details = {}) {
   hookLog('foreground-process-gate', 'PreToolUse', 'block', details);
+
+  let mitigation = '';
+  try {
+    if (mitigator) {
+      // details.kind already distinguishes the two refusals, so the rule id is
+      // taken from it rather than parsed out of the message — guard-mitigator
+      // keys on (rule id, argv shape) and explicitly forbids reading wording.
+      mitigation = mitigator.mitigationLine(mitigator.mitigate(
+        {
+          rule: `foreground-process-gate-${details.kind || 'unknown'}`,
+          cmd: blockSubject,
+          cwd: process.cwd(),
+          dir: mitigator.blockLedgerDir(),
+          sessionId: process.env.LIFEAI_SESSION_ID,
+        },
+        { evaluate: null },   // a headed-browser refusal has no command to re-evaluate
+      ));
+    }
+  } catch { /* annotation is never load-bearing */ }
+
   process.stdout.write(JSON.stringify({
-    systemMessage: `HARD BLOCK — Foreground process launch rejected.\n\n${message}`,
+    systemMessage: `HARD BLOCK — Foreground process launch rejected.\n\n${message}${mitigation ? `\n\n${mitigation}` : ''}`,
   }));
   process.exit(1);
 }
@@ -72,12 +119,20 @@ function checkPlaywright(command) {
   }
 }
 
+let blockSubject = '';
+
 async function main() {
   let raw;
   try { raw = JSON.parse(await readStdin()); } catch { process.exit(0); }
   const command = toolText(raw);
   if (!command) pass({ reason: 'no-command' });
 
+  // Preload BEFORE any check can block, so block() stays synchronous. The
+  // subject is the command itself, so repeated attempts at the SAME shape
+  // register as repeats rather than as unrelated events.
+  await loadMitigator();
+  blockSubject = command;
+
   checkPlaywright(command);
 
   pass({ reason: 'clean' });

package/hooks/require-work-item-on-commit.js

@@ -53,6 +53,54 @@ const os        = require('os');
 const { execFileSync } = require('child_process');
 const hookLog   = require('./hook-logger');
 
+/**
+ * The mitigator — OPTIONAL, because this hook crosses a repo boundary.
+ *
+ * EVERY BLOCK ROUTES THROUGH THE MITIGATOR (operator: "any block"). Audited
+ * 2026-08-30: 9 PreToolUse hooks wired, only the two guard dispatchers called
+ * mitigate(), so seven families refused with no repeat count and no
+ * classification.
+ *
+ * This file is the reason that matters most. Its unreadable-message refusal
+ * fired TWICE in one session on `git commit -F "$SP/msg.txt"` — a path the
+ * check cannot resolve because it holds a shell variable, not because anything
+ * was wrong with the message. Two identical refusals, no repeat count, nothing
+ * to distinguish "you keep doing this" from "this rule keeps being wrong". That
+ * is exactly the signal the mitigator exists to raise, and this hook could not
+ * raise it.
+ *
+ * Ships in rdc-skills and installs to ~/.claude/hooks, where lifeai-env may not
+ * exist, so the import is best-effort and its absence is not an error.
+ */
+let mitigator = null;
+let blockSubject = '';
+async function loadMitigator() {
+  try {
+    const envRoot = process.env.LIFEAI_ENV || 'C:/Dev/lifeai-env';
+    const file = path.join(envRoot, 'hooks', 'lib', 'guard-mitigator.mjs');
+    if (!fs.existsSync(file)) return;          // no lifeai-env here — that is fine
+    mitigator = await import(require('node:url').pathToFileURL(file).href);
+  } catch { /* annotation is never load-bearing */ }
+}
+
+/** One emit path for both refusals, so an annotation cannot be added to one and forgotten on the other. */
+function denyWith(rule, reason) {
+  let mitigation = '';
+  try {
+    if (mitigator) {
+      mitigation = mitigator.mitigationLine(mitigator.mitigate(
+        { rule, cmd: blockSubject, cwd: process.cwd(), dir: mitigator.blockLedgerDir(), sessionId: process.env.LIFEAI_SESSION_ID },
+        { evaluate: null },   // a commit-message refusal has no command to re-evaluate
+      ));
+    }
+  } catch { /* annotation is never load-bearing */ }
+  process.stdout.write(JSON.stringify({
+    decision: 'block',
+    reason: mitigation ? `${reason}\n\n${mitigation}` : reason,
+  }));
+  return process.exit(0);
+}
+
 const MARKER_FILE = path.join(
   process.env.USERPROFILE || process.env.HOME || os.homedir(),
   '.claude',
@@ -330,14 +378,13 @@ async function preToolUse(raw) {
   // for the wrong thing.
   if (!readable) {
     hookLog('require-work-item', 'PreToolUse', 'block-unreadable', {});
-    process.stdout.write(JSON.stringify({
-      decision: 'block',
-      reason: '⛔ [require-work-item] The commit message arrives on stdin, so this check cannot read it '
+    return denyWith(
+      'require-work-item-unreadable',
+      '⛔ [require-work-item] The commit message arrives on stdin, so this check cannot read it '
         + 'and will not guess. Nothing is wrong with your message — it is unverifiable from here. '
         + 'Re-run with the message where the check can see it: `git commit -F <path>` (a file), '
         + 'a heredoc (`git commit -F - <<\'EOF\' … EOF`), or `-m "<type>(<scope>): …"`.',
-    }));
-    return process.exit(0);
+    );
   }
 
   if (CONVENTIONAL_TYPES.test(msg.trim()) || UUID_PATTERN.test(msg) || ISSUE_REF.test(msg)) {
@@ -349,14 +396,13 @@ async function preToolUse(raw) {
   // or none declared at all) requires a work item and none was referenced —
   // this used to print a sentence and let the commit through regardless.
   hookLog('require-work-item', 'PreToolUse', 'block', { msg: msg.slice(0, 80) });
-  process.stdout.write(JSON.stringify({
-    decision: 'block',
-    reason: '⛔ [require-work-item] No work item reference or conventional commit type, and the current '
+  return denyWith(
+    'require-work-item',
+    '⛔ [require-work-item] No work item reference or conventional commit type, and the current '
       + 'flow requires one (build/refactor/overnight, or no flow declared). Add a Work-Item UUID or '
       + '#issue ref to the message, use fix(<scope>): ..., or declare a flow that does not need one '
       + '(rdc-flow.mjs: plan/design/collab) if this genuinely ships no trackable work.',
-  }));
-  return process.exit(0);
+  );
 }
 
 // ---------------------------------------------------------------------------
@@ -375,6 +421,12 @@ async function main() {
   let raw;
   try { raw = JSON.parse(input); } catch { return process.exit(0); }
 
+  // Preload BEFORE any refusal can fire, so denyWith() stays synchronous. The
+  // subject is the command, so repeated refusals of the SAME shape register as
+  // repeats — which is the whole point for this hook in particular.
+  await loadMitigator();
+  blockSubject = String(raw?.tool_input?.command || '');
+
   const event = raw.hook_event_name || raw.hookEventName || 'PreToolUse';
 
   if (event === 'PostToolUse') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifeaitools/rdc-skills",
-  "version": "0.35.14",
+  "version": "0.35.16",
   "description": "RDC typed-agent dispatch skill suite for Claude Code - plan, build, review, overnight builds",
   "keywords": [
     "claude-code",
@@ -45,7 +45,7 @@
     "rdc-design": "node scripts/rdc-design-cli.mjs",
     "test:hooks": "node scripts/test-rdc-hooks.mjs",
     "test:truth-gate": "node tests/run-evidence-gate.test.mjs && node tests/work-item-exit-gate-l2.test.mjs && node tests/work-item-exit-gate-l3.test.mjs && node tests/require-work-item-on-commit.test.mjs && node tests/harness-gates.test.mjs && node tests/foreground-process-gate.test.mjs",
-    "test:acceptance": "node tests/acceptance.test.mjs && node tests/install-rdc-skills.test.mjs && node tests/help-surface.test.mjs && node tests/manifest-contract-fields.test.mjs && node tests/plugin-namespace-names.test.mjs && node tests/skill-test-matrix.test.mjs && node tests/completion-gate-supervisor-admission.test.mjs && node tests/curl-surface.test.mjs && node tests/clauth-plugin-postinstall.test.mjs",
+    "test:acceptance": "node tests/acceptance.test.mjs && node tests/install-rdc-skills.test.mjs && node tests/help-surface.test.mjs && node tests/manifest-contract-fields.test.mjs && node tests/plugin-namespace-names.test.mjs && node tests/skill-test-matrix.test.mjs && node tests/completion-gate-supervisor-admission.test.mjs && node tests/curl-surface.test.mjs && node tests/clauth-plugin-postinstall.test.mjs && node tests/install-duplicate-purge.test.mjs",
     "acceptance": "node scripts/acceptance.mjs --changed",
     "test:mcp": "node tests/mcp.test.mjs",
     "test:mcp:remote": "node tests/mcp.test.mjs --remote",

package/scripts/install-rdc-skills.js

@@ -369,11 +369,96 @@ function buildPluginCache(cacheDir, version, gitSha) {
   }
 }
 
+// ── Is this entry a duplicate of a skill WE ship? ─────────────────────────────
+//
+// THE PREDICATE THIS REPLACES WAS DEAD. It removed an entry only when its
+// frontmatter name startsWith('rdc:'). Skills were later renamed to bare names
+// (`name: build`, not `name: rdc:build`) — the same rename the marketplace-sync
+// comment below refers to when it describes "/rdc:rdc:plan" appearing beside
+// "/rdc:plan". Measured 2026-08-30: 0 of 44 shipped skills carry an rdc: prefix.
+// So the purge matched nothing, removed nothing, and reported 0 while duplicate
+// registrations kept accumulating. Nothing failed loudly, because a purge that
+// finds nothing and a purge that cannot match anything print the same number.
+//
+// The replacement never keys on a prefix. It asks three independent questions,
+// any one of which is sufficient:
+//
+//   1. LEGACY NAME — the old rdc: prefix, kept so pre-rename installs still get
+//      cleaned. Dropping it would strand exactly the machines this function was
+//      written for.
+//   2. SYMLINK INTO OUR OWN PACKAGE — if the entry resolves to a file inside this
+//      package's skills/ tree, it IS our file, wearing a second name. That is
+//      unambiguous and survives any future rename.
+//   3. SHIPPED NAME + OUR MARKER — the name matches one we ship AND the body
+//      carries the output-contract line every rdc skill opens with. Name alone
+//      is deliberately NOT enough: a user skill legitimately called "build" must
+//      survive, and on this machine ~/.claude/skills holds clauth, coolify-*,
+//      leaflet-maps and notebooklm — none of which may ever be touched.
+//
+// Signal 3 covers 43 of 44 shipped skills; behavior-audit lacks the marker and
+// is caught by signal 2 when symlinked. A skill that is neither symlinked nor
+// marked is deliberately left alone — under-removing is recoverable, deleting a
+// user's own work is not.
+let _shippedSkillNames = null;
+function shippedSkillNames() {
+  if (_shippedSkillNames) return _shippedSkillNames;
+  _shippedSkillNames = new Set();
+  const dir = path.join(repoRoot, 'skills');
+  try {
+    for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (!e.isDirectory()) continue;
+      _shippedSkillNames.add(e.name);
+      for (const sf of ['SKILL.md', 'skill.md']) {
+        const p = path.join(dir, e.name, sf);
+        if (fs.existsSync(p)) {
+          const fm = readFrontmatter(p);
+          if (fm.name) _shippedSkillNames.add(fm.name);
+          break;
+        }
+      }
+    }
+  } catch { /* no skills/ dir — every check below simply returns false */ }
+  return _shippedSkillNames;
+}
+
+const RDC_SKILL_MARKER = 'guides/output-contract.md';
+
+function resolvesInsideOurSkills(candidate) {
+  try {
+    const real = fs.realpathSync(candidate);
+    const ours = fs.realpathSync(path.join(repoRoot, 'skills'));
+    const rel = path.relative(ours, real);
+    return rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel);
+  } catch {
+    return false;
+  }
+}
+
+function isRdcSkillDuplicate(candidate, skillFile) {
+  const fm = readFrontmatter(skillFile);
+
+  // 1. legacy rdc: prefix — pre-rename installs
+  if (fm.name && fm.name.startsWith('rdc:')) return true;
+
+  // 2. it literally is our file, reached by another path
+  if (resolvesInsideOurSkills(candidate)) return true;
+
+  // 3. our name AND our marker — both, never name alone
+  if (fm.name && shippedSkillNames().has(fm.name)) {
+    try {
+      if (fs.readFileSync(skillFile, 'utf8').includes(RDC_SKILL_MARKER)) return true;
+    } catch { /* unreadable → not a duplicate we are confident about */ }
+  }
+
+  return false;
+}
+
 // ── User-skills cleanup ───────────────────────────────────────────────────────
 // Older installer versions wrote skill files directly to ~/.claude/skills/user/.
 // Claude Code loads that directory AND the plugin cache, so any rdc skills left
 // there produce duplicate registrations and break the resolver.
-// This function nukes any entry whose frontmatter name starts with "rdc:".
+// It delegates to isRdcSkillDuplicate() above — a prefix test alone has not
+// matched anything since skills were renamed to bare names.
 // Scans BOTH the immediate dir and nested .md files (e.g. `user/skill.md`,
 // `user/rdc-build/SKILL.md`) so pre-plugin orphans are caught regardless of
 // naming convention.
@@ -390,8 +475,7 @@ function cleanUserSkills(userSkillsDir) {
         if (fs.existsSync(p)) { skillFile = p; break; }
       }
       if (!skillFile) continue;
-      const fm = readFrontmatter(skillFile);
-      if (fm.name && fm.name.startsWith('rdc:')) {
+      if (isRdcSkillDuplicate(candidate, skillFile)) {
         try { fs.rmSync(candidate, { recursive: true, force: true }); removed++; } catch {}
       }
     } else if (entry.isFile() && entry.name.endsWith('.md')) {
@@ -399,8 +483,7 @@ function cleanUserSkills(userSkillsDir) {
       // if their frontmatter declares an rdc:* skill. A previous version skipped
       // those names; that left an orphan rdc:build copy at user/skill.md which
       // registered as a duplicate "user" skill.
-      const fm = readFrontmatter(candidate);
-      if (fm.name && fm.name.startsWith('rdc:')) {
+      if (isRdcSkillDuplicate(candidate, candidate)) {
         try { fs.unlinkSync(candidate); removed++; } catch {}
       }
     }
@@ -417,8 +500,7 @@ function cleanGlobalSkillsRoot(skillsDir) {
     if (entry.name === 'user') continue; // handled separately
     const candidate = path.join(skillsDir, entry.name);
     if (entry.isFile() && entry.name.endsWith('.md')) {
-      const fm = readFrontmatter(candidate);
-      if (fm.name && fm.name.startsWith('rdc:')) {
+      if (isRdcSkillDuplicate(candidate, candidate)) {
         try { fs.unlinkSync(candidate); removed++; } catch {}
       }
     }
@@ -797,8 +879,7 @@ function registerCodexTarget(targetDir) {
       fs.rmSync(candidate, { recursive: true, force: true });
       removed++;
     } else {
-      const fm = readFrontmatter(path.join(candidate, 'SKILL.md'));
-      if (fm.name && fm.name.startsWith('rdc:')) {
+      if (isRdcSkillDuplicate(candidate, path.join(candidate, 'SKILL.md'))) {
         fs.rmSync(candidate, { recursive: true, force: true });
         removed++;
       }
@@ -1331,8 +1412,11 @@ async function main() {
             ? ['SKILL.md','skill.md'].map(s => path.join(p, s)).find(fs.existsSync)
             : (f.endsWith('.md') ? p : null);
           if (!skillFile) return false;
-          const fm = readFrontmatter(skillFile);
-          return fm.name && fm.name.startsWith('rdc:');
+          // Must use the SAME predicate the purge uses. When this asked a
+          // different (and dead) question, the purge removed nothing and this
+          // confirmed nothing was left — the two agreed, and agreement between
+          // a broken fix and a broken check is indistinguishable from success.
+          return isRdcSkillDuplicate(p, skillFile);
         })
       : [];
     if (stillThere.length === 0) {
@@ -1385,7 +1469,7 @@ async function main() {
 // scripts/probe-installed-hooks.mjs verify the real install path instead of
 // re-implementing it — a probe that copies its own way proves nothing about what
 // ships. Without this guard, requiring the module would run a full install.
-module.exports = { copyHookFiles, assertHooksLoadable, registerCodexTarget, syncMarketplaceCheckout, RDC_ENV_HOOK_TIMEOUT_SEC };
+module.exports = { copyHookFiles, assertHooksLoadable, registerCodexTarget, syncMarketplaceCheckout, RDC_ENV_HOOK_TIMEOUT_SEC, isRdcSkillDuplicate, cleanUserSkills, cleanGlobalSkillsRoot, shippedSkillNames };
 
 if (require.main === module) {
   main().catch(e => { fail(e.message); process.exit(1); });

package/tests/install-duplicate-purge.test.mjs

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+/**
+ * The duplicate-skill purge — the predicate, not the plumbing.
+ *
+ * cleanUserSkills() and cleanGlobalSkillsRoot() removed an entry only when its
+ * frontmatter name startsWith('rdc:'). Skills were later renamed to bare names
+ * (`name: build`), and measured 2026-08-30 exactly 0 of 44 shipped skills carry
+ * an rdc: prefix. So the purge matched nothing and removed nothing, while
+ * reporting 0 — indistinguishable from "there was nothing to remove".
+ *
+ * The first test below is the one that was failing in production and could not
+ * fail here, because nothing asserted the bare-name case. The rest exist so the
+ * fix cannot over-reach: a user's own skill must survive even when it shares a
+ * name with one we ship.
+ */
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+import { existsSync, mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(__dirname, '..');
+const require = createRequire(import.meta.url);
+const { isRdcSkillDuplicate, cleanUserSkills, cleanGlobalSkillsRoot, shippedSkillNames } =
+  require(join(REPO_ROOT, 'scripts', 'install-rdc-skills.js'));
+
+const MARKER = 'guides/output-contract.md';
+let sandbox;
+function fresh() {
+  sandbox = mkdtempSync(join(tmpdir(), 'rdc-purge-'));
+  return sandbox;
+}
+function skillDir(root, name, body) {
+  const d = join(root, name);
+  mkdirSync(d, { recursive: true });
+  writeFileSync(join(d, 'SKILL.md'), body);
+  return d;
+}
+function fm(name, extra = '') {
+  return `---\nname: ${name}\ndescription: test fixture\n---\n\n${extra}\n`;
+}
+
+// ── 0. the shipped set is real, not empty ────────────────────────────────────
+// If this is empty every other assertion below passes vacuously.
+const shipped = shippedSkillNames();
+assert.ok(shipped.size > 10, `shippedSkillNames() returned ${shipped.size} — too few to be real`);
+assert.ok(shipped.has('build'), 'expected "build" among shipped skill names');
+
+// ── 1. THE REGRESSION: a bare-named copy of a skill we ship is a duplicate ───
+// This is precisely what the old startsWith('rdc:') predicate could not see.
+{
+  const root = fresh();
+  const d = skillDir(root, 'build', fm('build', `> OUTPUT CONTRACT: \`${MARKER}\``));
+  assert.equal(isRdcSkillDuplicate(d, join(d, 'SKILL.md')), true,
+    'a bare-named copy of a shipped skill must be detected as a duplicate');
+  const removed = cleanUserSkills(root);
+  assert.equal(removed, 1, 'cleanUserSkills should remove exactly the duplicate');
+  assert.equal(existsSync(d), false, 'the duplicate directory should be gone');
+  rmSync(root, { recursive: true, force: true });
+}
+
+// ── 2. legacy rdc:-prefixed entries still get cleaned ────────────────────────
+// Pre-rename installs are the machines this function was originally written for.
+{
+  const root = fresh();
+  const d = skillDir(root, 'rdc-build', fm('rdc:build'));
+  assert.equal(isRdcSkillDuplicate(d, join(d, 'SKILL.md')), true, 'legacy rdc: prefix must still match');
+  assert.equal(cleanUserSkills(root), 1);
+  assert.equal(existsSync(d), false);
+  rmSync(root, { recursive: true, force: true });
+}
+
+// ── 3. SAFETY: a user's own skill with an unrelated name survives ────────────
+{
+  const root = fresh();
+  const d = skillDir(root, 'leaflet-maps', fm('leaflet-maps'));
+  assert.equal(isRdcSkillDuplicate(d, join(d, 'SKILL.md')), false);
+  assert.equal(cleanUserSkills(root), 0, 'must not touch a user skill');
+  assert.equal(existsSync(d), true, "the user's own skill must survive");
+  rmSync(root, { recursive: true, force: true });
+}
+
+// ── 4. SAFETY: a shipped NAME alone is not enough to delete ──────────────────
+// Someone may legitimately write their own skill called "build". Name plus our
+// marker is required; name alone must never be sufficient.
+{
+  const root = fresh();
+  const d = skillDir(root, 'build', fm('build', 'my own build skill, nothing to do with rdc'));
+  assert.equal(isRdcSkillDuplicate(d, join(d, 'SKILL.md')), false,
+    'shipped name WITHOUT our marker must not be treated as ours');
+  assert.equal(cleanUserSkills(root), 0);
+  assert.equal(existsSync(d), true);
+  rmSync(root, { recursive: true, force: true });
+}
+
+// ── 5. a symlink into our own skills/ tree is unambiguously ours ─────────────
+// Skipped where the platform refuses symlink creation without privileges; the
+// skip is loud, so it can never be mistaken for a pass.
+{
+  const root = fresh();
+  const target = join(REPO_ROOT, 'skills', 'build');
+  let made = true;
+  try { symlinkSync(target, join(root, 'build'), 'junction'); }
+  catch { made = false; }
+  if (made) {
+    assert.equal(isRdcSkillDuplicate(join(root, 'build'), join(root, 'build', 'SKILL.md')), true,
+      'a symlink resolving inside our skills/ tree must be detected');
+  } else {
+    console.log('  SKIP symlink case — platform refused symlink creation');
+  }
+  rmSync(root, { recursive: true, force: true });
+}
+
+// ── 6. cleanGlobalSkillsRoot: flat .md orphans at the top level ─────────────
+{
+  const root = fresh();
+  const flat = join(root, 'build.md');
+  writeFileSync(flat, fm('build', `> OUTPUT CONTRACT: \`${MARKER}\``));
+  const mine = join(root, 'coolify-verify.md');
+  writeFileSync(mine, fm('coolify-verify'));
+  const removed = cleanGlobalSkillsRoot(root);
+  assert.equal(removed, 1, 'exactly the rdc orphan should go');
+  assert.equal(existsSync(flat), false, 'flat rdc orphan should be removed');
+  assert.equal(existsSync(mine), true, "the user's own flat skill must survive");
+  rmSync(root, { recursive: true, force: true });
+}
+
+// ── 7. absent directory is not an error ──────────────────────────────────────
+assert.equal(cleanUserSkills(join(tmpdir(), 'rdc-purge-does-not-exist')), 0);
+assert.equal(cleanGlobalSkillsRoot(join(tmpdir(), 'rdc-purge-does-not-exist')), 0);
+
+console.log('install-rdc-skills duplicate-purge test — PASS');