jdd-sprint-kit 0.3.1

package/src/commands/init.js

@@ -0,0 +1,267 @@
+import * as p from '@clack/prompts';
+import { existsSync } from 'node:fs';
+import fsExtra from 'fs-extra';
+const { ensureDirSync } = fsExtra;
+import { join, relative } from 'node:path';
+import { detect, checkBmadCompat } from '../lib/detect.js';
+import { SPRINT_KIT_VERSION, SPRINT_KIT_FILES, BMAD_COMPAT } from '../lib/manifest.js';
+import { copySprintKitFiles } from '../lib/copy.js';
+import { mergeSettings, getSprintKitSettings, describeHookChanges } from '../lib/merge.js';
+import {
+  showIntro, showEnvStatus, promptIdeSelection,
+  showBmadRequired, showAlreadyInstalled, showOutro,
+  confirmOverwrite, confirmSettingsMerge,
+  showVerification,
+} from '../lib/prompts.js';
+import { convertToCodex } from '../lib/adapters/codex.js';
+
+export async function runInit(options = {}) {
+  const { yes = false, ide = 'claude-code', dryRun = false } = options;
+  const projectDir = process.cwd();
+
+  // --- Step 1: Intro ---
+  if (!yes) {
+    showIntro();
+  }
+
+  // --- Step 2: Environment detection ---
+  const env = detect(projectDir);
+  const nodeVersionOk = env.nodeVersion && parseInt(env.nodeVersion.split('.')[0], 10) >= 18;
+  const bmadCompat = checkBmadCompat(env.bmadVersion);
+
+  const envInfo = {
+    ...env,
+    projectDir,
+    nodeVersionOk,
+    bmadCompat,
+  };
+
+  if (!yes) {
+    showEnvStatus(envInfo);
+  }
+
+  // Node version check
+  if (!nodeVersionOk) {
+    if (yes) {
+      console.error('Error: Node.js >= 18 is required.');
+      process.exit(1);
+    }
+    p.cancel('Node.js 18 이상이 필요합니다. Node.js를 업그레이드해주세요.');
+    process.exit(1);
+  }
+
+  // Git warning (non-blocking)
+  if (!env.isGitRepo && !yes) {
+    p.log.warn('Git 레포지토리가 아닙니다. 계속 진행합니다.');
+  }
+
+  // --- Step 3/4: BMad check ---
+  if (!env.hasBmad) {
+    if (yes) {
+      console.error('Error: BMad Method is not installed. Run: npx bmad-method install');
+      process.exit(1);
+    }
+    showBmadRequired(null, 'unknown');
+    process.exit(1);
+  }
+
+  if (bmadCompat === 'below_minimum') {
+    if (yes) {
+      console.error(`Error: BMad Method ${env.bmadVersion} is below minimum ${BMAD_COMPAT.minimum}`);
+      process.exit(1);
+    }
+    showBmadRequired(env.bmadVersion, bmadCompat);
+    process.exit(1);
+  }
+
+  if (bmadCompat === 'above_verified' && !yes) {
+    p.log.warn(`BMad Method ${env.bmadVersion}은 검증된 버전(${BMAD_COMPAT.verified})보다 높습니다. 계속 진행합니다.`);
+  }
+
+  // Already installed notice
+  if (env.hasSprintKit && !yes) {
+    showAlreadyInstalled(env.sprintKitVersion);
+  }
+
+  // --- Step 3: IDE selection ---
+  let ideSelection = ide;
+  if (!yes) {
+    ideSelection = await promptIdeSelection();
+  }
+  const includeCodex = ideSelection.includes('codex');
+
+  // --- Step 5: Install Sprint Kit files ---
+  if (dryRun) {
+    const results = copySprintKitFiles(projectDir, { dryRun: true });
+    console.log('\n[Dry Run] Files that would be installed:');
+    for (const f of [...results.copied, ...results.overwritten]) {
+      const rel = relative(projectDir, f);
+      console.log(`  ${rel}`);
+    }
+    if (includeCodex) {
+      console.log('\n[Dry Run] Codex files that would be generated:');
+      console.log('  AGENTS.md');
+      for (const cmd of SPRINT_KIT_FILES.commands) {
+        console.log(`  .codex/skills/${cmd.replace('.md', '')}/SKILL.md`);
+      }
+      for (const rule of SPRINT_KIT_FILES.rules) {
+        console.log(`  .codex/rules/${rule}`);
+      }
+    }
+    return;
+  }
+
+  // Check for files that will be overwritten
+  if (!yes) {
+    const willOverwrite = [];
+    const dirs = [
+      { files: SPRINT_KIT_FILES.agents, dir: join('.claude', 'agents') },
+      { files: SPRINT_KIT_FILES.commands, dir: join('.claude', 'commands') },
+      { files: SPRINT_KIT_FILES.rules, dir: join('.claude', 'rules') },
+      { files: SPRINT_KIT_FILES.hooks, dir: join('.claude', 'hooks') },
+      { files: SPRINT_KIT_FILES.docs, dir: join('_bmad', 'docs') },
+    ];
+    for (const { files, dir } of dirs) {
+      for (const file of files) {
+        const fullPath = join(projectDir, dir, file);
+        if (existsSync(fullPath)) {
+          willOverwrite.push(join(dir, file));
+        }
+      }
+    }
+    if (willOverwrite.length > 0) {
+      const proceed = await confirmOverwrite(willOverwrite);
+      if (!proceed) {
+        p.cancel('설치가 취소되었습니다.');
+        process.exit(0);
+      }
+    }
+  }
+
+  const s = p.spinner();
+  if (!yes) s.start('Sprint Kit 파일 설치 중...');
+
+  const copyResults = copySprintKitFiles(projectDir);
+
+  if (!yes) {
+    s.stop('Sprint Kit 파일 설치 완료');
+    showCopyResults(copyResults);
+  }
+
+  // Codex conversion
+  if (includeCodex) {
+    if (!yes) {
+      const cs = p.spinner();
+      cs.start('Codex 추가 설치 중...');
+      const templateDir = join(projectDir); // Use project files as source after copy
+      const codexResults = convertToCodex(projectDir, templateDir);
+      cs.stop('Codex 추가 설치 완료');
+      p.note(
+        codexResults.converted.map(f => `  ${f}  ✓`).join('\n'),
+        'Codex 파일'
+      );
+    } else {
+      convertToCodex(projectDir, projectDir);
+    }
+  }
+
+  // --- Step 6: settings.json hook setup ---
+  const settingsPath = join(projectDir, '.claude', 'settings.json');
+  const backupPath = join(projectDir, '.claude', 'settings.json.bak');
+
+  if (env.hasSettings && !yes) {
+    const proceed = await confirmSettingsMerge();
+    if (proceed) {
+      const result = mergeSettings(settingsPath, backupPath);
+      p.log.success(`settings.json ${result.action === 'merged' ? '머지' : '생성'} 완료`);
+    } else {
+      p.log.info('settings.json 훅 설정을 건너뛰었습니다. 나중에 설정하려면: npx jdd-sprint-kit init');
+    }
+  } else {
+    mergeSettings(settingsPath, backupPath);
+    if (!yes) {
+      p.log.success(env.hasSettings ? 'settings.json 머지 완료' : 'settings.json 생성 완료');
+    }
+  }
+
+  // --- Step 7: Verification + Outro ---
+  const checks = verify(projectDir);
+
+  if (!yes) {
+    showVerification(checks);
+    showOutro(ideSelection);
+  } else {
+    const failed = checks.filter(c => !c.ok);
+    if (failed.length > 0) {
+      console.error('Verification failed:');
+      for (const c of failed) {
+        console.error(`  ✗ ${c.path} — ${c.label}`);
+      }
+      process.exit(1);
+    }
+    console.log(`Sprint Kit v${SPRINT_KIT_VERSION} installed successfully.`);
+  }
+}
+
+function showCopyResults(results) {
+  const lines = [];
+  const categoryCounts = {};
+
+  const categories = [
+    { key: 'agents', label: '에이전트', desc: 'Sprint의 각 단계를 자동 실행합니다', dir: '.claude/agents/' },
+    { key: 'commands', label: '커맨드', desc: '/sprint 등 슬래시 커맨드', dir: '.claude/commands/' },
+    { key: 'rules', label: '규칙', desc: 'Sprint 프로토콜과 검색 가이드', dir: '.claude/rules/' },
+    { key: 'hooks', label: '훅', desc: '세션 자동 저장/복구', dir: '.claude/hooks/' },
+    { key: 'docs', label: '문서', desc: 'Sprint Input/PRD 포맷 가이드', dir: '_bmad/docs/' },
+  ];
+
+  for (const cat of categories) {
+    const count = SPRINT_KIT_FILES[cat.key].length;
+    categoryCounts[cat.key] = count;
+    lines.push(`${cat.label} — ${cat.desc}:`);
+    lines.push(`  ${cat.dir}  ${count} files  ✓`);
+    lines.push('');
+  }
+
+  lines.push('프로토타입 스캐폴드:');
+  lines.push('  preview-template/  copied  ✓');
+  lines.push('');
+  lines.push('MCP 설정 템플릿:');
+  lines.push('  .mcp.json.example  copied  ✓');
+
+  p.note(lines.join('\n'), 'Sprint Kit 파일 설치 완료');
+}
+
+function verify(projectDir) {
+  return [
+    {
+      path: '_bmad/bmm/',
+      label: 'BMad core',
+      ok: existsSync(join(projectDir, '_bmad', 'bmm')),
+    },
+    {
+      path: `.claude/agents/ (${SPRINT_KIT_FILES.agents.length})`,
+      label: 'Sprint agents',
+      ok: SPRINT_KIT_FILES.agents.every(f =>
+        existsSync(join(projectDir, '.claude', 'agents', f))
+      ),
+    },
+    {
+      path: `.claude/commands/ (${SPRINT_KIT_FILES.commands.length})`,
+      label: 'Sprint commands',
+      ok: SPRINT_KIT_FILES.commands.every(f =>
+        existsSync(join(projectDir, '.claude', 'commands', f))
+      ),
+    },
+    {
+      path: '.claude/settings.json',
+      label: 'hooks registered',
+      ok: existsSync(join(projectDir, '.claude', 'settings.json')),
+    },
+    {
+      path: 'preview-template/',
+      label: 'prototype scaffold',
+      ok: existsSync(join(projectDir, 'preview-template')),
+    },
+  ];
+}

