BMAD-METHOD/tools/validate-skills.js

/**
 * Deterministic Skill Validator
 *
 * Validates 12 deterministic rules across all skill directories.
 * Acts as a fast first-pass complement to the inference-based skill validator.
 *
 * What it checks:
 * - SKILL-01: SKILL.md exists
 * - SKILL-02: SKILL.md frontmatter has name
 * - SKILL-03: SKILL.md frontmatter has description
 * - SKILL-04: name format (lowercase, hyphens, no forbidden substrings)
 * - SKILL-05: name matches directory basename
 * - SKILL-06: description quality (length, "Use when"/"Use if")
 * - SKILL-07: SKILL.md has body content after frontmatter
 * - PATH-02: no installed_path variable
 * - STEP-01: step filename format
 * - STEP-06: step frontmatter has no name/description
 * - STEP-07: step count 2-10
 * - SEQ-02: no time estimates
 * - TPL-01: template files must not contain compile-time {{.var}} substitutions
 *
 * Usage:
 *   node tools/validate-skills.js                    # All skills, human-readable
 *   node tools/validate-skills.js path/to/skill-dir  # Single skill
 *   node tools/validate-skills.js --strict           # Exit 1 on HIGH+ findings
 *   node tools/validate-skills.js --json             # JSON output
 */

const fs = require('node:fs');
const path = require('node:path');

const PROJECT_ROOT = path.resolve(__dirname, '..');
const SRC_DIR = path.join(PROJECT_ROOT, 'src');

// --- CLI Parsing ---

const args = process.argv.slice(2);
const STRICT = args.includes('--strict');
const JSON_OUTPUT = args.includes('--json');
const positionalArgs = args.filter((a) => !a.startsWith('--'));

// --- Constants ---

const NAME_REGEX = /^bmad-[a-z0-9]+(-[a-z0-9]+)*$/;
const STEP_FILENAME_REGEX = /^step-\d{2}[a-z]?-[a-z0-9-]+\.md$/;
const TIME_ESTIMATE_PATTERNS = [/takes?\s+\d+\s*min/i, /~\s*\d+\s*min/i, /estimated\s+time/i, /\bETA\b/];
const TEMPLATE_FILENAME_REGEX = /template/i;
const COMPILE_TIME_SUB_REGEX = /\{\{\.\w+\}\}/;

const SEVERITY_ORDER = { CRITICAL: 0, HIGH: 1, MEDIUM: 2, LOW: 3 };

// --- Output Escaping ---

function escapeAnnotation(str) {
  return str.replaceAll('%', '%25').replaceAll('\r', '%0D').replaceAll('\n', '%0A');
}

function escapeTableCell(str) {
  return String(str).replaceAll('|', String.raw`\|`);
}

// --- Frontmatter Parsing ---

/**
 * Parse YAML frontmatter from a markdown file.
 * Returns an object with key-value pairs, or null if no frontmatter.
 */
function parseFrontmatter(content) {
  const trimmed = content.trimStart();
  if (!trimmed.startsWith('---')) return null;

  let endIndex = trimmed.indexOf('\n---\n', 3);
  if (endIndex === -1) {
    // Handle file ending with \n---
    if (trimmed.endsWith('\n---')) {
      endIndex = trimmed.length - 4;
    } else {
      return null;
    }
  }

  const fmBlock = trimmed.slice(3, endIndex).trim();
  if (fmBlock === '') return {};

  const result = {};
  for (const line of fmBlock.split('\n')) {
    const colonIndex = line.indexOf(':');
    if (colonIndex === -1) continue;
    // Skip indented lines (nested YAML values)
    if (line[0] === ' ' || line[0] === '\t') continue;
    const key = line.slice(0, colonIndex).trim();
    let value = line.slice(colonIndex + 1).trim();
    // Strip surrounding quotes (single or double)
    if ((value.startsWith("'") && value.endsWith("'")) || (value.startsWith('"') && value.endsWith('"'))) {
      value = value.slice(1, -1);
    }
    result[key] = value;
  }

  return result;
}

/**
 * Parse YAML frontmatter, handling multiline values (description often spans lines).
 * Returns an object with key-value pairs, or null if no frontmatter.
 */
