@boyingliu01/xp-gate 0.31.4 → 0.32.0

package/lib/__tests__/doctor-tui-skill-freshness.test.js

@@ -154,3 +154,143 @@ describe('doctor-tui skill freshness (#439)', () => {
     expect(missing, `skills missing version frontmatter: ${missing.join(', ')}`).toEqual([]);
   });
 });
+
+/**
+ * @test REQ-635
+ * @intent doctor 的 "Installed skills" 检查从 config.installedSkills 取清单，
+ *         而 xp-gate init 从不写该字段，导致全新安装的机器（12/12 技能已部署）
+ *         稳定报 "No skills installed" 并在读盘前就返回；同时只解析单一平台，
+ *         init 实际部署的另外两个平台（含 .dsh）从不校验（#635）
+ * @covers AC-635-01, AC-635-02, AC-635-03
+ */
+describe('doctor-tui installed skills enumerate the filesystem (#635)', () => {
+  let tmpHome;
+  let originalHome;
+
+  // Same dir doctor-tui resolves as PKG_DIR (path.dirname of lib/). Re-declared
+  // here because the outer describe's copy is scoped to that callback.
+  const bundledSkillsDir = path.join(__dirname, '..', '..', 'skills');
+
+  // Every directory init deploys to. `.dsh` is the one detectPlatform() cannot
+  // report, and the one that went unverified entirely.
+  const DEPLOY_DIRS = [
+    ['opencode', ['.config', 'opencode', 'skills']],
+    ['dsh', ['.dsh', 'skills']],
+    ['qoder', ['.qoder', 'skills']],
+  ];
+
+  beforeEach(() => {
+    originalHome = process.env.HOME;
+    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'xpgate-635-'));
+    process.env.HOME = tmpHome;
+    vi.resetModules();
+    delete require.cache[require.resolve('../doctor-tui')];
+    delete require.cache[require.resolve('../shared-paths')];
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    fs.rmSync(tmpHome, { recursive: true, force: true });
+  });
+
+  /** Deploy a real bundled skill into one platform's skills dir. */
+  function deploy(platformDirs, name) {
+    const dir = path.join(tmpHome, ...platformDirs, name);
+    fs.mkdirSync(dir, { recursive: true });
+    const bundled = fs.readFileSync(path.join(bundledSkillsDir, name, 'SKILL.md'), 'utf8');
+    fs.writeFileSync(path.join(dir, 'SKILL.md'), bundled);
+  }
+
+  // AC-635-01: a machine with skills deployed and NO installedSkills config key
+  // must be verified, not reported as "No skills installed".
+  it('verifies deployed skills even when config.installedSkills is absent', () => {
+    deploy(['.config', 'opencode', 'skills'], 'grilling');
+    const { diagnoseInstalledSkills } = require('../doctor-tui');
+    const checks = [];
+    // init writes exactly this shape: no installedSkills key at all.
+    const issues = diagnoseInstalledSkills({ mode: 'global', templateDir: '/x' }, checks);
+
+    expect(issues).toBe(0);
+    const skills = checks.filter(c => c.name.startsWith('Skill '));
+    expect(skills.length).toBeGreaterThan(0);
+    expect(skills.every(c => c.status === 'PASS')).toBe(true);
+    // The old behaviour: a single SKIP row and zero skills examined.
+    expect(checks.find(c => c.name === 'Installed skills')).toBeUndefined();
+  });
+
+  // AC-635-02: `.dsh` is a first-class deploy target and must be checked, even
+  // though detectPlatform() never returns 'dsh'.
+  it('checks the .dsh platform, which detectPlatform() cannot report', () => {
+    deploy(['.dsh', 'skills'], 'grilling');
+    const { diagnoseInstalledSkills } = require('../doctor-tui');
+    const checks = [];
+    diagnoseInstalledSkills({ mode: 'global' }, checks);
+
+    const dshRows = checks.filter(c => c.name.startsWith('Skill [dsh]'));
+    expect(dshRows.length).toBeGreaterThan(0);
+    expect(dshRows[0].status).toBe('PASS');
+  });
+
+  // AC-635-03: all deployed platforms are verified in one run, not just the
+  // one detectPlatform() happens to pick.
+  it('verifies every deployed platform, not only the detected one', () => {
+    for (const [, dirs] of DEPLOY_DIRS) deploy(dirs, 'grilling');
+    const { diagnoseInstalledSkills } = require('../doctor-tui');
+    const checks = [];
+    diagnoseInstalledSkills({ mode: 'global' }, checks);
+
+    for (const [platform] of DEPLOY_DIRS) {
+      const rows = checks.filter(c => c.name.startsWith(`Skill [${platform}]`));
+      expect(rows.length, `no checks emitted for platform ${platform}`).toBeGreaterThan(0);
+    }
+  });
+
+  // Anti-vacuity: enumeration must still surface real drift. A stale copy in
+  // .dsh specifically must WARN — proving the new rows are not decorative.
+  it('reports drift found in a non-detected platform (anti-vacuity)', () => {
+    deploy(['.config', 'opencode', 'skills'], 'grilling');
+    const staleDir = path.join(tmpHome, '.dsh', 'skills', 'grilling');
+    fs.mkdirSync(staleDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(staleDir, 'SKILL.md'),
+      '---\nname: grilling\nversion: 0.0.1\n---\n\nstale body\n'
+    );
+
+    const { diagnoseInstalledSkills } = require('../doctor-tui');
+    const checks = [];
+    const issues = diagnoseInstalledSkills({ mode: 'global' }, checks);
+
+    expect(issues).toBeGreaterThan(0);
+    const stale = checks.find(c => c.name === 'Skill [dsh]: grilling');
+    expect(stale).toBeDefined();
+    expect(stale.status).toBe('WARN');
+    expect(stale.detail).toContain('Outdated');
+  });
+
+  // Honest SKIP: nothing deployed anywhere must say so, and name the locations
+  // it looked at — the old message could not be told apart from "not wired up".
+  it('reports SKIP naming every searched location when nothing is deployed', () => {
+    const { diagnoseInstalledSkills } = require('../doctor-tui');
+    const checks = [];
+    const issues = diagnoseInstalledSkills({ mode: 'global' }, checks);
+
+    expect(issues).toBe(0);
+    const row = checks.find(c => c.name === 'Installed skills');
+    expect(row).toBeDefined();
+    expect(row.status).toBe('SKIP');
+    expect(row.detail).toContain('dsh');
+  });
+
+  // Backwards compatibility: an explicit list keeps the legacy single-target
+  // contract and the unprefixed check names existing callers rely on.
+  it('honours an explicit installedSkills list without the platform prefix', () => {
+    deploy(['.config', 'opencode', 'skills'], 'grilling');
+    const { diagnoseInstalledSkills } = require('../doctor-tui');
+    const checks = [];
+    diagnoseInstalledSkills({ installedSkills: { grilling: {} } }, checks);
+
+    const row = checks.find(c => c.name === 'Skill: grilling');
+    expect(row).toBeDefined();
+    expect(row.status).toBe('PASS');
+  });
+});

