@pigcloud/skills 1.0.11 → 1.1.2

package/scripts/ci-validator.sh

@@ -1,114 +1,51 @@
-#!/bin/bash
-# ci-validator.sh - Skills CI 楠岃瘉鑴氭湰
-# 鐢ㄤ簬楠岃瘉鎶€鑳芥枃浠剁殑瀹屾暣鎬у拰瑙勮寖鎬?
-
-set -e
-
-echo "=== Skills CI Validator ==="
-
-# 1. 妫€鏌ユ妧鑳芥枃浠跺畬鏁存€?
-echo "[1/5] Checking skill files..."
-SKILLS_DIR="${SKILLS_DIR:-.trae/skills}"
-ERROR_COUNT=0
-
-for skill in $(find "$SKILLS_DIR" -name "SKILL.md" -type f); do
-    skill_name=$(basename $(dirname "$skill"))
-    
-    # 妫€鏌?frontmatter
-    if ! grep -q "^name:" "$skill"; then
-        echo "ERROR: Missing 'name' in $skill"
-        ERROR_COUNT=$((ERROR_COUNT + 1))
-    fi
-    if ! grep -q "^description:" "$skill"; then
-        echo "ERROR: Missing 'description' in $skill"
-        ERROR_COUNT=$((ERROR_COUNT + 1))
-    fi
-    if ! grep -q "^lifecycle_stage:" "$skill"; then
-        echo "WARN: Missing 'lifecycle_stage' in $skill"
-    fi
-    if ! grep -q "^version:" "$skill"; then
-        echo "WARN: Missing 'version' in $skill"
-    fi
-    
-    # 妫€鏌ュ繀瑕佺珷鑺?
-    for section in "When to Run" "Workflow"; do
-        if ! grep -q "## $section" "$skill"; then
-            echo "ERROR: Missing '$section' section in $skill"
-            ERROR_COUNT=$((ERROR_COUNT + 1))
-        fi
-    done
-    
-    # 妫€鏌?Lifecycle Position锛堟柊澧烇級
-    if ! grep -q "## Lifecycle Position" "$skill"; then
-        echo "WARN: Missing 'Lifecycle Position' in $skill (recommended)"
-    fi
-    
-    echo "鉁?$skill_name valid"
-done
-
-if [ "$ERROR_COUNT" -gt 0 ]; then
-    echo "ERROR: $ERROR_COUNT errors found in skill files"
-    exit 1
-fi
-echo "鉁?Skill files valid"
-
-# 2. 妫€鏌ョ敓鍛藉懆鏈熸槧灏勫畬鏁存€?
-echo "[2/5] Checking lifecycle mapping..."
-LIFECYCLE_STAGES="define plan build verify review ship meta"
-for stage in $LIFECYCLE_STAGES; do
-    count=$(grep -l "lifecycle_stage: \"$stage\"" $(find "$SKILLS_DIR" -name "SKILL.md" -type f) 2>/dev/null | wc -l || echo "0")
-    if [ "$count" -eq 0 ] && [ "$stage" != "meta" ]; then
-        echo "WARN: No skill mapped to '$stage' stage"
-    else
-        echo "鉁?$stage stage has $count skills"
-    fi
-done
-
-# 3. 妫€鏌ユ妧鑳介棿渚濊禆涓€鑷存€?
-echo "[3/5] Checking skill dependencies..."
-for skill in $(find "$SKILLS_DIR" -name "SKILL.md" -type f); do
-    deps=$(grep "^dependencies:" "$skill" | sed 's/dependencies: //' | tr ',' ' ' 2>/dev/null || echo "")
-    for dep in $deps; do
-        dep_name=$(echo "$dep" | tr -d '[]"')
-        if [ -n "$dep_name" ] && [ ! -d "$SKILLS_DIR/$dep_name" ]; then
-            echo "ERROR: Dependency '$dep_name' not found for $(basename $(dirname "$skill"))"
-            ERROR_COUNT=$((ERROR_COUNT + 1))
-        fi
-    done
-done
-
-if [ "$ERROR_COUNT" -gt 0 ]; then
-    echo "ERROR: Dependency errors found"
-    exit 1
-fi
-echo "鉁?Dependencies valid"
-
-# 4. 妫€鏌?Reference Checklists
-echo "[4/5] Checking reference checklists..."
-REQUIRED_CHECKLISTS="coding-checklist.md solid-checklist.md security-checklist.md performance-auditlist.md anti-rationalization.md"
-for checklist in $REQUIRED_CHECKLISTS; do
-    found=$(find "$SKILLS_DIR" -name "$checklist" -type f | wc -l)
-    if [ "$found" -eq 0 ]; then
-        echo "WARN: Missing reference checklist '$checklist'"
-    else
-        echo "鉁?Found $checklist"
-    fi
-done
-
-# 5. 妫€鏌?Agent Personas 鍜?Slash Commands
-echo "[5/5] Checking agent personas and slash commands..."
-if [ ! -f "$SKILLS_DIR/../references/agent-personas.md" ]; then
-    echo "WARN: Missing agent-personas.md"
-else
-    echo "鉁?Found agent-personas.md"
-fi
-
-if [ ! -f "$SKILLS_DIR/../references/slash-commands.md" ]; then
-    echo "WARN: Missing slash-commands.md"
-else
-    echo "鉁?Found slash-commands.md"
-fi
-
-echo "=== CI Validator Complete ==="
-echo "All checks passed!"
-exit 0
+#!/bin/bash
+
+set -e
+
+echo "=== Skills CI Validator ==="
+
+SKILLS_DIR="${SKILLS_DIR:-skills}"
+ERROR_COUNT=0
+
+echo "[1/3] Checking minimal skill contract..."
+for skill in $(find "$SKILLS_DIR" -name "SKILL.md" -type f); do
+    if ! grep -q "^name:" "$skill"; then
+        echo "ERROR: Missing 'name' in $skill"
+        ERROR_COUNT=$((ERROR_COUNT + 1))
+    fi
+    if ! grep -q "^description:" "$skill"; then
+        echo "ERROR: Missing 'description' in $skill"
+        ERROR_COUNT=$((ERROR_COUNT + 1))
+    fi
+
+    if grep -q "^lifecycle_stage:" "$skill" || grep -q "^rule_profile:" "$skill" || grep -q "^dependencies:" "$skill" || grep -q "^triggers:" "$skill" || grep -q "^inputs:" "$skill" || grep -q "^outputs:" "$skill" || grep -q "^workflow:" "$skill" || grep -q "^gates:" "$skill" || grep -q "^refs:" "$skill"; then
+        echo "ERROR: Legacy metadata found in $skill"
+        ERROR_COUNT=$((ERROR_COUNT + 1))
+    fi
+done
+
+if [ "$ERROR_COUNT" -gt 0 ]; then
+    echo "ERROR: $ERROR_COUNT error(s) found in skill files"
+    exit 1
+fi
+
+echo "[2/3] Checking canonical mappings..."
+if [ ! -f "$SKILLS_DIR/../rules/stages.json" ]; then
+    echo "ERROR: Missing rules/stages.json"
+    exit 1
+fi
+if [ ! -f "$SKILLS_DIR/../rules/skill-stage-map.json" ]; then
+    echo "ERROR: Missing rules/skill-stage-map.json"
+    exit 1
+fi
+
+echo "[3/3] Checking reference docs..."
+for file in "$SKILLS_DIR/../rules/index.md" "$SKILLS_DIR/../docs/skill-system-target.md"; do
+    if [ ! -f "$file" ]; then
+        echo "ERROR: Missing $file"
+        exit 1
+    fi
+done
+
+echo "=== CI Validator Complete ==="
+echo "All checks passed!"

