@polymorphism-tech/morph-spec 4.3.6 → 4.5.0

package/src/commands/project/init.js

@@ -18,15 +18,26 @@ import {
   createDirectoryLink
 } from '../../utils/file-copier.js';
 import { saveProjectMorphVersion, getInstalledCLIVersion } from '../../utils/version-checker.js';
-import { installClaudeHooks } from '../../utils/hooks-installer.js';
+import { installClaudeHooks, installGlobalStatusline } from '../../utils/claude-settings-manager.js';
+import { installSkills } from '../../utils/skills-installer.js';
+import { installAgents, installDomainAgents } from '../../utils/agents-installer.js';
 import { AutoContextOrchestrator } from '../../core/orchestrator.js';
 import { detectClaudeCode } from '../../llm/environment-detector.js';
 import inquirer from 'inquirer';
 import { detectProject } from '../../lib/detectors/index.js';
+import { detectClaudeConfig, mapMcpsToPhases, formatConfigSummary } from '../../lib/detectors/claude-config-detector.js';
+import { generateSettings, saveIntegrations } from '../../lib/generators/settings-generator.js';
+import {
+  orchestrateMcpSetup,
+  installAutoMcps,
+  installMcpWithCredentials,
+  generateSetupInstructions,
+  formatMcpStatusTable
+} from '../../lib/installers/mcp-installer.js';
 
 export async function initCommand(options) {
   const targetPath = options.path || process.cwd();
-  const claudeMdPath = join(import.meta.dirname, '..', '..', '..', 'CLAUDE.md');
+  const claudeMdPath = join(import.meta.dirname, '..', '..', '..', 'framework', 'CLAUDE.md');
 
   logger.header('MORPH-SPEC Framework Installation');
   logger.dim(`Target: ${targetPath}`);
@@ -62,12 +73,14 @@ export async function initCommand(options) {
 
     // 2. Create .morph directory structure
     spinner.text = 'Creating .morph structure...';
-    const projectPath = join(morphPath, 'project');
     const configDir = join(morphPath, 'config');
-    await ensureDir(join(projectPath, 'context'));
-    await ensureDir(join(projectPath, 'standards'));
-    await ensureDir(join(projectPath, 'outputs'));
+    const frameworkDestDir = join(morphPath, 'framework');
+    const contextDir = join(morphPath, 'context');
+    const featuresDir = join(morphPath, 'features');
+    await ensureDir(contextDir);
+    await ensureDir(featuresDir);
     await ensureDir(configDir);
+    await ensureDir(frameworkDestDir);
 
     // 3. Create config.json
     spinner.text = 'Generating config.json...';
@@ -87,7 +100,7 @@ export async function initCommand(options) {
 
     // 4. Create context/README.md
     spinner.text = 'Creating context README...';
-    const contextReadme = join(projectPath, 'context', 'README.md');
+    const contextReadme = join(contextDir, 'README.md');
     const readmeContent = `# ${dirName} - Project Context
 
 ## Overview
@@ -111,7 +124,7 @@ Run \`morph-spec detect\` to analyze your project.
     // 5. Copy framework templates (project-local overrides start from framework defaults)
     const contentDir = getContentDir();
     const frameworkTemplatesSrc = join(import.meta.dirname, '..', '..', '..', 'framework', 'templates');
-    const templatesDest = join(morphPath, 'templates');
+    const templatesDest = join(frameworkDestDir, 'templates');
     let templatesCopied = false;
     if (await pathExists(frameworkTemplatesSrc)) {
       await copyDirectory(frameworkTemplatesSrc, templatesDest);
@@ -123,7 +136,7 @@ Run \`morph-spec detect\` to analyze your project.
     // 6b. Copy framework standards hierarchy (universal standards)
     spinner.text = 'Copying framework standards hierarchy...';
     const frameworkStandardsSrc = join(import.meta.dirname, '..', '..', '..', 'framework', 'standards');
-    const frameworkStandardsDest = join(morphPath, 'standards');
+    const frameworkStandardsDest = join(frameworkDestDir, 'standards');
     if (await pathExists(frameworkStandardsSrc)) {
       // Copy entire hierarchy (core/, backend/, frontend/, infrastructure/)
       await copyDirectory(frameworkStandardsSrc, frameworkStandardsDest);
@@ -133,25 +146,12 @@ Run \`morph-spec detect\` to analyze your project.
     // 7. Copy agents.json (sourced from framework/ — canonical single source of truth)
     spinner.text = 'Copying agents configuration...';
     const agentsSrc = join(import.meta.dirname, '..', '..', '..', 'framework', 'agents.json');
-    const agentsDest = join(configDir, 'agents.json');
+    const agentsDest = join(frameworkDestDir, 'agents.json');
     if (await pathExists(agentsSrc)) {
       await copyFile(agentsSrc, agentsDest);
     }
 
-    // 8. Copy azure-pricing files
-    spinner.text = 'Copying Azure pricing data...';
-    const pricingSrc = join(contentDir, '.morph', 'config', 'azure-pricing.json');
-    const pricingDest = join(configDir, 'azure-pricing.json');
-    if (await pathExists(pricingSrc)) {
-      await copyFile(pricingSrc, pricingDest);
-    }
-    const pricingSchemaSrc = join(contentDir, '.morph', 'config', 'azure-pricing.schema.json');
-    const pricingSchemaDest = join(configDir, 'azure-pricing.schema.json');
-    if (await pathExists(pricingSchemaSrc)) {
-      await copyFile(pricingSchemaSrc, pricingSchemaDest);
-    }
-
-    // 9. Copy .claude commands and create symlinks for skills
+    // 8. Copy .claude commands and create symlinks for skills
     // Source: framework/ (canonical for all stacks)
     spinner.text = 'Setting up Claude Code integration...';
     const frameworkDir = join(import.meta.dirname, '..', '..', '..', 'framework');
@@ -220,9 +220,48 @@ Run \`morph-spec detect\` to analyze your project.
       }
     }
 
-    // 9b. Install/update agent-teams hooks in .claude/settings.local.json
+    // 9a. Install path-scoped rules to .claude/rules/ (native Claude Code pattern)
+    spinner.text = 'Installing path-scoped rules to .claude/rules/...';
+    const rulesSrc = join(frameworkDir, 'rules');
+    const rulesDest = join(claudeDest, 'rules');
+    let rulesCopied = false;
+    if (await pathExists(rulesSrc)) {
+      await copyDirectory(rulesSrc, rulesDest);
+      rulesCopied = true;
+    }
+
+    // 9b. Install morph skills to .claude/skills/ for native Claude Code discovery
+    spinner.text = 'Installing morph skills to .claude/skills/...';
+    await installSkills(targetPath);
+
+    // 9b2. Install tier-1/2 agents as native Claude Code subagents in .claude/agents/
+    spinner.text = 'Installing native subagents to .claude/agents/...';
+    await installAgents(targetPath, frameworkDir);
+
+    // 9b2b. Install level-2 domain agents as native Claude Code subagents in .claude/agents/
+    await installDomainAgents(targetPath, frameworkDir);
+
+    // 9b3. Install runtime CLAUDE.md to .claude/CLAUDE.md (Claude Code runtime instructions)
+    spinner.text = 'Installing .claude/CLAUDE.md...';
+    const runtimeClaudeMdSrc = join(frameworkDir, 'CLAUDE.md');
+    const runtimeClaudeMdDest = join(claudeDest, 'CLAUDE.md');
+    if (await pathExists(runtimeClaudeMdSrc)) {
+      await copyFile(runtimeClaudeMdSrc, runtimeClaudeMdDest);
+    }
+
+    // 9c. Install statusline globally to ~/.claude/ (applies to all Claude Code sessions)
+    spinner.text = 'Installing statusline globally to ~/.claude/...';
+    const HOOKS_SRC = join(import.meta.dirname, '..', '..', '..', 'framework', 'hooks', 'claude-code');
+    try {
+      await installGlobalStatusline(HOOKS_SRC);
+    } catch {
+      // Non-critical: global dir may not be writable in all environments
+      logger.dim('  ⚠ Could not install statusline globally (non-critical)');
+    }
+
+    // 9d. Install/update Claude Code hooks in .claude/settings.local.json
     spinner.text = 'Installing Claude Code hooks...';
-    const hooksInstalled = await installClaudeHooks(targetPath);
+    const hooksResult = await installClaudeHooks(targetPath);
 
     // 10. Save version info
     spinner.text = 'Saving version info...';
@@ -233,6 +272,234 @@ Run \`morph-spec detect\` to analyze your project.
     spinner.text = 'Updating .gitignore...';
     await updateGitignore(targetPath);
 
+    // 11b. Detect Claude Code environment (plugins, MCPs, skills)
+    spinner.text = 'Detecting Claude Code environment...';
+    let claudeConfigDetected = null;
+    let integrationsCreated = false;
+    try {
+      claudeConfigDetected = await detectClaudeConfig(targetPath);
+      const hasIntegrations = claudeConfigDetected.plugins.length > 0
+        || claudeConfigDetected.mcpServers.length > 0
+        || claudeConfigDetected.superpowers.installed;
+
+      if (hasIntegrations) {
+        spinner.stop();
+        logger.blank();
+        logger.header('Claude Code Environment Detected');
+
+        const summary = formatConfigSummary(claudeConfigDetected);
+        if (summary) {
+          logger.info(summary);
+        }
+
+        // Show MCP-to-phase mapping
+        if (claudeConfigDetected.mcpServers.length > 0) {
+          const phaseMap = mapMcpsToPhases(claudeConfigDetected.mcpServers);
+          logger.blank();
+          logger.dim('MCP usage by phase:');
+          for (const [phase, mcps] of Object.entries(phaseMap)) {
+            if (mcps.length > 0) {
+              logger.dim(`  ${phase}: ${mcps.map(m => m.name).join(', ')}`);
+            }
+          }
+        }
+
+        logger.blank();
+        const { saveIntegrationsChoice } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'saveIntegrationsChoice',
+          message: 'Save detected integrations and generate optimized settings?',
+          default: true
+        }]);
+
+        if (saveIntegrationsChoice) {
+          spinner.start('Saving integrations...');
+          await saveIntegrations(targetPath, claudeConfigDetected);
+          await generateSettings(targetPath, claudeConfigDetected, config);
+          integrationsCreated = true;
+          spinner.succeed('Integrations saved to .morph/config/integrations.json');
+        } else {
+          spinner.start('Continuing...');
+        }
+      }
+    } catch (error) {
+      // Non-fatal: continue without integrations
+      logger.dim(`  Claude config detection skipped: ${error.message}`);
+    }
+
+    // 11c. Stack detection (moved before MCP setup so we know the stack)
+    spinner.text = 'Detecting project stack...';
+    let detectedStack = 'unknown';
+    const hasProjectFiles = await pathExists(join(targetPath, 'package.json'))
+      || await pathExists(join(targetPath, 'src'))
+      || (await fs.readdir(targetPath)).some(f => f.endsWith('.csproj'));
+
+    if (hasProjectFiles) {
+      try {
+        const quickResults = await detectProject(targetPath, { conversation: false, generateStandards: false });
+        const structure = quickResults.structure;
+
+        if (structure?.stack && structure.stack !== 'unknown') {
+          detectedStack = structure.stack;
+          spinner.stop();
+          logger.blank();
+          logger.header('Existing Project Detected');
+          logger.info(`Stack detected: ${structure.stack}`);
+          if (structure?.architecture) logger.dim(`Architecture: ${structure.architecture}`);
+          if (structure?.uiLibrary) logger.dim(`UI Library: ${structure.uiLibrary}`);
+
+          const { standardsChoice } = await inquirer.prompt([{
+            type: 'list',
+            name: 'standardsChoice',
+            message: 'How should morph-spec handle your project standards?',
+            choices: [
+              { name: 'Keep morph-spec defaults (recommended)', value: 'morph-spec' },
+              { name: 'Detect project-specific standards', value: 'detect' }
+            ]
+          }]);
+
+          if (standardsChoice === 'detect') {
+            spinner.start('Generating project-specific standards...');
+            const fullResults = await detectProject(targetPath, { conversation: false });
+            const inferredPath = join(contextDir, 'standards.md');
+            await writeFile(inferredPath, fullResults.inferred.markdown);
+            spinner.succeed('Generated .morph/context/standards.md');
+            logger.dim('Review and edit .morph/context/standards.md as needed.');
+          }
+
+          spinner.start('Continuing...');
+        }
+      } catch (error) {
+        logger.dim(`  Stack detection skipped: ${error.message}`);
+      }
+    }
+
+    // 11d. MCP Auto-Setup
+    let mcpSetupResult = null;
+    if (!options.skipMcp) {
+      try {
+        spinner.stop();
+        const existingMcps = claudeConfigDetected?.mcpServers || [];
+        const orchestration = orchestrateMcpSetup(targetPath, detectedStack, existingMcps);
+
+        const autoNames = Object.keys(orchestration.autoInstallable);
+        const manualNames = Object.keys(orchestration.needsManualSetup);
+        const hasAutoMcps = autoNames.length > 0;
+        const hasManualMcps = manualNames.length > 0;
+
+        if (hasAutoMcps || hasManualMcps) {
+          logger.blank();
+          logger.header('MCP Server Setup');
+
+          // Auto-install prompt
+          let autoInstalled = {};
+          if (hasAutoMcps) {
+            const { installAuto } = await inquirer.prompt([{
+              type: 'confirm',
+              name: 'installAuto',
+              message: `Install recommended MCP servers? (${autoNames.join(', ')})`,
+              default: true
+            }]);
+
+            if (installAuto) {
+              spinner.start('Installing MCP servers...');
+              const result = await installAutoMcps(targetPath, orchestration.autoInstallable);
+              spinner.succeed(`Installed ${result.added.length} MCP server(s)`);
+              for (const name of result.added) {
+                autoInstalled[name] = orchestration.autoInstallable[name];
+              }
+            }
+          }
+
+          // Credential MCPs — inline setup or instructions
+          const manualInstalled = {};
+          if (hasManualMcps) {
+            for (const [name, entry] of Object.entries(orchestration.needsManualSetup)) {
+              logger.blank();
+
+              // Show warnings
+              for (const warning of entry.install.warnings || []) {
+                logger.warn(`  ${warning}`);
+              }
+
+              const capitalizedName = name.charAt(0).toUpperCase() + name.slice(1);
+              const { setupNow } = await inquirer.prompt([{
+                type: 'confirm',
+                name: 'setupNow',
+                message: `Set up ${capitalizedName} MCP now? (${entry.usage})`,
+                default: false
+              }]);
+
+              if (setupNow) {
+                // Collect credentials
+                const credentialValues = {};
+                for (const cred of entry.install.credentials) {
+                  const { value } = await inquirer.prompt([{
+                    type: cred.secret ? 'password' : 'input',
+                    name: 'value',
+                    message: `${cred.name}:`,
+                    mask: cred.secret ? '*' : undefined
+                  }]);
+                  credentialValues[cred.envVar] = value;
+                }
+
+                spinner.start(`Configuring ${name}...`);
+                await installMcpWithCredentials(targetPath, name, entry, credentialValues);
+                spinner.succeed(`${capitalizedName} MCP configured`);
+                manualInstalled[name] = entry;
+              } else {
+                // Show setup instructions
+                const instructions = generateSetupInstructions(name, entry);
+                logger.blank();
+                logger.dim('  Add to .claude/settings.local.json → mcpServers:');
+                logger.dim('  ' + '─'.repeat(55));
+                for (const line of instructions.configSnippet.split('\n')) {
+                  logger.dim(`  ${line}`);
+                }
+                logger.dim('  ' + '─'.repeat(55));
+
+                for (const cred of instructions.credentialUrls) {
+                  logger.dim(`  Get ${cred.name}: ${cred.helpUrl}`);
+                }
+                logger.dim(`  Or run later: ${instructions.cliCommand}`);
+              }
+            }
+          }
+
+          // Summary table
+          const justInstalled = { ...autoInstalled, ...manualInstalled };
+          const statusRows = formatMcpStatusTable(orchestration, justInstalled);
+
+          if (statusRows.length > 0) {
+            logger.blank();
+            logger.info('MCP Servers');
+            logger.dim('─'.repeat(60));
+
+            const STATUS_ICONS = {
+              installed: '✓',
+              available: '○',
+              already_configured: '✓',
+              needs_setup: '⚠',
+              prereq_missing: '✗',
+              not_relevant: '─'
+            };
+
+            for (const row of statusRows) {
+              const icon = STATUS_ICONS[row.status] || '?';
+              const statusLabel = row.status.replace(/_/g, ' ');
+              logger.dim(`  ${icon} ${row.name.padEnd(15)} ${statusLabel.padEnd(20)} ${row.detail}`);
+            }
+          }
+
+          mcpSetupResult = { autoInstalled, manualInstalled, orchestration };
+        }
+      } catch (error) {
+        logger.dim(`  MCP setup skipped: ${error.message}`);
+      }
+    } else {
+      logger.dim('\nSkipped MCP setup (--skip-mcp flag)');
+    }
+
     spinner.succeed('MORPH-SPEC installed successfully!');
 
     // Show next steps
@@ -242,7 +509,7 @@ Run \`morph-spec detect\` to analyze your project.
     logger.header('Next Steps');
 
     logger.step(1, 'Run detection: morph-spec detect');
-    logger.step(2, 'Review .morph/config.json and .morph/project/standards/inferred.md');
+    logger.step(2, 'Review .morph/config/config.json and .morph/context/standards.md');
     logger.step(3, 'Open project in VS Code with Claude Code');
     logger.step(4, 'Start your first feature:');
     logger.blank();
@@ -253,16 +520,27 @@ Run \`morph-spec detect\` to analyze your project.
 
     logger.info('Files installed:');
     logger.dim(`  ✓ CLAUDE.md`);
-    logger.dim(`  ✓ .morph/config/ (config.json, agents.json, azure-pricing.json)`);
-    logger.dim(`  ✓ .morph/standards/ (coding.md, architecture.md, azure.md, ...)`);
-    if (templatesCopied) {
-      logger.dim(`  ✓ .morph/templates/ (project-local overrides for framework templates)`);
-    }
-    logger.dim(`  ✓ .morph/project/ (context, standards, outputs)`);
+    logger.dim(`  ✓ .morph/config/ (config.json)`);
+    logger.dim(`  ✓ .morph/framework/ (agents.json, standards/, templates/)`);
+    logger.dim(`  ✓ .morph/context/ (project context)`);
+    logger.dim(`  ✓ .morph/features/ (feature outputs)`);
     if (commandsCopied) {
       logger.dim(`  ✓ .claude/commands/ (slash commands)`);
     }
-    logger.dim(`  ✓ .claude/settings.local.json (agent-teams hooks)`);
+    if (rulesCopied) {
+      logger.dim(`  ✓ .claude/rules/ (5 path-scoped rules)`);
+    }
+    logger.dim(`  ✓ .claude/settings.local.json (${hooksResult.installed} hooks installed)`);
+    if (integrationsCreated) {
+      logger.dim(`  ✓ .morph/config/integrations.json (detected plugins & MCPs)`);
+    }
+    if (mcpSetupResult) {
+      const autoCount = Object.keys(mcpSetupResult.autoInstalled).length;
+      const manualCount = Object.keys(mcpSetupResult.manualInstalled).length;
+      if (autoCount + manualCount > 0) {
+        logger.dim(`  ✓ MCP servers (${autoCount + manualCount} configured)`);
+      }
+    }
 
     if (symlinkCount > 0) {
       const linkType = process.platform === 'win32' ? 'junction-linked' : 'symlinked';
@@ -274,48 +552,6 @@ Run \`morph-spec detect\` to analyze your project.
 
     logger.blank();
 
-    // 12. Interactive stack/standards detection for existing projects
-    const hasProjectFiles = await pathExists(join(targetPath, 'package.json'))
-      || await pathExists(join(targetPath, 'src'))
-      || (await fs.readdir(targetPath)).some(f => f.endsWith('.csproj'));
-
-    if (hasProjectFiles) {
-      logger.blank();
-      logger.header('Existing Project Detected');
-
-      try {
-        const quickResults = await detectProject(targetPath, { conversation: false, generateStandards: false });
-        const structure = quickResults.structure;
-
-        if (structure?.stack && structure.stack !== 'unknown') {
-          logger.info(`Stack detected: ${structure.stack}`);
-          if (structure?.architecture) logger.dim(`Architecture: ${structure.architecture}`);
-          if (structure?.uiLibrary) logger.dim(`UI Library: ${structure.uiLibrary}`);
-        }
-
-        const { standardsChoice } = await inquirer.prompt([{
-          type: 'list',
-          name: 'standardsChoice',
-          message: 'How should morph-spec handle your project standards?',
-          choices: [
-            { name: 'Keep morph-spec defaults (recommended)', value: 'morph-spec' },
-            { name: 'Detect project-specific standards', value: 'detect' }
-          ]
-        }]);
-
-        if (standardsChoice === 'detect') {
-          spinner.start('Generating project-specific standards...');
-          const fullResults = await detectProject(targetPath, { conversation: false });
-          const inferredPath = join(morphPath, 'project', 'standards', 'inferred.md');
-          await writeFile(inferredPath, fullResults.inferred.markdown);
-          spinner.succeed('Generated .morph/project/standards/inferred.md');
-          logger.dim('Review and edit .morph/project/standards/inferred.md as needed.');
-        }
-      } catch (error) {
-        logger.warn(`Stack detection failed: ${error.message}`);
-      }
-    }
-
     // 13. LLM-based auto-detect project context (if Claude Code is available and not --skip-detection)
     if (!options.skipDetection && detectClaudeCode()) {
       logger.blank();
@@ -349,6 +585,12 @@ Run \`morph-spec detect\` to analyze your project.
       logger.dim('Run "morph-spec update --wizard" to configure manually.');
     }
 
+    // Suggest tutorial for first-time users
+    if (integrationsCreated) {
+      logger.blank();
+      logger.info('First time using morph-spec? Run `morph-spec tutorial` to get started.');
+    }
+
     logger.blank();
 
   } catch (error) {

package/src/commands/project/revert.js

@@ -0,0 +1,173 @@
+/**
+ * MORPH-SPEC Revert Command
+ *
+ * Revert a feature to a previous phase, optionally deleting later-phase outputs.
+ *
+ * Usage:
+ *   morph-spec revert <feature-name> --to <phase>
+ *   morph-spec revert <feature-name> --to design
+ *   morph-spec revert <feature-name> --to design --delete-outputs
+ */
+
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { loadState, saveState, getFeature } from '../../core/state/state-manager.js';
+
+/**
+ * Phase order for revert logic
+ */
+const PHASE_ORDER = [
+  { key: 'proposal', order: 0, outputs: ['proposal.md'] },
+  { key: 'setup', order: 1, outputs: [] },
+  { key: 'uiux', order: 2, outputs: ['ui-design-system.md', 'ui-mockups.md', 'ui-components.md', 'ui-flows.md'] },
+  { key: 'design', order: 3, outputs: ['spec.md', 'schema-analysis.md', 'contracts.cs', 'decisions.md'] },
+  { key: 'clarify', order: 4, outputs: ['clarifications.md'] },
+  { key: 'tasks', order: 5, outputs: ['tasks.md', 'tasks.json'] },
+  { key: 'implement', order: 6, outputs: ['recap.md'] },
+  { key: 'sync', order: 7, outputs: [] }
+];
+
+/**
+ * Get outputs that would be affected by reverting to a phase
+ */
+function getAffectedOutputs(targetPhase) {
+  const targetOrder = PHASE_ORDER.find(p => p.key === targetPhase)?.order ?? -1;
+  const affected = [];
+
+  for (const phase of PHASE_ORDER) {
+    if (phase.order > targetOrder) {
+      affected.push(...phase.outputs.map(o => ({ phase: phase.key, file: o })));
+    }
+  }
+
+  return affected;
+}
+
+/**
+ * Main revert command
+ */
+export async function revertCommand(featureName, options = {}) {
+  if (!featureName) {
+    console.error(chalk.red('Error: Feature name required'));
+    console.error(chalk.gray('Usage: morph-spec revert <feature-name> --to <phase>'));
+    process.exit(1);
+  }
+
+  const targetPhase = options.to;
+  if (!targetPhase) {
+    console.error(chalk.red('Error: Target phase required (--to <phase>)'));
+    console.error(chalk.gray(`Valid phases: ${PHASE_ORDER.map(p => p.key).join(', ')}`));
+    process.exit(1);
+  }
+
+  const targetDef = PHASE_ORDER.find(p => p.key === targetPhase);
+  if (!targetDef) {
+    console.error(chalk.red(`Error: Unknown phase: ${targetPhase}`));
+    console.error(chalk.gray(`Valid phases: ${PHASE_ORDER.map(p => p.key).join(', ')}`));
+    process.exit(1);
+  }
+
+  const feature = getFeature(featureName);
+  if (!feature) {
+    console.error(chalk.red(`Error: Feature '${featureName}' not found`));
+    process.exit(1);
+  }
+
+  const currentDef = PHASE_ORDER.find(p => p.key === feature.phase);
+  if (currentDef && targetDef.order >= currentDef.order) {
+    console.error(chalk.red(`Error: Cannot revert forward. Current phase: ${feature.phase}, target: ${targetPhase}`));
+    process.exit(1);
+  }
+
+  // Get affected outputs
+  const affected = getAffectedOutputs(targetPhase);
+  const outputDir = path.join(process.cwd(), '.morph/features', featureName);
+  const existingAffected = affected.filter(a =>
+    fs.existsSync(path.join(outputDir, a.file))
+  );
+
+  // Show what will happen
+  console.log(chalk.cyan('\n┌────────────────────────────────────────────────────────────┐'));
+  console.log(chalk.cyan('│                   MORPH-SPEC REVERT                        │'));
+  console.log(chalk.cyan('└────────────────────────────────────────────────────────────┘\n'));
+
+  console.log(chalk.white.bold(`Feature: ${featureName}`));
+  console.log(chalk.gray(`Current phase: ${feature.phase} → Reverting to: ${targetPhase}\n`));
+
+  if (existingAffected.length > 0) {
+    if (options.deleteOutputs) {
+      console.log(chalk.yellow('The following files will be DELETED:'));
+    } else {
+      console.log(chalk.yellow('The following outputs will be marked as draft (files preserved):'));
+    }
+    for (const item of existingAffected) {
+      console.log(chalk.gray(`  - ${item.file} (from ${item.phase} phase)`));
+    }
+    console.log('');
+  }
+
+  // Update state
+  const state = loadState();
+  const stateFeature = state.features[featureName];
+
+  // Revert phase
+  stateFeature.phase = targetPhase;
+  stateFeature.updatedAt = new Date().toISOString();
+
+  // Mark affected outputs as not created in state
+  const outputKeyMap = {
+    'proposal.md': 'proposal',
+    'spec.md': 'spec',
+    'schema-analysis.md': 'schemaAnalysis',
+    'contracts.cs': 'contracts',
+    'decisions.md': 'decisions',
+    'clarifications.md': 'clarifications',
+    'tasks.md': 'tasks',
+    'tasks.json': 'tasks',
+    'ui-design-system.md': 'uiDesignSystem',
+    'ui-mockups.md': 'uiMockups',
+    'ui-components.md': 'uiComponents',
+    'ui-flows.md': 'uiFlows',
+    'recap.md': 'recap'
+  };
+
+  for (const item of affected) {
+    const key = outputKeyMap[item.file];
+    if (key && stateFeature.outputs[key]) {
+      stateFeature.outputs[key].created = false;
+    }
+  }
+
+  // Reset approval gates for later phases
+  for (const phase of PHASE_ORDER) {
+    if (phase.order > targetDef.order && stateFeature.approvalGates?.[phase.key]) {
+      stateFeature.approvalGates[phase.key].approved = false;
+      stateFeature.approvalGates[phase.key].timestamp = null;
+      stateFeature.approvalGates[phase.key].approvedBy = null;
+    }
+  }
+
+  // Reset tasks if reverting before tasks phase
+  if (targetDef.order < 5) {
+    stateFeature.tasks = { total: 0, completed: 0, inProgress: 0, pending: 0 };
+  }
+
+  saveState(state);
+
+  // Delete files if requested
+  if (options.deleteOutputs && existingAffected.length > 0) {
+    for (const item of existingAffected) {
+      const filePath = path.join(outputDir, item.file);
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+      }
+    }
+    console.log(chalk.yellow(`Deleted ${existingAffected.length} file(s).`));
+  }
+
+  console.log(chalk.green(`✓ Feature '${featureName}' reverted to phase: ${targetPhase}`));
+  console.log(chalk.gray(`  State updated. Run 'morph-spec status ${featureName}' to see current status.\n`));
+}
+
+export default revertCommand;