@boyingliu01/xp-gate 0.31.3 → 0.32.0

package/lib/__tests__/detect-deps-dsh-profile.test.js

@@ -0,0 +1,106 @@
+/**
+ * @test REQ-635
+ * @intent `xp-gate init` 会向 ~/.dsh/skills 部署技能、npm 包也带 plugins/dsh，
+ *         但 PLATFORM_PROFILES 里没有 dsh 条目，getSkillsDirs('dsh') 静默回落到
+ *         opencode 的路径，导致 DSH 机器的技能从不被解析（#635）
+ * @covers AC-635-04, AC-635-05
+ */
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+describe('PLATFORM_PROFILES covers dsh (#635)', () => {
+  let tmpHome;
+  let originalHome;
+
+  beforeEach(() => {
+    originalHome = process.env.HOME;
+    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'xpgate-dsh-'));
+    process.env.HOME = tmpHome;
+    vi.resetModules();
+    delete require.cache[require.resolve('../detect-deps')];
+    delete require.cache[require.resolve('../shared-paths')];
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    fs.rmSync(tmpHome, { recursive: true, force: true });
+  });
+
+  // AC-635-04: asking for dsh skills must return the dsh directory, not a
+  // silent fallback to opencode's.
+  it('getSkillsDirs("dsh") resolves ~/.dsh, not the opencode fallback', () => {
+    const { getSkillsDirs } = require('../detect-deps');
+    const dirs = getSkillsDirs('dsh');
+
+    expect(dirs.length).toBeGreaterThan(0);
+    expect(dirs[0]).toBe(path.join(tmpHome, '.dsh', 'skills'));
+    // The pre-fix behaviour: falls through to PLATFORM_PROFILES.opencode.
+    expect(dirs[0]).not.toContain(path.join('.config', 'opencode'));
+  });
+
+  // AC-635-05: the profile is a real entry, so a caller enumerating platforms
+  // sees dsh alongside the three that were already there.
+  it('dsh is an enumerable platform profile with skillsDirs and requiredDeps', () => {
+    const { PLATFORM_PROFILES, getSkillsDirs } = require('../detect-deps');
+
+    expect(Object.keys(PLATFORM_PROFILES)).toContain('dsh');
+    expect(Object.keys(PLATFORM_PROFILES)).toEqual(
+      expect.arrayContaining(['opencode', 'claude-code', 'qoder', 'dsh'])
+    );
+
+    const profile = PLATFORM_PROFILES.dsh;
+    expect(Array.isArray(profile.skillsDirs)).toBe(true);
+    expect(profile.requiredDeps).toBeDefined();
+    // Profiles store home-relative segments; getSkillsDirs resolves them.
+    expect(profile.skillsDirs[0]).toEqual(['.dsh', 'skills']);
+    expect(getSkillsDirs('dsh')[0]).toBe(path.join(tmpHome, '.dsh', 'skills'));
+  });
+
+  // Every profile must be plain data — no getters mixed in with values, which
+  // would break Object.keys()/JSON round-trips and made the object's contract
+  // depend on which key you touched (Delphi R1 CI-01).
+  it('every profile is plain enumerable data, with no accessor properties', () => {
+    const { PLATFORM_PROFILES } = require('../detect-deps');
+
+    for (const name of Object.keys(PLATFORM_PROFILES)) {
+      const descriptor = Object.getOwnPropertyDescriptor(PLATFORM_PROFILES, name);
+      expect(descriptor.get, `${name} must not be an accessor`).toBeUndefined();
+      // A plain value also survives a JSON round-trip unchanged.
+      expect(JSON.parse(JSON.stringify(PLATFORM_PROFILES[name]))).toEqual(
+        PLATFORM_PROFILES[name]
+      );
+    }
+  });
+
+  // Paths must follow process.env.HOME rather than pinning the home directory
+  // at require() time — the trap doctor.js documents at its top.
+  it('resolved paths follow a HOME change after require', () => {
+    const { getSkillsDirs } = require('../detect-deps');
+    // Loaded above with the first tmpHome; move HOME and resolve again.
+    const secondHome = fs.mkdtempSync(path.join(os.tmpdir(), 'xpgate-dsh2-'));
+    try {
+      process.env.HOME = secondHome;
+      expect(getSkillsDirs('dsh')[0]).toBe(path.join(secondHome, '.dsh', 'skills'));
+      // The pre-existing profiles must follow too — they used to be frozen at
+      // require() time from a destructured HOME_DIR.
+      expect(getSkillsDirs('opencode')[0]).toBe(
+        path.join(secondHome, '.config', 'opencode', 'skills')
+      );
+    } finally {
+      fs.rmSync(secondHome, { recursive: true, force: true });
+    }
+  });
+
+  // Anti-vacuity: the three pre-existing profiles must keep their own paths,
+  // proving the getter did not disturb them.
+  it('leaves the pre-existing profiles unchanged', () => {
+    const { getSkillsDirs } = require('../detect-deps');
+
+    expect(getSkillsDirs('opencode')[0]).toBe(
+      path.join(tmpHome, '.config', 'opencode', 'skills')
+    );
+    expect(getSkillsDirs('qoder')[0]).toBe(path.join(tmpHome, '.qoder', 'skills'));
+    expect(getSkillsDirs('claude-code')[0]).toBe(path.join(tmpHome, '.claude', 'skills'));
+  });
+});

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));
 }
 
 /**