function parseFrontmatterMultiline(content) {
  const trimmed = content.trimStart();
  if (!trimmed.startsWith('---')) return null;

  let endIndex = trimmed.indexOf('\n---\n', 3);
  if (endIndex === -1) {
    // Handle file ending with \n---
    if (trimmed.endsWith('\n---')) {
      endIndex = trimmed.length - 4;
    } else {
      return null;
    }
  }

  const fmBlock = trimmed.slice(3, endIndex).trim();
  if (fmBlock === '') return {};

  const result = {};
  let currentKey = null;
  let currentValue = '';

  for (const line of fmBlock.split('\n')) {
    const colonIndex = line.indexOf(':');
    // New key-value pair: must start at column 0 (no leading whitespace) and have a colon
    if (colonIndex > 0 && line[0] !== ' ' && line[0] !== '\t') {
      // Save previous key
      if (currentKey !== null) {
        result[currentKey] = stripQuotes(currentValue.trim());
      }
      currentKey = line.slice(0, colonIndex).trim();
      currentValue = line.slice(colonIndex + 1);
    } else if (currentKey !== null) {
      // Skip YAML comment lines
      if (line.trimStart().startsWith('#')) continue;
      // Continuation of multiline value
      currentValue += '\n' + line;
    }
  }

  // Save last key
  if (currentKey !== null) {
    result[currentKey] = stripQuotes(currentValue.trim());
  }

  return result;
}

function stripQuotes(value) {
  if ((value.startsWith("'") && value.endsWith("'")) || (value.startsWith('"') && value.endsWith('"'))) {
    return value.slice(1, -1);
  }
  return value;
}

// --- Safe File Reading ---

/**
 * Read a file safely, returning null on error.
 * Pushes a warning finding if the file cannot be read.
 */
function safeReadFile(filePath, findings, relFile) {
  try {
    return fs.readFileSync(filePath, 'utf-8');
  } catch (error) {
    findings.push({
      rule: 'READ-ERR',
      title: 'File Read Error',
      severity: 'MEDIUM',
      file: relFile || path.basename(filePath),
      detail: `Cannot read file: ${error.message}`,
      fix: 'Check file permissions and ensure the file exists.',
    });
    return null;
  }
}

// --- Code Block Stripping ---

function stripCodeBlocks(content) {
  return content.replaceAll(/```[\s\S]*?```/g, (m) => m.replaceAll(/[^\n]/g, ''));
}

// --- Skill Discovery ---

function discoverSkillDirs(rootDirs) {
  const skillDirs = [];

  function walk(dir) {
    if (!fs.existsSync(dir)) return;
    const entries = fs.readdirSync(dir, { withFileTypes: true });

    for (const entry of entries) {
      if (!entry.isDirectory()) continue;
      if (entry.name === 'node_modules' || entry.name === '.git') continue;

      const fullPath = path.join(dir, entry.name);
      const skillMd = path.join(fullPath, 'SKILL.md');

      if (fs.existsSync(skillMd)) {
        skillDirs.push(fullPath);
      }

      // Keep walking into subdirectories to find nested skills
      walk(fullPath);
    }
  }

  for (const rootDir of rootDirs) {
    walk(rootDir);
  }

  return skillDirs.sort();
}

// --- File Collection ---

function collectSkillFiles(skillDir) {
  const files = [];

  function walk(dir) {
    const entries = fs.readdirSync(dir, { withFileTypes: true });
    for (const entry of entries) {
      if (entry.name === 'node_modules' || entry.name === '.git') continue;
      const fullPath = path.join(dir, entry.name);
      if (entry.isDirectory()) {
        walk(fullPath);
      } else if (entry.isFile()) {
        files.push(fullPath);
      }
    }
  }

  walk(skillDir);
  return files;
}

// --- Rule Checks ---

