musubi-sdd 3.7.1 → 3.9.0

package/README.ja.md

@@ -71,14 +71,14 @@ musubi init --windsurf  # Windsurf IDE
 
 ---
 
-## 📊 v2.1.0 の新機能
-
-- 🔄 **ワークフローエンジン** - ステージ管理とメトリクス収集の新CLI `musubi-workflow`
-- 📊 **メトリクス収集** - ステージごとの所要時間、イテレーション回数、フィードバックループを追跡
-- 🔬 **Spike/PoCステージ** - 要件定義前の調査・プロトタイピング用ステージ0
-- 👀 **コードレビューステージ** - 実装とテストの間のステージ5.5
-- 🔄 **振り返りステージ** - 継続的改善のためのステージ9
-- ✅ **ステージ検証ガイド** - ステージ遷移の検証チェックリスト
+## 📊 v3.7.1 の新機能
+
+- 🌐 **WebSocketリアルタイムGUI** - `musubi-browser`ダッシュボードでライブ更新
+- 📋 **GUIクイックアクション** - 新規要件モーダル、プロジェクト検証、レポートエクスポート
+- 🔄 **GitHub Actions統合** - `musubi-action`でCI/CD検証
+- 🔧 **OpenAPIコンバーター** - OpenAPI 3.x/Swagger 2.xスペックをMUSUBI形式に変換
+- 🌍 **多言語テンプレート** - 7言語対応（EN, JA, ZH, KO, ES, DE, FR）
+- 🤖 **Ollama統合** - 9つのモデルプリセットでローカルLLMをサポート
 
 ### 以前のバージョン (v2.0.0)
 

package/README.md

@@ -71,13 +71,14 @@ musubi init --windsurf  # Windsurf IDE
 
 ---
 
-## 📊 What's New in v3.6.1
-
-- 🚀 **ProactivePathOptimizer** - Continuous path optimization even during successful execution
-- 🎯 **GoalProgressTracker** - Real-time goal progress monitoring with milestone management
-- 🔄 **AdaptiveGoalModifier** - Dynamic goal adjustment based on execution context
-- 🛠️ **New CLI Commands** - `replan`, `goal`, `optimize`, `path` subcommands for orchestration
-- 📚 **Updated Agent Templates** - All 7 platforms with replanning command documentation
+## 📊 What's New in v3.7.1
+
+- 🌐 **WebSocket Real-time GUI** - Live replanning updates with `musubi-browser` dashboard
+- 📋 **GUI Quick Actions** - Modal dialog for New Requirement, Validate Project, Export Report
+- 🔄 **GitHub Actions Integration** - `musubi-action` for CI/CD with MUSUBI validation
+- 🔧 **OpenAPI Converter** - Convert OpenAPI 3.x/Swagger 2.x specs to MUSUBI format
+- 🌍 **Multi-language Templates** - 7 language support (EN, JA, ZH, KO, ES, DE, FR)
+- 🤖 **Ollama Integration** - Local LLM support with 9 model presets
 
 ### Previous (v3.6.0)
 

package/bin/musubi-orchestrate.js

@@ -9,6 +9,8 @@
  *   musubi-orchestrate run <pattern> --skills <skills...>  # Execute pattern with skills
  *   musubi-orchestrate auto <task>                          # Auto-select and execute skill
  *   musubi-orchestrate sequential --skills <skills...>      # Execute skills sequentially
+ *   musubi-orchestrate handoff --from <agent> --to <agent>  # Delegate to another agent
+ *   musubi-orchestrate triage --message <msg>               # Classify and route request
  *   musubi-orchestrate list-patterns                        # List available patterns
  *   musubi-orchestrate list-skills                          # List available skills
  *   musubi-orchestrate status                               # Show orchestration status
@@ -23,7 +25,15 @@ const {
   createOrchestrationEngine,
   PatternType,
   ExecutionStatus,
-  Priority
+  Priority,
+  HandoffPattern,
+  HandoffFilters,
+  HandoffConfig,
+  handoff,
+  TriagePattern,
+  TriageCategory,
+  TriageStrategy,
+  AgentCapability
 } = require('../src/orchestration');
 
 const {
@@ -758,6 +768,312 @@ program
     }
   });
 
