universal-dev-standards 4.1.0 → 5.0.0-beta.10

package/src/commands/init.js

@@ -1,110 +1,25 @@
 import chalk from 'chalk';
 import ora from 'ora';
+import { execSync } from 'child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { basename, join } from 'path';
 import {
-  getStandardsByLevel,
-  getRepositoryInfo,
-  getSkillFiles,
-  getStandardSource,
-  getOptionSource,
-  findOption
-} from '../utils/registry.js';
+  manifestExists as isInitialized
+} from '../core/manifest.js';
+import { t, detectLanguage } from '../i18n/messages.js';
 import { detectAll } from '../utils/detector.js';
+import { promptConfirm } from '../prompts/init.js';
+import { runInitFlow } from '../flows/init-flow.js';
+import { installStandards } from '../installers/standards-installer.js';
+import { installIntegrations } from '../installers/integration-installer.js';
+import { installSkills, installCommands } from '../installers/skills-installer.js';
+import { writeFinalManifest } from '../installers/manifest-installer.js';
 import {
-  copyStandard,
-  copyIntegration,
-  writeManifest,
-  isInitialized
-} from '../utils/copier.js';
-import { t } from '../i18n/messages.js';
-import {
-  downloadSkillToLocation,
   getInstalledSkillsInfo,
   getProjectInstalledSkillsInfo,
-  writeSkillsManifest,
-  getSkillsDir,
-  getProjectSkillsDir
-} from '../utils/github.js';
-import {
-  installSkillsToMultipleAgents,
-  installCommandsToMultipleAgents,
-  getInstalledSkillsInfoForAgent
-} from '../utils/skills-installer.js';
-import {
   getAgentConfig,
-  getAgentDisplayName,
-  getSkillsDirForAgent,
-  getCommandsDirForAgent
-} from '../config/ai-agent-paths.js';
-import {
-  promptAITools,
-  promptSkillsInstallLocation,
-  promptStandardsScope,
-  promptLevel,
-  promptLanguage,
-  promptFramework,
-  promptLocale,
-  promptConfirm,
-  promptFormat,
-  promptStandardOptions,
-  promptContentMode,
-  promptMethodology,
-  promptCommandsInstallation,
-  handleAgentsMdSharing
-} from '../prompts/init.js';
-import {
-  promptIntegrationConfig
-} from '../prompts/integrations.js';
-import {
-  writeIntegrationFile,
-  integrationFileExists,
-  getToolFilePath
-} from '../utils/integration-generator.js';
-import { computeFileHash } from '../utils/hasher.js';
-
-// Integration file mappings (legacy - for fallback)
-const INTEGRATION_MAPPINGS = {
-  cursor: {
-    source: 'integrations/cursor/.cursorrules',
-    target: '.cursorrules'
-  },
-  windsurf: {
-    source: 'integrations/windsurf/.windsurfrules',
-    target: '.windsurfrules'
-  },
-  cline: {
-    source: 'integrations/cline/.clinerules',
-    target: '.clinerules'
-  },
-  copilot: {
-    source: 'integrations/github-copilot/copilot-instructions.md',
-    target: '.github/copilot-instructions.md'
-  },
-  antigravity: {
-    source: 'integrations/google-antigravity/INSTRUCTIONS.md',
-    target: 'INSTRUCTIONS.md'
-  },
-  codex: {
-    source: 'integrations/openai-codex/AGENTS.md',
-    target: 'AGENTS.md'
-  },
-  'gemini-cli': {
-    source: 'integrations/gemini-cli/GEMINI.md',
-    target: 'GEMINI.md'
-  },
-  opencode: {
-    source: 'integrations/opencode/AGENTS.md',
-    target: 'AGENTS.md'
-  }
-};
-
-// Extension file mappings
-const EXTENSION_MAPPINGS = {
-  csharp: 'extensions/languages/csharp-style.md',
-  php: 'extensions/languages/php-style.md',
-  'fat-free': 'extensions/frameworks/fat-free-patterns.md',
-  'zh-tw': 'extensions/locales/zh-tw.md'
-};
+  getAgentDisplayName
+} from '../utils/github.js';
 
 /**
  * Init command - initialize standards in current project
@@ -112,10 +27,8 @@ const EXTENSION_MAPPINGS = {
  */
 export async function initCommand(options) {
   const projectPath = process.cwd();
-  const msg = t().commands.init;
-  const common = t().commands.common;
-
-  // Note: UI language is now set globally in uds.js preAction hook
+  let msg = t().commands.init;
+  let common = t().commands.common;
 
   console.log();
   console.log(chalk.bold(msg.title));
@@ -134,395 +47,34 @@ export async function initCommand(options) {
   spinner.succeed(msg.analysisComplete);
 
   // Show detected info
-  const detectedLangs = Object.entries(detected.languages)
-    .filter(([, v]) => v)
-    .map(([k]) => k);
-  const detectedFrameworks = Object.entries(detected.frameworks)
-    .filter(([, v]) => v)
-    .map(([k]) => k);
-  const detectedTools = Object.entries(detected.aiTools)
-    .filter(([, v]) => v)
-    .map(([k]) => k);
+  const detectedLangs = Object.entries(detected.languages).filter(([, v]) => v).map(([k]) => k);
+  const detectedFrameworks = Object.entries(detected.frameworks).filter(([, v]) => v).map(([k]) => k);
+  const detectedTools = Object.entries(detected.aiTools).filter(([, v]) => v).map(([k]) => k);
 
-  if (detectedLangs.length > 0) {
-    console.log(chalk.gray(`  ${msg.languages}: ${detectedLangs.join(', ')}`));
-  }
-  if (detectedFrameworks.length > 0) {
-    console.log(chalk.gray(`  ${msg.frameworks}: ${detectedFrameworks.join(', ')}`));
-  }
-  if (detectedTools.length > 0) {
-    console.log(chalk.gray(`  ${msg.aiTools}: ${detectedTools.join(', ')}`));
-  }
+  if (detectedLangs.length > 0) console.log(chalk.gray(`  ${msg.languages}: ${detectedLangs.join(', ')}`));
+  if (detectedFrameworks.length > 0) console.log(chalk.gray(`  ${msg.frameworks}: ${detectedFrameworks.join(', ')}`));
+  if (detectedTools.length > 0) console.log(chalk.gray(`  ${msg.aiTools}: ${detectedTools.join(', ')}`));
   console.log();
 
-  // Initialize configuration variables
-  let level = options.level ? parseInt(options.level, 10) : null;
-  let languages = options.lang ? [options.lang] : null;
-  let frameworks = options.framework ? [options.framework] : null;
-  let locale = options.locale || null;
-  let format = options.format || null;
-  let standardOptions = {};
-
-  // Skills configuration (unified for all AI agents)
-  let skillsConfig = {
-    installed: false,
-    location: null,       // Legacy: single location for backward compatibility
-    needsInstall: false,
-    updateTargets: [],    // Legacy: array of 'user' or 'project'
-    // New: multi-agent installations
-    skillsInstallations: [],  // Array of {agent, level}
-    commandsInstallations: [] // Array of {agent, level}
-  };
-
-  // AI tools configuration
-  let aiTools = [];
-  let integrations = [];
+  // Configuration object
+  let config = {};
 
   if (!options.yes) {
-    // ===== Interactive mode =====
-
-    // STEP 3: Ask for AI tools (all 9 supported tools)
-    aiTools = await promptAITools({
-      claudeCode: detected.aiTools.claudeCode || false,
-      cursor: detected.aiTools.cursor || false,
-      windsurf: detected.aiTools.windsurf || false,
-      cline: detected.aiTools.cline || false,
-      copilot: detected.aiTools.copilot || false,
-      antigravity: detected.aiTools.antigravity || false,
-      codex: detected.aiTools.codex || false,
-      opencode: detected.aiTools.opencode || false,
-      geminiCli: detected.aiTools.geminiCli || false
-    });
-
-    // Handle AGENTS.md sharing notification (Codex + OpenCode)
-    aiTools = handleAgentsMdSharing(aiTools);
-
-    // Check which tools support skills
-    const skillsSupportedTools = aiTools.filter(tool => {
-      const config = getAgentConfig(tool);
-      return config?.supportsSkills && config?.skills;
-    });
-    const hasSkillsTools = skillsSupportedTools.length > 0;
-
-    // STEP 4: Skills handling (unified for all AI agents)
-    // Now supports multiple agents with individual user/project level choices
-    if (hasSkillsTools) {
-      // Check existing installations for each skills-supported agent
-      console.log();
-      console.log(chalk.cyan(msg.skillsStatus));
-
-      let hasAnyExisting = false;
-      for (const tool of skillsSupportedTools) {
-        const displayName = getAgentDisplayName(tool);
-        const projectInfo = getInstalledSkillsInfoForAgent(tool, 'project', projectPath);
-        const userInfo = getInstalledSkillsInfoForAgent(tool, 'user');
-
-        if (projectInfo || userInfo) {
-          hasAnyExisting = true;
-          if (projectInfo) {
-            console.log(chalk.gray(`  ${displayName} ${msg.projectLevel}: v${projectInfo.version || 'unknown'}`));
-          }
-          if (userInfo) {
-            console.log(chalk.gray(`  ${displayName} ${msg.userLevel}: v${userInfo.version || 'unknown'}`));
-          }
-        }
-      }
-
-      if (!hasAnyExisting) {
-        console.log(chalk.gray(`  ${msg.noSkillsDetected}`));
-      }
-
-      // Prompt for installation locations (multi-agent, multi-select)
-      const installations = await promptSkillsInstallLocation(aiTools);
-
-      if (installations.length > 0) {
-        // Check if marketplace was selected
-        const isMarketplace = installations.some(i => i.level === 'marketplace');
-
-        if (isMarketplace) {
-          skillsConfig = {
-            ...skillsConfig,
-            installed: true,
-            location: 'marketplace',
-            needsInstall: false,
-            updateTargets: [],
-            skillsInstallations: installations
-          };
-        } else {
-          // File-based installations
-          skillsConfig = {
-            ...skillsConfig,
-            installed: true,
-            location: installations.length === 1 ? installations[0].level : 'multiple',
-            needsInstall: true,
-            updateTargets: installations.map(i => i.level),
-            skillsInstallations: installations
-          };
-        }
-      }
-
-      // STEP 4.5: Slash commands installation (for supported agents)
-      const commandsAgents = await promptCommandsInstallation(aiTools);
-      if (commandsAgents.length > 0) {
-        skillsConfig.commandsInstallations = commandsAgents;
-      }
-    }
-
-    // STEP 5: Standards scope (if Skills are installed)
-    const standardsScope = await promptStandardsScope(skillsConfig.installed);
-
-    // STEP 6: Adoption level
-    if (!level) {
-      level = await promptLevel();
-    }
-
-    // STEP 7: Standards format
-    if (!format) {
-      format = await promptFormat();
-    }
-
-    // STEP 8: Standard options
-    standardOptions = await promptStandardOptions(level);
-
-    // STEP 9: Language extensions
-    if (!languages) {
-      languages = await promptLanguage(detected.languages) || [];
-    }
-
-    // STEP 10: Framework extensions
-    if (!frameworks) {
-      frameworks = await promptFramework(detected.frameworks) || [];
-    }
-
-    // STEP 11: Locale
-    if (!locale) {
-      locale = await promptLocale();
-    }
-
-    // Determine integrations from AI tools (excluding claude-code)
-    integrations = aiTools.filter(t => t !== 'claude-code');
-
-    // STEP 12: Integration configuration for non-Claude tools
-    // All tools share the same configuration since they have identical functionality
-    const integrationConfigs = {};
-    if (integrations.length > 0) {
-      console.log();
-      console.log(chalk.cyan(msg.integrationConfig));
-
-      if (integrations.length > 1) {
-        console.log(chalk.gray(`  ${msg.sharedRuleConfig}`));
-        console.log();
-      }
-
-      // Check if any existing files
-      const existingFiles = {};
-      for (const tool of integrations) {
-        existingFiles[tool] = integrationFileExists(tool, projectPath);
-      }
-
-      const hasAnyExisting = Object.values(existingFiles).some(v => v);
-
-      // Prompt configuration once for all tools
-      // Use first tool as representative, but mention all tools
-      const toolNames = integrations.length === 1
-        ? integrations[0]
-        : `${integrations.slice(0, -1).join(', ')} & ${integrations[integrations.length - 1]}`;
-
-      const sharedConfig = await promptIntegrationConfig(toolNames, detected, hasAnyExisting);
-
-      // Apply shared config to all tools (unless user chose to keep existing)
-      if (sharedConfig.mergeStrategy !== 'keep') {
-        for (const tool of integrations) {
-          // Each tool gets the same config but with its specific tool name
-          integrationConfigs[tool] = { ...sharedConfig, tool };
-        }
-      }
-    }
-
-    // Store integration configs for later use
-    skillsConfig.integrationConfigs = integrationConfigs;
-
-    // Store standards scope for later use
-    skillsConfig.standardsScope = standardsScope;
-
-    // STEP 13: Content mode for integration files (if any AI tools selected)
-    let contentMode = 'minimal'; // default for backward compatibility
-    if (aiTools.length > 0) {
-      contentMode = await promptContentMode();
-    }
-    skillsConfig.contentMode = contentMode;
-
-    // STEP 14: Development methodology (experimental - requires -E flag)
-    let methodology = null;
-    if (options.experimental) {
-      methodology = await promptMethodology();
-    }
-    skillsConfig.methodology = methodology;
-
+    // Interactive Mode
+    config = await runInitFlow(options, detected, projectPath);
+    if (!config) return; // Flow cancelled or exited
+    // Re-fetch translations after language selection in flow
+    msg = t().commands.init;
+    common = t().commands.common;
   } else {
-    // ===== Non-interactive mode =====
-    level = level || 2;
-    format = format || 'ai';
-    languages = languages || Object.keys(detected.languages).filter(k => detected.languages[k]);
-    frameworks = frameworks || Object.keys(detected.frameworks).filter(k => detected.frameworks[k]);
-    integrations = Object.keys(detected.aiTools).filter(k => detected.aiTools[k] && k !== 'claudeCode');
-
-    // Default standard options
-    standardOptions = {
-      workflow: options.workflow || 'github-flow',
-      merge_strategy: options.mergeStrategy || 'squash',
-      commit_language: options.commitLang || 'english',
-      test_levels: options.testLevels ? options.testLevels.split(',') : ['unit-testing', 'integration-testing']
-    };
-
-    // Determine AI tools from detection for skills compatibility check
-    const detectedAiTools = Object.keys(detected.aiTools).filter(k => detected.aiTools[k]);
-    // Map detected keys to standard tool names
-    const aiToolsNormalized = detectedAiTools.map(k => {
-      if (k === 'claudeCode') return 'claude-code';
-      if (k === 'geminiCli') return 'gemini-cli';
-      return k;
-    });
-
-    // Assign normalized AI tools to manifest variable
-    aiTools = aiToolsNormalized;
-
-    // Check if only skills-compatible tools are detected
-    const hasSkillsCompatibleTool = aiToolsNormalized.some(t => t === 'claude-code' || t === 'opencode');
-    const onlySkillsCompatibleTools = aiToolsNormalized.every(t => t === 'claude-code' || t === 'opencode');
-
-    // Handle Skills configuration based on CLI flag
-    // Default: marketplace only if all detected tools support skills
-    // If non-skills tools are detected, default to 'none' (full standards)
-    let skillsLocationFlag = options.skillsLocation;
-    if (!skillsLocationFlag) {
-      skillsLocationFlag = (hasSkillsCompatibleTool && onlySkillsCompatibleTools) ? 'marketplace' : 'none';
-    }
-
-    // Content mode from CLI flag (default: index for best balance)
-    const contentModeFlag = options.contentMode || 'index';
-
-    if (skillsLocationFlag === 'marketplace') {
-      skillsConfig = {
-        installed: true,
-        location: 'marketplace',
-        needsInstall: false,
-        updateTargets: [],
-        standardsScope: 'minimal',
-        contentMode: contentModeFlag
-      };
-    } else if (skillsLocationFlag === 'none') {
-      skillsConfig = {
-        installed: false,
-        location: null,
-        needsInstall: false,
-        updateTargets: [],
-        standardsScope: 'full',
-        contentMode: contentModeFlag
-      };
-    } else if (skillsLocationFlag === 'project') {
-      skillsConfig = {
-        installed: true,
-        location: 'project',
-        needsInstall: true,
-        updateTargets: ['project'],
-        standardsScope: 'minimal',
-        contentMode: contentModeFlag
-      };
-    } else if (skillsLocationFlag === 'user') {
-      skillsConfig = {
-        installed: true,
-        location: 'user',
-        needsInstall: true,
-        updateTargets: ['user'],
-        standardsScope: 'minimal',
-        contentMode: contentModeFlag
-      };
-    } else {
-      // Fallback: auto-detect user/project installation
-      const userSkillsInfo = getInstalledSkillsInfo();
-      const projectSkillsInfo = getProjectInstalledSkillsInfo(projectPath);
-
-      if (userSkillsInfo?.installed || projectSkillsInfo?.installed) {
-        const location = projectSkillsInfo?.installed ? 'project' : 'user';
-        skillsConfig = {
-          installed: true,
-          location,
-          needsInstall: false,
-          updateTargets: [],
-          standardsScope: 'minimal',
-          contentMode: contentModeFlag
-        };
-      } else {
-        // Fallback to marketplace if nothing detected
-        skillsConfig = {
-          installed: true,
-          location: 'marketplace',
-          needsInstall: false,
-          updateTargets: [],
-          standardsScope: 'minimal',
-          contentMode: contentModeFlag
-        };
-      }
-    }
-
-    // Auto-install commands for detected agents that support commands
-    // This matches the interactive mode behavior where commands are checked by default (project level)
-    const commandsSupportedAgents = aiToolsNormalized.filter(tool => {
-      const config = getAgentConfig(tool);
-      return config?.commands !== null;
-    });
-
-    if (commandsSupportedAgents.length > 0) {
-      // Convert to {agent, level} format for consistency with interactive mode
-      skillsConfig.commandsInstallations = commandsSupportedAgents.map(agent => ({
-        agent,
-        level: 'project' // Default to project level in non-interactive mode
-      }));
-    }
+    // Non-interactive Mode (Defaults/Flags)
+    config = buildNonInteractiveConfig(options, detected, projectPath);
   }
 
-  // Configuration summary
-  console.log();
-  console.log(chalk.cyan(msg.configSummary));
-  console.log(chalk.gray(`  ${common.level}: ${level}`));
-  console.log(chalk.gray(`  ${common.format}: ${format === 'ai' ? 'Compact' : format === 'human' ? 'Detailed' : 'Both'}`));
-  console.log(chalk.gray(`  ${msg.standardsScope}: ${skillsConfig.standardsScope === 'minimal' ? msg.standardsScopeLean : msg.standardsScopeComplete}`));
-  console.log(chalk.gray(`  ${msg.contentModeLabel}: ${skillsConfig.contentMode === 'full' ? msg.contentModeFull : skillsConfig.contentMode === 'index' ? msg.contentModeIndex : msg.contentModeMinimal}`));
-  console.log(chalk.gray(`  ${msg.languages}: ${languages.length > 0 ? languages.join(', ') : common.none}`));
-  console.log(chalk.gray(`  ${msg.frameworks}: ${frameworks.length > 0 ? frameworks.join(', ') : common.none}`));
-  console.log(chalk.gray(`  ${msg.locale}: ${locale || msg.localeDefault}`));
-  console.log(chalk.gray(`  ${common.aiTools}: ${aiTools.length > 0 ? aiTools.join(', ') : common.none}`));
-  console.log(chalk.gray(`  ${msg.integrations}: ${integrations.length > 0 ? integrations.join(', ') : common.none}`));
-  console.log(chalk.gray(`  ${common.methodology}: ${skillsConfig.methodology || common.none}${skillsConfig.methodology ? chalk.yellow(' [Experimental]') : ''}`));
-
-  if (skillsConfig.installed) {
-    let skillsStatusText;
-    if (skillsConfig.location === 'marketplace') {
-      skillsStatusText = msg.skillsMarketplace;
-    } else {
-      skillsStatusText = skillsConfig.needsInstall
-        ? msg.skillsInstallTo.replace('{location}', skillsConfig.location)
-        : msg.skillsUsingExisting.replace('{location}', skillsConfig.location);
-    }
-    console.log(chalk.gray(`  ${msg.skillsLabel}: ${skillsStatusText}`));
-  }
-
-  // Show selected standard options
-  if (standardOptions.workflow) {
-    console.log(chalk.gray(`  ${msg.gitWorkflow}: ${standardOptions.workflow}`));
-  }
-  if (standardOptions.merge_strategy) {
-    console.log(chalk.gray(`  ${msg.mergeStrategy}: ${standardOptions.merge_strategy}`));
-  }
-  if (standardOptions.commit_language) {
-    console.log(chalk.gray(`  ${msg.commitLanguage}: ${standardOptions.commit_language}`));
-  }
-  if (standardOptions.test_levels && standardOptions.test_levels.length > 0) {
-    console.log(chalk.gray(`  ${msg.testLevels}: ${standardOptions.test_levels.join(', ')}`));
-  }
-  console.log();
+  // Show Configuration Summary
+  displaySummary(config, msg, common);
 
+  // Confirm Installation
   if (!options.yes) {
     const confirmed = await promptConfirm(msg.proceedInstall);
     if (!confirmed) {
@@ -531,610 +83,351 @@ export async function initCommand(options) {
     }
   }
 
-  // ===== Start installation =====
+  // ===== Execute Installation =====
   console.log();
-  const copySpinner = ora(msg.copyingStandards).start();
+  
+  // 1. Install Standards
+  const standardsResults = await installStandards(config, projectPath);
+  config.installedStandards = standardsResults.standards.map(s => basename(s));
 
-  const results = {
-    standards: [],
-    extensions: [],
-    integrations: [],
+  // 2. Install Integrations
+  const integrationResults = await installIntegrations(config, projectPath);
+
+  // 3. Install Skills & Commands
+  const skillsResults = {
     skills: [],
     commands: [],
     errors: [],
-    // New: hash tracking for enhanced file integrity
     skillHashes: {},
-    commandHashes: {},
-    integrationBlockHashes: {}
+    commandHashes: {}
   };
-
-  // Get standards for the selected level
-  const standards = getStandardsByLevel(level);
-
-  // Determine which standards to copy based on scope
-  const standardsToCopy = skillsConfig.standardsScope === 'minimal'
-    ? standards.filter(s => s.category === 'reference')
-    : standards.filter(s => s.category === 'reference' || s.category === 'skill');
-
-  // Helper to copy standard with format awareness
-  const copyStandardWithFormat = async (std, targetFormat) => {
-    const sourcePath = getStandardSource(std, targetFormat);
-    const result = await copyStandard(sourcePath, '.standards', projectPath);
-    return { ...result, sourcePath };
+  await installSkills(config.skillsConfig, projectPath, msg, skillsResults);
+  await installCommands(config.skillsConfig, projectPath, msg, skillsResults);
+
+  // Combine results
+  const combinedResults = {
+    standards: standardsResults.standards,
+    extensions: standardsResults.extensions,
+    integrations: integrationResults.integrations,
+    skills: skillsResults.skills,
+    commands: skillsResults.commands,
+    errors: [
+      ...standardsResults.errors,
+      ...integrationResults.errors,
+      ...skillsResults.errors
+    ],
+    fileHashes: standardsResults.fileHashes,
+    skillHashes: skillsResults.skillHashes,
+    commandHashes: skillsResults.commandHashes,
+    integrationBlockHashes: integrationResults.integrationBlockHashes,
+    manifestIntegrationConfigs: integrationResults.manifestIntegrationConfigs
   };
 
-  // Helper to copy option files
-  const copyOptionFiles = async (std, optionCategory, selectedOptionIds, targetFormat) => {
-    const copiedOptions = [];
-    if (!std.options || !std.options[optionCategory]) return copiedOptions;
-
-    const optionIds = Array.isArray(selectedOptionIds) ? selectedOptionIds : [selectedOptionIds];
-    for (const optionId of optionIds) {
-      const option = findOption(std, optionCategory, optionId);
-      if (option) {
-        const sourcePath = getOptionSource(option, targetFormat);
-        const result = await copyStandard(sourcePath, '.standards/options', projectPath);
-        if (result.success) {
-          copiedOptions.push(sourcePath);
-        } else {
-          results.errors.push(`${sourcePath}: ${result.error}`);
-        }
-      }
-    }
-    return copiedOptions;
-  };
+  // 4. Write Manifest & Display Summary
+  writeFinalManifest(config, combinedResults, projectPath);
 
-  // Copy standards based on format
-  const formatsToUse = format === 'both' ? ['ai', 'human'] : [format];
+  // 5. Setup Pre-commit Hook
+  await setupHuskyHook(projectPath);
 
-  for (const std of standardsToCopy) {
-    for (const targetFormat of formatsToUse) {
-      const { success, sourcePath, error } = await copyStandardWithFormat(std, targetFormat);
-      if (success) {
-        results.standards.push(sourcePath);
-      } else {
-        results.errors.push(`${sourcePath}: ${error}`);
-      }
-    }
+  process.exit(0);
+}
 
-    // Copy selected options for this standard
-    if (std.options) {
-      for (const targetFormat of formatsToUse) {
-        // Git workflow options
-        if (std.id === 'git-workflow') {
-          if (standardOptions.workflow) {
-            const copied = await copyOptionFiles(std, 'workflow', standardOptions.workflow, targetFormat);
-            results.standards.push(...copied);
-          }
-          if (standardOptions.merge_strategy) {
-            const copied = await copyOptionFiles(std, 'merge_strategy', standardOptions.merge_strategy, targetFormat);
-            results.standards.push(...copied);
-          }
-        }
-        // Commit message options
-        if (std.id === 'commit-message' && standardOptions.commit_language) {
-          const copied = await copyOptionFiles(std, 'commit_language', standardOptions.commit_language, targetFormat);
-          results.standards.push(...copied);
-        }
-        // Testing options
-        if (std.id === 'testing' && standardOptions.test_levels) {
-          const copied = await copyOptionFiles(std, 'test_level', standardOptions.test_levels, targetFormat);
-          results.standards.push(...copied);
-        }
+/**
+ * Configure Husky pre-commit hook
+ */
+async function setupHuskyHook(projectPath) {
+  const hasGit = existsSync(join(projectPath, '.git'));
+  if (!hasGit) return;
+
+  console.log(chalk.cyan('Configuring Pre-commit Hook (Husky)...'));
+
+  // 1. Install husky if needed
+  try {
+    const pkgPath = join(projectPath, 'package.json');
+    if (existsSync(pkgPath)) {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+      const hasHusky = pkg.devDependencies?.husky || pkg.dependencies?.husky;
+
+      if (!hasHusky) {
+        console.log(chalk.gray('  Installing husky...'));
+        execSync('npm install --save-dev husky', { stdio: 'ignore', cwd: projectPath });
       }
     }
+  } catch (e) {
+    console.log(chalk.yellow(`  ⚠ Failed to check/install husky: ${e.message}`));
+    return;
   }
 
-  copySpinner.succeed(msg.copiedStandards.replace('{count}', results.standards.length));
-
-  // Copy extensions
-  if (languages.length > 0 || frameworks.length > 0 || locale) {
-    const extSpinner = ora(msg.copyingExtensions).start();
-
-    for (const lang of languages) {
-      if (EXTENSION_MAPPINGS[lang]) {
-        const result = await copyStandard(EXTENSION_MAPPINGS[lang], '.standards', projectPath);
-        if (result.success) {
-          results.extensions.push(EXTENSION_MAPPINGS[lang]);
-        } else {
-          results.errors.push(`${EXTENSION_MAPPINGS[lang]}: ${result.error}`);
-        }
-      }
-    }
-
-    for (const fw of frameworks) {
-      if (EXTENSION_MAPPINGS[fw]) {
-        const result = await copyStandard(EXTENSION_MAPPINGS[fw], '.standards', projectPath);
-        if (result.success) {
-          results.extensions.push(EXTENSION_MAPPINGS[fw]);
-        } else {
-          results.errors.push(`${EXTENSION_MAPPINGS[fw]}: ${result.error}`);
-        }
-      }
+  // 2. Initialize husky
+  const huskyDir = join(projectPath, '.husky');
+  try {
+    if (!existsSync(huskyDir)) {
+       console.log(chalk.gray('  Initializing husky...'));
+       execSync('npx husky init', { stdio: 'ignore', cwd: projectPath });
     }
-
-    if (locale && EXTENSION_MAPPINGS[locale]) {
-      const result = await copyStandard(EXTENSION_MAPPINGS[locale], '.standards', projectPath);
-      if (result.success) {
-        results.extensions.push(EXTENSION_MAPPINGS[locale]);
-      } else {
-        results.errors.push(`${EXTENSION_MAPPINGS[locale]}: ${result.error}`);
-      }
-    }
-
-    extSpinner.succeed(msg.copiedExtensions.replace('{count}', results.extensions.length));
+  } catch (e) {
+     // Ignore, might already be init
   }
 
-  // Build installed standards list for compliance instructions (used by all AI tools)
-  const installedStandardsList = results.standards.map(s => basename(s));
-
-  // Determine common language setting
-  let commonLanguage = 'en';
-  if (locale === 'zh-tw') {
-    commonLanguage = 'zh-tw';
-  } else if (standardOptions?.commit_language === 'bilingual') {
-    commonLanguage = 'bilingual';
-  } else if (standardOptions?.commit_language === 'traditional-chinese') {
-    commonLanguage = 'zh-tw';
-  }
-
-  // Generate and write integrations
-  if (integrations.length > 0) {
-    const intSpinner = ora(msg.generatingIntegrations).start();
-    const integrationConfigs = skillsConfig.integrationConfigs || {};
-
-    // Track generated files to handle AGENTS.md sharing (codex + opencode)
-    const generatedFiles = new Set();
-
-    for (const tool of integrations) {
-      // Check if this file was already generated (for AGENTS.md sharing)
-      const targetFile = getToolFilePath(tool);
-      if (generatedFiles.has(targetFile)) {
-        // Skip - file already generated by another tool (e.g., codex generated AGENTS.md, skip opencode)
-        continue;
-      }
-
-      // Build enhanced config with installed standards
-      const enhancedConfig = {
-        ...integrationConfigs[tool],
-        tool,
-        categories: integrationConfigs[tool]?.categories || ['anti-hallucination', 'commit-standards', 'code-review'],
-        language: integrationConfigs[tool]?.language || commonLanguage,
-        installedStandards: installedStandardsList,
-        contentMode: skillsConfig.contentMode || 'minimal',
-        level: level,
-        // Pass commit_language for dynamic commit standards generation
-        commitLanguage: standardOptions?.commit_language || 'english'
-      };
-
-      // Use dynamic generator
-      const result = writeIntegrationFile(tool, enhancedConfig, projectPath);
-      if (result.success) {
-        results.integrations.push(result.path);
-        generatedFiles.add(targetFile);
-
-        // Capture integration block hash for tracking UDS content
-        if (result.blockHashInfo) {
-          results.integrationBlockHashes[result.path] = {
-            ...result.blockHashInfo,
-            installedAt: new Date().toISOString()
-          };
-        }
-      } else {
-        // Fall back to legacy static file copy
-        const mapping = INTEGRATION_MAPPINGS[tool];
-        if (mapping) {
-          const copyResult = await copyIntegration(mapping.source, mapping.target, projectPath);
-          if (copyResult.success) {
-            results.integrations.push(mapping.target);
-            generatedFiles.add(targetFile);
-          } else {
-            results.errors.push(`${tool}: ${result.error || copyResult.error}`);
-          }
-        } else {
-          results.errors.push(`${tool}: ${result.error}`);
-        }
-      }
+  // 3. Ensure .husky directory exists (fallback if husky init failed)
+  if (!existsSync(huskyDir)) {
+    try {
+      mkdirSync(huskyDir, { recursive: true });
+    } catch (e) {
+      console.log(chalk.red(`  ✗ Failed to create .husky directory: ${e.message}`));
+      return;
     }
-
-    intSpinner.succeed(msg.generatedIntegrations.replace('{count}', results.integrations.length));
   }
 
-  // Generate CLAUDE.md for Claude Code if selected
-  const claudeCodeSelected = aiTools.includes('claude-code');
-  if (claudeCodeSelected && !integrationFileExists('claude-code', projectPath)) {
-    const claudeSpinner = ora(msg.generatingClaudeMd).start();
-
-    const claudeConfig = {
-      tool: 'claude-code',
-      categories: ['anti-hallucination', 'commit-standards', 'code-review'],
-      languages: [],
-      exclusions: [],
-      customRules: [],
-      detailLevel: 'standard',
-      language: commonLanguage,
-      // Enhanced standards compliance fields
-      installedStandards: installedStandardsList,
-      contentMode: skillsConfig.contentMode || 'minimal',
-      level: level,
-      // Pass commit_language for dynamic commit standards generation
-      commitLanguage: standardOptions?.commit_language || 'english'
-    };
+  // 4. Add pre-commit hook
+  const preCommitPath = join(huskyDir, 'pre-commit');
+  const udsCmd = 'npx uds check --standard checkin-standards';
 
-    const result = writeIntegrationFile('claude-code', claudeConfig, projectPath);
-    if (result.success) {
-      results.integrations.push(result.path);
-      claudeSpinner.succeed(msg.generatedClaudeMd);
+  try {
+    let content = '';
+    if (existsSync(preCommitPath)) {
+      content = readFileSync(preCommitPath, 'utf-8');
     } else {
-      claudeSpinner.warn(msg.couldNotGenerateClaudeMd);
-      results.errors.push(`CLAUDE.md: ${result.error}`);
+      // Create if not exists (husky init usually creates it, but just in case)
+      content = '#!/usr/bin/env sh\n. "$(dirname -- "$0")/_/husky.sh"\n';
     }
-  }
 
-  // Install Skills if needed (unified multi-agent installation)
-  if (skillsConfig.needsInstall && skillsConfig.skillsInstallations?.length > 0) {
-    const skillSpinner = ora(msg.installingSkills).start();
-
-    // Use new unified installer for multi-agent support
-    const installResult = await installSkillsToMultipleAgents(
-      skillsConfig.skillsInstallations,
-      null, // Install all skills
-      projectPath
-    );
-
-    // Collect results
-    for (const agentResult of installResult.installations) {
-      if (agentResult.installed.length > 0) {
-        for (const skillName of agentResult.installed) {
-          if (!results.skills.includes(skillName)) {
-            results.skills.push(skillName);
-          }
-        }
-      }
-      for (const err of agentResult.errors) {
-        results.errors.push(`${agentResult.agent} - ${err.skill}: ${err.error}`);
+    if (!content.includes('checkin-standards')) {
+      writeFileSync(preCommitPath, content + `\n# UDS Standard Check\n${udsCmd}\n`, 'utf-8');
+      try {
+        execSync(`chmod +x ${preCommitPath}`);
+      } catch (e) {
+        // Ignore chmod failures on systems that don't support it
       }
-    }
-
-    // Collect skill file hashes for integrity tracking
-    if (installResult.allFileHashes) {
-      Object.assign(results.skillHashes, installResult.allFileHashes);
-    }
-
-    // Build location summary for display
-    const targetLocations = skillsConfig.skillsInstallations.map(inst => {
-      const displayName = getAgentDisplayName(inst.agent);
-      const dir = getSkillsDirForAgent(inst.agent, inst.level, projectPath);
-      return `${displayName} (${dir})`;
-    }).join(', ');
-
-    if (installResult.totalErrors === 0) {
-      skillSpinner.succeed(msg.installedSkills
-        .replace('{count}', installResult.totalInstalled)
-        .replace('{locations}', targetLocations));
+      console.log(chalk.green('  ✓ Adding uds check to pre-commit hook'));
     } else {
-      skillSpinner.warn(msg.installedSkillsWithErrors
-        .replace('{count}', installResult.totalInstalled)
-        .replace('{errors}', installResult.totalErrors));
-    }
-  } else if (skillsConfig.needsInstall && skillsConfig.updateTargets.length > 0) {
-    // Legacy fallback for backward compatibility
-    const skillSpinner = ora(msg.installingSkills).start();
-
-    const skillFiles = getSkillFiles();
-    const repoInfo = getRepositoryInfo();
-    let successCount = 0;
-    let errorCount = 0;
-
-    for (const target of skillsConfig.updateTargets) {
-      for (const [skillName, files] of Object.entries(skillFiles)) {
-        const result = await downloadSkillToLocation(
-          skillName,
-          files,
-          target,
-          target === 'project' ? projectPath : null
-        );
-
-        if (result.success) {
-          successCount++;
-          if (!results.skills.includes(skillName)) {
-            results.skills.push(skillName);
-          }
-        } else {
-          errorCount++;
-          const failedFiles = result.files.filter(f => !f.success).map(f => f.file).join(', ');
-          results.errors.push(`Skill ${skillName} (${target}): failed to install ${failedFiles}`);
-        }
-      }
-
-      // Write manifest for each target location
-      const targetDir = target === 'project'
-        ? getProjectSkillsDir(projectPath)
-        : getSkillsDir();
-      writeSkillsManifest(repoInfo.skills.version, targetDir);
+      console.log(chalk.gray('  ✓ Pre-commit hook already configured'));
     }
+  } catch (e) {
+    console.log(chalk.red(`  ✗ Failed to configure pre-commit hook: ${e.message}`));
+  }
+  console.log();
+}
 
-    const targetLocations = skillsConfig.updateTargets.map(t =>
-      t === 'project' ? getProjectSkillsDir(projectPath) : getSkillsDir()
-    ).join(', ');
+/**
+ * Build configuration for non-interactive mode
+ */
+function buildNonInteractiveConfig(options, detected, projectPath) {
+  const displayLanguage = options.locale || detectLanguage(null);
+  
+  // Determine AI tools
+  const detectedAiTools = Object.keys(detected.aiTools).filter(k => detected.aiTools[k]);
+  const aiToolsNormalized = detectedAiTools.map(k => {
+    if (k === 'claudeCode') return 'claude-code';
+    if (k === 'geminiCli') return 'gemini-cli';
+    return k;
+  });
+
+  // Skills Configuration Logic
+  const hasSkillsCompatibleTool = aiToolsNormalized.some(t => t === 'claude-code' || t === 'opencode');
+  const onlySkillsCompatibleTools = aiToolsNormalized.every(t => t === 'claude-code' || t === 'opencode');
+  
+  let skillsLocationFlag = options.skillsLocation;
+  if (!skillsLocationFlag) {
+    skillsLocationFlag = (hasSkillsCompatibleTool && onlySkillsCompatibleTools) ? 'marketplace' : 'none';
+  }
 
-    if (errorCount === 0) {
-      skillSpinner.succeed(msg.installedSkills.replace('{count}', successCount).replace('{locations}', targetLocations));
-    } else {
-      skillSpinner.warn(msg.installedSkillsWithErrors.replace('{count}', successCount).replace('{errors}', errorCount));
-    }
+  const contentModeFlag = options.contentMode || 'index';
+  let skillsConfig = {};
+
+  if (skillsLocationFlag === 'marketplace') {
+    skillsConfig = {
+      installed: true,
+      location: 'marketplace',
+      needsInstall: false,
+      updateTargets: [],
+      standardsScope: 'minimal',
+      contentMode: contentModeFlag
+    };
+  } else if (skillsLocationFlag === 'none') {
+    skillsConfig = {
+      installed: false,
+      location: null,
+      needsInstall: false,
+      updateTargets: [],
+      standardsScope: 'full',
+      contentMode: contentModeFlag
+    };
+  } else {
+    // Determine location (project vs user)
+    const userSkillsInfo = getInstalledSkillsInfo();
+    const projectSkillsInfo = getProjectInstalledSkillsInfo(projectPath);
+    let location = 'user';
+    
+    if (skillsLocationFlag === 'project' || projectSkillsInfo?.installed) {
+      location = 'project';
+    }
+
+    skillsConfig = {
+      installed: true,
+      location,
+      needsInstall: skillsLocationFlag === 'project' || skillsLocationFlag === 'user' || (!userSkillsInfo?.installed && !projectSkillsInfo?.installed),
+      updateTargets: [location],
+      standardsScope: 'minimal',
+      contentMode: contentModeFlag
+    };
   }
 
-  // Install slash commands if requested
-  if (skillsConfig.commandsInstallations?.length > 0) {
-    const cmdSpinner = ora(msg.installingCommands || 'Installing slash commands...').start();
+  // Auto-install commands
+  const commandsSupportedAgents = aiToolsNormalized.filter(tool => {
+    const config = getAgentConfig(tool);
+    return config?.commands !== null;
+  });
+
+  if (commandsSupportedAgents.length > 0) {
+    skillsConfig.commandsInstallations = commandsSupportedAgents.map(agent => ({
+      agent,
+      level: 'project'
+    }));
+  }
 
-    const cmdResult = await installCommandsToMultipleAgents(
-      skillsConfig.commandsInstallations,
-      null, // Install all commands
-      projectPath
-    );
+  return {
+    level: options.level ? parseInt(options.level, 10) : 2,
+    languages: options.lang ? [options.lang] : Object.keys(detected.languages).filter(k => detected.languages[k]),
+    frameworks: options.framework ? [options.framework] : Object.keys(detected.frameworks).filter(k => detected.frameworks[k]),
+    displayLanguage,
+    format: options.format || 'ai',
+    standardOptions: {
+      workflow: options.workflow || 'github-flow',
+      merge_strategy: options.mergeStrategy || 'squash',
+      commit_language: options.commitLang || 'english',
+      test_levels: options.testLevels ? options.testLevels.split(',') : ['unit-testing', 'integration-testing']
+    },
+    skillsConfig,
+    aiTools: aiToolsNormalized,
+    integrations: [...aiToolsNormalized],
+    contentMode: skillsConfig.contentMode || 'minimal',
+    standardsScope: skillsConfig.standardsScope || 'full',
+    methodology: null
+  };
+}
 
-    // Initialize commands results array if not exists
-    results.commands = results.commands || [];
+/**
+ * Get label for a value from translation labels object
+ * Tries to find in messages.js labels, falls back to original value
+ * @param {string} key - The translation key (e.g., 'gitWorkflow', 'mergeStrategy', 'level')
+ * @param {string|number} value - The value to look up
+ * @returns {string} The label or the original value if not found
+ */
+function getValueLabel(key, value) {
+  const translations = t();
+  // Try direct key lookup (e.g., t().gitWorkflow.labels)
+  const labels = translations[key]?.labels;
+  if (labels?.[value]) {
+    return labels[value];
+  }
+  // Try commands.init labels for nested structures
+  const initLabels = translations.commands?.init?.[key + 'Labels'];
+  if (initLabels?.[value]) {
+    return initLabels[value];
+  }
+  return String(value);
+}
 
-    // Collect results
-    for (const agentResult of cmdResult.installations) {
-      if (agentResult.installed.length > 0) {
-        for (const cmdName of agentResult.installed) {
-          if (!results.commands.includes(cmdName)) {
-            results.commands.push(cmdName);
-          }
-        }
-      }
-      for (const err of agentResult.errors) {
-        results.errors.push(`${agentResult.agent} command - ${err.command}: ${err.error}`);
-      }
-    }
+/**
+ * Display configuration summary
+ * Order follows init-flow.js question sequence for consistency
+ */
+function displaySummary(config, msg, common) {
+  console.log(chalk.cyan(msg.configSummary));
 
-    // Collect command file hashes for integrity tracking
-    if (cmdResult.allFileHashes) {
-      Object.assign(results.commandHashes, cmdResult.allFileHashes);
-    }
+  // 1. Display Language (STEP 1)
+  const displayLangLabel = config.displayLanguage === 'zh-tw' ? '繁體中文' : config.displayLanguage === 'zh-cn' ? '简体中文' : 'English';
+  console.log(chalk.gray(`  ${msg.displayLanguageLabel || 'Display Language'}: ${displayLangLabel}`));
 
-    // Build location summary
-    const cmdLocations = skillsConfig.commandsInstallations.map(item => {
-      // Support both {agent, level} objects and simple agent strings (backward compatibility)
-      const agent = typeof item === 'string' ? item : item.agent;
-      const level = typeof item === 'string' ? 'project' : (item.level || 'project');
-      const displayName = getAgentDisplayName(agent);
-      const dir = getCommandsDirForAgent(agent, level, projectPath);
-      return `${displayName} (${dir})`;
-    }).join(', ');
+  // 2. AI Tools (STEP 2) - Use getAgentDisplayName for readable names
+  const aiToolNames = config.aiTools.map(id => getAgentDisplayName(id) || id);
+  console.log(chalk.gray(`  ${common.aiTools}: ${aiToolNames.length > 0 ? aiToolNames.join(', ') : common.none}`));
 
-    if (cmdResult.totalErrors === 0) {
-      cmdSpinner.succeed((msg.installedCommands || 'Installed {count} commands to: {locations}')
-        .replace('{count}', cmdResult.totalInstalled)
-        .replace('{locations}', cmdLocations));
+  // 3. Skills Installation (STEP 4)
+  if (config.skillsConfig.installed) {
+    let skillsStatusText;
+    if (config.skillsConfig.location === 'marketplace') {
+      skillsStatusText = msg.skillsMarketplace;
+    } else if (config.skillsConfig.location === 'multiple') {
+      // Handle multiple installation locations
+      const count = config.skillsConfig.skillsInstallations?.length || 0;
+      skillsStatusText = (msg.skillsInstalledToCount || '{count} locations').replace('{count}', count);
     } else {
-      cmdSpinner.warn((msg.installedCommandsWithErrors || 'Installed {count} commands with {errors} errors')
-        .replace('{count}', cmdResult.totalInstalled)
-        .replace('{errors}', cmdResult.totalErrors));
-    }
-  }
-
-  // Compute file hashes for integrity checking
-  const fileHashes = {};
-  const now = new Date().toISOString();
-
-  // Helper to compute and store hash
-  const addFileHash = (relativePath) => {
-    const fullPath = join(projectPath, relativePath);
-    const hashInfo = computeFileHash(fullPath);
-    if (hashInfo) {
-      fileHashes[relativePath] = {
-        ...hashInfo,
-        installedAt: now
-      };
+      skillsStatusText = config.skillsConfig.needsInstall
+        ? msg.skillsInstallTo.replace('{location}', config.skillsConfig.location)
+        : msg.skillsUsingExisting.replace('{location}', config.skillsConfig.location);
     }
-  };
-
-  // Hash standards (stored as source paths, need to convert to target paths)
-  for (const sourcePath of results.standards) {
-    const fileName = basename(sourcePath);
-    // Check if it's an option file (path contains 'options/')
-    const relativePath = sourcePath.includes('options/')
-      ? join('.standards', 'options', fileName)
-      : join('.standards', fileName);
-    addFileHash(relativePath);
-  }
-
-  // Hash extensions
-  for (const sourcePath of results.extensions) {
-    const fileName = basename(sourcePath);
-    const relativePath = join('.standards', fileName);
-    addFileHash(relativePath);
+    console.log(chalk.gray(`  ${msg.skillsLabel}: ${skillsStatusText}`));
   }
 
-  // Hash integrations (already stored as target paths)
-  for (const targetPath of results.integrations) {
-    addFileHash(targetPath);
+  // 3b. Commands Installation (STEP 5)
+  if (config.skillsConfig.commandsInstallations?.length > 0) {
+    const count = config.skillsConfig.commandsInstallations.length;
+    const commandsStatusText = (msg.commandsInstalledToCount || '{count} locations').replace('{count}', count);
+    console.log(chalk.gray(`  ${msg.commandsLabel || 'Slash Commands'}: ${commandsStatusText}`));
   }
 
-  // Create manifest
-  const repoInfo = getRepositoryInfo();
+  // 4. Standards Scope (STEP 6)
+  console.log(chalk.gray(`  ${msg.standardsScope}: ${config.skillsConfig.standardsScope === 'minimal' ? msg.standardsScopeLean : msg.standardsScopeComplete}`));
 
-  // Always record options as user preferences (for Skills and future updates)
-  // Even when standards aren't copied locally (minimal scope), options should be preserved
-  const manifestOptions = {
-    workflow: standardOptions.workflow || null,
-    merge_strategy: standardOptions.merge_strategy || null,
-    commit_language: standardOptions.commit_language || null,
-    test_levels: standardOptions.test_levels || []
-  };
+  // 5. Adoption Level (STEP 7) - Use level.labels for translated display
+  const levelLabels = t().level?.labels || { 1: 'Level 1', 2: 'Level 2', 3: 'Level 3' };
+  console.log(chalk.gray(`  ${common.level}: ${levelLabels[config.level] || `Level ${config.level}`}`));
 
-  // Build integrationConfigs for manifest
-  // This allows uds update to regenerate integration files with the same settings
-  const manifestIntegrationConfigs = {};
-  const integrationConfigs = skillsConfig.integrationConfigs || {};
+  // 6. Standards Format (STEP 8)
+  const formatLabels = t().format?.labels || { ai: 'Compact', human: 'Detailed', both: 'Both' };
+  console.log(chalk.gray(`  ${common.format}: ${formatLabels[config.format]}`));
 
-  for (const targetPath of results.integrations) {
-    // Find the tool name for this integration
-    let toolName = null;
-    let config = null;
-
-    // Check if this is from the integrationConfigs (dynamic generation)
-    for (const [tool, toolConfig] of Object.entries(integrationConfigs)) {
-      const mapping = INTEGRATION_MAPPINGS[tool];
-      if (mapping && mapping.target === targetPath) {
-        toolName = tool;
-        config = toolConfig;
-        break;
-      }
-    }
-
-    // Check if this is CLAUDE.md
-    if (targetPath === 'CLAUDE.md' || targetPath === '.standards/CLAUDE.md') {
-      toolName = 'claude-code';
-      config = {
-        tool: 'claude-code',
-        categories: ['anti-hallucination', 'commit-standards', 'code-review'],
-        languages: [],
-        exclusions: [],
-        customRules: [],
-        detailLevel: 'standard',
-        language: commonLanguage
-      };
-    }
-
-    if (toolName && config) {
-      manifestIntegrationConfigs[targetPath] = {
-        tool: toolName,
-        categories: config.categories || [],
-        detailLevel: config.detailLevel || 'standard',
-        language: config.language || commonLanguage,
-        contentMode: skillsConfig.contentMode || 'minimal',
-        installedStandards: installedStandardsList,
-        generatedAt: now
-      };
-    }
+  // 7. Standard Options (STEP 9) - use labels for human-readable values
+  if (config.standardOptions.workflow) {
+    console.log(chalk.gray(`  ${msg.gitWorkflow}: ${getValueLabel('gitWorkflow', config.standardOptions.workflow)}`));
+  }
+  if (config.standardOptions.merge_strategy) {
+    console.log(chalk.gray(`  ${msg.mergeStrategy}: ${getValueLabel('mergeStrategy', config.standardOptions.merge_strategy)}`));
+  }
+  if (config.standardOptions.commit_language) {
+    console.log(chalk.gray(`  ${msg.commitLanguage}: ${getValueLabel('commitLanguage', config.standardOptions.commit_language)}`));
+  }
+  if (config.standardOptions.test_levels?.length > 0) {
+    const testLabels = config.standardOptions.test_levels.map(level => getValueLabel('testLevels', level));
+    console.log(chalk.gray(`  ${msg.testLevels}: ${testLabels.join(', ')}`));
   }
 
-  const manifest = {
-    version: '3.3.0', // Updated for enhanced file tracking
-    upstream: {
-      repo: 'AsiaOstrich/universal-dev-standards',
-      version: repoInfo.standards.version,
-      installed: new Date().toISOString().split('T')[0]
-    },
-    level,
-    format,
-    standardsScope: skillsConfig.standardsScope || 'full',
-    contentMode: skillsConfig.contentMode || 'minimal',
-    standards: results.standards,
-    extensions: results.extensions,
-    integrations: results.integrations,
-    integrationConfigs: manifestIntegrationConfigs,
-    options: manifestOptions,
-    aiTools,
-    skills: {
-      installed: skillsConfig.installed,
-      location: skillsConfig.location,
-      names: skillsConfig.location === 'marketplace' ? ['all-via-plugin'] : results.skills,
-      version: skillsConfig.installed ? repoInfo.skills.version : null,
-      // New: multi-agent installations tracking
-      installations: skillsConfig.skillsInstallations || []
-    },
-    commands: {
-      installed: skillsConfig.commandsInstallations?.length > 0,
-      names: results.commands || [],
-      installations: skillsConfig.commandsInstallations || []
-    },
-    methodology: skillsConfig.methodology ? {
-      active: skillsConfig.methodology,
-      available: ['tdd', 'bdd', 'sdd', 'atdd'],
-      config: {
-        checkpointsEnabled: true,
-        reminderIntensity: 'suggest',
-        skipLimit: 3
-      }
-    } : null,
-    fileHashes,
-    // New: enhanced file tracking for Skills, Commands, and Integration blocks
-    skillHashes: results.skillHashes || {},
-    commandHashes: results.commandHashes || {},
-    integrationBlockHashes: results.integrationBlockHashes || {}
-  };
+  // 8. Language Extensions (STEP 10)
+  console.log(chalk.gray(`  ${msg.languages}: ${config.languages.length > 0 ? config.languages.join(', ') : common.none}`));
 
-  writeManifest(manifest, projectPath);
+  // 9. Framework Extensions (STEP 11)
+  console.log(chalk.gray(`  ${msg.frameworks}: ${config.frameworks.length > 0 ? config.frameworks.join(', ') : common.none}`));
 
-  // Summary
-  console.log();
-  console.log(chalk.green(msg.initializedSuccess));
-  console.log();
+  // 10. Integration Config (STEP 12)
+  if (config.skillsConfig.integrationConfigs && Object.keys(config.skillsConfig.integrationConfigs).length > 0) {
+    // Get the first config (shared config)
+    const firstConfigKey = Object.keys(config.skillsConfig.integrationConfigs)[0];
+    const integrationConfig = config.skillsConfig.integrationConfigs[firstConfigKey];
 
-  const totalFiles = results.standards.length + results.extensions.length + results.integrations.length;
-  console.log(chalk.gray(`  ${msg.filesCopied.replace('{count}', totalFiles)}`));
+    if (integrationConfig && integrationConfig.mode) {
+      const modeLabels = t().integration?.mode?.labels || { default: 'Default', custom: 'Custom', merge: 'Merge' };
+      const modeLabel = modeLabels[integrationConfig.mode] || integrationConfig.mode;
+      console.log(chalk.gray(`  ${msg.integrationConfigLabel || 'Integration Config'}: ${modeLabel}`));
 
-  if (skillsConfig.installed) {
-    if (skillsConfig.location === 'marketplace') {
-      console.log(chalk.gray(`  ${msg.skillsUsingMarketplace}`));
-    } else if (results.skills.length > 0) {
-      // Build location summary from skillsInstallations or legacy updateTargets
-      const skillLocations = [];
-      if (skillsConfig.skillsInstallations?.length > 0) {
-        for (const inst of skillsConfig.skillsInstallations) {
-          const displayName = getAgentDisplayName(inst.agent);
-          const dir = getSkillsDirForAgent(inst.agent, inst.level, projectPath);
-          skillLocations.push(`${displayName}: ${dir}`);
-        }
-      } else {
-        // Legacy fallback
-        if (skillsConfig.updateTargets.includes('user')) {
-          skillLocations.push('~/.claude/skills/');
-        }
-        if (skillsConfig.updateTargets.includes('project')) {
-          skillLocations.push('.claude/skills/');
-        }
+      // If custom mode, show selected categories
+      if (integrationConfig.mode === 'custom' && integrationConfig.categories?.length > 0) {
+        const categoryLabels = t().integration?.categoryLabels || {};
+        const categoryNames = integrationConfig.categories.map(cat => categoryLabels[cat] || cat);
+        console.log(chalk.gray(`  ${msg.ruleCategoriesLabel || 'Rule Categories'}: ${categoryNames.join(', ')}`));
       }
-      console.log(chalk.gray(`  ${msg.skillsInstalledTo.replace('{count}', results.skills.length).replace('{locations}', skillLocations.join(' and '))}`));
     }
   }
 
-  // Show commands installation summary
-  if (results.commands?.length > 0) {
-    const cmdLocations = skillsConfig.commandsInstallations?.map(item => {
-      // Support both {agent, level} objects and simple agent strings (backward compatibility)
-      const agent = typeof item === 'string' ? item : item.agent;
-      const level = typeof item === 'string' ? 'project' : (item.level || 'project');
-      const displayName = getAgentDisplayName(agent);
-      const dir = getCommandsDirForAgent(agent, level, projectPath);
-      return `${displayName}: ${dir}`;
-    }).join(' and ') || '';
-
-    console.log(chalk.gray(`  ${(msg.commandsInstalledTo || 'Commands ({count}): {locations}').replace('{count}', results.commands.length).replace('{locations}', cmdLocations)}`));
-  }
-  console.log(chalk.gray(`  ${msg.manifestCreated}`));
+  // 11. Content Mode (STEP 13)
+  const contentModeLabels = t().contentMode?.labels || { index: 'Standard', full: 'Full', minimal: 'Minimal' };
+  console.log(chalk.gray(`  ${msg.contentModeLabel}: ${contentModeLabels[config.contentMode] || config.contentMode}`));
 
-  if (results.errors.length > 0) {
-    console.log();
-    console.log(chalk.yellow(msg.errorsOccurred.replace('{count}', results.errors.length)));
-    for (const err of results.errors) {
-      console.log(chalk.gray(`    ${err}`));
-    }
+  // 12. Methodology (STEP 14, experimental)
+  if (config.skillsConfig.methodology) {
+    console.log(chalk.gray(`  ${common.methodology}: ${config.skillsConfig.methodology} ${chalk.yellow('[Experimental]')}`));
   }
 
   console.log();
-  console.log(chalk.gray(msg.nextSteps));
-  console.log(chalk.gray(`  ${msg.reviewDirectory}`));
-  console.log(chalk.gray(`  ${msg.addToVcs}`));
-  if (skillsConfig.installed) {
-    // Build unique tool names from installations
-    const toolNames = skillsConfig.skillsInstallations?.length > 0
-      ? [...new Set(skillsConfig.skillsInstallations.map(inst => getAgentDisplayName(inst.agent)))].join(' / ')
-      : 'Claude Code';
-    console.log(chalk.gray(`  ${msg.restartAgent.replace('{tools}', toolNames)}`));
-    console.log(chalk.gray(`  4. ${msg.runCheck}`));
-  } else {
-    console.log(chalk.gray(`  3. ${msg.runCheck}`));
-  }
-  console.log();
-
-  // Exit explicitly to prevent hanging due to inquirer's readline interface
-  process.exit(0);
-}
+}