@ckelsoe/prompt-architect 3.2.1 → 3.3.1

package/scripts/install.js

@@ -46,18 +46,24 @@ const AGENTS = [
         return true;
       } catch { return false; }
     },
-    installPath: () => path.join(os.homedir(), '.gemini', 'skills', SKILL_NAME),
+    installPath: (project) => project
+      ? path.join(process.cwd(), '.gemini', 'skills', SKILL_NAME)
+      : path.join(os.homedir(), '.gemini', 'skills', SKILL_NAME),
     format: 'skill',
-    hint: () => '~/.gemini/skills/',
+    hint: (project) => project ? '.gemini/skills/ (project)' : '~/.gemini/skills/',
   },
   {
     id: 'agents',
     name: 'Agent Skills (universal)',
     detect: () => true, // Always available
     alwaysShow: true,
-    installPath: () => path.join(os.homedir(), '.agents', 'skills', SKILL_NAME),
+    installPath: (project) => project
+      ? path.join(process.cwd(), '.agents', 'skills', SKILL_NAME)
+      : path.join(os.homedir(), '.agents', 'skills', SKILL_NAME),
     format: 'skill',
-    hint: () => '~/.agents/skills/ (30+ compatible agents)',
+    hint: (project) => project
+      ? '.agents/skills/ (project, 30+ compatible agents)'
+      : '~/.agents/skills/ (30+ compatible agents)',
   },
   {
     id: 'windsurf',
@@ -66,6 +72,7 @@ const AGENTS = [
       return fs.existsSync(path.join(process.cwd(), '.windsurfrules')) ||
              fs.existsSync(path.join(os.homedir(), '.windsurf'));
     },
+    // .windsurfrules is inherently project-scoped, so --project is a no-op here.
     installPath: () => path.join(process.cwd(), '.windsurfrules'),
     format: 'adapter',
     adapterFile: 'for-windsurf.md',
@@ -128,12 +135,24 @@ function copyRecursive(src, dest) {
 const MARKER_START = '<!-- prompt-architect-start -->';
 const MARKER_END = '<!-- prompt-architect-end -->';
 
-function installSkillDir(sourcePath, destPath) {
+function installSkillDir(sourcePath, destPath, force = false) {
   const parentDir = path.dirname(destPath);
   if (!fs.existsSync(parentDir)) fs.mkdirSync(parentDir, { recursive: true });
 
+  // A symlink here almost always means the user has pointed this path at a
+  // working copy they are actively editing. rmSync would silently delete the
+  // link, so refuse unless they explicitly opt in with --force.
+  let linkStat = null;
+  try { linkStat = fs.lstatSync(destPath); } catch { /* does not exist */ }
+  if (linkStat && linkStat.isSymbolicLink() && !force) {
+    throw new Error(
+      `${destPath} is a symlink — refusing to replace it. ` +
+      `Remove it first, or re-run with --force if you meant to overwrite.`
+    );
+  }
+
   // Remove existing installation
-  if (fs.existsSync(destPath)) fs.rmSync(destPath, { recursive: true, force: true });
+  if (fs.existsSync(destPath) || linkStat) fs.rmSync(destPath, { recursive: true, force: true });
 
   copyRecursive(sourcePath, destPath);
 
@@ -154,16 +173,19 @@ function installAdapter(adaptersPath, agent, destPath) {
 
   if (agent.appendMode && fs.existsSync(destPath)) {
     const existing = fs.readFileSync(destPath, 'utf8');
-    // Remove old content if present
+    // Strip every previously-installed block, not just the first — without the
+    // `g` flag an older duplicate would survive and accumulate on each run.
     const cleaned = existing.replace(
-      new RegExp(`\\n?${escapeRegex(MARKER_START)}[\\s\\S]*?${escapeRegex(MARKER_END)}\\n?`),
+      new RegExp(`\\n?${escapeRegex(MARKER_START)}[\\s\\S]*?${escapeRegex(MARKER_END)}\\n?`, 'g'),
       ''
     );
     fs.writeFileSync(destPath, cleaned + markedContent, 'utf8');
   } else {
     const parentDir = path.dirname(destPath);
     if (!fs.existsSync(parentDir)) fs.mkdirSync(parentDir, { recursive: true });
-    fs.writeFileSync(destPath, adapterContent, 'utf8');
+    // Must write the *marked* content — an unmarked first copy is invisible to
+    // the strip above and could never be reclaimed on reinstall.
+    fs.writeFileSync(destPath, markedContent, 'utf8');
   }
 }
 
@@ -227,15 +249,19 @@ function showHelp() {
   Options:
     -a, --all      Install to all detected agents
     -p, --project  Use project-local paths where applicable
-    -f, --force    Overwrite existing installations
+    -f, --force    Also replace a symlinked install path (refused by default)
     -y, --yes      Accept defaults (all detected agents)
     -h, --help     Show this help
+
+  Note: installing always overwrites an existing skill directory. --force is
+  only needed when the target path is a symlink, which usually means you have
+  pointed it at a working copy on purpose.
 `);
 }
 
 // ─── Non-Interactive Install ─────────────────────────────────────
 
-function installNonInteractive(agentIds, sourcePath, adaptersPath, isProject) {
+function installNonInteractive(agentIds, sourcePath, adaptersPath, isProject, force) {
   const version = getVersion();
   const results = [];
 
@@ -245,7 +271,7 @@ function installNonInteractive(agentIds, sourcePath, adaptersPath, isProject) {
     const destPath = agent.installPath(isProject);
     try {
       if (agent.format === 'skill') {
-        installSkillDir(sourcePath, destPath);
+        installSkillDir(sourcePath, destPath, force);
       } else {
         installAdapter(adaptersPath, agent, destPath);
       }
@@ -278,7 +304,7 @@ function installNonInteractive(agentIds, sourcePath, adaptersPath, isProject) {
 
 // ─── Interactive Install ─────────────────────────────────────────
 
-async function installInteractive(sourcePath, adaptersPath, isProject) {
+async function installInteractive(sourcePath, adaptersPath, isProject, force) {
   const p = require('@clack/prompts');
   const version = getVersion();
 
@@ -352,7 +378,7 @@ async function installInteractive(sourcePath, adaptersPath, isProject) {
 
     try {
       if (agent.format === 'skill') {
-        installSkillDir(sourcePath, destPath);
+        installSkillDir(sourcePath, destPath, force);
       } else {
         installAdapter(adaptersPath, agent, destPath);
       }
@@ -405,27 +431,27 @@ async function main() {
 
   // Mode 1: Specific agent flags provided
   if (specificAgents.length > 0) {
-    installNonInteractive(specificAgents, sourcePath, adaptersPath, isProject);
+    installNonInteractive(specificAgents, sourcePath, adaptersPath, isProject, flags.force);
     return;
   }
 
   // Mode 2: --all flag
   if (flags.all) {
     const detected = AGENTS.filter(a => a.detect()).map(a => a.id);
-    installNonInteractive(detected, sourcePath, adaptersPath, isProject);
+    installNonInteractive(detected, sourcePath, adaptersPath, isProject, flags.force);
     return;
   }
 
   // Mode 3: --yes flag (accept defaults = all detected, non-interactive)
   if (flags.yes) {
-    const detected = AGENTS.filter(a => a.detect() && !a.alwaysShow).map(a => a.id);
-    installNonInteractive(detected.length > 0 ? detected : ['claude'], sourcePath, adaptersPath, isProject);
+    const detected = AGENTS.filter(a => a.detect()).map(a => a.id);
+    installNonInteractive(detected, sourcePath, adaptersPath, isProject, flags.force);
     return;
   }
 
   // Mode 4: Interactive
   if (isInteractive) {
-    await installInteractive(sourcePath, adaptersPath, isProject);
+    await installInteractive(sourcePath, adaptersPath, isProject, flags.force);
     return;
   }
 
@@ -435,12 +461,16 @@ async function main() {
   const version = getVersion();
   const results = [];
 
-  for (const agent of AGENTS) {
-    if (agent.id !== 'claude') continue;
+  // Install to every detected agent — this is the path most users hit via the
+  // postinstall hook, so restricting it to one agent would silently defeat the
+  // package's multi-agent support.
+  for (const agent of AGENTS.filter(a => a.detect())) {
     const destPath = agent.installPath(isProject);
     try {
       if (agent.format === 'skill') {
-        installSkillDir(sourcePath, destPath);
+        installSkillDir(sourcePath, destPath, flags.force);
+      } else {
+        installAdapter(adaptersPath, agent, destPath);
       }
       results.push({ agent: agent.name, path: destPath, success: true });
     } catch (err) {

package/scripts/test.js

@@ -63,50 +63,34 @@ test('CHANGELOG.md exists', () => {
   if (!fs.existsSync('CHANGELOG.md')) throw new Error('Not found');
 });
 
-test('All framework files exist', () => {
-  const frameworks = [
-    'co-star.md',
-    'risen.md',
-    'rise.md',
-    'tidd-ec.md',
-    'rtf.md',
-    'chain-of-thought.md',
-    'chain-of-density.md',
-  ];
-  frameworks.forEach(f => {
-    const fpath = path.join('skills', 'prompt-architect', 'references', 'frameworks', f);
-    if (!fs.existsSync(fpath)) {
-      throw new Error(`Framework ${f} not found`);
-    }
-  });
-});
+const FRAMEWORKS_DIR = path.join('skills', 'prompt-architect', 'references', 'frameworks');
+const TEMPLATES_DIR = path.join('skills', 'prompt-architect', 'assets', 'templates');
 
-test('All templates exist', () => {
-  const templates = [
-    'co-star_template.txt',
-    'risen_template.txt',
-    'rise-ie_template.txt',
-    'rise-ix_template.txt',
-    'tidd-ec_template.txt',
-    'rtf_template.txt',
-    'hybrid_template.txt',
-  ];
-  templates.forEach(t => {
-    const tpath = path.join('skills', 'prompt-architect', 'assets', 'templates', t);
-    if (!fs.existsSync(tpath)) {
-      throw new Error(`Template ${t} not found`);
-    }
-  });
+test('Framework reference docs exist', () => {
+  const docs = fs.readdirSync(FRAMEWORKS_DIR).filter(f => f.endsWith('.md'));
+  if (docs.length === 0) {
+    throw new Error('No framework reference docs found');
+  }
 });
 
-test('Python scripts exist', () => {
-  const scripts = ['framework_analyzer.py', 'prompt_evaluator.py'];
-  scripts.forEach(s => {
-    const spath = path.join('skills', 'prompt-architect', 'scripts', s);
-    if (!fs.existsSync(spath)) {
-      throw new Error(`Script ${s} not found`);
+test('Every framework has a template', () => {
+  // rise.md defines two independently-selectable frameworks.
+  const multi = { 'rise.md': ['rise-ie', 'rise-ix'] };
+  const templates = new Set(fs.readdirSync(TEMPLATES_DIR));
+  const missing = [];
+
+  for (const doc of fs.readdirSync(FRAMEWORKS_DIR).filter(f => f.endsWith('.md'))) {
+    const slugs = multi[doc] || [doc.replace(/\.md$/, '')];
+    for (const slug of slugs) {
+      if (!templates.has(`${slug}_template.txt`)) missing.push(`${slug}_template.txt`);
     }
-  });
+  }
+  if (missing.length > 0) {
+    throw new Error(`Missing templates: ${missing.join(', ')}`);
+  }
+  if (!templates.has('hybrid_template.txt')) {
+    throw new Error('Missing hybrid_template.txt');
+  }
 });
 
 test('package.json has required fields', () => {
@@ -163,6 +147,44 @@ test('All adapter files exist', () => {
   });
 });
 
+// SKILL.md <-> adapter drift guard.
+// These two files are hand-maintained copies of the same instructions and have
+// drifted before (the adapter was renumbered 1-7 while SKILL.md kept a duplicate
+// step 4). Compare the sections that must stay identical.
+test('Adapter has not drifted from SKILL.md', () => {
+  const skill = fs.readFileSync('skills/prompt-architect/SKILL.md', 'utf8');
+  const adapter = fs.readFileSync('adapters/system-prompt.md', 'utf8');
+
+  // 1. Step headings must match in number, order, and title.
+  const steps = s => (s.match(/^### \d+\. .+$/gm) || []).map(h => h.trim());
+  const skillSteps = steps(skill);
+  const adapterSteps = steps(adapter);
+  if (skillSteps.join('|') !== adapterSteps.join('|')) {
+    throw new Error(
+      `Step headings differ.\n  SKILL.md: ${JSON.stringify(skillSteps)}\n  adapter:  ${JSON.stringify(adapterSteps)}`
+    );
+  }
+
+  // 2. Step numbers must be a clean 1..N with no duplicates.
+  const nums = skillSteps.map(h => parseInt(h.match(/^### (\d+)\./)[1], 10));
+  const expected = nums.map((_, i) => i + 1);
+  if (nums.join(',') !== expected.join(',')) {
+    throw new Error(`Step numbering is not sequential: ${nums.join(',')}`);
+  }
+
+  // 3. The intent-routing framework names must match between the two files.
+  const routed = s => [...s.matchAll(/\*\*([A-Za-z][A-Za-z0-9 +'’-]*?)\*\*/g)]
+    .map(m => m[1]).filter(n => /^[A-Z]/.test(n));
+  const missing = [...new Set(routed(skill))].filter(n => !routed(adapter).includes(n));
+  const routingNames = ['CO-STAR', 'RISEN', 'RISE-IE', 'RISE-IX', 'TIDD-EC', 'CTF', 'RTF',
+    'APE', 'BAB', 'RACE', 'CRISPE', 'BROKE', 'CARE', 'ReAct', 'RCoT', 'RPEF'];
+  const dropped = routingNames.filter(n => skill.includes(n) && !adapter.includes(n));
+  if (dropped.length > 0) {
+    throw new Error(`Frameworks in SKILL.md but missing from adapter: ${dropped.join(', ')}`);
+  }
+  void missing;
+});
+
 // Agent Skills compliance tests
 test('SKILL.md has Agent Skills required fields', () => {
   const content = fs.readFileSync('skills/prompt-architect/SKILL.md', 'utf8');

package/scripts/validate-skill.js

@@ -49,35 +49,49 @@ const SKILL_DIR = path.join(__dirname, '..', 'skills', 'prompt-architect');
 const SKILL_FILE = path.join(SKILL_DIR, 'SKILL.md');
 
 const REQUIRED_DIRS = [
-  'scripts',
   'references/frameworks',
   'assets/templates',
 ];
 
-const REQUIRED_FRAMEWORKS = [
-  'co-star.md',
-  'risen.md',
-  'rise.md',
-  'tidd-ec.md',
-  'rtf.md',
-  'chain-of-thought.md',
-  'chain-of-density.md',
-];
+const FRAMEWORKS_DIR = path.join(SKILL_DIR, 'references', 'frameworks');
+const TEMPLATES_DIR = path.join(SKILL_DIR, 'assets', 'templates');
 
-const REQUIRED_TEMPLATES = [
-  'co-star_template.txt',
-  'risen_template.txt',
-  'rise-ie_template.txt',
-  'rise-ix_template.txt',
-  'tidd-ec_template.txt',
-  'rtf_template.txt',
-  'hybrid_template.txt',
-];
+// Templates that are not named after a single framework.
+const NON_FRAMEWORK_TEMPLATES = ['hybrid_template.txt'];
 
-const REQUIRED_SCRIPTS = [
-  'framework_analyzer.py',
-  'prompt_evaluator.py',
-];
+// Reference docs that define more than one independently-selectable framework.
+// rise.md documents RISE-IE and RISE-IX, each with its own template and routing row.
+const MULTI_FRAMEWORK_DOCS = { 'rise.md': ['rise-ie', 'rise-ix'] };
+
+// Read the filesystem rather than hardcoding lists — a hardcoded subset is why
+// count drift and a deleted reference doc could both pass CI silently.
+function listFrameworkDocs() {
+  return fs.readdirSync(FRAMEWORKS_DIR).filter(f => f.endsWith('.md')).sort();
+}
+
+function listTemplates() {
+  return fs.readdirSync(TEMPLATES_DIR).filter(f => f.endsWith('.txt')).sort();
+}
+
+// The advertised framework count: one per reference doc, except docs that
+// define several.
+function expectedFrameworkCount() {
+  return listFrameworkDocs().reduce(
+    (n, doc) => n + (MULTI_FRAMEWORK_DOCS[doc] ? MULTI_FRAMEWORK_DOCS[doc].length : 1),
+    0
+  );
+}
+
+// Every template slug a framework doc implies.
+function expectedTemplateSlugs() {
+  const slugs = [];
+  for (const doc of listFrameworkDocs()) {
+    const base = doc.replace(/\.md$/, '');
+    if (MULTI_FRAMEWORK_DOCS[doc]) slugs.push(...MULTI_FRAMEWORK_DOCS[doc]);
+    else slugs.push(base);
+  }
+  return slugs;
+}
 
 let errorCount = 0;
 let warningCount = 0;
@@ -115,47 +129,59 @@ function validateSkill() {
 
   // Check framework files
   info('\nValidating framework files...');
-  REQUIRED_FRAMEWORKS.forEach(framework => {
-    const frameworkPath = path.join(SKILL_DIR, 'references', 'frameworks', framework);
-    if (!fs.existsSync(frameworkPath)) {
-      error(`Framework file missing: ${framework}`);
-      errorCount++;
-    } else {
-      const stats = fs.statSync(frameworkPath);
-      const sizeKB = (stats.size / 1024).toFixed(2);
-      success(`Framework found: ${framework} (${sizeKB} KB)`);
-      
-      // Warn if framework file is too small
-      if (stats.size < 5000) {
-        warning(`Framework ${framework} seems small (< 5 KB)`);
-        warningCount++;
-      }
+  const frameworkDocs = listFrameworkDocs();
+  if (frameworkDocs.length === 0) {
+    error('No framework reference docs found');
+    errorCount++;
+  }
+  frameworkDocs.forEach(framework => {
+    const stats = fs.statSync(path.join(FRAMEWORKS_DIR, framework));
+    if (stats.size < 5000) {
+      warning(`Framework ${framework} seems small (< 5 KB)`);
+      warningCount++;
     }
   });
+  success(`${frameworkDocs.length} framework reference docs found`);
 
-  // Check template files
+  // Check every framework has its template, and no template is orphaned
   info('\nValidating template files...');
-  REQUIRED_TEMPLATES.forEach(template => {
-    const templatePath = path.join(SKILL_DIR, 'assets', 'templates', template);
-    if (!fs.existsSync(templatePath)) {
-      error(`Template file missing: ${template}`);
+  const templates = listTemplates();
+  const templateSet = new Set(templates);
+  let templateErrors = 0;
+
+  for (const slug of expectedTemplateSlugs()) {
+    const expected = `${slug}_template.txt`;
+    if (!templateSet.has(expected)) {
+      error(`Template missing for framework "${slug}": ${expected}`);
       errorCount++;
-    } else {
-      success(`Template found: ${template}`);
+      templateErrors++;
     }
-  });
+  }
 
-  // Check script files
-  info('\nValidating script files...');
-  REQUIRED_SCRIPTS.forEach(script => {
-    const scriptPath = path.join(SKILL_DIR, 'scripts', script);
-    if (!fs.existsSync(scriptPath)) {
-      error(`Script file missing: ${script}`);
+  const expectedSet = new Set([
+    ...expectedTemplateSlugs().map(s => `${s}_template.txt`),
+    ...NON_FRAMEWORK_TEMPLATES,
+  ]);
+  for (const template of templates) {
+    if (!expectedSet.has(template)) {
+      error(`Orphaned template with no corresponding framework doc: ${template}`);
       errorCount++;
-    } else {
-      success(`Script found: ${script}`);
+      templateErrors++;
     }
-  });
+  }
+  for (const template of NON_FRAMEWORK_TEMPLATES) {
+    if (!templateSet.has(template)) {
+      error(`Required non-framework template missing: ${template}`);
+      errorCount++;
+      templateErrors++;
+    }
+  }
+  if (templateErrors === 0) {
+    success(`${templates.length} templates found, all matched to frameworks`);
+  }
+
+  // Cross-check the advertised count against what is actually on disk
+  validateFrameworkCount();
 
   // Check package structure
   info('\nValidating package structure...');
@@ -170,6 +196,107 @@ function validateSkill() {
 
 }
 
+// Assert the advertised framework count matches the filesystem, everywhere it
+// is stated. This is the check whose absence let "27" survive to v3.2.2 while
+// 28 frameworks shipped.
+function validateFrameworkCount() {
+  info('\nValidating advertised framework count...');
+  const actual = expectedFrameworkCount();
+  const root = path.join(__dirname, '..');
+  const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+
+  const declared = (pkg.claudeCode && pkg.claudeCode.frameworks) || [];
+  if (declared.length !== actual) {
+    error(`package.json claudeCode.frameworks lists ${declared.length} frameworks, but ${actual} exist on disk`);
+    errorCount++;
+  } else {
+    success(`claudeCode.frameworks matches disk (${actual})`);
+  }
+
+  // Any prose that says "<N> ... framework" or "<N>-framework" must say N = actual.
+  const proseSites = [
+    'package.json',
+    '.claude-plugin/plugin.json',
+    '.claude-plugin/marketplace.json',
+    'README.md',
+    'adapters/system-prompt.md',
+    path.join('skills', 'prompt-architect', 'SKILL.md'),
+  ];
+  const countPattern = /(\d+)[\s-]+(?:research-backed\s+)?frameworks?\b/gi;
+  let mismatches = 0;
+
+  for (const rel of proseSites) {
+    const full = path.join(root, rel);
+    if (!fs.existsSync(full)) continue;
+    const lines = fs.readFileSync(full, 'utf8').split('\n');
+    lines.forEach((line, i) => {
+      let m;
+      countPattern.lastIndex = 0;
+      while ((m = countPattern.exec(line)) !== null) {
+        const n = parseInt(m[1], 10);
+        // Ignore small numbers — those are phrases like "two frameworks", or
+        // "2 frameworks" inside an explanatory sentence, not the headline count.
+        if (n >= 10 && n !== actual) {
+          error(`${rel}:${i + 1} advertises ${n} frameworks, but ${actual} exist — "${m[0]}"`);
+          errorCount++;
+          mismatches++;
+        }
+      }
+    });
+  }
+  if (mismatches === 0) {
+    success(`All advertised framework counts agree (${actual})`);
+  }
+}
+
+// CLAUDE.md claims CI validates the SKILL.md version. It did not. It does now,
+// along with every other site that carries the version.
+function validateVersionSites() {
+  info('\nValidating version consistency across all sites...');
+  const root = path.join(__dirname, '..');
+  const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+  const expected = pkg.version;
+
+  const sites = [];
+
+  sites.push({ name: 'package.json claudeCode.version', value: pkg.claudeCode && pkg.claudeCode.version });
+
+  const pluginPath = path.join(root, '.claude-plugin', 'plugin.json');
+  if (fs.existsSync(pluginPath)) {
+    sites.push({ name: 'plugin.json version', value: JSON.parse(fs.readFileSync(pluginPath, 'utf8')).version });
+  }
+
+  const marketPath = path.join(root, '.claude-plugin', 'marketplace.json');
+  if (fs.existsSync(marketPath)) {
+    const market = JSON.parse(fs.readFileSync(marketPath, 'utf8'));
+    (market.plugins || []).forEach((p, i) => {
+      sites.push({ name: `marketplace.json plugins[${i}].version`, value: p.version });
+    });
+  }
+
+  if (fs.existsSync(SKILL_FILE)) {
+    const fm = fs.readFileSync(SKILL_FILE, 'utf8').match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    const m = fm && fm[1].match(/^\s*version:\s*["']?([^"'\r\n]+)["']?\s*$/m);
+    sites.push({ name: 'SKILL.md metadata.version', value: m ? m[1].trim() : undefined });
+  }
+
+  let bad = 0;
+  for (const site of sites) {
+    if (site.value === undefined) {
+      error(`${site.name} is missing — cannot verify it matches package.json (${expected})`);
+      errorCount++;
+      bad++;
+    } else if (site.value !== expected) {
+      error(`${site.name} is ${site.value}, expected ${expected}`);
+      errorCount++;
+      bad++;
+    }
+  }
+  if (bad === 0) {
+    success(`All ${sites.length + 1} version sites agree (${expected})`);
+  }
+}
+
 function validateSkillFile() {
   const content = fs.readFileSync(SKILL_FILE, 'utf8');
   
@@ -185,7 +312,7 @@ function validateSkillFile() {
   const frontmatter = frontmatterMatch[1];
   
   // Check required fields
-  const requiredFields = ['name', 'description'];
+  const requiredFields = ['name', 'description', 'version'];
   requiredFields.forEach(field => {
     if (!frontmatter.includes(`${field}:`)) {
       error(`SKILL.md missing required field: ${field}`);
@@ -330,6 +457,7 @@ function validatePluginManifest() {
 try {
   validateSkill();
   validatePluginManifest();
+  validateVersionSites();
 
   // Final summary
   log('\n' + '='.repeat(50), 'blue');