package/scripts/generate-skill-prompt-library.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require('./migrate-skill-packages');

package/scripts/golden-prompt-suite.current.js

@@ -0,0 +1,211 @@
+function makeCase(skill, id, prompt, expectedOutput, expectedStop, expectedHandoff) {
+  return {
+    id,
+    prompt,
+    expectedFirstSkill: skill,
+    expectedOutput,
+    expectedStop,
+    expectedHandoff,
+  };
+}
+
+const cases = [
+  makeCase(
+    'requirement-discovery',
+    'discovery-clarify-scope',
+    'This request is still vague. Clarify the goal, success target, and missing facts first.',
+    ['problem statement', 'success target', 'unknowns', 'constraints', 'routing recommendation'],
+    'Do not jump into design or code; stop once the request is routeable.',
+    'business-analysis or ambiguity-detection',
+  ),
+  makeCase(
+    'business-analysis',
+    'analysis-business-terms',
+    'This is a business description. Extract the business goal, terms, and boundaries.',
+    ['glossary', 'business rules', 'ownership boundaries'],
+    'Do not decide design or implementation details.',
+    'ambiguity-detection',
+  ),
+  makeCase(
+    'ambiguity-detection',
+    'ambiguity-conflict-scan',
+    'This request may contain contradictions or hidden assumptions. Find them.',
+    ['blockers', 'conflicts', 'missing decisions'],
+    'Do not resolve conflicts without evidence.',
+    'impact-analysis',
+  ),
+  makeCase(
+    'impact-analysis',
+    'impact-existing-system',
+    'This change may affect an existing system. Map the impact surface.',
+    ['impact map', 'validation surfaces', 'release risks'],
+    'Do not write implementation.',
+    'architecture-design',
+  ),
+  makeCase(
+    'architecture-design',
+    'architecture-multi-module',
+    'This request affects multiple modules. Design the boundaries and tradeoffs.',
+    ['architecture decisions', 'boundaries', 'tradeoffs'],
+    'Do not write production code yet.',
+    'api-design',
+  ),
+  makeCase(
+    'api-design',
+    'api-contract-new-endpoint',
+    'Define a new API endpoint. Design the request, response, and compatibility rules.',
+    ['request shape', 'response shape', 'constraints'],
+    'Do not change implementation.',
+    'database-design',
+  ),
+  makeCase(
+    'database-design',
+    'database-schema-plan',
+    'This feature needs persistence. Design the schema and query shape.',
+    ['schema', 'indexes', 'query plan'],
+    'Do not write migration code yet.',
+    'task-breakdown',
+  ),
+  makeCase(
+    'task-breakdown',
+    'breakdown-executable-work',
+    'The plan is fixed. Break it into executable and verifiable tasks.',
+    ['task list', 'ordering', 'acceptance points'],
+    'Do not start implementation.',
+    'backend-development',
+  ),
+  makeCase(
+    'backend-development',
+    'backend-implementation-plan',
+    'This backend capability needs implementation. Give the smallest viable approach and code changes.',
+    ['implementation notes', 'code changes', 'validation'],
+    'Do not expand scope.',
+    'unit-test',
+  ),
+  makeCase(
+    'frontend-development',
+    'frontend-implementation-plan',
+    'This frontend page or component needs implementation. Outline the key steps and constraints.',
+    ['component changes', 'state handling', 'validation'],
+    'Do not change unrelated UI.',
+    'unit-test',
+  ),
+  makeCase(
+    'database-change',
+    'database-migration-safety',
+    'This change needs a database schema update. Confirm migration and rollback safety.',
+    ['migration steps', 'safety checks', 'rollback'],
+    'Do not skip rollback planning.',
+    'regression-check',
+  ),
+  makeCase(
+    'bug-fix',
+    'bugfix-minimal-root-cause',
+    'This bug already reproduced. Identify the root cause and give the smallest fix.',
+    ['root cause', 'fix', 'verification'],
+    'Do not broaden the scope.',
+    'regression-check',
+  ),
+  makeCase(
+    'unit-test',
+    'unit-test-behavior-coverage',
+    'This behavior needs tests. Design unit tests that cover the expected behavior.',
+    ['test cases', 'assertions', 'edge cases'],
+    'Do not modify production code.',
+    'code-review',
+  ),
+  makeCase(
+    'code-review',
+    'review-diff-correctness',
+    'Review this diff for correctness, maintainability, and regression risk.',
+    ['findings', 'severity', 'fix recommendations'],
+    'Do not refactor the code inside the review step.',
+    'evidence-collector',
+  ),
+  makeCase(
+    'security-review',
+    'security-risk-check',
+    'Check whether this change introduces auth, injection, or data exposure risks.',
+    ['security findings', 'risk level', 'mitigation'],
+    'Do not rewrite code.',
+    'regression-check',
+  ),
+  makeCase(
+    'performance-review',
+    'performance-bottleneck-check',
+    'Check whether this change introduces latency, throughput, or resource pressure risks.',
+    ['performance findings', 'bottleneck map', 'optimization advice'],
+    'Do not rewrite code.',
+    'regression-check',
+  ),
+  makeCase(
+    'regression-check',
+    'regression-behavior-scan',
+    'The change is complete. Check whether related behavior broke.',
+    ['regression matrix', 'safety check', 'remaining risk'],
+    'Do not change production code.',
+    'release-check',
+  ),
+  makeCase(
+    'release-check',
+    'release-readiness-check',
+    'Before release, check readiness and blockers.',
+    ['release readiness', 'blockers', 'next actions'],
+    'Do not start new feature work.',
+    'release-validation',
+  ),
+  makeCase(
+    'release-validation',
+    'release-post-check',
+    'After release, confirm the core behavior and release result are healthy.',
+    ['verification result', 'release status', 'issues'],
+    'Do not redesign the release plan.',
+    'change-log',
+  ),
+  makeCase(
+    'change-log',
+    'changelog-summary',
+    'Summarize this change into a clear changelog entry.',
+    ['change summary', 'impact', 'notes'],
+    'Do not rewrite implementation details.',
+    'deployment-guide',
+  ),
+  makeCase(
+    'deployment-guide',
+    'deployment-runbook',
+    'Write the deployment and startup guide for this capability.',
+    ['startup', 'verify', 'recover'],
+    'Do not change product scope.',
+    'codebase-learning',
+  ),
+  makeCase(
+    'codebase-learning',
+    'repo-orientation',
+    'I just entered this repository. Help me quickly map the structure, conventions, and key facts.',
+    ['repo map', 'conventions', 'key facts'],
+    'Do not propose implementation changes yet.',
+    'evidence-collector',
+  ),
+  makeCase(
+    'evidence-collector',
+    'evidence-pack',
+    'Organize the current evidence into a reusable fact pack.',
+    ['evidence', 'facts', 'handoff'],
+    'Do not reopen the design debate.',
+    'framework-guide',
+  ),
+  makeCase(
+    'framework-guide',
+    'framework-governance-overview',
+    'Explain how the repository conventions, rules, and skill layers fit together.',
+    ['guidance', 'rules', 'usage notes'],
+    'Do not invent repo policy.',
+    null,
+  ),
+];
+
+module.exports = {
+  name: 'golden-prompt-suite.current',
+  purpose: 'Golden prompt set for the current canonical skill catalog.',
+  cases,
+};