+// Handoff command - Explicit agent-to-agent delegation
+program
+  .command('handoff')
+  .description('Execute handoff pattern - Delegate task to another agent')
+  .requiredOption('-t, --task <task>', 'Task to handoff')
+  .requiredOption('--from <agent>', 'Source agent')
+  .requiredOption('--to <agent>', 'Target agent')
+  .option('-s, --skills <skills...>', 'Available skills/agents')
+  .option('--filter <filter>', 'Input filter (removeAllTools|userMessagesOnly|lastN|summarize|keepAll)', 'keepAll')
+  .option('--filter-n <n>', 'N value for lastN filter', '10')
+  .option('--reason <reason>', 'Handoff reason')
+  .option('--priority <priority>', 'Priority (low|normal|high|urgent)', 'normal')
+  .option('-i, --input <json>', 'Additional input data as JSON')
+  .option('-f, --format <type>', 'Output format (text|json)', 'text')
+  .action(async (options) => {
+    try {
+      console.log(chalk.bold('\n🤝 Handoff Pattern - Agent Delegation\n'));
+      console.log(chalk.dim(`From: ${options.from} → To: ${options.to}\n`));
+      
+      const engine = await createEngine(process.cwd());
+      
+      // Parse additional input
+      const additionalInput = options.input ? JSON.parse(options.input) : {};
+      
+      // Select input filter
+      let inputFilter;
+      switch (options.filter) {
+        case 'removeAllTools':
+          inputFilter = HandoffFilters.removeAllTools;
+          break;
+        case 'userMessagesOnly':
+          inputFilter = HandoffFilters.userMessagesOnly;
+          break;
+        case 'lastN':
+          inputFilter = HandoffFilters.lastN(parseInt(options.filterN, 10));
+          break;
+        case 'summarize':
+          inputFilter = HandoffFilters.summarize;
+          break;
+        default:
+          inputFilter = HandoffFilters.keepAll;
+      }
+      
+      // Create handoff configuration
+      const handoffConfig = new HandoffConfig({
+        targetAgent: options.to,
+        reason: options.reason || `Handoff from ${options.from} to ${options.to}`,
+        inputFilter,
+        priority: options.priority
+      });
+      
+      // Prepare agent definitions
+      const agents = [];
+      const skills = options.skills || [options.from, options.to];
+      
+      for (const skillName of skills) {
+        const skill = engine.getSkill(skillName);
+        if (skill) {
+          agents.push({
+            name: skillName,
+            ...skill,
+            handoffs: skillName === options.from ? [handoffConfig] : []
+          });
+        } else {
+          // Create placeholder agent
+          agents.push({
+            name: skillName,
+            description: `${skillName} agent`,
+            execute: async (input) => ({ agent: skillName, input, executed: true }),
+            handoffs: skillName === options.from ? [handoffConfig] : []
+          });
+        }
+      }
+      
+      // Create target agents array as required by HandoffPattern
+      const targetAgent = agents.find(a => a.name === options.to) || {
+        name: options.to,
+        description: `${options.to} agent`,
+        execute: async (input) => ({ agent: options.to, input, executed: true })
+      };
+      
+      const context = await engine.execute(PatternType.HANDOFF, {
+        task: options.task,
+        input: {
+          sourceAgent: options.from,
+          targetAgents: [targetAgent],  // Array of target agents
+          agents,
+          reason: options.reason || `Handoff from ${options.from} to ${options.to}`,
+          ...additionalInput
+        }
+      });
+      
+      if (options.format === 'json') {
+        console.log(JSON.stringify({
+          success: context.status === ExecutionStatus.COMPLETED,
+          sourceAgent: options.from,
+          targetAgent: options.to,
+          result: context.output,
+          handoffChain: context.output?.handoffChain || []
+        }, null, 2));
+      } else {
+        if (context.status === ExecutionStatus.COMPLETED) {
+          console.log(chalk.green('✓ Handoff completed successfully\n'));
+          
+          if (context.output?.handoffChain) {
+            console.log(chalk.bold('Handoff Chain:'));
+            for (const hop of context.output.handoffChain) {
+              console.log(`  ${chalk.cyan(hop.from)} → ${chalk.yellow(hop.to)}`);
+              if (hop.reason) {
+                console.log(chalk.dim(`    Reason: ${hop.reason}`));
+              }
+            }
+            console.log('');
+          }
+          
+          console.log(chalk.bold('Result:'));
+          console.log(`  Final Agent: ${chalk.cyan(context.output?.finalAgent || options.to)}`);
+          console.log(`  Status: ${chalk.green('Completed')}`);
+        } else {
+          console.log(chalk.red(`✗ Handoff failed: ${context.error}\n`));
+          process.exit(1);
+        }
+      }
+      
+      console.log('');
+      
+    } catch (error) {
+      console.error(chalk.red(`\n✗ Error: ${error.message}\n`));
+      if (process.env.DEBUG) {
+        console.error(error.stack);
+      }
+      process.exit(1);
+    }
+  });
+
+// Triage command - Request classification and routing
+program
+  .command('triage')
+  .description('Execute triage pattern - Classify and route request to appropriate agent')
+  .requiredOption('-m, --message <message>', 'Message/request to classify')
+  .option('-s, --skills <skills...>', 'Available agents/skills to route to')
+  .option('--strategy <strategy>', 'Classification strategy (keyword|intent|capability|hybrid|llm)', 'hybrid')
+  .option('--default-category <category>', 'Default category if no match', 'general')
+  .option('--threshold <threshold>', 'Confidence threshold (0-1)', '0.3')
+  .option('--auto-handoff', 'Automatically handoff to selected agent', false)
+  .option('-f, --format <type>', 'Output format (text|json)', 'text')
+  .action(async (options) => {
+    try {
+      console.log(chalk.bold('\n🎯 Triage Pattern - Request Classification\n'));
+      console.log(chalk.dim(`Message: "${options.message.substring(0, 50)}${options.message.length > 50 ? '...' : ''}"\n`));
+      
+      const engine = await createEngine(process.cwd());
+      
+      // Map strategy string to enum
+      const strategyMap = {
+        'keyword': TriageStrategy.KEYWORD,
+        'intent': TriageStrategy.INTENT,
+        'capability': TriageStrategy.CAPABILITY,
+        'hybrid': TriageStrategy.HYBRID,
+        'llm': TriageStrategy.LLM
+      };
+      
+      const strategy = strategyMap[options.strategy] || TriageStrategy.HYBRID;
+      
+      // Prepare agents with capabilities
+      const agents = [];
+      const defaultSkills = [
+        { name: 'billing-agent', categories: [TriageCategory.BILLING, TriageCategory.REFUND], keywords: ['invoice', 'payment', 'refund', 'charge', 'billing'] },
+        { name: 'support-agent', categories: [TriageCategory.SUPPORT], keywords: ['help', 'issue', 'problem', 'broken', 'support'] },
+        { name: 'sales-agent', categories: [TriageCategory.SALES], keywords: ['buy', 'purchase', 'pricing', 'discount', 'order'] },
+        { name: 'technical-agent', categories: [TriageCategory.TECHNICAL], keywords: ['api', 'bug', 'error', 'integration', 'code'] },
+        { name: 'general-agent', categories: [TriageCategory.GENERAL], keywords: [] }
+      ];
+      
+      const skillNames = options.skills || defaultSkills.map(s => s.name);
+      
+      for (const skillName of skillNames) {
+        const skill = engine.getSkill(skillName);
+        const defaultSkill = defaultSkills.find(s => s.name === skillName);
+        
+        const agentObj = {
+          name: skillName,
+          description: skill?.description || `${skillName} agent`,
+          execute: skill?.execute || (async (input) => ({ agent: skillName, input, executed: true }))
+        };
+        
+        agentObj.capability = new AgentCapability({
+          agent: agentObj,  // Reference to agent object
+          categories: defaultSkill?.categories || [TriageCategory.GENERAL],
+          keywords: defaultSkill?.keywords || [],
+          priority: 1
+        });
+        
+        agents.push(agentObj);
+      }
+      
+      const context = await engine.execute(PatternType.TRIAGE, {
+        task: 'Classify and route request',
+        input: {
+          message: options.message,
+          agents,
+          strategy,
+          defaultCategory: options.defaultCategory.toUpperCase(),
+          confidenceThreshold: parseFloat(options.threshold),
+          enableHandoff: options.autoHandoff  // Only handoff if explicitly requested
+        }
+      });
+      
+      if (options.format === 'json') {
+        console.log(JSON.stringify({
+          success: context.status === ExecutionStatus.COMPLETED,
+          classification: context.output?.classification,
+          selectedAgent: context.output?.selectedAgent,
+          confidence: context.output?.confidence,
+          category: context.output?.category
+        }, null, 2));
+      } else {
+        if (context.status === ExecutionStatus.COMPLETED) {
+          console.log(chalk.green('✓ Triage completed\n'));
+          
+          const classification = context.output?.classification || context.output;
+          
+          console.log(chalk.bold('Classification Result:'));
+          console.log(`  Category: ${chalk.cyan(classification?.category || 'N/A')}`);
+          console.log(`  Confidence: ${formatConfidence(classification?.confidence || 0)}`);
+          if (classification?.reasoning) {
+            console.log(`  Reasoning: ${chalk.dim(classification.reasoning)}`);
+          }
+          console.log('');
+          
+          if (context.output?.selectedAgent) {
+            console.log(chalk.bold('Routing Decision:'));
+            console.log(`  Selected Agent: ${chalk.yellow(context.output.selectedAgent)}`);
+            console.log(`  Agent Score: ${(context.output.agentScore || 0).toFixed(2)}`);
+          }
+          
+          if (options.autoHandoff && context.output?.handoffResult) {
+            console.log('');
+            console.log(chalk.bold('Handoff Result:'));
+            console.log(`  Status: ${chalk.green('Executed')}`);
+          }
+        } else {
+          console.log(chalk.red(`✗ Triage failed: ${context.error}\n`));
+          process.exit(1);
+        }
+      }
+      
+      console.log('');
+      
+    } catch (error) {
+      console.error(chalk.red(`\n✗ Error: ${error.message}\n`));
+      if (process.env.DEBUG) {
+        console.error(error.stack);
+      }
+      process.exit(1);
+    }
+  });
+
+// Triage categories command - List available categories
+program
+  .command('triage-categories')
+  .description('List available triage categories')
+  .option('-f, --format <type>', 'Output format (text|json)', 'text')
+  .action(async (options) => {
+    try {
+      console.log(chalk.bold('\n📋 Triage Categories\n'));
+      
+      const categories = Object.entries(TriageCategory).map(([key, value]) => ({
+        key,
+        value,
+        description: getCategoryDescription(value)
+      }));
+      
+      if (options.format === 'json') {
+        console.log(JSON.stringify(categories, null, 2));
+      } else {
+        for (const cat of categories) {
+          console.log(`  ${chalk.cyan(cat.value.padEnd(12))} - ${cat.description}`);
+        }
+      }
+      
+      console.log('');
+      
+    } catch (error) {
+      console.error(chalk.red(`\n✗ Error: ${error.message}\n`));
+      process.exit(1);
+    }
+  });
+
+/**
+ * Get category description
+ */
+function getCategoryDescription(category) {
+  const descriptions = {
+    [TriageCategory.BILLING]: 'Billing, invoices, payments, refunds',
+    [TriageCategory.SUPPORT]: 'General support, help requests, issues',
+    [TriageCategory.SALES]: 'Sales inquiries, purchases, pricing',
+    [TriageCategory.TECHNICAL]: 'Technical issues, bugs, API, integrations',
+    [TriageCategory.REFUND]: 'Refund requests and processing',
+    [TriageCategory.GENERAL]: 'General inquiries, catch-all category',
+    [TriageCategory.ESCALATION]: 'Escalated issues requiring supervisor attention',
+    [TriageCategory.UNKNOWN]: 'Unclassified requests'
+  };
+  return descriptions[category] || 'Unknown category';
+}
+
 program.parse(process.argv);
 
 if (!process.argv.slice(2).length) {

package/bin/musubi-validate.js

@@ -11,12 +11,20 @@
  *   musubi-validate article <1-9>   # Validate specific article
  *   musubi-validate gates           # Validate Phase -1 Gates
  *   musubi-validate complexity      # Validate complexity limits
+ *   musubi-validate guardrails      # Validate content with guardrails
  *   musubi-validate all             # Run all validations
  */
 
 const { Command } = require('commander');
 const chalk = require('chalk');
 const ConstitutionValidator = require('../src/validators/constitution');
+const {
+  createInputGuardrail,
+  createOutputGuardrail,
+  createSafetyCheckGuardrail,
+  GuardrailChain,
+  SafetyLevel
+} = require('../src/orchestration/guardrails');
 
 const program = new Command();
 
@@ -107,6 +115,134 @@ program
     }
   });
 