function validateSkill(skillDir) {
  const findings = [];
  const dirName = path.basename(skillDir);
  const skillMdPath = path.join(skillDir, 'SKILL.md');
  const workflowMdPath = path.join(skillDir, 'workflow.md');
  const stepsDir = path.join(skillDir, 'steps');

  // Collect all files in the skill for PATH-02 and SEQ-02
  const allFiles = collectSkillFiles(skillDir);

  // --- SKILL-01: SKILL.md must exist ---
  if (!fs.existsSync(skillMdPath)) {
    findings.push({
      rule: 'SKILL-01',
      title: 'SKILL.md Must Exist',
      severity: 'CRITICAL',
      file: 'SKILL.md',
      detail: 'SKILL.md not found in skill directory.',
      fix: 'Create SKILL.md as the skill entrypoint.',
    });
    // Cannot check SKILL-02 through SKILL-07 without SKILL.md
    return findings;
  }

  const skillContent = safeReadFile(skillMdPath, findings, 'SKILL.md');
  if (skillContent === null) return findings;
  const skillFm = parseFrontmatterMultiline(skillContent);

  // --- SKILL-02: frontmatter has name ---
  if (!skillFm || !('name' in skillFm)) {
    findings.push({
      rule: 'SKILL-02',
      title: 'SKILL.md Must Have name in Frontmatter',
      severity: 'CRITICAL',
      file: 'SKILL.md',
      detail: 'Frontmatter is missing the `name` field.',
      fix: 'Add `name: <skill-name>` to the frontmatter.',
    });
  } else if (skillFm.name === '') {
    findings.push({
      rule: 'SKILL-02',
      title: 'SKILL.md Must Have name in Frontmatter',
      severity: 'CRITICAL',
      file: 'SKILL.md',
      detail: 'Frontmatter `name` field is empty.',
      fix: 'Set `name` to the skill directory name (kebab-case).',
    });
  }

  // --- SKILL-03: frontmatter has description ---
  if (!skillFm || !('description' in skillFm)) {
    findings.push({
      rule: 'SKILL-03',
      title: 'SKILL.md Must Have description in Frontmatter',
      severity: 'CRITICAL',
      file: 'SKILL.md',
      detail: 'Frontmatter is missing the `description` field.',
      fix: 'Add `description: <what it does and when to use it>` to the frontmatter.',
    });
  } else if (skillFm.description === '') {
    findings.push({
      rule: 'SKILL-03',
      title: 'SKILL.md Must Have description in Frontmatter',
      severity: 'CRITICAL',
      file: 'SKILL.md',
      detail: 'Frontmatter `description` field is empty.',
      fix: 'Add a description stating what the skill does and when to use it.',
    });
  }

  const name = skillFm && skillFm.name;
  const description = skillFm && skillFm.description;

  // Deprecated skills are thin compatibility shims that forward to a replacement.
  // They intentionally omit a "Use when" trigger so users are steered to the new
  // skill instead, so exempt them from the SKILL-06 trigger-phrase requirement.
  const isDeprecated = typeof description === 'string' && /^\s*deprecated\b/i.test(description);

  // --- SKILL-04: name format ---
  if (name && !NAME_REGEX.test(name)) {
    findings.push({
      rule: 'SKILL-04',
      title: 'name Format',
      severity: 'HIGH',
      file: 'SKILL.md',
      detail: `name "${name}" does not match pattern: ${NAME_REGEX}`,
      fix: 'Rename to comply with lowercase letters, numbers, and hyphens only (max 64 chars).',
    });
  }

  // --- SKILL-05: name matches directory ---
  if (name && name !== dirName) {
    findings.push({
      rule: 'SKILL-05',
      title: 'name Must Match Directory Name',
      severity: 'HIGH',
      file: 'SKILL.md',
      detail: `name "${name}" does not match directory name "${dirName}".`,
      fix: `Change name to "${dirName}" or rename the directory.`,
    });
  }

  // --- SKILL-06: description quality ---
  if (description) {
    if (description.length > 1024) {
      findings.push({
        rule: 'SKILL-06',
        title: 'description Quality',
        severity: 'MEDIUM',
        file: 'SKILL.md',
        detail: `description is ${description.length} characters (max 1024).`,
        fix: 'Shorten the description to 1024 characters or less.',
      });
    }

    if (!isDeprecated && !/use\s+when\b/i.test(description) && !/use\s+if\b/i.test(description)) {
      findings.push({
        rule: 'SKILL-06',
        title: 'description Quality',
        severity: 'MEDIUM',
        file: 'SKILL.md',
        detail: 'description does not contain "Use when" or "Use if" trigger phrase.',
        fix: 'Append a "Use when..." clause to explain when to invoke this skill.',
      });
    }
  }

  // --- SKILL-07: SKILL.md must have body content after frontmatter ---
  {
    const trimmed = skillContent.trimStart();
    let bodyStart = -1;
    if (trimmed.startsWith('---')) {
      let endIdx = trimmed.indexOf('\n---\n', 3);
      if (endIdx !== -1) {
        bodyStart = endIdx + 4;
      } else if (trimmed.endsWith('\n---')) {
        bodyStart = trimmed.length; // no body at all
      }
    } else {
      bodyStart = 0; // no frontmatter, entire file is body
    }
    const body = bodyStart >= 0 ? trimmed.slice(bodyStart).trim() : '';
    if (body === '') {
      findings.push({
        rule: 'SKILL-07',
        title: 'SKILL.md Must Have Body Content',
        severity: 'HIGH',
        file: 'SKILL.md',
        detail: 'SKILL.md has no content after frontmatter. L2 instructions are required.',
        fix: 'Add markdown body with skill instructions after the closing ---.',
      });
    }
  }

  // --- PATH-02: no installed_path ---
  for (const filePath of allFiles) {
    // Only check markdown and yaml files
    const ext = path.extname(filePath);
    if (!['.md', '.yaml', '.yml'].includes(ext)) continue;

    const relFile = path.relative(skillDir, filePath);
    const content = safeReadFile(filePath, findings, relFile);
    if (content === null) continue;

    // Check frontmatter for installed_path key
    const fm = parseFrontmatter(content);
    if (fm && 'installed_path' in fm) {
      findings.push({
        rule: 'PATH-02',
        title: 'No installed_path Variable',
        severity: 'HIGH',
        file: relFile,
        detail: 'Frontmatter contains `installed_path:` key.',
        fix: 'Remove `installed_path` from frontmatter. Use relative paths instead.',
      });
    }

    // Check content for any mention of installed_path (variable ref, prose, bare text)
    const stripped = stripCodeBlocks(content);
    const lines = stripped.split('\n');
    for (const [i, line] of lines.entries()) {
      if (/installed_path/i.test(line)) {
        findings.push({
          rule: 'PATH-02',
          title: 'No installed_path Variable',
          severity: 'HIGH',
          file: relFile,
          line: i + 1,
          detail: '`installed_path` reference found in content.',
          fix: 'Remove all installed_path usage. Use relative paths (`./path` or `../path`) instead.',
        });
      }
    }
  }

  // --- STEP-01: step filename format ---
  // --- STEP-06: step frontmatter no name/description ---
  // --- STEP-07: step count ---
  // Only check the literal steps/ directory (variant directories like steps-c, steps-v
  // use different naming conventions and are excluded per the rule specification)
  if (fs.existsSync(stepsDir) && fs.statSync(stepsDir).isDirectory()) {
    const stepDirName = 'steps';
    const stepFiles = fs.readdirSync(stepsDir).filter((f) => f.endsWith('.md'));

    // STEP-01: filename format
    for (const stepFile of stepFiles) {
      if (!STEP_FILENAME_REGEX.test(stepFile)) {
        findings.push({
          rule: 'STEP-01',
          title: 'Step File Naming',
          severity: 'MEDIUM',
          file: path.join(stepDirName, stepFile),
          detail: `Filename "${stepFile}" does not match pattern: ${STEP_FILENAME_REGEX}`,
          fix: 'Rename to step-NN-description.md (NN = zero-padded number, optional letter suffix).',
        });
      }
    }

    // STEP-06: step frontmatter has no name/description
    for (const stepFile of stepFiles) {
      const stepPath = path.join(stepsDir, stepFile);
      const stepContent = safeReadFile(stepPath, findings, path.join(stepDirName, stepFile));
      if (stepContent === null) continue;
      const stepFm = parseFrontmatter(stepContent);

      if (stepFm) {
        if ('name' in stepFm) {
          findings.push({
            rule: 'STEP-06',
            title: 'Step File Frontmatter: No name or description',
            severity: 'MEDIUM',
            file: path.join(stepDirName, stepFile),
            detail: 'Step file frontmatter contains `name:` — this is metadata noise.',
            fix: 'Remove `name:` from step file frontmatter.',
          });
        }
        if ('description' in stepFm) {
          findings.push({
            rule: 'STEP-06',
            title: 'Step File Frontmatter: No name or description',
            severity: 'MEDIUM',
            file: path.join(stepDirName, stepFile),
            detail: 'Step file frontmatter contains `description:` — this is metadata noise.',
            fix: 'Remove `description:` from step file frontmatter.',
          });
        }
      }
    }

    // STEP-07: step count 2-10
    const stepCount = stepFiles.filter((f) => f.startsWith('step-')).length;
    if (stepCount > 0 && (stepCount < 2 || stepCount > 10)) {
      const detail =
        stepCount < 2
          ? `Only ${stepCount} step file found — consider inlining into workflow.md.`
          : `${stepCount} step files found — more than 10 risks LLM context degradation.`;
      findings.push({
        rule: 'STEP-07',
        title: 'Step Count',
        severity: 'LOW',
        file: stepDirName + '/',
        detail,
        fix: stepCount > 10 ? 'Consider consolidating steps.' : 'Consider expanding or inlining.',
      });
    }
  }

  // --- SEQ-02: no time estimates ---
  for (const filePath of allFiles) {
    const ext = path.extname(filePath);
    if (!['.md', '.yaml', '.yml'].includes(ext)) continue;

    const relFile = path.relative(skillDir, filePath);
    const content = safeReadFile(filePath, findings, relFile);
    if (content === null) continue;
    const stripped = stripCodeBlocks(content);
    const lines = stripped.split('\n');

    for (const [i, line] of lines.entries()) {
      for (const pattern of TIME_ESTIMATE_PATTERNS) {
        if (pattern.test(line)) {
          findings.push({
            rule: 'SEQ-02',
            title: 'No Time Estimates',
            severity: 'LOW',
            file: relFile,
            line: i + 1,
            detail: `Time estimate pattern found: "${line.trim()}"`,
            fix: 'Remove time estimates — AI execution speed varies too much.',
          });
          break; // Only report once per line
        }
      }
    }
  }

  // --- TPL-01: template files must not contain compile-time {{.var}} substitutions ---
  // Template files seed durable, version-controlled artifacts (spec files) that
  // execute on other machines. Baking a {{.var}} at render time would freeze a
  // machine-local value into every downstream artifact.
  for (const filePath of allFiles) {
    if (path.extname(filePath) !== '.md') continue;
    const base = path.basename(filePath);
    if (!TEMPLATE_FILENAME_REGEX.test(base)) continue;

    const relFile = path.relative(skillDir, filePath);
    const content = safeReadFile(filePath, findings, relFile);
    if (content === null) continue;

    const lines = content.split('\n');
    for (const [i, line] of lines.entries()) {
      const match = line.match(COMPILE_TIME_SUB_REGEX);
      if (match) {
        findings.push({
          rule: 'TPL-01',
          title: 'Template files must not contain compile-time substitutions',
          severity: 'HIGH',
          file: relFile,
          line: i + 1,
          detail: `Template file contains compile-time substitution \`${match[0]}\` — this would be baked at render time and leak a machine-local value into every spec produced from the template.`,
          fix: 'Remove the `{{.var}}` reference. Use single-curly `{var}` if the value should be resolved at LLM runtime by the consumer of the generated spec.',
        });
      }
    }
  }

  return findings;
}