package/lib/__tests__/gate-runner.test.js

@@ -67,10 +67,11 @@ function initializeGitProject() {
 
 // Runs runGateAdapter in a child node process (worker threads forbid process
 // chdir, and runGateAdapter execs bash), capturing stdout/exit status.
-function runChildAdapter(gateRunnerAbsPath, fragmentPath, cwd = tmpProject) {
+function runChildAdapter(gateRunnerAbsPath, fragmentPath, cwd = tmpProject, opts = null) {
+  const optsArgument = opts ? `, ${JSON.stringify(opts)}` : '';
   const script = [
     `const { runGateAdapter } = require(${JSON.stringify(gateRunnerAbsPath)});`,
-    `runGateAdapter(${JSON.stringify(fragmentPath)}, ${JSON.stringify(cwd)});`,
+    `runGateAdapter(${JSON.stringify(fragmentPath)}, ${JSON.stringify(cwd)}${optsArgument});`,
     "console.log('__ADAPTER_DONE__');",
   ].join('\n');
   try {
@@ -146,6 +147,32 @@ describe('gate-runner.js — runGateAdapter', () => {
     expect(stdout).toContain('__ADAPTER_DONE__');
   }, 30000);
 
+  it('propagates the whole tracked tree under scope=all, one file per line (#589/#<new>)', () => {
+    const runnerAbsPath = path.resolve(__dirname, '../gate-runner.js');
+    writeAdapterCommon();
+    initializeGitProject();
+    fs.writeFileSync(path.join(tmpProject, 'untracked.ts'), 'const value = 3;\n');
+    // Two tracked files so a one-line join (the old JSON.stringify form) would fail
+    // the equality check even though the list was non-empty.
+    fs.writeFileSync(path.join(tmpProject, 'second.ts'), 'const value = 4;\n');
+    execFileSync('git', ['add', 'second.ts'], { cwd: tmpProject });
+    execFileSync('git', ['-c', 'core.hooksPath=/dev/null', 'commit', '-qm', 'second'], {
+      cwd: tmpProject,
+    });
+    writeGateFragment([
+      `printf '%s\\n' "${shellParameter('CHANGED_FILES')}" | grep -qx 'tracked.ts' || exit 87`,
+      `printf '%s\\n' "${shellParameter('CHANGED_FILES')}" | grep -qx 'second.ts' || exit 86`,
+      `[ "$(printf '%s\\n' "${shellParameter('CHANGED_FILES')}" | wc -l)" -eq 2 ] || exit 85`,
+      `if [ "${shellParameter('GATE_SCOPE')}" != "all" ]; then exit 84; fi`,
+    ]);
+
+    const fragPath = path.join(tmpAdapters, 'gate-9.sh');
+    const { status, stdout } = runChildAdapter(runnerAbsPath, fragPath, tmpProject, { scope: 'all' });
+
+    expect(status).toBe(0);
+    expect(stdout).toContain('__ADAPTER_DONE__');
+  }, 30000);
+
   it('runs a standalone gate bash fallback through the public CLI (REQ-standalone-gates-05)', () => {
     const packageFixture = path.join(tmpProject, 'package');
     fs.cpSync(path.resolve(__dirname, '../..'), packageFixture, { recursive: true });

package/lib/__tests__/issue-586-principles-cmdline.test.js

@@ -140,6 +140,41 @@ describe('REQ-613: Gate 4 must not blow the Windows command-line limit', () => {
     expect(fs.existsSync(refPath) && plan.cleanup === false).toBe(false);
   });
 
+  it('AC-613-02: without a local tsx, npm\u2019s own npx entry runs under node.exe', () => {
+    // `spawnSync('npx', ..., { shell: false })` is ENOENT on Windows: CreateProcess
+    // resolves only `.exe`, while the installed entry point is `npx.cmd`. Running
+    // npm's JS entry with the current node binary is the same program, without a shim
+    // — and without handing the file list to cmd.exe.
+    const existsSpy = vi.spyOn(fs, 'existsSync').mockImplementation((candidate) =>
+      String(candidate).endsWith(path.join('npm', 'bin', 'npx-cli.js'))
+    );
+    try {
+      const plan = principles.buildPrinciplesInvocation(['a.ts'], 'json');
+      expect(plan.command).toBe(process.execPath);
+      expect(plan.args[0]).toMatch(/npx-cli\.js$/);
+      expect(plan.useShell).toBe(false);
+    } finally {
+      existsSpy.mockRestore();
+    }
+  });
+
+  it('AC-613-02: the bare-npx fallback asks for a shell exactly where the shim needs one', () => {
+    // Last resort when neither tsx nor npm's entry can be found. The shell flag must
+    // still travel with the plan: hard-coding false is what produced ENOENT on
+    // Windows, hard-coding true is what produced the 8191-character limit.
+    const existsSpy = vi.spyOn(fs, 'existsSync').mockReturnValue(false);
+    try {
+      const direct = principles.buildPrinciplesInvocation(['a.ts'], 'json');
+      expect(direct.command).toBe('npx');
+      expect(direct.useShell).toBe(process.platform === 'win32');
+
+      const byReference = principles.buildPrinciplesInvocation(longFileList(LARGE_FILE_COUNT), 'json');
+      expect(byReference.useShell).toBe(process.platform === 'win32');
+    } finally {
+      existsSpy.mockRestore();
+    }
+  });
+
   it('AC-613-02: the WIRE test \u2014 the call site actually uses the plan it builds', () => {
     // This case exists because the first version of this suite had a hole: every
     // other case asserts on `buildPrinciplesInvocation`'s OUTPUT, and reverting the

package/lib/__tests__/issue-618-gate-not-run.test.js

@@ -0,0 +1,100 @@
+/**
+ * @test REQ-618 `check --all` must not count a gate that ran NOTHING as passed
+ * @intent Three gates the CLI advertises as runnable analysed nothing and were
+ *         counted as passes. Measured on xp-gate 0.31.3:
+ *
+ *             Gate python-health: TypeScript module not found and no bash fallback available.
+ *             Gate test-layers:   TypeScript module not found and no bash fallback available.
+ *             Gate pbt:           TypeScript module not found and no bash fallback available.
+ *
+ *             [xp-gate check --all] 8 passed / 2 failed / 5 skipped / 15 total
+ *
+ *         None of the three analysed anything, and all three were inside the
+ *         `8 passed`. The root cause was `runTsGate()`'s no-entry branch: it
+ *         printed a message and then fell through to `return 0`, which is
+ *         indistinguishable from "ran and found nothing". #568 taught the
+ *         summary to separate `preCommitOnly` skips from passes; this is the
+ *         same distinction one level down -- a gate that could not run is a
+ *         skip, not a pass.
+ *
+ *         The second defect on the same path: the bash-fallback branch called
+ *         `runGateAdapter(...)` and DISCARDED its verdict, so a fallback that
+ *         failed still reported 0.
+ * @covers AC-618-01, AC-618-02, AC-618-03
+ */
+const gateRunner = require('../gate-runner.js');
+const { checkAllGates } = require('../check.js');
+
+const { GATE_REGISTRY, GATE_NOT_RUN } = gateRunner;
+
+/** Original registry contents, restored after every test. */
+let ORIGINAL_REGISTRY;
+
+const SENTINEL_GATE_ID = '618-sentinel';
+const PASS_GATE_ID = '618-pass';
+const FAIL_GATE_ID = '618-fail';
+
+beforeEach(() => {
+  ORIGINAL_REGISTRY = { ...GATE_REGISTRY };
+  for (const k of Object.keys(GATE_REGISTRY)) delete GATE_REGISTRY[k];
+});
+
+afterEach(() => {
+  for (const k of Object.keys(GATE_REGISTRY)) delete GATE_REGISTRY[k];
+  Object.assign(GATE_REGISTRY, ORIGINAL_REGISTRY);
+});
+
+function installGates() {
+  GATE_REGISTRY[SENTINEL_GATE_ID] = {
+    name: 'ran nothing',
+    description: 'no module, no fallback',
+    aliases: [],
+    run: () => GATE_NOT_RUN,
+  };
+  GATE_REGISTRY[PASS_GATE_ID] = {
+    name: 'ran and passed',
+    description: 'ordinary passing gate',
+    aliases: [],
+    run: () => 0,
+  };
+  GATE_REGISTRY[FAIL_GATE_ID] = {
+    name: 'ran and failed',
+    description: 'ordinary failing gate',
+    aliases: [],
+    run: () => 1,
+  };
+}
+
+test('AC-618-01: the sentinel is distinct from every exit code', () => {
+  // It must not be a number: 0 means "ran, found nothing" and 1 means "failed".
+  expect(typeof GATE_NOT_RUN).not.toBe('number');
+  expect(GATE_NOT_RUN).not.toBe(0);
+  expect(GATE_NOT_RUN).not.toBe(1);
+});
+
+test('AC-618-02: a gate that ran nothing is counted as skipped, not passed', async () => {
+  installGates();
+  const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+  try {
+    await checkAllGates('.');
+    const printed = log.mock.calls.map(c => String(c[0])).join('\n');
+    // 3 gates total: one skipped (ran nothing), one passed, one failed.
+    expect(printed).toMatch(/1 passed \/ 1 failed \/ 1 skipped \/ 3 total/);
+  } finally {
+    log.mockRestore();
+  }
+});
+
+test('AC-618-03: runGate propagates the sentinel instead of flattening it to 0', async () => {
+  installGates();
+  const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+  try {
+    // The sentinel must survive runGate(), otherwise check.js cannot see it.
+    expect(await gateRunner.runGate(SENTINEL_GATE_ID, '.')).toBe(GATE_NOT_RUN);
+    // And the ordinary verdicts must be untouched by the change.
+    expect(await gateRunner.runGate(PASS_GATE_ID, '.')).toBe(0);
+    expect(await gateRunner.runGate(FAIL_GATE_ID, '.')).toBe(1);
+  } finally {
+    log.mockRestore();
+  }
+});

package/lib/__tests__/shared-utils.test.js

@@ -65,5 +65,26 @@ describe('shared-utils', () => {
       expect(fs.existsSync(path.join(destDir, 'verify.sh'))).toBe(false);
       expect(fs.existsSync(path.join(destDir, 'VERSION'))).toBe(false);
     });
+    it('copies hooks/lib so gate-3 can source the complexity ratchet library', () => {
+      // gate-3.sh resolves $GATE_DIR/lib/ccn-ratchet.sh, and GATE_DIR is this same
+      // adapters directory (init.js: copyAdapters(srcDir, GLOBAL_ADAPTERS_DIR)). The
+      // installer used to skip hooks/lib entirely, so the source failed with "No such
+      // file or directory", evaluate_ccn_ratchet stayed undefined and the ratchet
+      // graded every CCN regression as PASS.
+      const pkgRoot = path.join(tmpRoot, 'pkg');
+      fs.mkdirSync(path.join(pkgRoot, 'hooks', 'lib'), { recursive: true });
+      fs.writeFileSync(path.join(pkgRoot, 'gate-3.sh'), '# gate-3');
+      fs.writeFileSync(path.join(pkgRoot, 'hooks', 'lib', 'ccn-ratchet.sh'), '# ratchet');
+      fs.writeFileSync(path.join(pkgRoot, 'hooks', 'lib', 'now-ms.sh'), '# now-ms');
+
+      const destDir = path.join(tmpRoot, 'adapters');
+      fs.mkdirSync(destDir, { recursive: true });
+
+      const { copyAdapters } = require('../shared-utils');
+      copyAdapters(pkgRoot, destDir);
+
+      expect(fs.existsSync(path.join(destDir, 'lib', 'ccn-ratchet.sh'))).toBe(true);
+      expect(fs.existsSync(path.join(destDir, 'lib', 'now-ms.sh'))).toBe(true);
+    });
   });
 });

package/lib/check.js

@@ -2,7 +2,7 @@
 
 const { principles } = require('./principles.js');
 const { arch } = require('./arch.js');
-const { getGateInfo, runGate, resolveAlias, getAliases } = require('./gate-runner.js');
+const { getGateInfo, runGate, resolveAlias, getAliases, GATE_NOT_RUN } = require('./gate-runner.js');
 
 /**
  * Resolve a token (gate ID or alias) to a canonical gate ID.
@@ -151,7 +151,11 @@ async function checkAllGates(target) {
     // read CHANGED_FILES from scanning an empty diff and reporting SKIP — which
     // read like a pass while checking LESS than an ordinary commit.
     const code = await runGate(gate.id, target, { scope: 'all' });
-    if (code === 0) tally.passed += 1;
+    // #618: a gate that ran nothing (no TS module, no bash fallback) returns the
+    // GATE_NOT_RUN sentinel. Counting it as passed put three gates that analysed
+    // nothing inside "8 passed"; it is a skip, and the summary must say so.
+    if (code === GATE_NOT_RUN) tally.skipped += 1;
+    else if (code === 0) tally.passed += 1;
     else tally.failed += 1;
     console.log('');
   }

package/lib/detect-deps.js

@@ -3,7 +3,10 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-const { HOME_DIR, detectPlatform } = require('./shared-paths.js');
+// HOME_DIR is deliberately NOT destructured here: the platform profiles keep
+// home-relative path segments and resolve them through getSkillsDirs() instead,
+// so nothing in this module freezes the home directory at require() time.
+const { detectPlatform } = require('./shared-paths.js');
 
 const REQUIRED_DEPS = [
   { name: 'superpowers', repo: 'obra/superpowers', minVersion: '1.0.0' },
@@ -231,27 +234,51 @@ function getToolInstallCmd(toolEntry, platform) {
  * Platform profiles — each AI agent platform has its own skills directory.
  * All platforms require the same dependencies (superpowers, gstack).
  *
+ * `skillsDirs` is a list of path SEGMENTS relative to the home directory, not
+ * an absolute path. It used to hold `path.join(HOME_DIR, ...)` evaluated at
+ * require() time, which pinned every profile to whatever HOME was when
+ * detect-deps was first loaded — the same trap doctor.js documents at its top.
+ * Keeping segments here and resolving them in getSkillsDirs() makes the
+ * profiles plain, uniform data (no mix of getters and values) that follows
+ * process.env.HOME, and gives the platform-to-directory mapping one source of
+ * truth (Delphi R1 CI-01 / MA-01 on #635).
+ *
  * @covers Issue #128 Bug 1 — Qoder platform was excluded from dependency checks
+ * @covers Issue #635 — dsh was missing entirely
  */
 const PLATFORM_PROFILES = {
   opencode: {
     skillsDirs: [
-      path.join(HOME_DIR, '.config', 'opencode', 'skills'),
-      path.join(HOME_DIR, '.config', 'opencode'),
+      ['.config', 'opencode', 'skills'],
+      ['.config', 'opencode'],
     ],
     requiredDeps: REQUIRED_DEPS,
   },
   'claude-code': {
     skillsDirs: [
-      path.join(HOME_DIR, '.claude', 'skills'),
-      path.join(HOME_DIR, '.claude'),
+      ['.claude', 'skills'],
+      ['.claude'],
     ],
     requiredDeps: REQUIRED_DEPS,
   },
   qoder: {
     skillsDirs: [
-      path.join(HOME_DIR, '.qoder', 'skills'),
-      path.join(HOME_DIR, '.qoder'),
+      ['.qoder', 'skills'],
+      ['.qoder'],
+    ],
+    requiredDeps: REQUIRED_DEPS,
+  },
+  // #635: `xp-gate init` deploys skills to ~/.dsh/skills, the npm package ships
+  // plugins/dsh (`@boyingliu01/dsh-plugin-xp-gate`), and
+  // scripts/sync-package-content.js lists `dsh` among PLUGINS — but this entry
+  // was missing, so getSkillsDirs('dsh') fell through to the opencode paths and
+  // DSH skills were never resolved. detectPlatform() still never returns 'dsh'
+  // (there is no marker it could key on that opencode's would not also match),
+  // so callers that must cover DSH ask for it by name.
+  dsh: {
+    skillsDirs: [
+      ['.dsh', 'skills'],
+      ['.dsh'],
     ],
     requiredDeps: REQUIRED_DEPS,
   },
@@ -262,12 +289,17 @@ const PLATFORM_PROFILES = {
 
 /**
  * Get the skills directories for a given platform.
- * @param {string} platform - 'opencode' | 'claude-code' | 'qoder'
- * @returns {string[]}
+ *
+ * Resolves the home directory at call time so the result follows
+ * process.env.HOME, and so every profile is a plain data entry.
+ *
+ * @param {string} platform - 'opencode' | 'claude-code' | 'qoder' | 'dsh'
+ * @returns {string[]} absolute paths; skillsDirs[0] is the skills directory
  */
 function getSkillsDirs(platform) {
   const profile = PLATFORM_PROFILES[platform] || PLATFORM_PROFILES.opencode;
-  return profile.skillsDirs;
+  const home = require('./shared-paths.js').HOME_DIR;
+  return profile.skillsDirs.map((segments) => path.join(home, ...segments));
 }
 
 /**

package/lib/doctor-tui.js

@@ -117,38 +117,128 @@ function compareSemver(a, b) {
   return 0;
 }
 
+/**
+ * Every skills directory `xp-gate init` deploys to, derived from
+ * PLATFORM_PROFILES so the platform-to-directory mapping has one source of
+ * truth. A hardcoded copy here would drift the moment a platform is added
+ * (Delphi R1 MA-01).
+ *
+ * init deploys to all of these at once, so doctor has to verify all of them —
+ * resolving a single "current" platform silently left the others unchecked
+ * (#635). `.dsh` is included because the package ships `plugins/dsh` and
+ * `sync-package-content.js` treats `dsh` as a first-class platform, even
+ * though `detectPlatform()` never returns it.
+ *
+ * Resolved through getSkillsDirs() at call time: the home directory and the
+ * profile list are read lazily, and tests reassign process.env.HOME.
+ *
+ * @returns {Array<{platform: string, dir: string}>}
+ */
+function skillsDeployTargets() {
+  const { PLATFORM_PROFILES, getSkillsDirs } = require('./detect-deps.js');
+  return Object.keys(PLATFORM_PROFILES).map((platform) => ({
+    platform,
+    // skillsDirs[0] is the skills directory; [1] is the broader platform dir.
+    dir: getSkillsDirs(platform)[0],
+  }));
+}
+
+/**
+ * List the skill names actually present in a skills directory.
+ *
+ * A skill counts as installed when `<dir>/<name>/SKILL.md` exists — the same
+ * shape `install-skill` writes. Returns [] when the directory is missing or
+ * unreadable; a missing directory is "not deployed here", not an error.
+ *
+ * @param {string} dir
+ * @returns {string[]}
+ */
+function listInstalledSkillNames(dir) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries
+    .filter((e) => e.isDirectory() && fs.existsSync(path.join(dir, e.name, 'SKILL.md')))
+    .map((e) => e.name)
+    .sort();
+}
+
 /**
  * Check 9: Installed skills vs package-bundled skills (#332).
  * Uses semver version comparison on SKILL.md frontmatter when available;
  * falls back to byte-for-byte content comparison for skills without version field.
+ *
+ * The skill list comes from the filesystem, not from `config.installedSkills`:
+ * `xp-gate init` never writes that field, so keying off it made this check
+ * report "No skills installed" on a fully deployed machine and return before
+ * touching disk (#635). An explicit `config.installedSkills` is still honoured
+ * when present, so callers and older tests keep their behaviour.
+ *
  * @param {object} config
  * @param {Array} checks
  * @returns {number} issue count
  */
 function diagnoseInstalledSkills(config, checks) {
-  const installedSkills = config.installedSkills || {};
-  const skillNames = Object.keys(installedSkills);
-  if (skillNames.length === 0) {
-    checks.push({ name: 'Installed skills', status: 'SKIP', detail: 'No skills installed' });
-    return 0;
-  }
-
   const bundledSkillsDir = path.join(PKG_DIR, 'skills');
   if (!fs.existsSync(bundledSkillsDir)) {
     checks.push({ name: 'Installed skills', status: 'SKIP', detail: 'Package skills dir not found' });
     return 0;
   }
 
+  const explicit = config && config.installedSkills ? Object.keys(config.installedSkills) : [];
+  const targets = skillsDeployTargets();
+
+  // An explicit `installedSkills` list is a caller saying "check THIS list, for
+  // THIS platform" — legacy single-target behaviour, kept so existing callers
+  // and their tests retain an unchanged contract (Delphi R1 MA-02).
+  //
+  // The asymmetry with the default path below is deliberate and load-bearing:
+  // the explicit list names no directory, so a platform still has to be
+  // inferred, and silently checking a different platform's directory than the
+  // caller meant would be worse than checking one. `xp-gate init` never writes
+  // this field, so in practice doctor takes the filesystem path below.
   const platform = detectPlatform();
-  let userSkillsDir;
-  if (platform === 'qoder') {
-    userSkillsDir = path.join(HOME_DIR, '.qoder', 'skills');
-  } else if (platform === 'claude-code') {
-    userSkillsDir = path.join(HOME_DIR, '.claude', 'skills');
-  } else {
-    userSkillsDir = path.join(HOME_DIR, '.config', 'opencode', 'skills');
+  if (explicit.length > 0) {
+    const match = targets.find((t) => t.platform === platform) || targets[0];
+    return diagnoseSkillsInDir(explicit, match.dir, bundledSkillsDir, checks, null);
   }
 
+  // No explicit list: verify every directory that actually has skills deployed.
+  const deployed = targets.filter((t) => listInstalledSkillNames(t.dir).length > 0);
+  if (deployed.length === 0) {
+    checks.push({
+      name: 'Installed skills',
+      status: 'SKIP',
+      detail: `No skills deployed in any known location (${targets.map((t) => t.platform).join(', ')})`,
+    });
+    return 0;
+  }
+
+  let issues = 0;
+  for (const target of deployed) {
+    const names = listInstalledSkillNames(target.dir);
+    issues += diagnoseSkillsInDir(names, target.dir, bundledSkillsDir, checks, target.platform);
+  }
+  return issues;
+}
+
+/**
+ * Compare one deployed skills directory against the bundled copy.
+ *
+ * @param {string[]} skillNames
+ * @param {string} userSkillsDir
+ * @param {string} bundledSkillsDir
+ * @param {Array} checks
+ * @param {string|null} platformLabel - prefix for check names, or null for the
+ *   legacy unprefixed names (explicit-installedSkills callers).
+ * @returns {number} issue count
+ */
+function diagnoseSkillsInDir(skillNames, userSkillsDir, bundledSkillsDir, checks, platformLabel) {
+  const label = (name) => (platformLabel ? `Skill [${platformLabel}]: ${name}` : `Skill: ${name}`);
+
   let issues = 0;
   for (const name of skillNames) {
     const bundledSkillMd = path.join(bundledSkillsDir, name, 'SKILL.md');
@@ -156,7 +246,7 @@ function diagnoseInstalledSkills(config, checks) {
 
     if (!fs.existsSync(bundledSkillMd)) continue;
     if (!fs.existsSync(userSkillMd)) {
-      checks.push({ name: `Skill: ${name}`, status: 'FAIL', detail: 'Installed SKILL.md missing' });
+      checks.push({ name: label(name), status: 'FAIL', detail: 'Installed SKILL.md missing' });
       issues++;
       continue;
     }
@@ -174,24 +264,24 @@ function diagnoseInstalledSkills(config, checks) {
         // Version strings not valid semver — fall back to content comparison
         if (!sameContentIgnoringLineEndings(bundledContent, userContent)) {
           checks.push({
-            name: `Skill: ${name}`,
+            name: label(name),
             status: 'WARN',
             detail: `Outdated — run xp-gate update-skill --all (installed: ${userVersion}, bundled: ${bundledVersion})`,
           });
           issues++;
         } else {
-          checks.push({ name: `Skill: ${name}`, status: 'PASS', detail: 'Up to date' });
+          checks.push({ name: label(name), status: 'PASS', detail: 'Up to date' });
         }
       } else if (cmp < 0) {
         checks.push({
-          name: `Skill: ${name}`,
+          name: label(name),
           status: 'WARN',
           detail: `Outdated — run xp-gate update-skill --all (installed: ${userVersion}, bundled: ${bundledVersion})`,
         });
         issues++;
       } else {
         // cmp >= 0: installed version is same or newer than bundled
-        checks.push({ name: `Skill: ${name}`, status: 'PASS', detail: 'Up to date' });
+        checks.push({ name: label(name), status: 'PASS', detail: 'Up to date' });
       }
     } else {
       // No version in at least one file — compare content, but not byte-for-byte:
@@ -206,13 +296,13 @@ function diagnoseInstalledSkills(config, checks) {
         withoutVersionLine(userContent)
       )) {
         checks.push({
-          name: `Skill: ${name}`,
+          name: label(name),
           status: 'WARN',
           detail: 'Content differs and version cannot be determined (missing version frontmatter) — compare manually before running update-skill (it pulls from main, which may be older than the installed copy)',
         });
         issues++;
       } else {
-        checks.push({ name: `Skill: ${name}`, status: 'PASS', detail: 'Up to date' });
+        checks.push({ name: label(name), status: 'PASS', detail: 'Up to date' });
       }
     }
   }