musubi-sdd 0.8.4 → 0.8.6

package/README.ja.md

@@ -15,7 +15,7 @@ MUSUBIは、6つの主要フレームワークのベスト機能を統合した
 - 📋 **憲法ガバナンス** - 9つの不変条項 + フェーズ-1ゲートによる品質保証
 - 📝 **EARS要件ジェネレーター** - 5つのEARSパターンで明確な要件を作成（v0.8.0）
 - 🏗️ **設計ドキュメントジェネレーター** - トレーサビリティ付きC4モデルとADRを作成（v0.8.2）
-- 🔄 **差分仕様** - ブラウンフィールドおよびグリーンフィールドプロジェクト対応
+- 🔄 **変更管理システム** - ブラウンフィールドプロジェクト向け差分仕様（v0.8.6）
 - 🧭 **自動更新プロジェクトメモリ** - ステアリングシステムがアーキテクチャ、技術スタック、製品コンテキストを維持
 - 🚀 **自動オンボーディング** - `musubi-onboard` が既存プロジェクトを分析し、ステアリングドキュメントを生成（2-5分）
 - 🔄 **自動同期** - `musubi-sync` がコードベースの変更を検出し、ステアリングドキュメントを最新に保つ
@@ -129,6 +129,24 @@ musubi-tasks list --priority P0         # 重要タスクのみ表示
 musubi-tasks update 001 "In Progress"   # タスクステータス更新
 musubi-tasks validate                   # タスク完全性を検証
 musubi-tasks graph                      # 依存関係グラフ表示
+
+# エンドツーエンドトレーサビリティ（v0.8.5）
+musubi-trace matrix                             # トレーサビリティマトリクス生成
+musubi-trace matrix --format markdown > trace.md # Markdownにエクスポート
+musubi-trace coverage                           # カバレッジ統計計算
+musubi-trace coverage --min-coverage 100        # 100%カバレッジ要求
+musubi-trace gaps                               # 孤立した要件/コード検出
+musubi-trace requirement REQ-AUTH-001           # 特定要件をトレース
+musubi-trace validate                           # 100%トレーサビリティ検証（第5条）
+
+# ブラウンフィールドプロジェクト向け変更管理（v0.8.6）
+musubi-change init CHANGE-001 --title "認証機能追加"  # 変更提案を作成
+musubi-change validate CHANGE-001 --verbose     # 差分仕様を検証
+musubi-change apply CHANGE-001 --dry-run        # 変更をプレビュー
+musubi-change apply CHANGE-001                  # コードベースに変更を適用
+musubi-change archive CHANGE-001                # specs/にアーカイブ
+musubi-change list --status pending             # 保留中の変更をリスト
+musubi-change list --format json                # JSON形式でリスト
 ```
 
 ### プロジェクトタイプ

package/README.md

@@ -19,7 +19,7 @@ MUSUBI is a comprehensive SDD (Specification Driven Development) framework that
 - 📋 **Constitutional Governance** - 9 immutable articles + Phase -1 Gates for quality enforcement
 - 📝 **EARS Requirements Generator** - Create unambiguous requirements with 5 EARS patterns (v0.8.0)
 - 🏗️ **Design Document Generator** - Create C4 models and ADRs with traceability (v0.8.2)
-- 🔄 **Delta Specifications** - Brownfield and greenfield project support
+- 🔄 **Change Management System** - Delta specifications for brownfield projects (v0.8.6)
 - 🧭 **Auto-Updating Project Memory** - Steering system maintains architecture, tech stack, and product context
 - 🚀 **Automatic Onboarding** - `musubi-onboard` analyzes existing projects and generates steering docs (2-5 minutes)
 - 🔄 **Auto-Sync** - `musubi-sync` detects codebase changes and keeps steering docs current
@@ -133,6 +133,24 @@ musubi-tasks list --priority P0                 # List critical tasks
 musubi-tasks update 001 "In Progress"           # Update task status
 musubi-tasks validate                           # Validate task completeness
 musubi-tasks graph                              # Show dependency graph
+
+# End-to-end traceability (v0.8.5)
+musubi-trace matrix                             # Generate traceability matrix
+musubi-trace matrix --format markdown > trace.md # Export to markdown
+musubi-trace coverage                           # Calculate coverage statistics
+musubi-trace coverage --min-coverage 100        # Require 100% coverage
+musubi-trace gaps                               # Detect orphaned requirements/code
+musubi-trace requirement REQ-AUTH-001           # Trace specific requirement
+musubi-trace validate                           # Validate 100% traceability (Article V)
+
+# Change management for brownfield projects (v0.8.6)
+musubi-change init CHANGE-001 --title "Add authentication"  # Create change proposal
+musubi-change validate CHANGE-001 --verbose     # Validate delta specification
+musubi-change apply CHANGE-001 --dry-run        # Preview changes
+musubi-change apply CHANGE-001                  # Apply changes to codebase
+musubi-change archive CHANGE-001                # Archive to specs/
+musubi-change list --status pending             # List pending changes
+musubi-change list --format json                # List in JSON format
 ```
 
 ### Project Types

