@polymorphism-tech/morph-spec 7.3.0 → 7.5.0

package/src/commands/project/init.js

@@ -1,515 +1,517 @@
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { homedir } from 'os';
-import fs from 'fs-extra';
-import ora from 'ora';
-import { execSync } from 'child_process';
-import { logger } from '../../utils/logger.js';
-import {
-  pathExists,
-  readJson,
-  writeJson,
-  writeFile
-} from '../../utils/file-copier.js';
-import { getInstalledCLIVersion, checkProjectOutdated } from '../../utils/version-checker.js';
-import { installClaudeHooks } from '../../utils/claude-settings-manager.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,
-  installCompanionSkills,
-  installMcpWithCredentials,
-  generateSetupInstructions,
-  formatMcpStatusTable,
-  isRemoteMcp,
-  setupStitch
-} from '../../lib/installers/mcp-installer.js';
-import { setupInfra, installRulesForStack } from '../../scripts/setup-infra.js';
-import { installSkills } from '../../utils/skills-installer.js';
-import { installAgents, installDomainAgents } from '../../utils/agents-installer.js';
-import { getProjectTags } from '../../lib/stack-filter.js';
-import { updateCommand } from './update.js';
-
-export async function initCommand(options) {
-  const targetPath = options.path || process.cwd();
-
-  logger.header('MORPH-SPEC Framework Installation');
-  logger.dim(`Target: ${targetPath}`);
-  logger.blank();
-
-  // Check if already initialized
-  const morphPath = join(targetPath, '.morph');
-  if (await pathExists(morphPath)) {
-    if (!options.force) {
-      // Check if project version is outdated — auto-update instead of blocking
-      const projectCheck = await checkProjectOutdated(targetPath);
-      if (projectCheck.isOutdated) {
-        logger.info(`MORPH already initialized (v${projectCheck.current}). Framework update available (v${projectCheck.cliVersion}).`);
-        logger.blank();
-        return updateCommand(options);
-      }
-      logger.warn('MORPH already initialized in this directory (up to date).');
-      logger.dim('Use --force to overwrite existing installation.');
-      process.exit(1);
-    }
-    logger.warn('Overwriting existing MORPH installation...');
-  }
-
-  const spinner = ora('Installing MORPH-SPEC...').start();
-
-  try {
-
-    // Steps 1-10: Infrastructure (headless, no prompts)
-    spinner.stop();
-    const infraResult = await setupInfra(targetPath);
-    spinner.start('Continuing...');
-
-    // Derive display variables from what setupInfra installed
-    const cliVersion = getInstalledCLIVersion();
-    const commandsCopied = await pathExists(join(targetPath, '.claude', 'commands'));
-    const rulesCopied = await pathExists(join(targetPath, '.claude', 'rules'));
-    // Re-run installClaudeHooks to get the result object (idempotent — hooks already installed)
-    const hooksResult = await installClaudeHooks(targetPath);
-
-    // Re-derive config path for stack detection updates
-    const configDir = join(morphPath, 'config');
-    const configPath = join(configDir, 'config.json');
-    const contextDir = join(morphPath, 'context');
-
-    // Read config written by setupInfra so stack detection can update it
-    let config = (await pathExists(configPath)) ? await readJson(configPath) : { project: {} };
-    if (!config.project) config.project = {};
-
-    // 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;
-
-          // Persist detected stack to config.json
-          if (structure?.stack && structure.stack !== 'unknown') {
-            config.project.stack = structure.stack;
-          }
-          if (structure?.architecture && structure.architecture !== 'unknown') {
-            config.project.architecture = structure.architecture;
-          }
-          if (structure?.uiLibrary) {
-            config.project.uiLibrary = structure.uiLibrary;
-          }
-          if (structure?.integrations?.length > 0) {
-            config.project.integrations = structure.integrations;
-          }
-          await writeJson(configPath, config);
-
-          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}`);
-          if (structure?.integrations?.length > 0) logger.dim(`Integrations: ${structure.integrations.join(', ')}`);
-
-          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.');
-          }
-
-          // Re-install stack-filtered assets now that we know the stack
-          const stackTags = getProjectTags(config);
-          if (stackTags.length > 0) {
-            spinner.start('Re-installing stack-filtered assets...');
-            const frameworkDir = join(targetPath, '.morph', 'framework');
-            const fwSrcDir = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'framework');
-
-            // Rules
-            const rulesSrc = join(fwSrcDir, 'rules');
-            const rulesDest = join(targetPath, '.claude', 'rules');
-            installRulesForStack(rulesSrc, rulesDest, stackTags);
-
-            // Skills
-            await installSkills(targetPath, { projectTags: stackTags });
-
-            // Agents (domain personas from agents.json)
-            await installAgents(targetPath, fwSrcDir, { projectTags: stackTags });
-            await installDomainAgents(targetPath, fwSrcDir, { projectTags: stackTags });
-
-            spinner.succeed(`Stack-filtered assets reinstalled for [${stackTags.join(', ')}]`);
-          }
-
-          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];
-              }
-
-              // Install companion skills for MCPs that define them (e.g., Stitch agent skills)
-              const skillResults = installCompanionSkills(orchestration.autoInstallable);
-              for (const r of skillResults) {
-                if (r.success) {
-                  logger.info(`✓ Companion skills installed: ${r.repo}`);
-                } else {
-                  logger.warn(`Failed to install companion skills: ${r.repo}`);
-                }
-              }
-            }
-          }
-
-          // 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) {
-                // Stitch — automated setup via setupStitch()
-                if (name === 'stitch' && !entry.install.autoInstall) {
-                  spinner.start('Setting up Stitch MCP...');
-                  const stitchResult = await setupStitch(targetPath);
-                  if (stitchResult.success) {
-                    spinner.succeed('Stitch MCP setup complete');
-                    manualInstalled[name] = entry;
-                  } else {
-                    const failedStep = stitchResult.steps.find(s => !s.success && s.step !== 'enable-api' && s.step !== 'health-check');
-                    spinner.fail(`Stitch setup failed: ${failedStep?.error || 'unknown'}`);
-                  }
-                  if (entry.companionSkills?.installCommand) {
-                    const skillResults = installCompanionSkills({ stitch: entry });
-                    for (const r of skillResults) {
-                      if (r.success) logger.success(`  Companion skills installed: ${r.repo}`);
-                    }
-                  }
-                  continue;
-                }
-
-                // Remote MCPs — launch OAuth via claude mcp add
-                if (isRemoteMcp(entry.install.config)) {
-                  const url = entry.install.config.url;
-                  logger.info(`  Launching ${capitalizedName} OAuth authentication...`);
-                  try {
-                    execSync(`claude mcp add --transport http ${name} ${url}`, {
-                      stdio: 'inherit',
-                      timeout: 120000
-                    });
-                    logger.success(`  ${capitalizedName} MCP configured`);
-                    manualInstalled[name] = entry;
-                  } catch {
-                    logger.warn(`  ${capitalizedName} setup cancelled. Run later: claude mcp add --transport http ${name} ${url}`);
-                  }
-                  continue;
-                }
-
-                // 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 .mcp.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)');
-    }
-
-    // Auto-generate architecture context (non-blocking on failure)
-    spinner.text = 'Generating architecture context...';
-    try {
-      const { scanArchitecture, renderArchitectureContext } = await import('../../lib/generators/architecture-scanner.js');
-      const scanResult = await scanArchitecture(targetPath);
-      await renderArchitectureContext(targetPath, scanResult);
-      spinner.succeed('Architecture context generated');
-    } catch {
-      // Non-fatal: placeholder README.md remains
-      spinner.warn('Architecture context generation skipped');
-    }
-
-    spinner.succeed('MORPH-SPEC installed successfully!');
-
-    // Show next steps
-    logger.blank();
-    logger.success(`MORPH-SPEC v${cliVersion} installed successfully!`);
-    logger.blank();
-    logger.header('Next Steps');
-
-    logger.step(1, 'Review .morph/config/config.json');
-    logger.step(2, 'Open project in VS Code with Claude Code');
-    logger.step(3, 'Start your first feature:');
-    logger.blank();
-    logger.box([
-      'Ask Claude Code to implement a feature'
-    ]);
-    logger.blank();
-
-    logger.info('Files installed:');
-    logger.dim(`  ✓ CLAUDE.md`);
-    logger.dim(`  ✓ .morph/config/ (config.json)`);
-    logger.dim(`  ✓ .morph/framework/ (agents.json, standards/, templates/, hooks/)`);
-    logger.dim(`  ✓ .morph/context/ (project context)`);
-    logger.dim(`  ✓ .morph/features/ (feature outputs)`);
-    if (commandsCopied) {
-      logger.dim(`  ✓ .claude/commands/ (slash commands)`);
-    }
-    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)`);
-      }
-    }
-
-    logger.dim('  ✓ .claude/skills/ (installed as skill directories)');
-
-    // Show agent team breakdown from setup-infra result
-    const agents = infraResult?.agents;
-    if (agents) {
-      const total = (agents.tier1 || 0) + (agents.tier2 || 0) + (agents.specialists || 0) + (agents.personas || 0);
-      logger.dim(`  ✓ .claude/agents/ (${total} domain personas installed)`);
-    } else {
-      logger.dim('  ✓ .claude/agents/ (native subagents installed)');
-    }
-
-    logger.dim('  ✓ ~/.claude/statusline.sh (global statusline installed)');
-
-    // Check CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS in ~/.claude/settings.local.json
-    logger.blank();
-    const globalSettingsPath = join(homedir(), '.claude', 'settings.local.json');
-    let agentTeamsEnabled = false;
-    try {
-      const globalSettings = await readJson(globalSettingsPath);
-      agentTeamsEnabled = globalSettings?.env?.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS === '1';
-    } catch {
-      // File missing or unreadable — treat as not enabled
-    }
-
-    if (agentTeamsEnabled) {
-      logger.success('Agent Teams: CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS enabled ✓');
-    } else {
-      logger.warn('Agent Teams not enabled. To activate multi-agent workflows, add to ~/.claude/settings.local.json:');
-      logger.dim('  {"env": {"CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"}}');
-    }
-
-    logger.blank();
-
-    // Populate Claude Code persistent memory so future sessions enter contextualized
-    try {
-      const { installProjectMemory } = await import('../../lib/installers/memory-installer.js');
-      const memResult = await installProjectMemory(targetPath, {
-        projectName: config.project?.name ?? targetPath.split(/[\\/]/).pop(),
-        frameworkVersion: config.frameworkVersion ?? cliVersion,
-        stack: config.project?.stack,
-      });
-      logger.dim(`  ✓ Claude Code memory populated (${memResult.projectMemoryPath})`);
-    } catch (err) {
-      logger.dim(`  ⚠ Memory install skipped: ${err.message}`);
-    }
-
-    // Suggest tutorial for first-time users
-    if (integrationsCreated) {
-      logger.blank();
-      logger.info('First time using morph-spec? Run `/morph-proposal <feature>` to start a new feature.');
-    }
-
-    logger.blank();
-    logger.warn('IMPORTANT: Restart your Claude Code session for morph-* skills to be available.');
-    logger.dim('Skills installed in .claude/skills/ are only registered at session start.');
-    logger.blank();
-
-  } catch (error) {
-    spinner.fail('Installation failed');
-    logger.error(error.message);
-    process.exit(1);
-  }
-}
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { homedir } from 'os';
+import fs from 'fs-extra';
+import ora from 'ora';
+import { execSync } from 'child_process';
+import { logger } from '../../utils/logger.js';
+import {
+  pathExists,
+  readJson,
+  writeJson,
+  writeFile
+} from '../../utils/file-copier.js';
+import { getInstalledCLIVersion, checkProjectOutdated } from '../../utils/version-checker.js';
+import { installClaudeHooks } from '../../utils/claude-settings-manager.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,
+  installCompanionSkills,
+  installMcpWithCredentials,
+  generateSetupInstructions,
+  formatMcpStatusTable,
+  isRemoteMcp,
+  setupStitch
+} from '../../lib/installers/mcp-installer.js';
+import { setupInfra, installRulesForStack } from '../../scripts/setup-infra.js';
+import { installSkills } from '../../utils/skills-installer.js';
+import { installAgents, installDomainAgents } from '../../utils/agents-installer.js';
+import { getProjectTags } from '../../lib/stack-filter.js';
+import { updateCommand } from './update.js';
+
+export async function initCommand(options) {
+  const targetPath = options.path || process.cwd();
+
+  logger.header('MORPH-SPEC Framework Installation');
+  logger.dim(`Target: ${targetPath}`);
+  logger.blank();
+
+  // Check if already initialized
+  const morphPath = join(targetPath, '.morph');
+  if (await pathExists(morphPath)) {
+    if (!options.force) {
+      // Check if project version is outdated — auto-update instead of blocking
+      const projectCheck = await checkProjectOutdated(targetPath);
+      if (projectCheck.isOutdated) {
+        logger.info(`MORPH already initialized (v${projectCheck.current}). Framework update available (v${projectCheck.cliVersion}).`);
+        logger.blank();
+        return updateCommand(options);
+      }
+      logger.warn('MORPH already initialized in this directory (up to date).');
+      logger.dim('Use --force to overwrite existing installation.');
+      process.exit(1);
+    }
+    logger.warn('Overwriting existing MORPH installation...');
+  }
+
+  const spinner = ora('Installing MORPH-SPEC...').start();
+
+  try {
+
+    // Steps 1-10: Infrastructure (headless, no prompts)
+    spinner.stop();
+    const infraResult = await setupInfra(targetPath);
+    spinner.start('Continuing...');
+
+    // Derive display variables from what setupInfra installed
+    const cliVersion = getInstalledCLIVersion();
+    const commandsCopied = await pathExists(join(targetPath, '.claude', 'commands'));
+    const rulesCopied = await pathExists(join(targetPath, '.claude', 'rules'));
+    // Re-run installClaudeHooks to get the result object (idempotent — hooks already installed)
+    const hooksResult = await installClaudeHooks(targetPath);
+
+    // Re-derive config path for stack detection updates
+    const configDir = join(morphPath, 'config');
+    const configPath = join(configDir, 'config.json');
+    const contextDir = join(morphPath, 'context');
+
+    // Read config written by setupInfra so stack detection can update it
+    let config = (await pathExists(configPath)) ? await readJson(configPath) : { project: {} };
+    if (!config.project) config.project = {};
+
+    // 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 = process.stdin.isTTY
+          ? (await inquirer.prompt([{
+              type: 'confirm',
+              name: 'saveIntegrationsChoice',
+              message: 'Save detected integrations and generate optimized settings?',
+              default: true
+            }])).saveIntegrationsChoice
+          : 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;
+
+          // Persist detected stack to config.json
+          if (structure?.stack && structure.stack !== 'unknown') {
+            config.project.stack = structure.stack;
+          }
+          if (structure?.architecture && structure.architecture !== 'unknown') {
+            config.project.architecture = structure.architecture;
+          }
+          if (structure?.uiLibrary) {
+            config.project.uiLibrary = structure.uiLibrary;
+          }
+          if (structure?.integrations?.length > 0) {
+            config.project.integrations = structure.integrations;
+          }
+          await writeJson(configPath, config);
+
+          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}`);
+          if (structure?.integrations?.length > 0) logger.dim(`Integrations: ${structure.integrations.join(', ')}`);
+
+          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.');
+          }
+
+          // Re-install stack-filtered assets now that we know the stack
+          const stackTags = getProjectTags(config);
+          if (stackTags.length > 0) {
+            spinner.start('Re-installing stack-filtered assets...');
+            const frameworkDir = join(targetPath, '.morph', 'framework');
+            const fwSrcDir = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'framework');
+
+            // Rules
+            const rulesSrc = join(fwSrcDir, 'rules');
+            const rulesDest = join(targetPath, '.claude', 'rules');
+            installRulesForStack(rulesSrc, rulesDest, stackTags);
+
+            // Skills
+            await installSkills(targetPath, { projectTags: stackTags });
+
+            // Agents (domain personas from agents.json)
+            await installAgents(targetPath, fwSrcDir, { projectTags: stackTags });
+            await installDomainAgents(targetPath, fwSrcDir, { projectTags: stackTags });
+
+            spinner.succeed(`Stack-filtered assets reinstalled for [${stackTags.join(', ')}]`);
+          }
+
+          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];
+              }
+
+              // Install companion skills for MCPs that define them (e.g., Stitch agent skills)
+              const skillResults = installCompanionSkills(orchestration.autoInstallable);
+              for (const r of skillResults) {
+                if (r.success) {
+                  logger.info(`✓ Companion skills installed: ${r.repo}`);
+                } else {
+                  logger.warn(`Failed to install companion skills: ${r.repo}`);
+                }
+              }
+            }
+          }
+
+          // 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) {
+                // Stitch — automated setup via setupStitch()
+                if (name === 'stitch' && !entry.install.autoInstall) {
+                  spinner.start('Setting up Stitch MCP...');
+                  const stitchResult = await setupStitch(targetPath);
+                  if (stitchResult.success) {
+                    spinner.succeed('Stitch MCP setup complete');
+                    manualInstalled[name] = entry;
+                  } else {
+                    const failedStep = stitchResult.steps.find(s => !s.success && s.step !== 'enable-api' && s.step !== 'health-check');
+                    spinner.fail(`Stitch setup failed: ${failedStep?.error || 'unknown'}`);
+                  }
+                  if (entry.companionSkills?.installCommand) {
+                    const skillResults = installCompanionSkills({ stitch: entry });
+                    for (const r of skillResults) {
+                      if (r.success) logger.success(`  Companion skills installed: ${r.repo}`);
+                    }
+                  }
+                  continue;
+                }
+
+                // Remote MCPs — launch OAuth via claude mcp add
+                if (isRemoteMcp(entry.install.config)) {
+                  const url = entry.install.config.url;
+                  logger.info(`  Launching ${capitalizedName} OAuth authentication...`);
+                  try {
+                    execSync(`claude mcp add --transport http ${name} ${url}`, {
+                      stdio: 'inherit',
+                      timeout: 120000
+                    });
+                    logger.success(`  ${capitalizedName} MCP configured`);
+                    manualInstalled[name] = entry;
+                  } catch {
+                    logger.warn(`  ${capitalizedName} setup cancelled. Run later: claude mcp add --transport http ${name} ${url}`);
+                  }
+                  continue;
+                }
+
+                // 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 .mcp.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)');
+    }
+
+    // Auto-generate architecture context (non-blocking on failure)
+    spinner.text = 'Generating architecture context...';
+    try {
+      const { scanArchitecture, renderArchitectureContext } = await import('../../lib/generators/architecture-scanner.js');
+      const scanResult = await scanArchitecture(targetPath);
+      await renderArchitectureContext(targetPath, scanResult);
+      spinner.succeed('Architecture context generated');
+    } catch {
+      // Non-fatal: placeholder README.md remains
+      spinner.warn('Architecture context generation skipped');
+    }
+
+    spinner.succeed('MORPH-SPEC installed successfully!');
+
+    // Show next steps
+    logger.blank();
+    logger.success(`MORPH-SPEC v${cliVersion} installed successfully!`);
+    logger.blank();
+    logger.header('Next Steps');
+
+    logger.step(1, 'Review .morph/config/config.json');
+    logger.step(2, 'Open project in VS Code with Claude Code');
+    logger.step(3, 'Start your first feature:');
+    logger.blank();
+    logger.box([
+      'Ask Claude Code to implement a feature'
+    ]);
+    logger.blank();
+
+    logger.info('Files installed:');
+    logger.dim(`  ✓ CLAUDE.md`);
+    logger.dim(`  ✓ .morph/config/ (config.json)`);
+    logger.dim(`  ✓ .morph/framework/ (agents.json, standards/, templates/, hooks/)`);
+    logger.dim(`  ✓ .morph/context/ (project context)`);
+    logger.dim(`  ✓ .morph/features/ (feature outputs)`);
+    if (commandsCopied) {
+      logger.dim(`  ✓ .claude/commands/ (slash commands)`);
+    }
+    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)`);
+      }
+    }
+
+    logger.dim('  ✓ .claude/skills/ (installed as skill directories)');
+
+    // Show agent team breakdown from setup-infra result
+    const agents = infraResult?.agents;
+    if (agents) {
+      const total = (agents.tier1 || 0) + (agents.tier2 || 0) + (agents.specialists || 0) + (agents.personas || 0);
+      logger.dim(`  ✓ .claude/agents/ (${total} domain personas installed)`);
+    } else {
+      logger.dim('  ✓ .claude/agents/ (native subagents installed)');
+    }
+
+    logger.dim('  ✓ ~/.claude/statusline.sh (global statusline installed)');
+
+    // Check CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS in ~/.claude/settings.local.json
+    logger.blank();
+    const globalSettingsPath = join(homedir(), '.claude', 'settings.local.json');
+    let agentTeamsEnabled = false;
+    try {
+      const globalSettings = await readJson(globalSettingsPath);
+      agentTeamsEnabled = globalSettings?.env?.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS === '1';
+    } catch {
+      // File missing or unreadable — treat as not enabled
+    }
+
+    if (agentTeamsEnabled) {
+      logger.success('Agent Teams: CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS enabled ✓');
+    } else {
+      logger.warn('Agent Teams not enabled. To activate multi-agent workflows, add to ~/.claude/settings.local.json:');
+      logger.dim('  {"env": {"CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"}}');
+    }
+
+    logger.blank();
+
+    // Populate Claude Code persistent memory so future sessions enter contextualized
+    try {
+      const { installProjectMemory } = await import('../../lib/installers/memory-installer.js');
+      const memResult = await installProjectMemory(targetPath, {
+        projectName: config.project?.name ?? targetPath.split(/[\\/]/).pop(),
+        frameworkVersion: config.frameworkVersion ?? cliVersion,
+        stack: config.project?.stack,
+      });
+      logger.dim(`  ✓ Claude Code memory populated (${memResult.projectMemoryPath})`);
+    } catch (err) {
+      logger.dim(`  ⚠ Memory install skipped: ${err.message}`);
+    }
+
+    // Suggest tutorial for first-time users
+    if (integrationsCreated) {
+      logger.blank();
+      logger.info('First time using morph-spec? Run `/morph-proposal <feature>` to start a new feature.');
+    }
+
+    logger.blank();
+    logger.warn('IMPORTANT: Restart your Claude Code session for morph-* skills to be available.');
+    logger.dim('Skills installed in .claude/skills/ are only registered at session start.');
+    logger.blank();
+
+  } catch (error) {
+    spinner.fail('Installation failed');
+    logger.error(error.message);
+    process.exit(1);
+  }
+}