@pigcloud/skills 1.0.0

package/rules/workflow/selection.md

@@ -0,0 +1,25 @@
+# Workflow Selection Rules
+
+## 默认做法
+
+- Decide the next skill based on the current artifact, not the final desired outcome.
+- Prefer the earliest stage that can safely absorb the input.
+- If the stage is unclear, choose routing over execution.
+
+## 禁区
+
+- Do not skip to implementation when the input is still vague.
+- Do not choose a deeper stage just because it is more convenient.
+
+## 检查
+
+- Is the next stage the smallest safe step?
+- Is the reason for selection visible?
+
+## 回放信号
+
+- Trigger when the request is asking "what should happen next" or "where should this go".
+
+## References
+
+- `workflow/index.md`

package/rules/workflow/stop.md

@@ -0,0 +1,25 @@
+# Workflow Stop Rules
+
+## 默认做法
+
+- Stop as soon as the current stage has produced its expected artifact.
+- Preserve a clean handoff note for the next owner.
+- Do not carry next-stage work into the current stage.
+
+## 禁区
+
+- Do not keep refining past the stage boundary.
+- Do not smuggle implementation work into a routing or handoff task.
+
+## 检查
+
+- Is the artifact complete for this stage?
+- Is the next stage ready to take over?
+
+## 回放信号
+
+- Trigger when a stage boundary, handoff, or stop condition needs to be enforced.
+
+## References
+
+- `workflow/index.md`

package/scripts/ci-validator.sh

@@ -0,0 +1,114 @@
+#!/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-checklist.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

package/scripts/run-golden-replays.js