package/bin/musubi-change.js

@@ -0,0 +1,250 @@
+#!/usr/bin/env node
+
+/**
+ * MUSUBI Change Management CLI
+ * 
+ * Manages delta specifications for brownfield projects
+ * Implements ADDED/MODIFIED/REMOVED/RENAMED change tracking
+ * 
+ * Usage:
+ *   musubi-change init <change-id>       # Create change proposal
+ *   musubi-change apply <change-id>      # Apply change to codebase
+ *   musubi-change archive <change-id>    # Archive completed change
+ *   musubi-change list                   # List all changes
+ *   musubi-change validate <change-id>   # Validate delta format
+ */
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const ChangeManager = require('../src/managers/change.js');
+
+const program = new Command();
+
+program
+  .name('musubi-change')
+  .description('MUSUBI Change Management - Delta specifications for brownfield projects')
+  .version('0.8.6');
+
+// Initialize change proposal
+program
+  .command('init <change-id>')
+  .description('Create new change proposal with delta specification')
+  .option('-t, --title <title>', 'Change title')
+  .option('-d, --description <description>', 'Change description')
+  .option('--changes <dir>', 'Changes directory', 'storage/changes')
+  .option('--template <path>', 'Custom delta template')
+  .action(async (changeId, options) => {
+    try {
+      const workspaceRoot = process.cwd();
+      const manager = new ChangeManager(workspaceRoot);
+
+      console.log(chalk.blue('📝 Creating change proposal...'));
+      console.log(chalk.dim(`Change ID: ${changeId}`));
+
+      const result = await manager.initChange(changeId, {
+        title: options.title,
+        description: options.description,
+        changesDir: options.changes,
+        template: options.template
+      });
+
+      console.log(chalk.green('✓ Change proposal created successfully'));
+      console.log(chalk.dim(`Location: ${result.file}`));
+      console.log();
+      console.log(chalk.yellow('Next steps:'));
+      console.log(chalk.dim('1. Edit the delta specification'));
+      console.log(chalk.dim(`2. Run: musubi-change validate ${changeId}`));
+      console.log(chalk.dim(`3. Run: musubi-change apply ${changeId}`));
+    } catch (error) {
+      console.error(chalk.red('✗ Failed to create change proposal'));
+      console.error(chalk.dim(error.message));
+      process.exit(1);
+    }
+  });
+
+// Apply change to codebase
+program
+  .command('apply <change-id>')
+  .description('Apply change proposal to codebase')
+  .option('--changes <dir>', 'Changes directory', 'storage/changes')
+  .option('--dry-run', 'Preview changes without applying')
+  .option('--force', 'Force apply even with validation errors')
+  .action(async (changeId, options) => {
+    try {
+      const workspaceRoot = process.cwd();
+      const manager = new ChangeManager(workspaceRoot);
+
+      if (options.dryRun) {
+        console.log(chalk.blue('🔍 Previewing changes (dry run)...'));
+      } else {
+        console.log(chalk.blue('⚙️  Applying changes...'));
+      }
+
+      const result = await manager.applyChange(changeId, {
+        changesDir: options.changes,
+        dryRun: options.dryRun,
+        force: options.force
+      });
+
+      if (options.dryRun) {
+        console.log(chalk.yellow('\nPreview (no changes applied):'));
+        console.log(chalk.green(`  ${result.stats.added} files to be added`));
+        console.log(chalk.blue(`  ${result.stats.modified} files to be modified`));
+        console.log(chalk.red(`  ${result.stats.removed} files to be removed`));
+        console.log(chalk.yellow(`  ${result.stats.renamed} files to be renamed`));
+      } else {
+        console.log(chalk.green('\n✓ Changes applied successfully'));
+        console.log(chalk.green(`  ${result.stats.added} files added`));
+        console.log(chalk.blue(`  ${result.stats.modified} files modified`));
+        console.log(chalk.red(`  ${result.stats.removed} files removed`));
+        console.log(chalk.yellow(`  ${result.stats.renamed} files renamed`));
+        
+        console.log();
+        console.log(chalk.yellow('Next steps:'));
+        console.log(chalk.dim('1. Test the changes'));
+        console.log(chalk.dim(`2. Run: musubi-change archive ${changeId}`));
+      }
+    } catch (error) {
+      console.error(chalk.red('✗ Failed to apply changes'));
+      console.error(chalk.dim(error.message));
+      process.exit(1);
+    }
+  });
+
+// Archive completed change
+program
+  .command('archive <change-id>')
+  .description('Archive completed change to specs/')
+  .option('--changes <dir>', 'Changes directory', 'storage/changes')
+  .option('--specs <dir>', 'Specs archive directory', 'specs')
+  .action(async (changeId, options) => {
+    try {
+      const workspaceRoot = process.cwd();
+      const manager = new ChangeManager(workspaceRoot);
+
+      console.log(chalk.blue('📦 Archiving change...'));
+
+      const result = await manager.archiveChange(changeId, {
+        changesDir: options.changes,
+        specsDir: options.specs
+      });
+
+      console.log(chalk.green('✓ Change archived successfully'));
+      console.log(chalk.dim(`Source: ${result.source}`));
+      console.log(chalk.dim(`Archive: ${result.archive}`));
+      console.log();
+      console.log(chalk.yellow('Delta merged to canonical specification'));
+    } catch (error) {
+      console.error(chalk.red('✗ Failed to archive change'));
+      console.error(chalk.dim(error.message));
+      process.exit(1);
+    }
+  });
+
+// List all changes
+program
+  .command('list')
+  .description('List all change proposals')
+  .option('--changes <dir>', 'Changes directory', 'storage/changes')
+  .option('--status <status>', 'Filter by status (pending|applied|archived)')
+  .option('--format <format>', 'Output format (table|json)', 'table')
+  .action(async (options) => {
+    try {
+      const workspaceRoot = process.cwd();
+      const manager = new ChangeManager(workspaceRoot);
+
+      const changes = await manager.listChanges({
+        changesDir: options.changes,
+        status: options.status
+      });
+
+      if (options.format === 'json') {
+        console.log(JSON.stringify(changes, null, 2));
+        return;
+      }
+
+      // Table format
+      console.log(chalk.bold('\nChange Proposals:\n'));
+      
+      if (changes.length === 0) {
+        console.log(chalk.dim('No changes found'));
+        return;
+      }
+
+      console.log(chalk.dim('ID'.padEnd(20) + 'Title'.padEnd(40) + 'Status'.padEnd(15) + 'Date'));
+      console.log(chalk.dim('-'.repeat(90)));
+
+      changes.forEach(change => {
+        const statusColor = {
+          pending: chalk.yellow,
+          applied: chalk.blue,
+          archived: chalk.green
+        }[change.status] || chalk.white;
+
+        console.log(
+          change.id.padEnd(20) +
+          change.title.padEnd(40) +
+          statusColor(change.status.padEnd(15)) +
+          change.date
+        );
+      });
+
+      console.log();
+      console.log(chalk.dim(`Total: ${changes.length} change(s)`));
+    } catch (error) {
+      console.error(chalk.red('✗ Failed to list changes'));
+      console.error(chalk.dim(error.message));
+      process.exit(1);
+    }
+  });
+
+// Validate delta format
+program
+  .command('validate <change-id>')
+  .description('Validate delta specification format')
+  .option('--changes <dir>', 'Changes directory', 'storage/changes')
+  .option('-v, --verbose', 'Show detailed validation results')
+  .action(async (changeId, options) => {
+    try {
+      const workspaceRoot = process.cwd();
+      const manager = new ChangeManager(workspaceRoot);
+
+      console.log(chalk.blue('🔍 Validating delta specification...'));
+
+      const result = await manager.validateChange(changeId, {
+        changesDir: options.changes,
+        verbose: options.verbose
+      });
+
+      if (result.valid) {
+        console.log(chalk.green('✓ Delta specification is valid'));
+        
+        if (options.verbose) {
+          console.log();
+          console.log(chalk.bold('Summary:'));
+          console.log(chalk.green(`  ${result.stats.added} ADDED items`));
+          console.log(chalk.blue(`  ${result.stats.modified} MODIFIED items`));
+          console.log(chalk.red(`  ${result.stats.removed} REMOVED items`));
+          console.log(chalk.yellow(`  ${result.stats.renamed} RENAMED items`));
+        }
+      } else {
+        console.log(chalk.red('✗ Validation failed'));
+        console.log();
+        
+        result.errors.forEach(error => {
+          console.log(chalk.red(`  • ${error.message}`));
+          if (error.line) {
+            console.log(chalk.dim(`    Line ${error.line}`));
+          }
+        });
+        
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red('✗ Failed to validate change'));
+      console.error(chalk.dim(error.message));
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/bin/musubi-trace.js

@@ -0,0 +1,367 @@
+#!/usr/bin/env node
+
+/**
+ * MUSUBI Traceability System CLI
+ * 
+ * Provides end-to-end traceability from requirements to code to tests
+ * Ensures 100% coverage and detects gaps
+ * 
+ * Usage:
+ *   musubi-trace matrix                      # Generate full traceability matrix
+ *   musubi-trace coverage                    # Calculate requirement coverage
+ *   musubi-trace gaps                        # Detect orphaned requirements/code
+ *   musubi-trace requirement <id>            # Trace specific requirement
+ *   musubi-trace validate                    # Validate 100% coverage
+ */
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const TraceabilityAnalyzer = require('../src/analyzers/traceability');
+
+const program = new Command();
+
+program
+  .name('musubi-trace')
+  .description('MUSUBI Traceability System - End-to-end requirement traceability')
+  .version('0.8.5');
+
+// Generate traceability matrix
+program
+  .command('matrix')
+  .description('Generate full traceability matrix')
+  .option('-f, --format <type>', 'Output format (table|markdown|json|html)', 'table')
+  .option('-o, --output <path>', 'Output file path')
+  .option('--requirements <path>', 'Requirements directory', 'docs/requirements')
+  .option('--design <path>', 'Design directory', 'docs/design')
+  .option('--tasks <path>', 'Tasks directory', 'docs/tasks')
+  .option('--code <path>', 'Source code directory', 'src')
+  .option('--tests <path>', 'Tests directory', 'tests')
+  .action(async (options) => {
+    try {
+      console.log(chalk.bold('\n📊 Generating Traceability Matrix\n'));
+      
+      const analyzer = new TraceabilityAnalyzer(process.cwd());
+      const matrix = await analyzer.generateMatrix(options);
+      
+      if (options.output) {
+        const fs = require('fs-extra');
+        await fs.writeFile(options.output, analyzer.formatMatrix(matrix, options.format), 'utf-8');
+        console.log(chalk.green(`✓ Matrix saved to ${options.output}`));
+      } else {
+        console.log(analyzer.formatMatrix(matrix, options.format));
+      }
+      
+      console.log();
+      console.log(chalk.bold('Summary:'));
+      console.log(chalk.dim(`  Requirements: ${matrix.summary.totalRequirements}`));
+      console.log(chalk.dim(`  With Design: ${matrix.summary.withDesign} (${matrix.summary.designCoverage}%)`));
+      console.log(chalk.dim(`  With Tasks: ${matrix.summary.withTasks} (${matrix.summary.tasksCoverage}%)`));
+      console.log(chalk.dim(`  With Code: ${matrix.summary.withCode} (${matrix.summary.codeCoverage}%)`));
+      console.log(chalk.dim(`  With Tests: ${matrix.summary.withTests} (${matrix.summary.testsCoverage}%)`));
+      console.log();
+      
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Calculate coverage
+program
+  .command('coverage')
+  .description('Calculate requirement coverage statistics')
+  .option('--requirements <path>', 'Requirements directory', 'docs/requirements')
+  .option('--design <path>', 'Design directory', 'docs/design')
+  .option('--tasks <path>', 'Tasks directory', 'docs/tasks')
+  .option('--code <path>', 'Source code directory', 'src')
+  .option('--tests <path>', 'Tests directory', 'tests')
+  .option('--min-coverage <percent>', 'Minimum required coverage', '100')
+  .action(async (options) => {
+    try {
+      console.log(chalk.bold('\n📈 Calculating Coverage\n'));
+      
+      const analyzer = new TraceabilityAnalyzer(process.cwd());
+      const coverage = await analyzer.calculateCoverage(options);
+      
+      const minCoverage = parseInt(options.minCoverage);
+      
+      console.log(chalk.bold('Coverage Report:'));
+      console.log();
+      
+      const stages = [
+        { name: 'Requirements → Design', value: coverage.designCoverage, color: coverage.designCoverage >= minCoverage ? chalk.green : chalk.red },
+        { name: 'Requirements → Tasks', value: coverage.tasksCoverage, color: coverage.tasksCoverage >= minCoverage ? chalk.green : chalk.red },
+        { name: 'Requirements → Code', value: coverage.codeCoverage, color: coverage.codeCoverage >= minCoverage ? chalk.green : chalk.red },
+        { name: 'Requirements → Tests', value: coverage.testsCoverage, color: coverage.testsCoverage >= minCoverage ? chalk.green : chalk.red }
+      ];
+      
+      stages.forEach(stage => {
+        const bar = '█'.repeat(Math.floor(stage.value / 2));
+        console.log(stage.color(`  ${stage.name.padEnd(25)} ${bar} ${stage.value}%`));
+      });
+      
+      console.log();
+      console.log(chalk.bold('Overall Coverage:'));
+      const overallColor = coverage.overall >= minCoverage ? chalk.green : chalk.red;
+      console.log(overallColor(`  ${coverage.overall}% (min: ${minCoverage}%)`));
+      console.log();
+      
+      if (coverage.overall >= minCoverage) {
+        console.log(chalk.green('✓ Coverage meets requirements\n'));
+        process.exit(0);
+      } else {
+        console.log(chalk.red('✗ Coverage below minimum threshold\n'));
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Detect gaps
+program
+  .command('gaps')
+  .description('Detect orphaned requirements, design, tasks, and untested code')
+  .option('--requirements <path>', 'Requirements directory', 'docs/requirements')
+  .option('--design <path>', 'Design directory', 'docs/design')
+  .option('--tasks <path>', 'Tasks directory', 'docs/tasks')
+  .option('--code <path>', 'Source code directory', 'src')
+  .option('--tests <path>', 'Tests directory', 'tests')
+  .option('-v, --verbose', 'Show detailed gap information')
+  .action(async (options) => {
+    try {
+      console.log(chalk.bold('\n🔍 Detecting Gaps\n'));
+      
+      const analyzer = new TraceabilityAnalyzer(process.cwd());
+      const gaps = await analyzer.detectGaps(options);
+      
+      let hasGaps = false;
+      
+      if (gaps.orphanedRequirements.length > 0) {
+        hasGaps = true;
+        console.log(chalk.red.bold('Orphaned Requirements (no design/tasks):'));
+        gaps.orphanedRequirements.forEach(req => {
+          console.log(chalk.red(`  • ${req.id}: ${req.title}`));
+          if (options.verbose && req.file) {
+            console.log(chalk.dim(`    ${req.file}`));
+          }
+        });
+        console.log();
+      }
+      
+      if (gaps.orphanedDesign.length > 0) {
+        hasGaps = true;
+        console.log(chalk.yellow.bold('Orphaned Design (no requirements):'));
+        gaps.orphanedDesign.forEach(design => {
+          console.log(chalk.yellow(`  • ${design.id}: ${design.title}`));
+          if (options.verbose && design.file) {
+            console.log(chalk.dim(`    ${design.file}`));
+          }
+        });
+        console.log();
+      }
+      
+      if (gaps.orphanedTasks.length > 0) {
+        hasGaps = true;
+        console.log(chalk.yellow.bold('Orphaned Tasks (no requirements):'));
+        gaps.orphanedTasks.forEach(task => {
+          console.log(chalk.yellow(`  • ${task.id}: ${task.title}`));
+          if (options.verbose && task.file) {
+            console.log(chalk.dim(`    ${task.file}`));
+          }
+        });
+        console.log();
+      }
+      
+      if (gaps.untestedCode.length > 0) {
+        hasGaps = true;
+        console.log(chalk.red.bold('Untested Code (no test coverage):'));
+        gaps.untestedCode.forEach(code => {
+          console.log(chalk.red(`  • ${code.file}:${code.function || code.class}`));
+          if (options.verbose && code.lines) {
+            console.log(chalk.dim(`    Lines: ${code.lines}`));
+          }
+        });
+        console.log();
+      }
+      
+      if (gaps.missingTests.length > 0) {
+        hasGaps = true;
+        console.log(chalk.red.bold('Missing Tests (requirements not tested):'));
+        gaps.missingTests.forEach(req => {
+          console.log(chalk.red(`  • ${req.id}: ${req.title}`));
+        });
+        console.log();
+      }
+      
+      if (!hasGaps) {
+        console.log(chalk.green('✓ No gaps detected - 100% traceability!\n'));
+        process.exit(0);
+      } else {
+        console.log(chalk.bold('Gap Summary:'));
+        console.log(chalk.dim(`  Orphaned Requirements: ${gaps.orphanedRequirements.length}`));
+        console.log(chalk.dim(`  Orphaned Design: ${gaps.orphanedDesign.length}`));
+        console.log(chalk.dim(`  Orphaned Tasks: ${gaps.orphanedTasks.length}`));
+        console.log(chalk.dim(`  Untested Code: ${gaps.untestedCode.length}`));
+        console.log(chalk.dim(`  Missing Tests: ${gaps.missingTests.length}`));
+        console.log();
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Trace specific requirement
+program
+  .command('requirement <id>')
+  .description('Trace specific requirement through design, tasks, code, and tests')
+  .option('--requirements <path>', 'Requirements directory', 'docs/requirements')
+  .option('--design <path>', 'Design directory', 'docs/design')
+  .option('--tasks <path>', 'Tasks directory', 'docs/tasks')
+  .option('--code <path>', 'Source code directory', 'src')
+  .option('--tests <path>', 'Tests directory', 'tests')
+  .action(async (id, options) => {
+    try {
+      console.log(chalk.bold(`\n🔗 Tracing Requirement: ${id}\n`));
+      
+      const analyzer = new TraceabilityAnalyzer(process.cwd());
+      const trace = await analyzer.traceRequirement(id, options);
+      
+      if (!trace.requirement) {
+        console.log(chalk.red(`✗ Requirement ${id} not found\n`));
+        process.exit(1);
+      }
+      
+      console.log(chalk.bold('Requirement:'));
+      console.log(chalk.cyan(`  ${trace.requirement.id}: ${trace.requirement.title}`));
+      console.log(chalk.dim(`  ${trace.requirement.file}`));
+      console.log();
+      
+      if (trace.design.length > 0) {
+        console.log(chalk.bold('Design:'));
+        trace.design.forEach(d => {
+          console.log(chalk.green(`  ✓ ${d.id}: ${d.title}`));
+          console.log(chalk.dim(`    ${d.file}`));
+        });
+        console.log();
+      } else {
+        console.log(chalk.yellow('⚠ No design found\n'));
+      }
+      
+      if (trace.tasks.length > 0) {
+        console.log(chalk.bold('Tasks:'));
+        trace.tasks.forEach(t => {
+          console.log(chalk.green(`  ✓ ${t.id}: ${t.title} (${t.status})`));
+          console.log(chalk.dim(`    ${t.file}`));
+        });
+        console.log();
+      } else {
+        console.log(chalk.yellow('⚠ No tasks found\n'));
+      }
+      
+      if (trace.code.length > 0) {
+        console.log(chalk.bold('Code:'));
+        trace.code.forEach(c => {
+          console.log(chalk.green(`  ✓ ${c.file}:${c.function || c.class}`));
+          console.log(chalk.dim(`    Lines: ${c.lines}`));
+        });
+        console.log();
+      } else {
+        console.log(chalk.yellow('⚠ No code implementation found\n'));
+      }
+      
+      if (trace.tests.length > 0) {
+        console.log(chalk.bold('Tests:'));
+        trace.tests.forEach(t => {
+          console.log(chalk.green(`  ✓ ${t.file}:${t.test}`));
+          console.log(chalk.dim(`    Status: ${t.status || 'passing'}`));
+        });
+        console.log();
+      } else {
+        console.log(chalk.red('✗ No tests found\n'));
+      }
+      
+      const coverage = {
+        design: trace.design.length > 0,
+        tasks: trace.tasks.length > 0,
+        code: trace.code.length > 0,
+        tests: trace.tests.length > 0
+      };
+      
+      const coveragePercent = Object.values(coverage).filter(Boolean).length * 25;
+      const coverageColor = coveragePercent === 100 ? chalk.green : coveragePercent >= 75 ? chalk.yellow : chalk.red;
+      
+      console.log(chalk.bold('Coverage:'));
+      console.log(coverageColor(`  ${coveragePercent}% (${Object.values(coverage).filter(Boolean).length}/4 stages)`));
+      console.log();
+      
+      process.exit(coveragePercent === 100 ? 0 : 1);
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Validate 100% coverage
+program
+  .command('validate')
+  .description('Validate 100% traceability coverage (Constitutional Article V)')
+  .option('--requirements <path>', 'Requirements directory', 'docs/requirements')
+  .option('--design <path>', 'Design directory', 'docs/design')
+  .option('--tasks <path>', 'Tasks directory', 'docs/tasks')
+  .option('--code <path>', 'Source code directory', 'src')
+  .option('--tests <path>', 'Tests directory', 'tests')
+  .option('--strict', 'Fail on any gaps (default: true)', true)
+  .action(async (options) => {
+    try {
+      console.log(chalk.bold('\n🔍 Validating Traceability (Article V)\n'));
+      
+      const analyzer = new TraceabilityAnalyzer(process.cwd());
+      const validation = await analyzer.validate(options);
+      
+      console.log(chalk.bold('Article V: Complete Traceability'));
+      console.log();
+      
+      if (validation.passed) {
+        console.log(chalk.green('✓ 100% traceability achieved'));
+        console.log(chalk.dim(`  Requirements: ${validation.coverage.totalRequirements}`));
+        console.log(chalk.dim(`  Design Coverage: ${validation.coverage.designCoverage}%`));
+        console.log(chalk.dim(`  Tasks Coverage: ${validation.coverage.tasksCoverage}%`));
+        console.log(chalk.dim(`  Code Coverage: ${validation.coverage.codeCoverage}%`));
+        console.log(chalk.dim(`  Test Coverage: ${validation.coverage.testsCoverage}%`));
+        console.log();
+        process.exit(0);
+      } else {
+        console.log(chalk.red('✗ Traceability gaps detected'));
+        console.log();
+        
+        if (validation.gaps.orphanedRequirements.length > 0) {
+          console.log(chalk.red(`  Orphaned Requirements: ${validation.gaps.orphanedRequirements.length}`));
+        }
+        if (validation.gaps.untestedCode.length > 0) {
+          console.log(chalk.red(`  Untested Code: ${validation.gaps.untestedCode.length}`));
+        }
+        if (validation.gaps.missingTests.length > 0) {
+          console.log(chalk.red(`  Missing Tests: ${validation.gaps.missingTests.length}`));
+        }
+        
+        console.log();
+        console.log(chalk.dim('Run `musubi-trace gaps` for detailed gap analysis'));
+        console.log();
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program.parse(process.argv);
+
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}