// --- Output Formatting ---

function formatHumanReadable(results) {
  const output = [];
  let totalFindings = 0;
  const severityCounts = { CRITICAL: 0, HIGH: 0, MEDIUM: 0, LOW: 0 };

  output.push(
    `\nValidating skills in: ${SRC_DIR}`,
    `Mode: ${STRICT ? 'STRICT (exit 1 on HIGH+)' : 'WARNING (exit 0)'}${JSON_OUTPUT ? ' + JSON' : ''}\n`,
  );

  let totalSkills = 0;
  let skillsWithFindings = 0;

  for (const { skillDir, findings } of results) {
    totalSkills++;
    const relDir = path.relative(PROJECT_ROOT, skillDir);

    if (findings.length > 0) {
      skillsWithFindings++;
      output.push(`\n${relDir}`);

      for (const f of findings) {
        totalFindings++;
        severityCounts[f.severity]++;
        const location = f.line ? ` (line ${f.line})` : '';
        output.push(`  [${f.severity}] ${f.rule} — ${f.title}`, `    File: ${f.file}${location}`, `    ${f.detail}`);

        if (process.env.GITHUB_ACTIONS) {
          const absFile = path.join(skillDir, f.file);
          const ghFile = path.relative(PROJECT_ROOT, absFile);
          const line = f.line || 1;
          const level = f.severity === 'LOW' ? 'notice' : 'warning';
          console.log(`::${level} file=${ghFile},line=${line}::${escapeAnnotation(`${f.rule}: ${f.detail}`)}`);
        }
      }
    }
  }

  // Summary
  output.push(
    `\n${'─'.repeat(60)}`,
    `\nSummary:`,
    `   Skills scanned: ${totalSkills}`,
    `   Skills with findings: ${skillsWithFindings}`,
    `   Total findings: ${totalFindings}`,
  );

  if (totalFindings > 0) {
    output.push('', `   | Severity | Count |`, `   |----------|-------|`);
    for (const sev of ['CRITICAL', 'HIGH', 'MEDIUM', 'LOW']) {
      if (severityCounts[sev] > 0) {
        output.push(`   | ${sev.padEnd(8)} | ${String(severityCounts[sev]).padStart(5)} |`);
      }
    }
  }

  const hasHighPlus = severityCounts.CRITICAL > 0 || severityCounts.HIGH > 0;

  if (totalFindings === 0) {
    output.push(`\n   All skills passed validation!`);
  } else if (STRICT && hasHighPlus) {
    output.push(`\n   [STRICT MODE] HIGH+ findings found — exiting with failure.`);
  } else if (STRICT) {
    output.push(`\n   [STRICT MODE] Only MEDIUM/LOW findings — pass.`);
  } else {
    output.push(`\n   Run with --strict to treat HIGH+ findings as errors.`);
  }

  output.push('');

  // Write GitHub Actions step summary
  if (process.env.GITHUB_STEP_SUMMARY) {
    let summary = '## Skill Validation\n\n';
    if (totalFindings > 0) {
      summary += '| Skill | Rule | Severity | File | Detail |\n';
      summary += '|-------|------|----------|------|--------|\n';
      for (const { skillDir, findings } of results) {
        const relDir = path.relative(PROJECT_ROOT, skillDir);
        for (const f of findings) {
          summary += `| ${escapeTableCell(relDir)} | ${f.rule} | ${f.severity} | ${escapeTableCell(f.file)} | ${escapeTableCell(f.detail)} |\n`;
        }
      }
      summary += '\n';
    }
    summary += `**${totalSkills} skills scanned, ${totalFindings} findings**\n`;
    fs.appendFileSync(process.env.GITHUB_STEP_SUMMARY, summary);
  }

  return { output: output.join('\n'), hasHighPlus };
}