@@ -0,0 +1,312 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const https = require('https');
+const path = require('path');
+
+const suite = require('../skills/references/golden-prompt-suite.js');
+
+const repoRoot = path.join(__dirname, '..');
+const skillsRoot = path.join(repoRoot, 'skills');
+
+function parseArgs(argv) {
+  const options = {
+    provider: process.env.PIG_SKILLS_REPLAY_PROVIDER || 'openai',
+    model: process.env.OPENAI_MODEL || 'gpt-4.1-mini',
+    limit: 0,
+    out: null,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === '--provider') {
+      options.provider = argv[++index];
+      continue;
+    }
+    if (token.startsWith('--provider=')) {
+      options.provider = token.slice('--provider='.length);
+      continue;
+    }
+    if (token === '--model') {
+      options.model = argv[++index];
+      continue;
+    }
+    if (token.startsWith('--model=')) {
+      options.model = token.slice('--model='.length);
+      continue;
+    }
+    if (token === '--limit') {
+      options.limit = Number(argv[++index]) || 0;
+      continue;
+    }
+    if (token.startsWith('--limit=')) {
+      options.limit = Number(token.slice('--limit='.length)) || 0;
+      continue;
+    }
+    if (token === '--out') {
+      options.out = argv[++index];
+      continue;
+    }
+    if (token.startsWith('--out=')) {
+      options.out = token.slice('--out='.length);
+      continue;
+    }
+  }
+
+  return options;
+}
+
+function readSkillCatalog() {
+  return fs.readdirSync(skillsRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && entry.name !== 'references')
+    .map((entry) => {
+      const skillFile = path.join(skillsRoot, entry.name, 'SKILL.md');
+      const content = fs.readFileSync(skillFile, 'utf8');
+      const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+      const frontmatter = frontmatterMatch ? frontmatterMatch[1] : '';
+      const name = (frontmatter.match(/^name:\s*(.+)$/m) || [])[1]?.trim() || entry.name;
+      const description = (frontmatter.match(/^description:\s*(.+)$/m) || [])[1]?.trim() || '';
+      const lifecycleStage = (frontmatter.match(/^lifecycle_stage:\s*(.+)$/m) || [])[1]?.trim() || '';
+      const outputSection = (content.match(/## Output\s+([\s\S]*?)(?:\n## |\n---|$)/) || [])[1] || '';
+      const gatesSection = (content.match(/## Stop Rules\s+([\s\S]*?)(?:\n## |\n---|$)/) || [])[1] || '';
+
+      return {
+        name,
+        description,
+        lifecycleStage,
+        outputs: outputSection
+          .split(/\r?\n/)
+          .map((line) => line.trim().replace(/^-+\s*/, ''))
+          .filter(Boolean)
+          .map((line) => line.replace(/^[*-]\s*/, '')),
+        stopRules: gatesSection
+          .split(/\r?\n/)
+          .map((line) => line.trim().replace(/^-+\s*/, ''))
+          .filter(Boolean),
+      };
+    });
+}
+
+function buildSystemPrompt(catalog) {
+  const lines = [
+    'You are evaluating the pig-skills workflow replay suite.',
+    'Choose the first skill that should handle the prompt.',
+    'Return ONLY valid JSON with these keys:',
+    '{"firstSkill":"...","artifact":"...","stopRule":"...","handoff":"...","notes":"..."}',
+    'Use exact canonical skill names.',
+    'Artifact should be short and reflect the expected work product.',
+    'Do not explain your reasoning outside the JSON object.',
+    '',
+    'Available skills:',
+    ...catalog.map((skill) => `- ${skill.name} | ${skill.description} | outputs: ${skill.outputs.join('; ')} | stop: ${skill.stopRules.join(' | ')}`),
+  ];
+  return lines.join('\n');
+}
+
+function normalizeText(value) {
+  return String(value || '')
+    .toLowerCase()
+    .replace(/\s+/g, ' ')
+    .replace(/[^\p{L}\p{N}\s-]+/gu, '')
+    .trim();
+}
+
+function extractJson(text) {
+  const content = String(text || '').trim();
+  const start = content.indexOf('{');
+  const end = content.lastIndexOf('}');
+  if (start < 0 || end < 0 || end <= start) {
+    throw new Error('Model output did not contain JSON.');
+  }
+  return JSON.parse(content.slice(start, end + 1));
+}
+
+function matchesOutput(actual, expectedItems) {
+  const normalized = normalizeText(actual);
+  const items = expectedItems.map((item) => normalizeText(item));
+  const hits = items.filter((item) => normalized.includes(item));
+  return {
+    score: hits.length === items.length ? 2 : hits.length > 0 ? 1 : 0,
+    hits,
+    missing: items.filter((item) => !normalized.includes(item)),
+  };
+}
+
+function matchesText(actual, expected) {
+  if (expected === null) {
+    return {
+      score: actual === null || actual === undefined || String(actual).trim() === '' ? 2 : 0,
+      actual,
+    };
+  }
+  const normalizedActual = normalizeText(actual);
+  const normalizedExpected = normalizeText(expected);
+  return {
+    score: normalizedActual === normalizedExpected
+      ? 2
+      : normalizedActual.includes(normalizedExpected)
+        ? 1
+        : 0,
+    actual,
+  };
+}
+
+function buildMockResponse(testCase) {
+  return {
+    firstSkill: testCase.expectedFirstSkill,
+    artifact: testCase.expectedOutput.join(', '),
+    stopRule: testCase.expectedStop,
+    handoff: testCase.expectedHandoff,
+    notes: 'mock replay',
+  };
+}
+
+function postJson(url, payload, apiKey) {
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify(payload);
+    const request = https.request(url, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+      },
+    }, (response) => {
+      const chunks = [];
+      response.on('data', (chunk) => chunks.push(chunk));
+      response.on('end', () => {
+        const raw = Buffer.concat(chunks).toString('utf8');
+        if (response.statusCode && response.statusCode >= 400) {
+          return reject(new Error(`OpenAI API error ${response.statusCode}: ${raw}`));
+        }
+        try {
+          resolve(JSON.parse(raw));
+        } catch (error) {
+          reject(new Error(`Failed to parse API response: ${error.message}\n${raw}`));
+        }
+      });
+    });
+
+    request.on('error', reject);
+    request.write(body);
+    request.end();
+  });
+}
+
+async function runOpenAI(model, systemPrompt, userPrompt) {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    throw new Error('OPENAI_API_KEY is required for provider=openai.');
+  }
+
+  const response = await postJson('https://api.openai.com/v1/chat/completions', {
+    model,
+    temperature: 0,
+    messages: [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: userPrompt },
+    ],
+  }, apiKey);
+
+  const content = response?.choices?.[0]?.message?.content;
+  if (!content) {
+    throw new Error('OpenAI response did not include message content.');
+  }
+  return extractJson(content);
+}
+
+async function evaluateCase(testCase, context) {
+  const userPrompt = [
+    `Prompt: ${testCase.prompt}`,
+    'Return the first skill, the artifact shape, the stop boundary, and the next handoff.',
+    'Keep the response concise and only use the canonical skill names from the catalog.',
+  ].join('\n');
+
+  const modelOutput = context.provider === 'mock'
+    ? buildMockResponse(testCase)
+    : await runOpenAI(context.model, context.systemPrompt, userPrompt);
+
+  const firstSkillResult = matchesText(modelOutput.firstSkill, testCase.expectedFirstSkill);
+  const artifactResult = matchesOutput(modelOutput.artifact, testCase.expectedOutput);
+  const stopResult = matchesText(modelOutput.stopRule, testCase.expectedStop);
+  const handoffResult = matchesText(modelOutput.handoff, testCase.expectedHandoff);
+
+  const score = firstSkillResult.score + artifactResult.score + stopResult.score + handoffResult.score;
+  const passed = firstSkillResult.score === 2 && artifactResult.score === 2 && stopResult.score === 2 && handoffResult.score === 2;
+
+  return {
+    id: testCase.id,
+    prompt: testCase.prompt,
+    expected: {
+      firstSkill: testCase.expectedFirstSkill,
+      output: testCase.expectedOutput,
+      stopRule: testCase.expectedStop,
+      handoff: testCase.expectedHandoff,
+    },
+    actual: modelOutput,
+    scores: {
+      firstSkill: firstSkillResult.score,
+      artifact: artifactResult.score,
+      stopRule: stopResult.score,
+      handoff: handoffResult.score,
+      total: score,
+    },
+    passed,
+  };
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const catalog = readSkillCatalog();
+  const systemPrompt = buildSystemPrompt(catalog);
+  const cases = options.limit > 0 ? suite.cases.slice(0, options.limit) : suite.cases;
+
+  const context = {
+    provider: options.provider,
+    model: options.model,
+    systemPrompt,
+  };
+
+  console.log(`# Golden replay run`);
+  console.log(`provider: ${context.provider}`);
+  console.log(`model: ${context.model}`);
+  console.log(`cases: ${cases.length}`);
+
+  const results = [];
+  for (const testCase of cases) {
+    const result = await evaluateCase(testCase, context);
+    results.push(result);
+    const status = result.passed ? 'PASS' : 'FAIL';
+    console.log(`${status} ${result.id} (${result.scores.total}/8)`);
+    if (!result.passed) {
+      console.log(JSON.stringify(result, null, 2));
+    }
+  }
+
+  const passedCount = results.filter((result) => result.passed).length;
+  const report = {
+    provider: context.provider,
+    model: context.model,
+    totalCases: results.length,
+    passedCases: passedCount,
+    failedCases: results.length - passedCount,
+    results,
+  };
+
+  if (options.out) {
+    const outputPath = path.resolve(options.out);
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+    fs.writeFileSync(outputPath, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
+  }
+
+  if (passedCount !== results.length) {
+    process.exitCode = 1;
+  } else {
+    console.log('Golden replay complete: all cases passed.');
+  }
+}
+
+main().catch((error) => {
+  console.error(error.message);
+  process.exitCode = 1;
+});

package/scripts/validate-rules.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const repoRoot = path.join(__dirname, '..');
+const rulesRoot = path.join(repoRoot, 'rules');
+const bundlesPath = path.join(rulesRoot, 'bundles.json');
+const skillProfileMapPath = path.join(rulesRoot, 'skill-profile-map.json');
+const skillsRoot = path.join(repoRoot, 'skills');
+const expectedBundles = ['core', 'workflow', 'product', 'coding', 'docs', 'review', 'overlays'];
+const requiredSections = [
+  '## 默认做法',
+  '## 禁区',
+  '## 检查',
+  '## 回放信号',
+  '## References',
+];
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function readText(filePath) {
+  return fs.readFileSync(filePath, 'utf8');
+}
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+function readSkillDirectories() {
+  return fs.readdirSync(skillsRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && entry.name !== 'references')
+    .map((entry) => entry.name)
+    .sort();
+}
+
+function readSkillProfile(skillName) {
+  const skillFile = path.join(skillsRoot, skillName, 'SKILL.md');
+  const content = readText(skillFile);
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return null;
+  const profileMatch = match[1].match(/^rule_profile:\s*(.+)$/m);
+  return profileMatch ? profileMatch[1].trim() : null;
+}
+
+function verifyBundleFiles(bundleName, bundleConfig) {
+  assert(bundleConfig && typeof bundleConfig === 'object', `${bundleName}: missing bundle config`);
+  assert(typeof bundleConfig.entry === 'string' && bundleConfig.entry.length > 0, `${bundleName}: missing entry`);
+  assert(Array.isArray(bundleConfig.files) && bundleConfig.files.length > 0, `${bundleName}: missing files`);
+
+  const files = new Set(bundleConfig.files);
+  files.add(bundleConfig.entry);
+
+  for (const relativePath of files) {
+    assert(relativePath.startsWith(`${bundleName}/`) || relativePath === `${bundleName}/index.md`, `${bundleName}: file escapes bundle namespace: ${relativePath}`);
+    const filePath = path.join(rulesRoot, relativePath);
+    assert(fs.existsSync(filePath), `${bundleName}: missing file ${relativePath}`);
+    const content = readText(filePath);
+    for (const section of requiredSections) {
+      assert(content.includes(section), `${relativePath}: missing section ${section}`);
+    }
+  }
+
+  if (bundleConfig.profiles) {
+    for (const [profileName, profileConfig] of Object.entries(bundleConfig.profiles)) {
+      assert(typeof profileConfig.entry === 'string' && profileConfig.entry.length > 0, `${bundleName}/${profileName}: missing entry`);
+      assert(Array.isArray(profileConfig.files) && profileConfig.files.length > 0, `${bundleName}/${profileName}: missing files`);
+      const profileFiles = new Set(profileConfig.files);
+      profileFiles.add(profileConfig.entry);
+      for (const relativePath of profileFiles) {
+        assert(relativePath.startsWith(`${bundleName}/`) || relativePath === `${bundleName}/index.md`, `${bundleName}/${profileName}: file escapes bundle namespace: ${relativePath}`);
+        const filePath = path.join(rulesRoot, relativePath);
+        assert(fs.existsSync(filePath), `${bundleName}/${profileName}: missing file ${relativePath}`);
+      }
+    }
+  }
+}
+
+function main() {
+  const bundles = readJson(bundlesPath);
+  const skillProfileMap = readJson(skillProfileMapPath);
+  const skillDirs = readSkillDirectories();
+
+  for (const bundleName of expectedBundles) {
+    assert(Object.prototype.hasOwnProperty.call(bundles, bundleName), `bundles.json missing ${bundleName} bundle`);
+  }
+
+  for (const [bundleName, bundleConfig] of Object.entries(bundles)) {
+    verifyBundleFiles(bundleName, bundleConfig);
+  }
+
+  for (const skillName of skillDirs) {
+    const declaredProfile = readSkillProfile(skillName);
+    assert(declaredProfile, `${skillName}: missing rule_profile`);
+    const mapped = skillProfileMap[skillName];
+    assert(mapped, `${skillName}: missing skill-profile mapping`);
+    assert(mapped.profile === declaredProfile, `${skillName}: profile mismatch (${mapped.profile} != ${declaredProfile})`);
+    assert(expectedBundles.includes(mapped.bundle), `${skillName}: unknown bundle ${mapped.bundle}`);
+    assert(bundles[mapped.bundle].profiles && bundles[mapped.bundle].profiles[mapped.profile], `${skillName}: unknown profile ${mapped.bundle}/${mapped.profile}`);
+  }
+
+  const indexContent = readText(path.join(rulesRoot, 'index.md'));
+  for (const bundleName of expectedBundles) {
+    assert(indexContent.includes(bundleName), `rules/index.md should mention ${bundleName}`);
+  }
+  assert(indexContent.includes('skill-profile-map.json'), 'rules/index.md should mention skill-profile-map.json');
+
+  const loaderContent = readText(path.join(repoRoot, 'bin', 'rules-loader.js'));
+  assert(loaderContent.includes("const CORE_BUNDLE_NAME = 'core'"), 'rules-loader.js should define core bundle');
+  assert(loaderContent.includes("const CORE_PROFILE_NAME = 'core'"), 'rules-loader.js should define core profile');
+  assert(loaderContent.includes("hasCodingSignals"), 'rules-loader.js should define coding detection');
+
+  console.log(`=== Rules validation complete for ${skillDirs.length} skills and ${Object.keys(bundles).length} bundles ===`);
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(error.message);
+  process.exitCode = 1;
+}

package/scripts/validate-skill-replay-signals.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const repoRoot = path.join(__dirname, '..');
+const skillsRoot = path.join(repoRoot, 'skills');
+
+function readSkillDirectories() {
+  return fs.readdirSync(skillsRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && entry.name !== 'references')
+    .map((entry) => entry.name)
+    .sort();
+}
+
+function readSkillFile(skillName) {
+  const skillFile = path.join(skillsRoot, skillName, 'SKILL.md');
+  return fs.readFileSync(skillFile, 'utf8');
+}
+
+function validateSkill(skillName) {
+  const content = readSkillFile(skillName);
+  const lines = content.split(/\r?\n/);
+  const sectionLines = [];
+  let inReplaySection = false;
+
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!inReplaySection) {
+      if (line === '## Replay Signals') {
+        inReplaySection = true;
+      }
+      continue;
+    }
+
+    if (line.startsWith('## ')) {
+      break;
+    }
+
+    if (line.length > 0) {
+      sectionLines.push(line.replace(/^[-*]\s*/, ''));
+    }
+  }
+
+  if (sectionLines.length === 0) {
+    throw new Error(`${skillName}: missing Replay Signals section`);
+  }
+
+  const requiredPrefixes = [
+    'Input signal:',
+    'Output to verify:',
+    'Stop signal:',
+    'Handoff signal:',
+  ];
+
+  const missing = requiredPrefixes.filter((prefix) => !sectionLines.some((line) => line.startsWith(prefix)));
+  if (missing.length > 0) {
+    throw new Error(`${skillName}: Replay Signals missing lines: ${missing.join(' | ')}`);
+  }
+}
+
+function main() {
+  for (const skillName of readSkillDirectories()) {
+    validateSkill(skillName);
+  }
+
+  console.log('=== Replay signal validation complete ===');
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(error.message);
+  process.exitCode = 1;
+}