@boyingliu01/xp-gate 0.14.8 → 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)',
@@ -173,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__/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.

package/lib/gate-runner.js

@@ -0,0 +1,209 @@
+'use strict';
+
+const { execSync, execFileSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+// Gate metadata registry — maps gate IDs to names, descriptions, and how to run them.
+// Standalone gates (<gate-id>: { run }) are invokable via xp-gate gate-<id>.
+// Pre-commit-only gates (<gate-id>: { preCommitOnly: true }) run only in git commit context.
+const GATE_REGISTRY = {
+  '0': {
+    name: 'Version Consistency',
+    description: 'Check VERSION file matches all package.json versions',
+    preCommitOnly: true,
+    reason: 'Requires git-staged context to compare VERSION with package.json files',
+  },
+  '1': {
+    name: 'Code Quality',
+    description: 'Language-specific static analysis and linting (ESLint, Ruff, govet, etc.)',
+    preCommitOnly: true,
+    reason: 'Requires language detection from changed files and adapter routing',
+  },
+  '2': {
+    name: 'Duplicate Code',
+    description: 'jscpd duplicate code detection',
+    run: (targetPath) => {
+      const jscpdConfig = findConfig(targetPath, 'jscpd.conf.json');
+      const args = [targetPath || '.'];
+      if (jscpdConfig) args.push('--config', jscpdConfig);
+      execFileSync('npx', ['-y', 'jscpd', ...args], { stdio: 'inherit' });
+    },
+  },
+  '3': {
+    name: 'Cyclomatic Complexity',
+    description: 'lizard cyclomatic complexity analysis',
+    run: (targetPath) => {
+      const script = resolveGateScript('3');
+      if (script) {
+        execSync(`bash "${script}"`, { stdio: 'inherit' });
+      } else {
+        const target = targetPath || '.';
+        console.log(`Running lizard on ${target}...`);
+        execFileSync('lizard', [target, '--CCN', '10', '--length', '50', '--arguments', '5', '--warnings_only'], { stdio: 'inherit' });
+      }
+    },
+  },
+  '4': {
+    name: 'Clean Code + SOLID Principles',
+    description: '14 Clean Code/SOLID rules across 9 languages',
+    run: (targetPath) => {
+      const { principles } = require('./principles.js');
+      return principles([targetPath || '.']);
+    },
+  },
+  '5': {
+    name: 'Tests + Coverage',
+    description: 'Unit test execution and code coverage enforcement (≥80%)',
+    preCommitOnly: true,
+    reason: 'Requires language detection and adapter-sourced test execution with coverage reports',
+  },
+  '6': {
+    name: 'Architecture + Boy Scout Rule',
+    description: 'Architecture layer boundary validation and warning baseline enforcement',
+    run: (targetPath) => {
+      const { arch } = require('./arch.js');
+      return arch([]);
+    },
+  },
+  '7': {
+    name: 'IaC Security',
+    description: 'Infrastructure-as-Code security scanning (checkov, hadolint, kube-score, tflint)',
+    run: (targetPath) => {
+      const script = resolveGateScript('7');
+      if (script) {
+        execSync(`bash "${script}"`, { stdio: 'inherit' });
+      } else {
+        console.log('IaC security scan requires git-staged context for changed files detection.');
+        console.log('Run: git commit to trigger Gate 7 automatically.');
+      }
+    },
+  },
+  '8': {
+    name: 'Secret Scanning',
+    description: 'gitleaks secret and credential detection',
+    run: (targetPath) => {
+      const script = resolveGateScript('8');
+      if (script) {
+        execSync(`bash "${script}"`, { stdio: 'inherit' });
+      } else {
+        console.log('Secret scanning requires git-staged context for changed files detection.');
+        console.log('Run: git commit to trigger Gate 8 automatically.');
+      }
+    },
+  },
+  '9': {
+    name: 'SAST Security',
+    description: 'semgrep static application security testing',
+    run: (targetPath) => {
+      const script = resolveGateScript('9');
+      if (script) {
+        execSync(`bash "${script}"`, { stdio: 'inherit' });
+      } else {
+        console.log('SAST scanning requires git-staged context for changed files detection.');
+        console.log('Run: git commit to trigger Gate 9 automatically.');
+      }
+    },
+  },
+  '10': {
+    name: 'Build Integrity',
+    description: 'TypeScript compilation, npm pack, and import validation',
+    preCommitOnly: true,
+    reason: 'Build integrity checks require language detection and build tool context',
+  },
+  '11': {
+    name: 'Sprint Flow Enforcement',
+    description: 'Sprint state and delphi-review validation',
+    preCommitOnly: true,
+    reason: 'Requires sprint state (.sprint-state/) and git branch context',
+  },
+};
+
+function findConfig(basePath, fileName) {
+  const candidates = [
+    path.join(basePath || '.', fileName),
+    path.join(process.cwd(), fileName),
+  ];
+  for (const c of candidates) {
+    if (fs.existsSync(c)) return c;
+  }
+  return null;
+}
+
+function resolveGateScript(gateNum) {
+  const candidates = [
+    path.join(process.cwd(), 'githooks', 'gates', `gate-${gateNum}-*.sh`),
+    path.join(process.cwd(), 'githooks', `gate-${gateNum}.sh`),
+  ];
+
+  // Try glob patterns
+  for (const pattern of candidates) {
+    if (pattern.includes('*')) {
+      const dir = path.dirname(pattern);
+      const prefix = path.basename(pattern).replace('*', '');
+      if (fs.existsSync(dir)) {
+        const match = fs.readdirSync(dir).find(f => f.startsWith(`gate-${gateNum}-`) && f.endsWith('.sh'));
+        if (match) return path.join(dir, match);
+      }
+    } else if (fs.existsSync(pattern)) {
+      return pattern;
+    }
+  }
+
+  // Check global install
+  const globalDir = path.join(require('os').homedir(), '.config', 'xp-gate', 'adapters');
+  const globalScript = path.join(globalDir, `gate-${gateNum}.sh`);
+  if (fs.existsSync(globalScript)) return globalScript;
+
+  return null;
+}
+
+function getGateInfo(gateId) {
+  return GATE_REGISTRY[String(gateId)] || null;
+}
+
+function getAllGates() {
+  return Object.entries(GATE_REGISTRY).map(([id, info]) => ({
+    id,
+    name: info.name,
+    description: info.description,
+    preCommitOnly: info.preCommitOnly || false,
+    reason: info.reason || null,
+  }));
+}
+
+async function runGate(gateId, targetPath) {
+  const gate = GATE_REGISTRY[String(gateId)];
+  if (!gate) {
+    console.error(`Unknown gate: ${gateId}`);
+    console.error('Available gates: ' + Object.keys(GATE_REGISTRY).join(', '));
+    return 1;
+  }
+
+  if (gate.preCommitOnly) {
+    console.log(`━━━ Gate ${gateId}: ${gate.name} ━━━`);
+    console.log(`⏭️  SKIPPED - ${gate.reason}`);
+    console.log('   This gate runs automatically during git commit.');
+    console.log('   Run: git commit to trigger all gates.');
+    return 0;
+  }
+
+  if (gate.run) {
+    console.log(`━━━ Gate ${gateId}: ${gate.name} ━━━`);
+    try {
+      const result = gate.run(targetPath);
+      if (result && typeof result.then === 'function') {
+        return await result;
+      }
+      return 0;
+    } catch (err) {
+      console.error(` Gate ${gateId} FAILED: ${err.message}`);
+      return 1;
+    }
+  }
+
+  console.error(`Gate ${gateId}: ${gate.name} — no execution handler available`);
+  return 1;
+}
+
+module.exports = { GATE_REGISTRY, getGateInfo, getAllGates, runGate };

package/lib/shared-utils.js

@@ -60,7 +60,7 @@ function copyAdapters(srcDir, destDir) {
   const githooksDir = path.resolve(srcDir, '..', '..', '..', 'githooks');
   if (fs.existsSync(githooksDir)) {
     fs.readdirSync(githooksDir).forEach(f => {
-      if (f.startsWith('gate-') && f.endsWith('.sh')) {
+      if ((f.startsWith('gate-') || f === 'sprint-gate.sh') && f.endsWith('.sh')) {
         fs.copyFileSync(path.join(githooksDir, f), path.join(destDir, f));
       }
     });

package/lib/sprint-status.js

@@ -70,6 +70,7 @@ function statusIcon(status) {
   switch (status) {
     case 'completed': return '✅';
     case 'in_progress': return '🔄';
+    case 'skipped': return '⏭️';
     default: return '⏳';
   }
 }
@@ -145,7 +146,8 @@ function formatPhaseLine(key, history, maxNameLen) {
   const icon = statusIcon(status);
   const dur = formatDuration(history?.duration_seconds);
   const statusLabel = status === 'completed' ? 'Completed' :
-    status === 'in_progress' ? 'In Progress' : 'Pending';
+    status === 'in_progress' ? 'In Progress' :
+    status === 'skipped' ? 'Skipped' : 'Pending';
   return `  Phase ${key.padStart(4)}  ${name.padEnd(maxNameLen + 1)} ${icon} ${dur.padEnd(5)} ${statusLabel}`;
 }
 

package/lib/update-hooks.js

@@ -190,7 +190,7 @@ function copyAdapters(srcDir, destDir, dryRun, noBackup) {
 function copyGateScripts(srcDir, destDir, dryRun, noBackup) {
   if (!fs.existsSync(srcDir)) return;
   fs.readdirSync(srcDir).forEach(f => {
-    if (f.startsWith('gate-') && f.endsWith('.sh')) {
+    if ((f.startsWith('gate-') || f === 'sprint-gate.sh') && f.endsWith('.sh')) {
       const src = path.join(srcDir, f);
       const dest = path.join(destDir, f);
       atomicCopyFile(src, dest, dryRun, noBackup, f);

package/lib/upgrade.js

@@ -95,6 +95,14 @@ async function handleApplyMode(result, pkgName) {
     // Also check for and update the local OpenCode plugin if installed.
     await upgradeOpenCodePlugin();
 
+    // Update all installed skills to match the newly upgraded package (#332)
+    try {
+      const { updateSkill } = require('./update-skill.js');
+      await updateSkill(null, { all: true, verbose: false });
+    } catch {
+      // Non-blocking: skill update failure should never break the main upgrade flow.
+    }
+
     return 0;
   } catch (err) {
     const msg = err.message || '';

package/mock-policy/AGENTS.md

@@ -1,9 +1,9 @@
 # SRC/MOCK-POLICY KNOWLEDGE BASE
 
 **Generated:** 2026-07-13
-**Commit:** d83bb96
-**Branch:** main
-**Version:** 0.14.8.0
+**Commit:** cb954fe
+**Branch:** sprint/2026-07-13-01
+**Version:** 0.14.9.0
 
 ## OVERVIEW
 Mock layering policy enforcement — Gate M3 of pre-push hook. Ensures integration tests use real implementations for internal dependencies, mock external dependencies, and annotate pending mocks with removal plans. Combines project scope scanning, mock decision engine, and per-file validation into a single pipeline.

package/mutation/AGENTS.md

@@ -1,9 +1,9 @@
 # SRC/MUTATION KNOWLEDGE BASE
 
 **Generated:** 2026-07-13
-**Commit:** d83bb96
-**Branch:** main
-**Version:** 0.14.8.0
+**Commit:** cb954fe
+**Branch:** sprint/2026-07-13-01
+**Version:** 0.14.9.0
 
 ## OVERVIEW
 **Gate M** (incremental mutation testing) + **Gate M2** helpers (test-layer detection used by `src/mock-policy/`). Pre-push quality gate. TypeScript-only; uses Stryker.