package/scripts/migrate-skill-packages.js

@@ -0,0 +1,309 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const repoRoot = path.join(__dirname, '..');
+const legacySuitePath = path.join(repoRoot, 'skills', 'references', 'golden-prompt-suite.current.js');
+const suitePath = path.join(repoRoot, 'scripts', 'golden-prompt-suite.current.js');
+const skillsRoot = path.join(repoRoot, 'skills');
+
+function readSkillDirectories() {
+  const results = [];
+
+  function walk(dir) {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name === 'references') {
+        continue;
+      }
+
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const skillFile = path.join(fullPath, 'SKILL.md');
+        if (fs.existsSync(skillFile)) {
+          results.push(fullPath);
+        }
+        walk(fullPath);
+      }
+    }
+  }
+
+  walk(skillsRoot);
+  return results.sort();
+}
+
+function readSkillFrontmatter(skillFile) {
+  const content = fs.readFileSync(skillFile, 'utf8');
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  const frontmatter = match ? match[1] : '';
+  const name = (frontmatter.match(/^name:\s*(.+)$/m) || [])[1]?.trim() || path.basename(path.dirname(skillFile));
+  const description = (frontmatter.match(/^description:\s*(.+)$/m) || [])[1]?.trim() || '';
+  return { content, name, description };
+}
+
+function readSkillSpec(skillDir) {
+  const specPath = path.join(skillDir, 'skill-spec.json');
+  if (fs.existsSync(specPath)) {
+    return JSON.parse(fs.readFileSync(specPath, 'utf8'));
+  }
+
+  const skillFile = path.join(skillDir, 'SKILL.md');
+  const { name, description, content } = readSkillFrontmatter(skillFile);
+  const title = (content.match(/^#\s+(.+)$/m) || [])[1]?.trim() || name;
+  const extractSection = (title) => {
+    const match = content.match(new RegExp(`## ${title}\\s*\\n\\n([\\s\\S]*?)(?=\\n## |$)`));
+    if (!match) {
+      return [];
+    }
+    return match[1]
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter((line) => line.startsWith('- '))
+      .map((line) => line.slice(2).trim());
+  };
+  const extractSectionText = (sectionTitle) => {
+    const match = content.match(new RegExp(`## ${sectionTitle}\\s*\\n\\n([\\s\\S]*?)(?=\\n## |$)`));
+    return match ? match[1].trim().replace(/\r/g, '') : '';
+  };
+
+  return {
+    group: path.relative(skillsRoot, skillDir).split(path.sep)[0],
+    name,
+    description,
+    title,
+    purpose: extractSectionText('Purpose'),
+    whenToUse: extractSection('When to Use'),
+    how: extractSection('How'),
+    whenToAvoid: extractSection('When to Avoid'),
+    caseId: null,
+    source: 'fallback-from-skill-md',
+  };
+}
+
+function extractFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  return match ? match[1] : '';
+}
+
+function parseSkillCase(suite, skillName) {
+  const found = suite.cases.find((item) => item.expectedFirstSkill === skillName);
+  if (!found) {
+    throw new Error(`Missing golden replay case for ${skillName}`);
+  }
+  return found;
+}
+
+function trimTrailingPunctuation(value) {
+  return String(value || '').replace(/[。．\.]+$/u, '').trim();
+}
+
+function cleanBlockText(value) {
+  return String(value || '').replace(/\r/g, '').trimEnd();
+}
+
+function formatList(items) {
+  return items.length ? items.map((item) => `- ${item}`).join('\n') : '- none';
+}
+
+function renderSkillMd(spec) {
+  const title = spec.title || spec.name.split('-').map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(' ');
+  const lines = [
+    '---',
+    `name: ${spec.name}`,
+    `description: ${spec.description}`,
+    '---',
+    '',
+    `# ${title}`,
+    '',
+    '## Purpose',
+    '',
+    spec.purpose || spec.description,
+    '',
+    '## When to Use',
+    '',
+    ...spec.whenToUse.map((line) => `- ${line}`),
+    '',
+    '## How',
+    '',
+    ...spec.how.map((line) => `- ${line}`),
+    '',
+    '## When to Avoid',
+    '',
+    ...spec.whenToAvoid.map((line) => `- ${line}`),
+  ];
+  return `${lines.join('\n')}\n`;
+}
+
+function renderPromptTemplate(skillName, description, example) {
+  return [
+    `# ${skillName}`,
+    '',
+    '## Prompt Template',
+    '',
+    '```text',
+    `You are handling the ${skillName} skill.`,
+    `Goal: ${trimTrailingPunctuation(description) || 'Complete the stage-specific work for this request.'}`,
+    'Inputs: the request, supporting evidence, constraints, and existing repository facts.',
+    `Output contract: ${example.expectedOutput.join(', ')}.`,
+    `Stop rule: ${trimTrailingPunctuation(example.expectedStop)}.`,
+    `Handoff: ${trimTrailingPunctuation(example.expectedHandoff || 'none')}.`,
+    'Keep the response scoped to this stage and do not absorb the work of the next stage.',
+    '```',
+    '',
+    '## Notes',
+    '',
+    '- Keep the template aligned with the local replay case and local assets.',
+    '- Read `cases.md` for the matching replay example.',
+  ].join('\n');
+}
+
+function renderCasesDoc(skillName, example) {
+  return [
+    `# ${skillName}`,
+    '',
+    '## Replay Case',
+    '',
+    `- Case: \`${example.id}\``,
+    `- First skill: \`${example.expectedFirstSkill}\``,
+    '',
+    '### Prompt',
+    '',
+    '```text',
+    cleanBlockText(example.prompt),
+    '```',
+    '',
+    '### Expected Output',
+    '',
+    formatList(example.expectedOutput),
+    '',
+    '### Stop Rule',
+    '',
+    `- ${example.expectedStop}`,
+    '',
+    '### Handoff',
+    '',
+    `- ${example.expectedHandoff || 'none'}`,
+  ].join('\n');
+}
+
+function renderReferencesReadme(skillName, description) {
+  return [
+    `# ${skillName} References`,
+    '',
+    'This directory is local to the skill and is the only reference entry point for this skill.',
+    '',
+    '## Contents',
+    '',
+    '- `../skill-spec.json`: design source for regenerating this skill',
+    '- `prompt-template.md`: reusable prompt wording for this skill',
+    '- `cases.md`: human-readable replay case for this skill',
+    '- `../assets/golden-prompt-suite.current.js`: machine-readable local case fixture',
+    '',
+    '## Guidance',
+    '',
+    '- Keep skill-specific explanation here instead of pushing it into a stage-level shared library.',
+    '- Keep shared hard constraints in `../../../rules/index.md`.',
+    '- Keep canonical names unchanged.',
+    description ? `- Skill summary: ${description}` : '- Skill summary: none',
+  ].join('\n');
+}
+
+function renderAssetModule(skillName, example, description) {
+  const payload = {
+    name: `${skillName}.golden-prompt-suite.current`,
+    skill: skillName,
+    description,
+    cases: [example],
+  };
+
+  return [
+    '#!/usr/bin/env node',
+    '',
+    `module.exports = ${JSON.stringify(payload, null, 2)};`,
+    '',
+  ].join('\n');
+}
+
+function updateSkillFile(skillFile) {
+  const skillDir = path.dirname(skillFile);
+  const spec = readSkillSpec(skillDir);
+  fs.writeFileSync(skillFile, renderSkillMd(spec), 'utf8');
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function removeFileIfExists(filePath) {
+  if (fs.existsSync(filePath)) {
+    fs.unlinkSync(filePath);
+  }
+}
+
+function main() {
+  const sourceSuitePath = fs.existsSync(suitePath) ? suitePath : legacySuitePath;
+  if (!fs.existsSync(sourceSuitePath)) {
+    throw new Error(`Replay suite not found: ${sourceSuitePath}`);
+  }
+
+  const suite = require(sourceSuitePath);
+  const skillDirs = readSkillDirectories();
+  const packages = [];
+
+  for (const skillDir of skillDirs) {
+    const skillFile = path.join(skillDir, 'SKILL.md');
+    const spec = readSkillSpec(skillDir);
+    const { name, description } = spec;
+    const example = parseSkillCase(suite, name);
+    const referencesDir = path.join(skillDir, 'references');
+    const assetsDir = path.join(skillDir, 'assets');
+
+    ensureDir(referencesDir);
+    ensureDir(assetsDir);
+
+    fs.writeFileSync(path.join(referencesDir, 'README.md'), `${renderReferencesReadme(name, description)}\n`, 'utf8');
+    fs.writeFileSync(path.join(referencesDir, 'prompt-template.md'), `${renderPromptTemplate(name, description, example)}\n`, 'utf8');
+    fs.writeFileSync(path.join(referencesDir, 'cases.md'), `${renderCasesDoc(name, example)}\n`, 'utf8');
+    fs.writeFileSync(path.join(assetsDir, 'golden-prompt-suite.current.js'), `${renderAssetModule(name, example, description)}\n`, 'utf8');
+    updateSkillFile(skillFile);
+
+    packages.push({
+      name,
+      description,
+      files: {
+        references: path.relative(repoRoot, referencesDir),
+        assets: path.relative(repoRoot, assetsDir),
+      },
+    });
+  }
+
+  if (sourceSuitePath !== suitePath) {
+    fs.copyFileSync(sourceSuitePath, suitePath);
+  }
+
+  const legacyFiles = [
+    path.join(repoRoot, 'skills', 'references', 'README.md'),
+    path.join(repoRoot, 'skills', 'references', 'golden-prompt-suite.md'),
+    path.join(repoRoot, 'skills', 'references', 'golden-prompt-suite.current.js'),
+    path.join(repoRoot, 'skills', 'references', 'open-source-skill-patterns.md'),
+    path.join(repoRoot, 'skills', 'references', 'rule-loading-map.md'),
+    path.join(repoRoot, 'skills', 'references', 'skill-authoring-standard.md'),
+    path.join(repoRoot, 'skills', 'references', 'skill-boundary-template.md'),
+    path.join(repoRoot, 'skills', 'references', 'skill-enhanced-template.md'),
+    path.join(repoRoot, 'skills', 'references', 'skill-prompt-library.md'),
+    path.join(repoRoot, 'skills', 'references', 'skill-reference-matrix.md'),
+  ];
+
+  for (const filePath of legacyFiles) {
+    removeFileIfExists(filePath);
+  }
+
+  const legacyDir = path.join(repoRoot, 'skills', 'references');
+  if (fs.existsSync(legacyDir) && fs.readdirSync(legacyDir).length === 0) {
+    fs.rmdirSync(legacyDir);
+  }
+
+  console.log(`Migrated ${packages.length} skill packages.`);
+}
+
+main();