+// Guardrails validation
+program
+  .command('guardrails')
+  .description('Validate content with input/output guardrails')
+  .argument('[content]', 'Content to validate (or use --file)')
+  .option('--file <path>', 'Read content from file')
+  .option('-t, --type <type>', 'Guardrail type (input|output|safety)', 'input')
+  .option('-l, --level <level>', 'Safety level (basic|standard|strict|paranoid)', 'standard')
+  .option('--constitutional', 'Enable constitutional compliance checks')
+  .option('--redact', 'Enable redaction for output guardrails')
+  .option('-f, --format <type>', 'Output format (console|json)', 'console')
+  .action(async (content, options) => {
+    try {
+      // Get content from argument, file, or stdin
+      let inputContent = content;
+      
+      if (options.file) {
+        const fs = require('fs');
+        const path = require('path');
+        const filePath = path.resolve(process.cwd(), options.file);
+        inputContent = fs.readFileSync(filePath, 'utf-8');
+      } else if (!inputContent && !process.stdin.isTTY) {
+        // Read from stdin
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+          chunks.push(chunk);
+        }
+        inputContent = Buffer.concat(chunks).toString('utf-8');
+      }
+
+      if (!inputContent) {
+        console.error(chalk.red('✗ No content provided. Use --file or pipe content.'));
+        process.exit(1);
+      }
+
+      let guardrail;
+      const guardrailType = options.type.toLowerCase();
+
+      switch (guardrailType) {
+        case 'input':
+          guardrail = createInputGuardrail('userInput', {
+            sanitize: true
+          });
+          break;
+        
+        case 'output':
+          guardrail = createOutputGuardrail(options.redact ? 'redact' : 'safe');
+          break;
+        
+        case 'safety':
+          guardrail = createSafetyCheckGuardrail(options.level, {
+            enforceConstitution: options.constitutional
+          });
+          break;
+        
+        default:
+          console.error(chalk.red(`✗ Unknown guardrail type: ${guardrailType}`));
+          process.exit(1);
+      }
+
+      console.log(chalk.dim(`\n🛡️  Running ${guardrailType} guardrail validation...\n`));
+
+      const result = await guardrail.run(inputContent);
+
+      displayGuardrailResults(result, options);
+      process.exit(result.passed ? 0 : 1);
+    } catch (error) {
+      console.error(chalk.red('✗ Guardrail validation error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Guardrails chain validation
+program
+  .command('guardrails-chain')
+  .description('Run a chain of guardrails on content')
+  .argument('[content]', 'Content to validate')
+  .option('--file <path>', 'Read content from file')
+  .option('--parallel', 'Run guardrails in parallel')
+  .option('--stop-on-failure', 'Stop on first failure')
+  .option('-f, --format <type>', 'Output format (console|json)', 'console')
+  .action(async (content, options) => {
+    try {
+      // Get content
+      let inputContent = content;
+      
+      if (options.file) {
+        const fs = require('fs');
+        const path = require('path');
+        const filePath = path.resolve(process.cwd(), options.file);
+        inputContent = fs.readFileSync(filePath, 'utf-8');
+      } else if (!inputContent && !process.stdin.isTTY) {
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+          chunks.push(chunk);
+        }
+        inputContent = Buffer.concat(chunks).toString('utf-8');
+      }
+
+      if (!inputContent) {
+        console.error(chalk.red('✗ No content provided. Use --file or pipe content.'));
+        process.exit(1);
+      }
+
+      // Create guardrail chain
+      const chain = new GuardrailChain({
+        name: 'ValidationChain',
+        parallel: options.parallel || false,
+        stopOnFirstFailure: options.stopOnFailure || false
+      });
+
+      // Add default guardrails
+      chain.add(createInputGuardrail('security'));
+      chain.add(createSafetyCheckGuardrail('standard'));
+      chain.add(createOutputGuardrail('safe'));
+
+      console.log(chalk.dim('\n🔗 Running guardrail chain validation...\n'));
+
+      const result = await chain.run(inputContent);
+
+      displayChainResults(result, options);
+      process.exit(result.passed ? 0 : 1);
+    } catch (error) {
+      console.error(chalk.red('✗ Guardrail chain error:'), error.message);
+      process.exit(1);
+    }
+  });
+
 // Score validation (numeric score output for CI/CD)
 program
   .command('score')
@@ -345,6 +481,104 @@ function displayMarkdown(title, results) {
   }
 }
 
+/**
+ * Display guardrail validation results
+ */
+function displayGuardrailResults(result, options) {
+  if (options.format === 'json') {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  console.log(chalk.bold('Guardrail Validation Results'));
+  console.log(chalk.bold('━'.repeat(50)));
+
+  if (result.passed) {
+    console.log(chalk.green(`\n✓ PASSED - ${result.guardrailName}\n`));
+  } else {
+    console.log(chalk.red(`\n✗ FAILED - ${result.guardrailName}\n`));
+  }
+
+  if (result.message) {
+    console.log(chalk.dim(`Message: ${result.message}`));
+  }
+
+  console.log(chalk.dim(`Execution time: ${result.executionTimeMs}ms\n`));
+
+  if (result.violations && result.violations.length > 0) {
+    console.log(chalk.bold.red('Violations:'));
+    result.violations.forEach(violation => {
+      const severityIcon = violation.severity === 'error' ? '✗' : 
+                           violation.severity === 'warning' ? '⚠' : 'ℹ';
+      const severityColor = violation.severity === 'error' ? chalk.red :
+                            violation.severity === 'warning' ? chalk.yellow : chalk.blue;
+      console.log(severityColor(`  ${severityIcon} [${violation.code}] ${violation.message}`));
+    });
+    console.log();
+  }
+
+  // Show metadata if redaction was applied
+  if (result.metadata?.redactionApplied) {
+    console.log(chalk.bold.blue('Redaction Applied:'));
+    console.log(chalk.dim(`  ${result.metadata.redactionCount} item(s) redacted`));
+    if (result.metadata.redactions) {
+      result.metadata.redactions.forEach(r => {
+        console.log(chalk.dim(`    - ${r.type}: ${r.count}`));
+      });
+    }
+    console.log();
+  }
+
+  // Show quality scores if available
+  if (result.metadata?.qualityScores) {
+    console.log(chalk.bold.blue('Quality Scores:'));
+    Object.entries(result.metadata.qualityScores).forEach(([name, score]) => {
+      console.log(chalk.dim(`  ${name}: ${(score * 100).toFixed(1)}%`));
+    });
+    console.log();
+  }
+}
+
+/**
+ * Display guardrail chain results
+ */
+function displayChainResults(result, options) {
+  if (options.format === 'json') {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  console.log(chalk.bold('Guardrail Chain Results'));
+  console.log(chalk.bold('━'.repeat(50)));
+
+  if (result.passed) {
+    console.log(chalk.green(`\n✓ PASSED - ${result.chainName}\n`));
+  } else {
+    console.log(chalk.red(`\n✗ FAILED - ${result.chainName}\n`));
+  }
+
+  console.log(chalk.dim(`Guardrails executed: ${result.executedCount}/${result.guardrailCount}`));
+  console.log(chalk.dim(`Total time: ${result.executionTimeMs}ms\n`));
+
+  // Show individual guardrail results
+  console.log(chalk.bold('Individual Results:'));
+  result.results.forEach((r, index) => {
+    const icon = r.passed ? chalk.green('✓') : chalk.red('✗');
+    console.log(`  ${icon} ${r.guardrailName} (${r.executionTimeMs}ms)`);
+  });
+  console.log();
+
+  // Show all violations
+  if (result.violations && result.violations.length > 0) {
+    console.log(chalk.bold.red('All Violations:'));
+    result.violations.forEach(violation => {
+      const severityColor = violation.severity === 'error' ? chalk.red : chalk.yellow;
+      console.log(severityColor(`  • [${violation.code}] ${violation.message}`));
+    });
+    console.log();
+  }
+}
+
 // Parse arguments
 program.parse(process.argv);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "musubi-sdd",
-  "version": "3.7.1",
+  "version": "3.9.0",
   "description": "Ultimate Specification Driven Development Tool with 27 Agents for 7 AI Coding Platforms + MCP Integration (Claude Code, GitHub Copilot, Cursor, Gemini CLI, Windsurf, Codex, Qwen Code)",
   "main": "src/index.js",
   "bin": {