@boyingliu01/xp-gate 0.14.7 → 0.14.9

package/bin/xp-gate.js

@@ -14,6 +14,7 @@ const { arch } = require('../lib/arch.js');
 const { upgrade } = require('../lib/upgrade.js');
 const { bootstrap } = require('../lib/bootstrap.js');
 const { updateHooks } = require('../lib/update-hooks.js');
+const gateRunner = require('../lib/gate-runner.js');
 
 function handleUIReview() {
   const { execSync } = require('child_process');
@@ -105,9 +106,9 @@ const COMMANDS = {
     usage: 'xp-gate baseline <create|show|reset|diff>'
   },
   'check': {
-    description: 'Run user-invokable quality gates (Gate 4 Principles + Gate 6 Architecture) on a path',
+    description: 'Run quality gates (--list, --all, --gates <ids>, or <gate-id>)',
     run: subargs => check(subargs).then(code => process.exit(code)),
-    usage: 'xp-gate check <file_or_directory> [--gates principles,arch]'
+    usage: 'xp-gate check <file_or_directory|gate_number> [--gates gates] [--all] [--list]'
   },
   'principles': {
     description: 'Run Clean Code + SOLID principles checker (Gate 4 standalone)',
@@ -137,6 +138,14 @@ const COMMANDS = {
     },
     usage: 'xp-gate sprint-status [--json] [--watch] [--dir <path>]'
   },
+  'next-sprint': {
+    description: 'Analyze remaining open issues and plan next iteration',
+    run: subargs => {
+      const { handleNextSprint } = require('../lib/next-sprint.js');
+      handleNextSprint(subargs).then(code => process.exit(code));
+    },
+    usage: 'xp-gate next-sprint [--json] [--plan] [--dir <path>]'
+  },
   'update-hooks': {
     description: 'Sync latest hooks from xp-gate package to project',
     run: subargs => {
@@ -165,9 +174,29 @@ const COMMANDS = {
       install(subargs).then(code => process.exit(code));
     },
     usage: 'xp-gate install [--global]'
+  },
+  'gate-list': {
+    description: 'List all quality gates and their availability',
+    run: subargs => check(['--list']).then(code => process.exit(code)),
+    usage: 'xp-gate gate-list'
+  },
+  'gate-all': {
+    description: 'Run all invokable quality gates',
+    run: subargs => check(['--all', ...subargs]).then(code => process.exit(code)),
+    usage: 'xp-gate gate-all [<path>]'
   }
 };
 
+for (let i = 0; i <= 11; i++) {
+  const gateId = String(i);
+  const gateInfo = gateRunner.GATE_REGISTRY[gateId];
+  COMMANDS[`gate-${gateId}`] = {
+    description: `Run Gate ${gateId}: ${gateInfo?.name || 'Unknown'}`,
+    run: subargs => gateRunner.runGate(gateId, subargs[0]).then(code => process.exit(code)),
+    usage: `xp-gate gate-${gateId} [<path>]`
+  };
+}
+
 function printHelp() {
   console.log('xp-gate - AI development workflow tool');
   console.log('');

package/lib/__tests__/next-sprint.test.js

@@ -0,0 +1,231 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+describe('next-sprint', () => {
+  let tmpDir;
+  let consoleSpy;
+  let processExitSpy;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'next-sprint-test-'));
+    consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    processExitSpy = vi.spyOn(process, 'exit').mockImplementation(() => {});
+    // Clear require cache to ensure fresh module for each test
+    delete require.cache[require.resolve('../next-sprint')];
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  function createState(overrides = {}) {
+    const stateDir = path.join(tmpDir, '.sprint-state');
+    fs.mkdirSync(stateDir, { recursive: true });
+    const state = {
+      id: 'sprint-2026-06-30-01',
+      task_description: 'Test Sprint',
+      phase: 4,
+      status: 'completed',
+      started_at: new Date().toISOString(),
+      phase_history: [
+        {
+          phase: 2,
+          phase_name: 'BUILD',
+          status: 'completed',
+          reqs: {
+            'REQ-001': { name: 'Implement login', status: 'completed' },
+            'REQ-002': { name: 'Implement logout', status: 'completed' },
+          },
+        },
+      ],
+      ...overrides,
+    };
+    fs.writeFileSync(path.join(stateDir, 'sprint-state.json'), JSON.stringify(state));
+    return state;
+  }
+
+  function mockGhCli(issues) {
+    const { execSync } = require('child_process');
+    vi.spyOn(require('child_process'), 'execSync').mockImplementation((cmd) => {
+      if (cmd.includes('gh issue list')) {
+        return JSON.stringify(issues);
+      }
+      return '';
+    });
+  }
+
+  describe('readSprintState', () => {
+    it('returns null when no sprint state exists', () => {
+      const { readSprintState } = require('../next-sprint');
+      const result = readSprintState(tmpDir);
+      expect(result).toBeNull();
+    });
+
+    it('returns parsed state when sprint state exists', () => {
+      const state = createState();
+      const { readSprintState } = require('../next-sprint');
+      const result = readSprintState(tmpDir);
+      expect(result).toBeDefined();
+      expect(result.id).toBe('sprint-2026-06-30-01');
+    });
+  });
+
+  describe('getCurrentSprintReqs', () => {
+    it('extracts requirements from sprint state', () => {
+      createState();
+      const { readSprintState, getCurrentSprintReqs } = require('../next-sprint');
+      const state = readSprintState(tmpDir);
+      const reqs = getCurrentSprintReqs(state);
+      expect(reqs).toHaveLength(2);
+      expect(reqs[0].name).toBe('Implement login');
+      expect(reqs[1].name).toBe('Implement logout');
+    });
+
+    it('returns empty array when no phase history', () => {
+      const { getCurrentSprintReqs } = require('../next-sprint');
+      const reqs = getCurrentSprintReqs({ phase_history: [] });
+      expect(reqs).toEqual([]);
+    });
+  });
+
+  describe('filterRemainingIssues', () => {
+    it('filters out issues already in sprint', () => {
+      const issues = [
+        { number: 1, title: 'Implement login', labels: [], createdAt: '2026-06-30T00:00:00Z' },
+        { number: 2, title: 'Implement logout', labels: [], createdAt: '2026-06-30T00:00:00Z' },
+        { number: 3, title: 'Implement signup', labels: [], createdAt: '2026-06-30T00:00:00Z' },
+      ];
+      const sprintReqs = [{ name: 'Implement login' }, { name: 'Implement logout' }];
+      const { filterRemainingIssues } = require('../next-sprint');
+      const result = filterRemainingIssues(issues, sprintReqs);
+      expect(result).toHaveLength(1);
+      expect(result[0].number).toBe(3);
+    });
+
+    it('returns all issues when no sprint reqs', () => {
+      const issues = [
+        { number: 1, title: 'Implement login', labels: [], createdAt: '2026-06-30T00:00:00Z' },
+        { number: 2, title: 'Implement logout', labels: [], createdAt: '2026-06-30T00:00:00Z' },
+      ];
+      const { filterRemainingIssues } = require('../next-sprint');
+      const result = filterRemainingIssues(issues, []);
+      expect(result).toHaveLength(2);
+    });
+  });
+
+  describe('formatIssuesTable', () => {
+    it('formats issues as table', () => {
+      const issues = [
+        { number: 1, title: 'Implement login', labels: [{ name: 'feature' }], createdAt: '2026-06-30T00:00:00Z' },
+        { number: 2, title: 'Implement logout', labels: [{ name: 'bug' }], createdAt: '2026-06-30T00:00:00Z' },
+      ];
+      const { formatIssuesTable } = require('../next-sprint');
+      const result = formatIssuesTable(issues);
+      expect(result).toContain('Remaining Open Issues');
+      expect(result).toContain('Implement login');
+      expect(result).toContain('feature');
+    });
+
+    it('handles empty issues', () => {
+      const { formatIssuesTable } = require('../next-sprint');
+      const result = formatIssuesTable([]);
+      expect(result).toBe('No remaining issues found.');
+    });
+  });
+
+  describe('generateSprintPlan', () => {
+    it('generates sprint plan for remaining issues', () => {
+      const issues = [
+        { number: 1, title: 'Implement login', labels: [], createdAt: '2026-06-30T00:00:00Z' },
+        { number: 2, title: 'Implement logout', labels: [], createdAt: '2026-06-30T00:00:00Z' },
+      ];
+      const { generateSprintPlan } = require('../next-sprint');
+      const result = generateSprintPlan(issues);
+      expect(result).toContain('Suggested Next Sprint Plan');
+      expect(result).toContain('#1');
+      expect(result).toContain('sprint-flow');
+    });
+
+    it('returns null when no issues', () => {
+      const { generateSprintPlan } = require('../next-sprint');
+      const result = generateSprintPlan([]);
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('handleNextSprint', () => {
+    it('outputs remaining issues in table format', async () => {
+      createState();
+      const { execSync } = require('child_process');
+      vi.spyOn(require('child_process'), 'execSync').mockImplementation((cmd) => {
+        if (cmd.includes('gh issue list')) {
+          return JSON.stringify([
+            { number: 1, title: 'Implement login', labels: [{ name: 'feature' }], createdAt: '2026-06-30T00:00:00Z' },
+            { number: 2, title: 'Implement logout', labels: [{ name: 'bug' }], createdAt: '2026-06-30T00:00:00Z' },
+            { number: 3, title: 'Implement signup', labels: [{ name: 'enhancement' }], createdAt: '2026-06-30T00:00:00Z' },
+          ]);
+        }
+        return '';
+      });
+      delete require.cache[require.resolve('../next-sprint')];
+      const { handleNextSprint } = require('../next-sprint');
+      const result = await handleNextSprint(['--dir', tmpDir]);
+      expect(result).toBe(0);
+      expect(consoleSpy).toHaveBeenCalled();
+      const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+      expect(output).toContain('Remaining Open Issues');
+      expect(output).toContain('Implement signup');
+    });
+
+    it('outputs JSON when --json flag', async () => {
+      createState();
+      vi.spyOn(require('child_process'), 'execSync').mockImplementation((cmd) => {
+        if (cmd.includes('gh issue list')) {
+          return JSON.stringify([
+            { number: 1, title: 'Implement login', labels: [], createdAt: '2026-06-30T00:00:00Z' },
+          ]);
+        }
+        return '';
+      });
+      delete require.cache[require.resolve('../next-sprint')];
+      const { handleNextSprint } = require('../next-sprint');
+      const result = await handleNextSprint(['--json', '--dir', tmpDir]);
+      expect(result).toBe(0);
+      const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+      const parsed = JSON.parse(output);
+      expect(parsed).toHaveProperty('current_sprint');
+      expect(parsed).toHaveProperty('remaining_issues');
+    });
+
+    it('outputs plan when --plan flag', async () => {
+      createState();
+      vi.spyOn(require('child_process'), 'execSync').mockImplementation((cmd) => {
+        if (cmd.includes('gh issue list')) {
+          return JSON.stringify([
+            { number: 5, title: 'Implement password reset', labels: [], createdAt: '2026-06-30T00:00:00Z' },
+          ]);
+        }
+        return '';
+      });
+      delete require.cache[require.resolve('../next-sprint')];
+      const { handleNextSprint } = require('../next-sprint');
+      const result = await handleNextSprint(['--plan', '--dir', tmpDir]);
+      expect(result).toBe(0);
+      const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+      expect(output).toContain('Suggested Next Sprint Plan');
+    });
+
+    it('returns 1 when gh CLI not available', async () => {
+      vi.spyOn(require('child_process'), 'execSync').mockImplementation(() => {
+        throw new Error('gh: command not found');
+      });
+      delete require.cache[require.resolve('../next-sprint')];
+      const { handleNextSprint } = require('../next-sprint');
+      const result = await handleNextSprint(['--dir', tmpDir]);
+      expect(result).toBe(1);
+    });
+  });
+});

package/lib/__tests__/update-hooks.test.js

@@ -140,6 +140,18 @@ describe('updateHooks', () => {
       expect(fs.readFileSync(path.join(dest, 'gate-4.sh'), 'utf8')).toContain('gate4-v2');
     });
 
+    it('copies sprint-gate.sh alongside gate-*.sh scripts (#335)', () => {
+      createPackageSource();
+      fs.writeFileSync(path.join(tmpPackage, 'sprint-gate.sh'), '#!/bin/bash\necho "sprint-gate-v1"');
+      const mod = getModule();
+      const dest = path.join(tmpProject, 'gates-sprint');
+      fs.mkdirSync(dest, { recursive: true });
+
+      mod.copyGateScripts(tmpPackage, dest, false, true);
+
+      expect(fs.readFileSync(path.join(dest, 'sprint-gate.sh'), 'utf8')).toContain('sprint-gate-v1');
+    });
+
     it('does not copy non-gate files', () => {
       createPackageSource();
       fs.writeFileSync(path.join(tmpPackage, 'some-other.sh'), 'echo other');

package/lib/__tests__/upgrade-skill-sync.test.js

@@ -0,0 +1,65 @@
+/**
+ * @test REQ-332 xp-gate upgrade --apply must update installed skills
+ * @intent After upgrade --apply, all installed skills should be refreshed to match the new package version
+ * @covers AC-332-01, AC-332-02, AC-332-03, AC-332-04
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+describe('upgrade --apply skill sync — #332', () => {
+  // AC-332-01: upgrade.js handleApplyMode calls updateSkill after successful upgrade
+  it('AC-332-01: upgrade.js contains updateSkill call after plugin upgrade', () => {
+    const source = fs.readFileSync(require.resolve('../upgrade.js'), 'utf8');
+    expect(source).toContain("require('./update-skill.js')");
+    expect(source).toContain('updateSkill(null, { all: true');
+  });
+
+  // AC-332-02: updateSkill call is inside try/catch (non-blocking)
+  it('AC-332-02: updateSkill call is wrapped in try/catch for non-blocking behavior', () => {
+    const source = fs.readFileSync(require.resolve('../upgrade.js'), 'utf8');
+    const lines = source.split('\n');
+    let foundRequire = false;
+    let inTryBlock = false;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].includes("require('./update-skill.js')")) {
+        foundRequire = true;
+        for (let j = i - 1; j >= 0; j--) {
+          if (/^\s*try\s*\{/.test(lines[j])) {
+            inTryBlock = true;
+            break;
+          }
+          if (/^\s*(function|async function|=>)/.test(lines[j])) break;
+        }
+        break;
+      }
+    }
+    expect(foundRequire).toBe(true);
+    expect(inTryBlock).toBe(true);
+  });
+
+  // AC-332-03: updateSkill call is placed after upgradeOpenCodePlugin (correct ordering)
+  it('AC-332-03: updateSkill is called after upgradeOpenCodePlugin in handleApplyMode', () => {
+    const source = fs.readFileSync(require.resolve('../upgrade.js'), 'utf8');
+    const pluginIdx = source.indexOf('upgradeOpenCodePlugin()');
+    const skillIdx = source.indexOf("require('./update-skill.js')");
+    expect(pluginIdx).toBeGreaterThan(-1);
+    expect(skillIdx).toBeGreaterThan(pluginIdx);
+  });
+});
+
+describe('doctor skill version check — #332', () => {
+  // AC-332-04: doctor.js diagnose() includes skill version consistency check
+  it('AC-332-04: doctor.js diagnose() contains diagnoseInstalledSkills call', () => {
+    const source = fs.readFileSync(require.resolve('../doctor.js'), 'utf8');
+    expect(source).toContain('diagnoseInstalledSkills');
+  });
+
+  // AC-332-05: diagnoseInstalledSkills compares installed skills against package-bundled skills
+  it('AC-332-05: diagnoseInstalledSkills reads config installedSkills and package skills dir', () => {
+    const source = fs.readFileSync(require.resolve('../doctor.js'), 'utf8');
+    expect(source).toContain('installedSkills');
+    expect(source).toContain('diagnoseInstalledSkills');
+    expect(source).toContain('skills');
+  });
+});

package/lib/check.js

@@ -2,49 +2,144 @@
 
 const { principles } = require('./principles.js');
 const { arch } = require('./arch.js');
+const { getGateInfo, runGate } = require('./gate-runner.js');
+
+function parseCheckArgs(args) {
+  const flags = { all: false, list: false, gateIds: null };
+  const posArgs = [];
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg === '--all') { flags.all = true; i++; }
+    else if (arg === '--list') { flags.list = true; i++; }
+    else if (arg === '--gates' && i + 1 < args.length) {
+      flags.gateIds = args[i + 1].split(',').map(s => s.trim()).filter(Boolean);
+      i += 2;
+    }
+    else if (arg.startsWith('--gates=')) {
+      flags.gateIds = arg.split('=')[1].split(',').map(s => s.trim()).filter(Boolean);
+      i++;
+    }
+    else { posArgs.push(arg); i++; }
+  }
+  const rawTarget = posArgs[0] || null;
+  const isGateNumber = rawTarget && /^\d+$/.test(rawTarget);
+  return {
+    ...flags,
+    positionals: posArgs,
+    pathArg: isGateNumber ? posArgs[1] || null : rawTarget,
+    gateNumber: isGateNumber ? rawTarget : null,
+  };
+}
 
-// Runs the user-invokable subset of quality gates on a path. Mirrors what the
-// pre-commit hook does, but as a standalone CLI surface. Intentionally narrower
-// than the full pre-commit run (no git staging context, no Boy Scout baseline).
-// Currently delegates to: Gate 4 (Principles) + Gate 6 (Architecture).
 async function check(args) {
-  const target = args[0];
-  if (!target) {
-    console.error('Usage: xp-gate check <file_or_directory> [--gates principles,arch]');
+  const opts = parseCheckArgs(args);
+
+  if (opts.list) return listGates();
+  if (opts.gateNumber && !opts.all && !opts.gateIds) return runGate(opts.gateNumber, opts.pathArg);
+  if (opts.all) return checkAllGates(opts.pathArg);
+  if (opts.gateIds && opts.gateIds.length > 0) return runGatesByIds(opts.gateIds, opts.pathArg);
+
+  if (!opts.pathArg) {
+    console.error('Usage: xp-gate check <file_or_directory|gate_number> [options]');
+    console.error('');
+    console.error('Options:');
+    console.error('  --gates <ids>    Run specific gates (comma-separated, e.g. "3,4,6")');
+    console.error('  --all             Run all invokable gates');
+    console.error('  --list            List all available gates');
+    console.error('');
+    console.error('Examples:');
+    console.error('  xp-gate check src/                   # Run principles + architecture check');
+    console.error('  xp-gate check 3                      # Run Gate 3 (Complexity)');
+    console.error('  xp-gate check --gates 3,4,6          # Run gates 3, 4, and 6');
+    console.error('  xp-gate check --all                  # Run all invokable gates');
+    console.error('  xp-gate check --list                 # List available gates');
     return 1;
   }
 
-  const gatesIdx = args.indexOf('--gates');
-  const gateList = gatesIdx >= 0
-    ? args[gatesIdx + 1].split(',').map(s => s.trim()).filter(Boolean)
-    : ['principles', 'arch'];
+  return runDefaultChecks(opts.pathArg);
+}
+
+async function runDefaultChecks(target) {
+  let failures = 0;
+  let ran = 0;
+
+  console.log('━━━ Gate 4: Principles ━━━');
+  const principlesCode = await principles([target]);
+  if (principlesCode !== 0) failures += 1;
+  ran += 1;
+
+  console.log('━━━ Gate 6: Architecture ━━━');
+  const archCode = await arch([]);
+  if (archCode !== 0) failures += 1;
+  ran += 1;
+
+  console.log('');
+  console.log(`[xp-gate check] ${ran - failures}/${ran} gate(s) passed`);
+  return failures === 0 ? 0 : 1;
+}
 
+async function checkAllGates(target) {
+  const { getAllGates } = require('./gate-runner.js');
+  const invokableGates = getAllGates().filter(g => !g.preCommitOnly);
   let failures = 0;
   let ran = 0;
 
-  if (gateList.includes('principles')) {
-    console.log('━━━ Gate 4: Principles ━━━');
-    const code = await principles([target]);
+  for (const gate of invokableGates) {
+    const code = await runGate(gate.id, target);
     if (code !== 0) failures += 1;
     ran += 1;
+    console.log('');
   }
 
-  if (gateList.includes('arch')) {
-    console.log('━━━ Gate 6: Architecture ━━━');
-    const code = await arch([]);
+  console.log(`[xp-gate check --all] ${ran - failures}/${ran} gate(s) passed`);
+  return failures === 0 ? 0 : 1;
+}
+
+async function runGatesByIds(gateIds, target) {
+  let failures = 0;
+  let ran = 0;
+
+  for (const gateId of gateIds) {
+    const code = await runGate(gateId, target);
     if (code !== 0) failures += 1;
     ran += 1;
+    console.log('');
   }
 
   if (ran === 0) {
-    console.error(`[xp-gate check] No valid gates in --gates list: ${gateList.join(',')}`);
-    console.error('  Available gates: principles, arch');
+    console.error(`[xp-gate check] No valid gates in --gates list: ${gateIds.join(',')}`);
+    console.error('  Run: xp-gate check --list  to see available gates');
     return 1;
   }
 
-  console.log('');
   console.log(`[xp-gate check] ${ran - failures}/${ran} gate(s) passed`);
   return failures === 0 ? 0 : 1;
 }
 
+function listGates() {
+  const { getAllGates } = require('./gate-runner.js');
+  const allGates = getAllGates();
+
+  console.log('');
+  console.log('XP-Gate Quality Gates:');
+  console.log('┌──────┬──────────────────────────────┬──────────┬──────────────────────────────────────────┐');
+  console.log('│ Gate │ Name                         │ CLI      │ Description                              │');
+  console.log('├──────┼──────────────────────────────┼──────────┼──────────────────────────────────────────┤');
+  for (const gate of allGates) {
+    const id = gate.id.padEnd(4);
+    const name = gate.name.slice(0, 28).padEnd(28);
+    const cli = gate.preCommitOnly ? 'commit' : 'check';
+    const desc = gate.description.slice(0, 40).padEnd(40);
+    console.log(`│ ${id} │ ${name} │ ${cli.padEnd(8)} │ ${desc} │`);
+  }
+  console.log('└──────┴──────────────────────────────┴──────────┴──────────────────────────────────────────┘');
+  console.log('');
+  console.log('Legend:');
+  console.log('  check   — invokable via xp-gate check <gate-id>');
+  console.log('  commit  — only runs during git commit (pre-commit hook)');
+  console.log('');
+  return 0;
+}
+
 module.exports = { check };

package/lib/doctor.js

@@ -263,6 +263,9 @@ function diagnose() {
   // --- Check 8: TUI auto-registration ---
   issues += diagnoseTuiRegistration(checks);
 
+  // --- Check 9: Installed skills version consistency (#332) ---
+  issues += diagnoseInstalledSkills(config, checks);
+
   return { checks, issues };
 }
 
@@ -689,6 +692,66 @@ function diagnoseTuiRegistration(checks) {
   return 1;
 }
 
+/**
+ * Check 9: Installed skills vs package-bundled skills (#332).
+ * Reports WARN for each installed skill whose SKILL.md differs from the bundled version.
+ * @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 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');
+  }
+
+  let issues = 0;
+  for (const name of skillNames) {
+    const bundledSkillMd = path.join(bundledSkillsDir, name, 'SKILL.md');
+    const userSkillMd = path.join(userSkillsDir, name, 'SKILL.md');
+
+    if (!fs.existsSync(bundledSkillMd)) continue;
+    if (!fs.existsSync(userSkillMd)) {
+      checks.push({ name: `Skill: ${name}`, status: 'FAIL', detail: 'Installed SKILL.md missing' });
+      issues++;
+      continue;
+    }
+
+    const bundledContent = fs.readFileSync(bundledSkillMd, 'utf8');
+    const userContent = fs.readFileSync(userSkillMd, 'utf8');
+    if (bundledContent !== userContent) {
+      checks.push({
+        name: `Skill: ${name}`,
+        status: 'WARN',
+        detail: 'Outdated — run xp-gate update-skill --all',
+      });
+      issues++;
+    } else {
+      checks.push({ name: `Skill: ${name}`, status: 'PASS', detail: 'Up to date' });
+    }
+  }
+
+  return issues;
+}
+
 /**
  * Fix TUI registration: ensure @boyingliu01/opencode-plugin/tui is in tui.json.
  * Uses atomic write (tmp + renameSync) for JSON safety.