function formatJson(results) {
  const allFindings = [];
  for (const { skillDir, findings } of results) {
    const relDir = path.relative(PROJECT_ROOT, skillDir);
    for (const f of findings) {
      allFindings.push({
        skill: relDir,
        rule: f.rule,
        title: f.title,
        severity: f.severity,
        file: f.file,
        line: f.line || null,
        detail: f.detail,
        fix: f.fix,
      });
    }
  }

  // Sort by severity
  allFindings.sort((a, b) => SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity]);

  const hasHighPlus = allFindings.some((f) => f.severity === 'CRITICAL' || f.severity === 'HIGH');

  return { output: JSON.stringify(allFindings, null, 2), hasHighPlus };
}

// --- Main ---

if (require.main === module) {
  // Determine which skills to validate
  let skillDirs;

  if (positionalArgs.length > 0) {
    // Single skill directory specified
    const target = path.resolve(positionalArgs[0]);
    if (!fs.existsSync(target) || !fs.statSync(target).isDirectory()) {
      console.error(`Error: "${positionalArgs[0]}" is not a valid directory.`);
      process.exit(2);
    }
    skillDirs = [target];
  } else {
    // Discover all skills
    skillDirs = discoverSkillDirs([SRC_DIR]);
  }

  if (skillDirs.length === 0) {
    console.error('No skill directories found.');
    process.exit(2);
  }

  // Validate each skill
  const results = [];
  for (const skillDir of skillDirs) {
    const findings = validateSkill(skillDir);
    results.push({ skillDir, findings });
  }

  // Format output
  const { output, hasHighPlus } = JSON_OUTPUT ? formatJson(results) : formatHumanReadable(results);
  console.log(output);

  // Exit code
  if (STRICT && hasHighPlus) {
    process.exit(1);
  }
}

// --- Exports (for testing) ---
module.exports = { parseFrontmatter, parseFrontmatterMultiline, validateSkill, discoverSkillDirs };