package/src/commands/update.js

@@ -0,0 +1,132 @@
+import * as p from '@clack/prompts';
+import { existsSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { detect, checkBmadCompat } from '../lib/detect.js';
+import { SPRINT_KIT_VERSION, SPRINT_KIT_FILES } from '../lib/manifest.js';
+import { updateSprintKitFiles } from '../lib/copy.js';
+import { mergeSettings } from '../lib/merge.js';
+
+export async function runUpdate(options = {}) {
+  const { yes = false, dryRun = false } = options;
+  const projectDir = process.cwd();
+
+  if (!yes) {
+    p.intro(`JDD Sprint Kit Update v${SPRINT_KIT_VERSION}`);
+  }
+
+  // Environment check
+  const env = detect(projectDir);
+
+  if (!env.hasSprintKit) {
+    if (yes) {
+      console.error('Error: Sprint Kit is not installed. Run: npx jdd-sprint-kit init');
+      process.exit(1);
+    }
+    p.cancel('Sprint Kit이 설치되어 있지 않습니다. 먼저 init을 실행해주세요: npx jdd-sprint-kit init');
+    process.exit(1);
+  }
+
+  if (!env.hasBmad) {
+    if (yes) {
+      console.error('Error: BMad Method is not installed.');
+      process.exit(1);
+    }
+    p.cancel('BMad Method가 설치되어 있지 않습니다.');
+    process.exit(1);
+  }
+
+  const bmadCompat = checkBmadCompat(env.bmadVersion);
+  if (bmadCompat === 'below_minimum') {
+    if (yes) {
+      console.error(`Error: BMad Method ${env.bmadVersion} is below minimum.`);
+      process.exit(1);
+    }
+    p.cancel(`BMad Method ${env.bmadVersion}은 최소 버전 미만입니다.`);
+    process.exit(1);
+  }
+
+  // Version comparison
+  if (!yes) {
+    p.note(
+      [
+        `현재 설치: v${env.sprintKitVersion}`,
+        `업데이트:  v${SPRINT_KIT_VERSION}`,
+      ].join('\n'),
+      '버전 정보'
+    );
+  }
+
+  if (dryRun) {
+    const results = updateSprintKitFiles(projectDir, { dryRun: true });
+    console.log('\n[Dry Run] Files that would be updated:');
+    for (const f of [...results.copied, ...results.overwritten]) {
+      const rel = relative(projectDir, f);
+      console.log(`  ${rel}`);
+    }
+    return;
+  }
+
+  // Show overwrite policy summary
+  if (!yes) {
+    p.note(
+      [
+        '덮어쓰기 대상 (Sprint Kit 소유):',
+        '  .claude/agents/*.md',
+        '  .claude/commands/{sprint,...}.md',
+        '  .claude/rules/bmad-*.md',
+        '  .claude/hooks/*.sh',
+        '  _bmad/docs/*.md',
+        '  preview-template/',
+        '  .mcp.json.example',
+        '',
+        '머지 대상:',
+        '  .claude/settings.json (사용자 훅 보존)',
+        '',
+        '스킵 대상 (사용자/BMad 소유):',
+        '  .claude/commands/bmad/',
+        '  _bmad/bmm/, _bmad/core/',
+        '  .mcp.json, CLAUDE.md, specs/',
+      ].join('\n'),
+      '업데이트 정책'
+    );
+
+    const proceed = await p.confirm({
+      message: '업데이트를 진행하시겠습니까?',
+    });
+    if (p.isCancel(proceed) || !proceed) {
+      p.cancel('업데이트가 취소되었습니다.');
+      process.exit(0);
+    }
+  }
+
+  // Execute update
+  const s = yes ? null : p.spinner();
+  if (s) s.start('Sprint Kit 파일 업데이트 중...');
+
+  const results = updateSprintKitFiles(projectDir);
+
+  if (s) s.stop('Sprint Kit 파일 업데이트 완료');
+
+  // Merge settings.json
+  const settingsPath = join(projectDir, '.claude', 'settings.json');
+  const backupPath = join(projectDir, '.claude', 'settings.json.bak');
+  mergeSettings(settingsPath, backupPath);
+
+  // Summary
+  const newCount = results.copied.length;
+  const updatedCount = results.overwritten.length;
+
+  if (!yes) {
+    p.note(
+      [
+        `새로 추가: ${newCount} files`,
+        `업데이트:  ${updatedCount} files`,
+        `settings.json: 머지 완료`,
+      ].join('\n'),
+      '업데이트 결과'
+    );
+    p.outro(`Sprint Kit v${SPRINT_KIT_VERSION} 업데이트 완료!`);
+  } else {
+    console.log(`Sprint Kit v${SPRINT_KIT_VERSION} updated. (${newCount} new, ${updatedCount} updated)`);
+  }
+}

package/src/lib/adapters/codex.js

@@ -0,0 +1,68 @@
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import fsExtra from 'fs-extra';
+const { ensureDirSync } = fsExtra;
+import { join, basename } from 'node:path';
+import { SPRINT_KIT_FILES } from '../manifest.js';
+
+export function convertToCodex(projectDir, templateDir) {
+  const results = { converted: [], skipped: [] };
+
+  convertAgentsToCodex(projectDir, templateDir, results);
+  convertCommandsToSkills(projectDir, templateDir, results);
+  convertRulesToCodex(projectDir, templateDir, results);
+  // Hooks are not supported in Codex — skip
+
+  return results;
+}
+
+function convertAgentsToCodex(projectDir, templateDir, results) {
+  // .claude/agents/*.md → AGENTS.md (concatenated)
+  const agentsDir = join(templateDir, '.claude', 'agents');
+  const lines = ['# Sprint Kit Agents\n'];
+
+  for (const file of SPRINT_KIT_FILES.agents) {
+    const src = join(agentsDir, file);
+    if (!existsSync(src)) continue;
+    const content = readFileSync(src, 'utf-8');
+    const name = basename(file, '.md');
+    lines.push(`## ${name}\n`);
+    lines.push(content);
+    lines.push('\n---\n');
+  }
+
+  const dest = join(projectDir, 'AGENTS.md');
+  writeFileSync(dest, lines.join('\n'));
+  results.converted.push('AGENTS.md');
+}
+
+function convertCommandsToSkills(projectDir, templateDir, results) {
+  // .claude/commands/*.md → .codex/skills/{name}/SKILL.md
+  const skillsDir = join(projectDir, '.codex', 'skills');
+  ensureDirSync(skillsDir);
+
+  for (const file of SPRINT_KIT_FILES.commands) {
+    const src = join(templateDir, '.claude', 'commands', file);
+    if (!existsSync(src)) continue;
+    const name = basename(file, '.md');
+    const skillDir = join(skillsDir, name);
+    ensureDirSync(skillDir);
+    const content = readFileSync(src, 'utf-8');
+    writeFileSync(join(skillDir, 'SKILL.md'), content);
+    results.converted.push(`.codex/skills/${name}/SKILL.md`);
+  }
+}
+
+function convertRulesToCodex(projectDir, templateDir, results) {
+  // .claude/rules/*.md → .codex/rules/*.md
+  const rulesDir = join(projectDir, '.codex', 'rules');
+  ensureDirSync(rulesDir);
+
+  for (const file of SPRINT_KIT_FILES.rules) {
+    const src = join(templateDir, '.claude', 'rules', file);
+    if (!existsSync(src)) continue;
+    const content = readFileSync(src, 'utf-8');
+    const dest = join(rulesDir, file);
+    writeFileSync(dest, content);
+    results.converted.push(`.codex/rules/${file}`);
+  }
+}

package/src/lib/copy.js

@@ -0,0 +1,131 @@
+import fsExtra from 'fs-extra';
+const { copySync, ensureDirSync } = fsExtra;
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { SPRINT_KIT_FILES, SPRINT_KIT_VERSION } from './manifest.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TEMPLATES_DIR = join(__dirname, '..', '..', 'templates');
+
+// Overwrite policy per category
+const OVERWRITE_POLICY = {
+  agents:   'overwrite',   // Sprint Kit owned
+  commands: 'overwrite',   // Sprint Kit owned
+  rules:    'overwrite',   // Sprint Kit owned
+  hooks:    'overwrite',   // Sprint Kit owned
+  docs:     'overwrite',   // Sprint Kit owned
+};
+
+export function copySprintKitFiles(projectDir, options = {}) {
+  const { dryRun = false, force = false } = options;
+  const results = { copied: [], skipped: [], overwritten: [] };
+
+  // Agents
+  for (const file of SPRINT_KIT_FILES.agents) {
+    copyFile(
+      join(TEMPLATES_DIR, '.claude', 'agents', file),
+      join(projectDir, '.claude', 'agents', file),
+      results, { dryRun, force }
+    );
+  }
+
+  // Commands (Sprint Kit only — bmad/ is BMad-owned)
+  for (const file of SPRINT_KIT_FILES.commands) {
+    copyFile(
+      join(TEMPLATES_DIR, '.claude', 'commands', file),
+      join(projectDir, '.claude', 'commands', file),
+      results, { dryRun, force }
+    );
+  }
+
+  // Rules
+  for (const file of SPRINT_KIT_FILES.rules) {
+    copyFile(
+      join(TEMPLATES_DIR, '.claude', 'rules', file),
+      join(projectDir, '.claude', 'rules', file),
+      results, { dryRun, force }
+    );
+  }
+
+  // Hooks
+  for (const file of SPRINT_KIT_FILES.hooks) {
+    copyFile(
+      join(TEMPLATES_DIR, '.claude', 'hooks', file),
+      join(projectDir, '.claude', 'hooks', file),
+      results, { dryRun, force }
+    );
+  }
+
+  // Docs
+  for (const file of SPRINT_KIT_FILES.docs) {
+    copyFile(
+      join(TEMPLATES_DIR, '_bmad', 'docs', file),
+      join(projectDir, '_bmad', 'docs', file),
+      results, { dryRun, force }
+    );
+  }
+
+  // Preview template
+  const previewSrc = join(TEMPLATES_DIR, 'preview-template');
+  const previewDest = join(projectDir, 'preview-template');
+  if (existsSync(previewSrc)) {
+    if (dryRun) {
+      results.copied.push('preview-template/');
+    } else {
+      ensureDirSync(previewDest);
+      copySync(previewSrc, previewDest, { overwrite: true });
+      results.overwritten.push('preview-template/');
+    }
+  }
+
+  // .mcp.json.example
+  const mcpSrc = join(TEMPLATES_DIR, '.mcp.json.example');
+  const mcpDest = join(projectDir, '.mcp.json.example');
+  if (existsSync(mcpSrc)) {
+    copyFile(mcpSrc, mcpDest, results, { dryRun, force });
+  }
+
+  // Write version marker
+  if (!dryRun) {
+    const versionPath = join(projectDir, '.claude', '.sprint-kit-version');
+    ensureDirSync(dirname(versionPath));
+    writeFileSync(versionPath, SPRINT_KIT_VERSION + '\n');
+  }
+
+  // Ensure specs/ directory exists
+  if (!dryRun) {
+    ensureDirSync(join(projectDir, 'specs'));
+  }
+
+  return results;
+}
+
+function copyFile(src, dest, results, { dryRun, force }) {
+  if (!existsSync(src)) {
+    results.skipped.push(dest);
+    return;
+  }
+
+  const destExists = existsSync(dest);
+
+  if (dryRun) {
+    results[destExists ? 'overwritten' : 'copied'].push(dest);
+    return;
+  }
+
+  ensureDirSync(dirname(dest));
+  copySync(src, dest, { overwrite: true });
+
+  if (destExists) {
+    results.overwritten.push(dest);
+  } else {
+    results.copied.push(dest);
+  }
+}
+
+// For update: apply overwrite policy
+export function updateSprintKitFiles(projectDir, options = {}) {
+  // Same as copy but respects SKIP rules
+  return copySprintKitFiles(projectDir, { ...options, force: true });
+}

package/src/lib/detect.js

@@ -0,0 +1,81 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { BMAD_COMPAT } from './manifest.js';
+
+export function detect(projectDir) {
+  return {
+    nodeVersion: getNodeVersion(),
+    isGitRepo: existsSync(join(projectDir, '.git')),
+    hasBmad: existsSync(join(projectDir, '_bmad', 'bmm')),
+    bmadVersion: readBmadVersion(projectDir),
+    hasSprintKit: existsSync(join(projectDir, '.claude', '.sprint-kit-version')),
+    sprintKitVersion: readSprintKitVersion(projectDir),
+    hasClaude: existsSync(join(projectDir, '.claude')),
+    hasSettings: existsSync(join(projectDir, '.claude', 'settings.json')),
+    hasMcpConfig: existsSync(join(projectDir, '.mcp.json')),
+  };
+}
+
+function getNodeVersion() {
+  try {
+    return process.version.replace(/^v/, '');
+  } catch {
+    return null;
+  }
+}
+
+function readBmadVersion(projectDir) {
+  // Try reading from _bmad/_config/manifest.yaml
+  const manifestPath = join(projectDir, '_bmad', '_config', 'manifest.yaml');
+  if (!existsSync(manifestPath)) return null;
+  try {
+    const content = readFileSync(manifestPath, 'utf-8');
+    const match = content.match(/version:\s*['"]?([^'"\n]+)/);
+    return match ? match[1].trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+function readSprintKitVersion(projectDir) {
+  const versionPath = join(projectDir, '.claude', '.sprint-kit-version');
+  if (!existsSync(versionPath)) return null;
+  try {
+    return readFileSync(versionPath, 'utf-8').trim();
+  } catch {
+    return null;
+  }
+}
+
+// Parse semver-ish version strings including pre-release tags like "6.0.0-Beta.8"
+export function parseVersion(version) {
+  if (!version) return null;
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/);
+  if (!match) return null;
+  return {
+    major: parseInt(match[1], 10),
+    minor: parseInt(match[2], 10),
+    patch: parseInt(match[3], 10),
+    prerelease: match[4] || null,
+    raw: version,
+  };
+}
+
+// Returns: 'compatible', 'above_verified', 'below_minimum', 'unknown'
+export function checkBmadCompat(bmadVersion) {
+  if (!bmadVersion) return 'unknown';
+  const current = parseVersion(bmadVersion);
+  const minimum = parseVersion(BMAD_COMPAT.minimum);
+  const verified = parseVersion(BMAD_COMPAT.verified);
+  if (!current || !minimum || !verified) return 'unknown';
+
+  if (compareMajorMinor(current, minimum) < 0) return 'below_minimum';
+  if (compareMajorMinor(current, verified) > 0) return 'above_verified';
+  return 'compatible';
+}
+
+function compareMajorMinor(a, b) {
+  if (a.major !== b.major) return a.major - b.major;
+  if (a.minor !== b.minor) return a.minor - b.minor;
+  return 0; // Patch differences are ignored per policy
+}