moai-adk 0.4.5__py3-none-any.whl → 0.20.1__py3-none-any.whl

moai_adk/templates/.claude/commands/alfred/0-project.md

@@ -1,6 +1,7 @@
 ---
 name: alfred:0-project
-description: Initialize project document - create product/structure/tech.md and set optimization for each language
+description: "Initialize project metadata and documentation"
+argument-hint: "[setting|update]"
 allowed-tools:
   - Read
   - Write
@@ -16,39 +17,58 @@ allowed-tools:
 ---
 
 # 📋 MoAI-ADK Step 0: Initialize/Update Universal Language Support Project Documentation
-> Interactive prompts rely on `Skill("moai-alfred-tui-survey")` so AskUserQuestion renders TUI selection menus for user surveys and approvals.
+
+> **Note**: Interactive prompts use `AskUserQuestion tool (documented in moai-alfred-ask-user-questions skill)` for TUI selection menus. The skill is loaded on-demand when user interaction is required.
 
 ## 🎯 Command Purpose
 
-Automatically analyzes the project environment to create/update product/structure/tech.md documents and configure language-specific optimization settings.
+Automatically analyzes the project environment to create/update product/structure/tech.md documents and configure language-specific optimization settings with **language-first contextual flows**.
 
-## 📋 Execution flow
+## 🌐 Language-First Architecture (CRITICAL)
 
-0. **Conversation Language Selection**: User selects the language for all dialogs and documentation
-1. **Environment Analysis**: Automatically detect project type (new/legacy) and codebase language
-2. **Establishment of interview strategy**: Select question tree suited to project characteristics
-3. **User Verification**: Review and approve interview plan
-4. **Create project documentation**: Create product/structure/tech.md in the selected language
-5. **Create configuration file**: config.json auto-configuration
+**Core Principle**: Language selection ALWAYS happens BEFORE any other configuration or operations.
 
-## 🧠 Associated Skills & Agents
+### Language-First Flow Rules
+1. **Language First**: Language selection is the VERY FIRST step in ANY flow
+2. **Context Persistence**: Once selected, ALL subsequent interactions use that language
+3. **Flow Adaptation**: Each flow (fresh install/update/settings) adapts based on language context
+4. **Settings Respect**: Existing language settings are confirmed before any operations
 
-| Agent | Core Skill | Purpose |
-| ----- | -------- | ------- |
-| project-manager | `moai-alfred-language-detection` | Initialize project and interview requirements |
-| trust-checker | `moai-alfred-trust-validation` | Verify initial project structure (optional) |
+### Contextual Flow Differentiation
+| Context | Language Handling | Flow Type | Key Features |
+|---------|-------------------|-----------|--------------|
+| **Fresh Install** | Language selection FIRST | Installation questionnaire | Complete setup, language-aware documentation |
+| **Update Mode** | Language confirmation FIRST | Update/merge questionnaire | Template optimization, language-aware updates |
+| **Existing Project** | Language confirmation FIRST | Settings modification options | Language change priority, contextual settings |
 
-**Note**: TUI Survey Skill is used for user confirmations during project initialization and is shared across all interactive prompts.
+## 📋 Execution Flow
+
+**Step 1: Command Routing** - Detect subcommand and route to appropriate workflow
+**Step 2: Language Context Establishment** - ALWAYS determine/confirm language FIRST
+**Step 3: Contextual Flow Execution** - Execute appropriate contextual flow
+**Step 4: Skills Integration** - Use specialized skills with language context
+**Step 5: Completion** - Provide next step options in selected language
+
+## 🧠 Associated Skills & Agents
+
+| Agent/Skill                    | Core Skill                          | Purpose                                       |
+| ------------------------------ | ----------------------------------- | --------------------------------------------- |
+| project-manager                | `moai-alfred-language-detection`    | Initialize project and interview requirements |
+| trust-checker                  | `moai-alfred-trust-validation`      | Verify initial project structure (optional)   |
+| **NEW: Language Initializer**  | `moai-project-language-initializer` | Handle language and user setup workflows      |
+| **NEW: Config Manager**        | `moai-project-config-manager`       | Manage all configuration operations           |
+| **NEW: Template Optimizer**    | `moai-project-template-optimizer`   | Handle template comparison and optimization   |
+| **NEW: Batch Questions**       | `moai-project-batch-questions`      | Standardize user interaction patterns        |
 
 ## 🔗 Associated Agent
 
 - **Primary**: project-manager (📋 planner) - Dedicated to project initialization
 - **Quality Check**: trust-checker (✅ Quality assurance lead) - Initial structural verification (optional)
-- **Secondary**: None (standalone execution)
+- **Secondary**: 4 specialized skills for complex workflows
 
 ## 💡 Example of use
 
-The user executes the `/alfred:8-project` command to analyze the project and create/update documents.
+The user executes the `/alfred:0-project` command to analyze the project and create/update documents.
 
 ## Command Overview
 
@@ -58,12 +78,14 @@ It is a systematic initialization system that analyzes the project environment a
 - **Project type classification**: Automatically determine new vs. existing projects
 - **High-performance initialization**: Achieve 0.18 second initialization with TypeScript-based CLI
 - **2-step workflow**: 1) Analysis and planning → 2) Execution after user approval
+- **Skills-based architecture**: Complex operations handled by dedicated skills
 
 ## How to use
 
-The user executes the `/alfred:8-project` command to start analyzing the project and creating/updating documents.
+The user executes the `/alfred:0-project` command to start analyzing the project and creating/updating documents.
 
 **Automatic processing**:
+
 - Update mode if there is an existing `.moai/project/` document
 - New creation mode if there is no document
 - Automatic detection of language and project type
@@ -75,7 +97,7 @@ The user executes the `/alfred:8-project` command to start analyzing the project
 - ❌ Create a file in the `.claude/memory/` directory
 - ❌ Create a file `.claude/commands/alfred/*.json`
 - ❌ Unnecessary overwriting of existing documents
-- ❌ Date and numerical prediction (“within 3 months”, “50% reduction”) etc.)
+- ❌ Date and numerical prediction ("within 3 months", "50% reduction") etc.
 - ❌ Hypothetical scenarios, expected market size, future technology trend predictions
 
 **Expressions to use**:
@@ -88,1020 +110,425 @@ The user executes the `/alfred:8-project` command to start analyzing the project
 
 ---
 
-## 🚀 STEP 0: Conversation Language Selection (NEW in v0.4.2)
-
-**Purpose**: Establish the conversation language before project initialization begins. This selection applies to all Alfred prompts, interview questions, and generated documentation.
-
-### 0.1 Display Language Selection Menu
-
-Alfred displays a language selection menu as the **very first interaction** using `Skill("moai-alfred-tui-survey")`:
-
-**Question**:
-```
-Which language would you like to use for the project initialization and documentation?
-```
-
-**Options** (AskUserQuestion with moai-alfred-tui-survey):
-- **English** (en) — All dialogs and documentation in English
-- **한국어** (ko) — All dialogs and documentation in Korean
-- **日本語** (ja) — All dialogs and documentation in Japanese
-- **中文** (zh) — All dialogs and documentation in Chinese
-- **Other** — User can specify custom language (e.g., "Español", "Français", "Deutsch")
-
-### 0.2 Store Language Preference
-
-Alfred records the selected language:
-
-```json
-{
-  "conversation_language": "ko",
-  "conversation_language_name": "한국어",
-  "selected_at": "2025-10-22T12:34:56Z"
-}
-```
-
-This language preference is:
-- Passed to all sub-agents as a context parameter
-- Stored in `.moai/config.json` under `language` field
-- Used to generate all documentation in the selected language
-- Displayed in CLAUDE.md under "## Project Information"
-
-### 0.3 Transition to STEP 1
-
-After language selection, all subsequent interactions proceed in the selected language:
-- Alfred's prompts are translated
-- project-manager sub-agent receives language parameter
-- Interview questions are in the selected language
-- Generated documents (product.md, structure.md, tech.md) are in the selected language
-- CLAUDE.md displays the selected language prominently
-
-**Example output for Korean selection**:
-```markdown
-✅ 언어 선택 완료: 한국어 (ko)
-
-이제 프로젝트 환경 분석으로 진행하겠습니다...
-```
-
----
-
-## 🚀 STEP 1: Environmental analysis and interview plan development
-
-Analyze the project environment and develop a systematic interview plan.
-
-### 1.0 Check backup directory (highest priority)
-
-**Processing backup files after moai-adk init reinitialization**
-
-Alfred first checks the `.moai-backups/` directory:
-
-```bash
-# Check latest backup timestamp
-ls -t .moai-backups/ | head -1
-
-# Check the optimized flag in config.json
-grep "optimized" .moai/config.json
-```
-
-**Backup existence conditions**:
-- `.moai-backups/` directory exists
-- `.moai/project/*.md` file exists in the latest backup folder
-- `optimized: false` in `config.json` (immediately after reinitialization)
-
-**Select user if backup exists**  
-Call `Skill("moai-alfred-tui-survey")` to display a TUI with the following options:
-- **Merge**: Merge backup contents and latest template (recommended)
-- **New**: Ignore the backup and start a new interview
-- **Skip**: Keep current file (terminate task)
-
-**Response processing**:
-- **"Merge"** → Proceed to Phase 1.1 (backup merge workflow)
-- **"Create new"** → Proceed to Phase 1.2 (Project environment analysis) (existing process)
-- **"Skip"** → End task
-
-**No backup or optimized: true**:
-- Proceed directly to Phase 1.2 (project environment analysis)
-
----
-
-### 1.1 Backup merge workflow (when user selects “Merge”)
-
-**Purpose**: Restore only user customizations while maintaining the latest template structure.
-
-**STEP 1: Read backup file**
-
-Alfred reads files from the latest backup directory:
-```bash
-# Latest backup directory path
-BACKUP_DIR=.moai-backups/$(ls -t .moai-backups/ | head -1)
-
-# Read backup file
-Read $BACKUP_DIR/.moai/project/product.md
-Read $BACKUP_DIR/.moai/project/structure.md
-Read $BACKUP_DIR/.moai/project/tech.md
-Read $BACKUP_DIR/CLAUDE.md
-```
-
-**STEP 2: Detect template defaults**
-
-The following patterns are considered "template defaults" (not merged):
-- "Define your key user base"
-- "Describe the core problem you are trying to solve"
-- "List the strengths and differences of your project"
-- "{{PROJECT_NAME}}", "{{PROJECT_DESCRIPTION}}", etc. Variable format
-- Guide phrases such as "Example:", "Sample:", "Example:", etc.
-
-**STEP 3: Extract user customization**
-
-Extract only **non-template default content** from the backup file:
-- `product.md`:
-- Define your actual user base in the USER section
- - Describe the actual problem in the PROBLEM section
- - Real differences in the STRATEGY section
- - Actual success metrics in the SUCCESS section
-- `structure.md`:
-- Actual design in the ARCHITECTURE section
- - Actual module structure in the MODULES section
- - Actual integration plan in the INTEGRATION section
-- `tech.md`:
-- The actual technology stack
- in the STACK section - The actual framework
- in the FRAMEWORK section - The actual quality policy
- in the QUALITY section - `HISTORY` section: **Full Preservation** (all files)
-
-**STEP 4: Merge Strategy**
-
-```markdown
-Latest template structure (v0.4.0+)
-    ↓
-Insert user customization (extracted from backup file)
-    ↓
-HISTORY section updates
-    ↓
-Version update (v0.1.x → v0.1.x+1)
-```
-
-**Merge Principle**:
-- ✅ Maintain the latest version of the template structure (section order, header, @TAG format)
-- ✅ Insert only user customization (actual content written)
-- ✅ Cumulative preservation of the HISTORY section (existing history + merge history)
-- ❌ Replace template default values ​​with the latest version
-
-**STEP 5: HISTORY Section Update**
-
-After the merge is complete, add history to the HISTORY section of each file:
-```yaml
-### v0.1.x+1 (2025-10-19)
-- **UPDATED**: Merge backup files (automatic optimization)
-- AUTHOR: @Alfred
-- BACKUP: .moai-backups/20251018-003638/
-- REASON: Restoring user customization after moai-adk init reinitialization
-```
-
-**STEP 6: Update config.json**
-
-Set optimization flags after the merge is complete:
-```json
-{
-  "project": {
-    "optimized": true,
-    "last_merge": "2025-10-19T12:34:56+09:00",
-    "backup_source": ".moai-backups/20251018-003638/"
-  }
-}
-```
-
-**STEP 7: Completion Report**
-
-```markdown
-✅ Backup merge completed!
-
-📁 Merged files:
-- .moai/project/product.md (v0.1.4 → v0.1.5)
-- .moai/project/structure.md (v0.1.1 → v0.1.2)
-- .moai/project/tech.md (v0.1.1 → v0.1.2)
-- .moai/config.json (optimized: false → true)
-
-🔍 Merge history:
-- USER section: Restore customized contents of backup file
-- PROBLEM section: Restore problem description of backup file
-- STRATEGY section: Restore differentials of backup file
-- HISTORY section: Add merge history (cumulative retention)
+## 🚀 Command Router: Detect and Route
+
+**Your immediate task**: Detect which subcommand the user provided and route to the correct workflow.
+
+### Step 1: Check what subcommand the user provided
+
+**Look at the user's command carefully**:
+- Did they type `/alfred:0-project setting`?
+- Did they type `/alfred:0-project update`?
+- Did they type just `/alfred:0-project` (no subcommand)?
+- Did they type something invalid like `/alfred:0-project xyz`?
+
+### Step 2: Route based on subcommand
+
+**IF user typed: `/alfred:0-project setting`**:
+1. Print: "🔧 Entering Settings Mode - Modify existing project configuration"
+2. **IMPORTANT**: Language context will be established in SETTINGS MODE
+3. Jump to **SETTINGS MODE** below
+4. Skip ALL other sections
+5. Stop after completing SETTINGS MODE
+6. **DO NOT proceed** to other workflows
+
+**ELSE IF user typed: `/alfred:0-project update`**:
+1. Print: "🔄 Entering Template Update Mode - Optimize templates after moai-adk update"
+2. **IMPORTANT**: Language context will be established FIRST in UPDATE MODE
+3. Jump to **UPDATE MODE** below
+4. Skip ALL other sections
+5. Stop after completing UPDATE MODE
+6. **DO NOT proceed** to other workflows
+
+**ELSE IF user typed: `/alfred:0-project` (no subcommand, nothing after)**:
+1. Check if the file `.moai/config.json` exists in the current directory
+   - Read the file path: `.moai/config.json`
+   - IF file exists → Print "✅ Project is already initialized!" AND jump to **AUTO-DETECT MODE**
+   - IF file does NOT exist → Print "🚀 Starting first-time project initialization..." AND jump to **INITIALIZATION MODE**
+   - **CRITICAL**: Both modes will establish language context FIRST
+
+**ELSE IF user typed an invalid subcommand** (like `/alfred:0-project xyz`):
+1. Print this error message:
+   ```
+   ❌ Unknown subcommand: xyz
 
-💾 Backup file location:
-- Original backup: .moai-backups/20251018-003638/
-- Retention period: Permanent (until manual deletion)
+   Valid subcommands:
+   /alfred:0-project          - Auto-detect mode (first-time or already initialized)
+   /alfred:0-project setting  - Modify existing settings
+   /alfred:0-project update   - Optimize templates after moai-adk update
 
-📋 Next steps:
-1. Review the merged document
-2. Additional modifications if necessary
-3. Create your first SPEC with /alfred:1-plan
+   Example: /alfred:0-project setting
+   ```
+2. Exit immediately
+3. **DO NOT make any changes**
 
----
-**Task completed: /alfred:0-project terminated**
-```
+### Step 3: CRITICAL RULES
 
-**Finish work after merge**: Complete immediately without interview
+⚠️ **IMPORTANT - Read this carefully**:
+- Execute ONLY ONE mode per command invocation
+- **DO NOT execute multiple modes** (e.g., do not run setting mode AND first-time setup in the same invocation)
+- Stop and exit immediately after completing the selected mode
+- **DO NOT jump to other workflows** unless that is the explicitly detected mode
+- **DO NOT guess** which mode the user wanted - always detect from their actual command
 
 ---
 
-### 1.2 Run project environment analysis (when user selects "New" or no backup)
-
-**Automatically analyzed items**:
-
-1. **Project Type Detection**
- Alfred classifies new vs existing projects by analyzing the directory structure:
- - Empty directory → New project
- - Code/documentation present → Existing project
+## 🔧 SETTINGS MODE: Modify Existing Project Configuration
 
-2. **Auto-detect language/framework**: Detects the main language of your project based on file patterns
-   - pyproject.toml, requirements.txt → Python
-   - package.json, tsconfig.json → TypeScript/Node.js
-   - pom.xml, build.gradle → Java
-   - go.mod → Go
-   - Cargo.toml → Rust
-- backend/ + frontend/ → full stack
+**When to execute**: `/alfred:0-project setting` OR user selected "Modify Settings" from auto-detect mode
 
-3. **Document status analysis**
- - Check the status of existing `.moai/project/*.md` files
- - Identify areas of insufficient information
- - Organize items that need supplementation
+### Step 1: Language-First Settings Context
+**IMPORTANT**: Always establish language context BEFORE any settings modifications.
 
-4. **Project structure evaluation**
- - Directory structure complexity
- - Monolingual vs. hybrid vs. microservice
- - Code base size estimation
+1. **Check `.moai/config.json`** for existing language settings
+2. **Language Confirmation** (in current language):
+   - If no config exists → **STOP** and redirect to INITIALIZATION MODE
+   - If config exists → Display current language and confirm
+3. **Set Settings Language Context**: ALL settings interactions in confirmed language
 
-### 1.3 Establish interview strategy (when user selects “New”)
-
-**Select question tree by project type**:
-
-| Project Type              | Question Category  | Focus Areas                                   |
-| ------------------------- | ------------------ | --------------------------------------------- |
-| **New Project**           | Product Discovery  | Mission, Users, Problems Solved               |
-| **Existing Project**      | Legacy Analysis    | Code Base, Technical Debt, Integration Points |
-| **TypeScript conversion** | Migration Strategy | TypeScript conversion for existing projects   |
-
-**Question Priority**:
-- **Essential Questions**: Core Business Value, Key User Bases (all projects)
-- **Technical Questions**: Language/Framework, Quality Policy, Deployment Strategy
-- **Governance**: Security Requirements, Traceability Strategy (Optional)
-
-### 1.4 Generate Interview Plan Report (when user selects “Create New”)
-
-**Format of plan to be presented to users**:
-
-```markdown
-## 📊 Project initialization plan: [PROJECT-NAME]
+### Step 2: Load and Display Current Configuration (in confirmed language)
+1. **Read `.moai/config.json`** to verify it exists and is valid JSON
+2. **Extract and display current settings** (in confirmed language):
+   ```
+   ✅ **언어**: [language.conversation_language_name]
+   ✅ **닉네임**: [user.nickname]
+   ✅ **에이전트 프롬프트 언어**: [language.agent_prompt_language]
+   ✅ **GitHub 자동 브랜치 삭제**: [github.auto_delete_branches]
+   ✅ **SPEC Git 워크플로우**: [github.spec_git_workflow]
+   ✅ **보고서 생성**: [report_generation.user_choice]
+   ✅ **선택된 도메인**: [stack.selected_domains]
+   ```
 
-### Environmental Analysis Results
-- **Project Type**: [New/Existing/Hybrid]
-- **Languages ​​Detected**: [Language List]
-- **Current Document Status**: [Completeness Rating 0-100%]
-- **Structure Complexity**: [Simple/Medium/Complex]
+### Step 3: Language Change Option (CRITICAL)
+**Before showing other settings, offer language change first** (in confirmed language):
 
-### 🎯 Interview strategy
-- **Question category**: Product Discovery / Structure / Tech
-- **Expected number of questions**: [N (M required + K optional)]
-- **Estimated time required**: [Time estimation]
-- **Priority area**: [Focus on Areas to be covered]
+1. **Language Priority Question**:
+   - "언어 설정을 변경하시겠습니까?" (in Korean)
+   - "Would you like to change language settings?" (in English)
+   - Options: "Change Language" | "Keep Current" | "Show All Settings"
 
-### ⚠️ Notes
-- **Existing document**: [Overwrite vs supplementation strategy]
-- **Language settings**: [Automatic detection vs manual setting]
-- **Configuration conflicts**: [Compatibility with existing config.json]
+2. **IF user selects "Change Language"**:
+   ```python
+   Skill("moai-project-language-initializer", mode="language_change_only")
+   ```
+   - Update language context
+   - Restart settings mode in new language
 
-### ✅ Expected deliverables
-- **product.md**: [Business requirements document]
-- **structure.md**: [System architecture document]
-- **tech.md**: [Technology stack and policy document]
-- **config.json**: [Project configuration file]
+3. **IF user selects "Keep Current" or "Show All Settings"**:
+   - Continue with current language context
+   - Proceed to Step 4
 
----
-**Approval Request**: Would you like to proceed with the interview using the above plan?
- (Choose “Proceed,” “Modify [Content],” or “Abort”)
+### Step 4: Use Config Manager Skill (Language-Aware)
+```python
+Skill("moai-project-config-manager", language=confirmed_language)
 ```
 
-### 1.5 Wait for user approval (moai-alfred-tui-survey) (when user selects "New")
-
-After Alfred receives the project-manager's interview plan report, calls `Skill("moai-alfred-tui-survey")` and asks whether Phase 2 is approved.
-- **Proceed**: Interview conducted according to approved plan
-- **Modify**: Re-establish the plan (re-execute Phase 1)
-- **Stop**: Stop initialization
-
-**Response processing**:
-- **"Progress"** (`answers["0"] === "Progress"`) → Execute Phase 2
-- **"Modify"** (`answers["0"] === "Modify"`) → Repeat Phase 1 (recall project-manager)
-- **"Abort"** (`answers["0"] === "Abort"`) → End task
+**Purpose**: Let the skill handle all configuration modification workflows with language context
+**The skill will** (in confirmed language):
+- Ask which settings to modify (using batched questions in confirmed language)
+- Collect new values using batched questions in confirmed language
+- Update config.json with proper merge strategy
+- Handle validation and error recovery with language-appropriate messages
+- Provide completion report in confirmed language
+
+### Step 5: Exit after completion (in confirmed language)
+1. **Print**: "✅ 설정 업데이트 완료!" (or equivalent in confirmed language)
+2. **Offer Next Steps** (in confirmed language):
+   - Option 1: "추가 설정 수정" → Continue settings mode
+   - Option 2: "프로젝트 문서 생성" → Guide to `/alfred:1-plan`
+   - Option 3: "종료" → End command
+3. **Do NOT proceed** to any other workflows
+4. **End command execution**
 
 ---
 
-## 🚀 STEP 2: Execute project initialization (after user approves “New”)
-
-**Note**: This step will only be executed if the user selects **"New"**.
-- When selecting "Merge": End the task in Phase 1.1 (Merge Backups)
-- When selecting "Skip": End the task
-- When selecting "New": Proceed with the process below
-
-After user approval, the project-manager agent performs initialization.
-
-### 2.1 Call project-manager agent (when user selects "New")
-
-Alfred starts project initialization by calling the project-manager agent with the following parameters:
-
-**Parameters passed to project-manager**:
-- **conversation_language** (from STEP 0): Language code selected by user (e.g., "ko", "en", "ja", "zh")
-- **language_name** (from STEP 0): Display name of selected language (e.g., "Korean", "English")
-- Detected Languages: [Language List from codebase detection]
-- Project Type: [New/Existing]
-- Existing Document Status: [Existence/Absence]
-- Approved Interview Plan: [Plan Summary]
-
-**Execution**:
-```bash
-# Pseudo-code showing parameter flow
-Task(
-    subagent_type="project-manager",
-    description="Initialize project with conversation language support",
-    prompt=f"""You are project-manager. Initialize project with these parameters:
-    - conversation_language: "{conversation_language}"  # e.g., "ko"
-    - language_name: "{language_name}"  # e.g., "Korean"
-    - project_type: "{project_type}"  # e.g., "new"
-    - detected_languages: {detected_languages}
-
-    All interviews and documentation must be generated in the conversation_language.
-    Update .moai/config.json with these language parameters.
-    """
-)
-```
-
-**Outcome**: The project-manager agent conducts structured interviews entirely in the selected language and creates/updates product/structure/tech.md documents in that language.
-
-### 2.2 Automatic activation of Alfred Skills (optional)
-
-After the project-manager has finished creating the document, **Alfred can optionally call Skills** (upon user request).
-
-**Automatic activation conditions** (optional):
-
-| Conditions                           | Automatic selection Skill    | Purpose                                |
-| ------------------------------------ | ---------------------------- | -------------------------------------- |
-| User Requests “Quality Verification” | moai-alfred-trust-validation | Initial project structure verification |
-
-**Execution flow** (optional):
-```
-1. project-manager completion
-    ↓
-2. User selection:
- - "Quality verification required" → moai-alfred-trust-validation (Level 1 quick scan)
- - "Skip" → Complete immediately
-```
-
-**Note**: Quality verification is optional during the project initialization phase.
-
-### 2.3 Sub-agent moai-alfred-tui-survey (Nested)
-
-**The project-manager agent can internally call the TUI survey skill** to check the details of the task.
-
-**When to call**:
-- Before overwriting existing project documents
-- When selecting language/framework
-- When changing important settings
-
-**Example** (inside project-manager): Ask whether to "overwrite file" with `Skill("moai-alfred-tui-survey")`,
-- Allows you to choose between **Overwrite** / **Merge** / **Skip**.
-
-**Nested pattern**:
-- **Command level** (Phase approval): Called by Alfred → "Shall we proceed with Phase 2?"
-- **Sub-agent level** (Detailed confirmation): Called by project-manager → "Shall we overwrite the file?"
-
-### 2.4 Processing method by project type
-
-#### A. New project (Greenfield)
-
-**Interview Flow**:
-
-1. **Product Discovery** (create product.md)
- - Define core mission (@DOC:MISSION-001)
- - Identify key user base (@SPEC:USER-001)
- - Identify key problems to solve (@SPEC:PROBLEM-001)
- - Summary of differences and strengths (@DOC:STRATEGY-001)
- - Setting success indicators (@SPEC:SUCCESS-001)
-
-2. **Structure Blueprint** (create structure.md)
- - Selection of architecture strategy (@DOC:ARCHITECTURE-001)
- - Division of responsibilities by module (@DOC:MODULES-001)
- - External system integration plan (@DOC:INTEGRATION-001)
- - Define traceability strategy (@DOC:TRACEABILITY-001)
-
-3. **Tech Stack Mapping** (written by tech.md)
- - Select language & runtime (@DOC:STACK-001)
- - Determine core framework (@DOC:FRAMEWORK-001)
- - Set quality gate (@DOC:QUALITY-001)
-   - Define security policy (@DOC:SECURITY-001)
- - Plan distribution channels (@DOC:DEPLOY-001)
-
-**Automatically generate config.json**:
-```json
-{
-  "project_name": "detected-name",
-  "project_type": "single|fullstack|microservice",
-  "project_language": "python|typescript|java|go|rust",
-  "test_framework": "pytest|vitest|junit|go test|cargo test",
-  "linter": "ruff|biome|eslint|golint|clippy",
-  "formatter": "black|biome|prettier|gofmt|rustfmt",
-  "coverage_target": 85,
-  "mode": "personal"
-}
-```
-
-#### B. Existing project (legacy introduction)
-
-**Legacy Snapshot & Alignment**:
-
-**STEP 1: Identify the overall project structure**
-
-Alfred identifies the entire project structure:
-- Visualize the directory structure using the tree or find commands
-- Exclude build artifacts such as node_modules, .git, dist, build, __pycache__, etc.
-- Identify key source directories and configuration files.
-
-**Output**:
-- Visualize the entire folder/file hierarchy of the project
-- Identify major directories (src/, tests/, docs/, config/, etc.)
-- Check language/framework hint files (package.json, pyproject.toml, go.mod, etc.)
-
-**STEP 2: Establish parallel analysis strategy**
-
-Alfred identifies groups of files by the Glob pattern:
-1. **Configuration files**: *.json, *.toml, *.yaml, *.yml, *.config.js
-2. **Source code files**: src/**/*.{ts,js,py,go,rs,java}
-3. **Test files**: tests/**/*.{ts,js,py,go,rs,java}, **/*.test.*, **/*.spec.*
-4. **Documentation files**: *.md, docs/**/*.md, README*, CHANGELOG*
-
-**Parallel Read Strategy**:
-- Speed ​​up analysis by reading multiple files simultaneously with the Read tool
-- Batch processing for each file group
-- Priority: Configuration file → Core source → Test → Document
-
-**STEP 3: Analysis and reporting of characteristics for each file**
-
-As each file is read, the following information is collected:
-
-1. **Configuration file analysis**
- - Project metadata (name, version, description)
- - Dependency list and versions
- - Build/test script
- - Confirm language/framework
-
-2. **Source code analysis**
- - Identify major modules and classes
- - Architectural pattern inference (MVC, clean architecture, microservice, etc.)
- - Identify external API calls and integration points
- - Key areas of domain logic
-
-3. **Test code analysis**
- - Check test framework
- - Identify coverage settings
- - Identify key test scenarios
- - Evaluate TDD compliance
-
-4. **Document analysis**
- - Existing README contents
- - Existence of architecture document
- - API document status
- - Installation/deployment guide completeness
-
-**Report Format**:
-```markdown
-## Analysis results for each file
-
-### Configuration file
-- package.json: Node.js 18+, TypeScript 5.x, Vitest test
-- tsconfig.json: strict mode, ESNext target
-- biome.json: Linter/formatter settings exist
-
-### Source code (src/)
-- src/core/: Core business logic (3 modules)
-- src/api/: REST API endpoints (5 routers)
-- src/utils/: Utility functions (logging, verification, etc.)
-- Architecture: Hierarchical (controller) → service → repository)
-
-### Tests (tests/)
-- Vitest + @testing-library used
-- Unit test coverage estimated at about 60%
-- E2E testing lacking
-
-### Documentation
-- README.md: Only installation guide
-- Absence of API documentation
-- Absence of architecture document
-```
+## 🔄 UPDATE MODE: Template Optimization After moai-adk Update
 
-**STEP 4: Comprehensive analysis and product/structure/tech reflection**
-
-Based on the collected information, it is reflected in three major documents:
-
-1. Contents reflected in **product.md**
- - Project mission extracted from existing README/document
- - Main user base and scenario inferred from code
- - Backtracking of core problem to be solved
- - Preservation of existing assets in “Legacy Context”
-
-2. Contents reflected in **structure.md**
- - Identified actual directory structure
- - Responsibility analysis results for each module
- - External system integration points (API calls, DB connections, etc.)
- - Technical debt items (marked with @CODE tag)
-
-3. **tech.md reflection content**
- - Languages/frameworks/libraries actually in use
- - Existing build/test pipeline
- - Status of quality gates (linter, formatter, test coverage)
- - Identification of security/distribution policy
- - Items requiring improvement (marked with TODO tags)
-
-**Preservation Policy**:
-- Supplement only the missing parts without overwriting existing documents
-- Preserve conflicting content in the “Legacy Context” section
-- Mark items needing improvement with @CODE and TODO tags
-
-**Example Final Report**:
-```markdown
-## Complete analysis of existing project
-
-### Environment Information
-- **Language**: TypeScript 5.x (Node.js 18+)
-- **Framework**: Express.js
-- **Test**: Vitest (coverage ~60%)
-- **Linter/Formatter**: Biome
-
-### Main findings
-1. **Strengths**:
- - High type safety (strict mode)
- - Clear module structure (separation of core/api/utils)
-
-2. **Needs improvement**:
- - Test coverage below 85% (TODO:TEST-COVERAGE-001)
- - Absence of API documentation (TODO:DOCS-API-001)
- - Insufficient E2E testing (@CODE:TEST-E2E-001)
-
-### Next step
-1. product/structure/tech.md creation completed
-2. @CODE/TODO item priority confirmation
-3. /alfred:Start writing an improvement SPEC with 1-spec
-```
-
-### 2.3 Document creation and verification
+**When to execute**: `/alfred:0-project update` OR user selected template optimization
 
-**Output**:
-- `.moai/project/product.md` (Business Requirements)
-- `.moai/project/structure.md` (System Architecture)
-- `.moai/project/tech.md` (Technology Stack and policy)
-- `.moai/config.json` (project settings)
+### Step 1: Language-First Update Context Detection
+**IMPORTANT**: Always establish language context BEFORE any update operations.
 
-**Quality Verification**:
-- [ ] Verify existence of all required @TAG sections
-- [ ] Verify compliance with EARS syntax format
-- [ ] Verify config.json syntax validity
-- [ ] Verify cross-document consistency
+1. **Check `.moai/config.json`** for existing language settings
+2. **Language Confirmation** (in current language):
+   - If no config exists → Run language selection FIRST
+   - If config exists → Confirm current language settings
+3. **Set Update Language Context**: ALL update interactions in confirmed language
 
-### 2.4 Completion Report
+### Step 2: Contextual Update Analysis
+**Analyze the update context** (in confirmed language):
 
-```markdown
-✅ Project initialization complete!
+1. **Update Type Detection**:
+   ```
+   🔍 **업데이트 유형 분석 중...**
+   ✅ **moai-adk 버전 변경 감지**: [version detection]
+   ✅ **백업 파일 발견**: [backup analysis]
+   ✅ **템플릿 변경 사항**: [template differences]
+   ```
 
-📁 Documents generated:
-- .moai/project/product.md (Business Definition)
-- .moai/project/structure.md (Architecture Design)
-- .moai/project/tech.md (Technology Stack)
-- .moai/config.json (project settings)
+2. **Backup Discovery**:
+   - Check `.moai-backups/` directory for existing backups
+   - Analyze backup versions and completeness
+   - Identify which backup to use for comparison
 
-🔍 Detected environments:
-- Language: [List of languages]
-- Frameworks: [List of frameworks]
-- Test tools: [List of tools]
+3. **Template Comparison**:
+   - Check template versions vs current project files
+   - Analyze what needs optimization
+   - Detect user customizations vs template defaults
 
-📋 Next steps:
-1. Review the generated document
-2. Create your first SPEC with /alfred:1-plan
-3. If necessary, readjust with /alfred:8-project update
+### Step 3: Use Template Optimizer Skill (Language-Aware)
+```python
+Skill("moai-project-template-optimizer", mode="update", language=confirmed_language)
 ```
 
-### 2.5: Initial structural verification (optional)
-
-After project initialization is complete, you can optionally run quality verification.
-
-**Execution Conditions**: Only when explicitly requested by the user.
-
-**Verification Purpose**:
-- Basic verification of project documentation and configuration files
-- Verification of compliance with the TRUST principles of the initial structure
-- Validation of configuration files
-
-**How ​​it works**:
-Alfred only calls the trust-checker agent to perform project initial structural verification if explicitly requested by the user.
-
-**Verification items**:
-- **Document completeness**: Check existence of required sections in product/structure/tech.md
-- **Settings validity**: Verify config.json JSON syntax and required fields
-- **TAG scheme**: Check compliance with @TAG format in document
-- **EARS syntax**: Validation of the EARS template to be used when writing SPECs
+**Purpose**: Let the skill handle template comparison and optimization with language context
+**The skill will** (in confirmed language):
+- Detect and analyze existing backups
+- Compare current templates with backup files
+- Perform smart merging to preserve user customizations
+- Update optimization flags in config.json
+- Generate completion report in confirmed language
 
-**Run Verification**: Level 1 quick scan (3-5 seconds)
-
-**Handling verification results**:
-
-✅ **Pass**: Can proceed to next step
-- Documents and settings are all normal
-
-⚠️ **Warning**: Proceed after warning
-- Some optional sections are missing
-- Recommendations not applied
-
-❌ **Critical**: Needs fix
-- Required section missing
-- config.json syntax error
-- User choice: “Revalidate after fix” or “Skip”
-
-**Skip verification**:
-- Verification is not run by default
-- Run only when explicitly requested by the user
-
-### 2.6: Agent & Skill Tailoring (Project Optimization)
-
-Based on the results of the interviews and initial analysis, we recommend and activate sub-agents and skills that should be immediately utilized in the project.
-Before actual application, user confirmation is received with `Skill("moai-alfred-tui-survey")`, and selected items are recorded in `CLAUDE.md` and `.moai/config.json`.
-
-#### 2.6.0 Create cc-manager briefing
-
-Once the document creation is complete, **read all three documents (product/structure/tech.md)** and summarize the following information to create a text called `cc_manager_briefing`.
-
-- `product.md`: Organize the mission, key users, problems to be solved, success indicators, and backlog (TODO) with a quotation from the original text or a one-line summary.
-- `structure.md`: Records architecture type, module boundaries and scope of responsibility, external integration, traceability strategy, and TODO contents.
-- `tech.md`: Organizes language/framework version, build/test/deployment procedures, quality/security policy, operation/monitoring method, and TODO items.
-
-Be sure to include the source (e.g. `product.md@SPEC:SUCCESS-001`) for each item so that cc-manager can understand the basis.
-
-#### 2.6.1 cc-manager judgment guide
-
-cc-manager selects the required sub-agents and skills based on the briefing.The table below is a reference guide to help you make a decision, and when making an actual call, the supporting sentences from the relevant document are also delivered.
-
-|Project requirements (document basis) |Recommended sub-agent/skill |Purpose |
-| -------------------------------- | ------------------------------------------------------------------------- | ------------------------------------------------ |
-|High quality and coverage goals (`product.md@SPEC:SUCCESS-001`) |`tdd-implementer`, `moai-essentials-debug`, `moai-essentials-review` |Establishment of RED·GREEN·REFACTOR workflow |
-|Traceability/TAG improvement request (`structure.md@DOC:TRACEABILITY-001`) |`doc-syncer`, `moai-alfred-tag-scanning`, `moai-alfred-trust-validation` |Enhanced TAG traceability and document/code synchronization |
-|Deployment automation/branch strategy required (`structure.md` Architecture/TODO) |`git-manager`, `moai-alfred-git-workflow`, `moai-foundation-git` |Branch Strategy·Commit Policy·PR Automation |
-|Refactoring legacy modules (`product.md` BACKLOG, `tech.md` TODO) |`implementation-planner`, `moai-alfred-refactoring-coach`, `moai-essentials-refactor` |Technical Debt Diagnosis and Refactoring Roadmap |
-|Strengthening regulatory/security compliance (`tech.md@DOC:SECURITY-001`) |`quality-gate`, `moai-alfred-trust-validation`, `moai-foundation-trust`, `moai-domain-security` |TRUST S (Secured) and Trackable Compliance, Security Consulting |
-|CLI Automation/Tooling Requirements (`tech.md` BUILD/CLI section) |`implementation-planner`, `moai-domain-cli-tool`, detected language skills (e.g. `moai-lang-python`) |CLI command design, input/output standardization |
-|Data analysis/reporting needs (`product.md` DATA, `tech.md` ANALYTICS) |`implementation-planner`, `moai-domain-data-science`, detected language skills |Data Pipeline·Notebook Job Definition |
-|Improved database structure (`structure.md` DB, `tech.md` STORAGE) |`doc-syncer`, `moai-domain-database`, `moai-alfred-tag-scanning` |Strengthening schema documentation and TAG-DB mapping |
-|DevOps/Infrastructure automation required (`tech.md` DEVOPS, `structure.md` CI/CD) |`implementation-planner`, `moai-domain-devops`, `moai-alfred-git-workflow` |Establishing a deployment pipeline and IaC strategy |
-|Introduction of ML/AI functions (`product.md` AI, `tech.md` MODEL) |`implementation-planner`, `moai-domain-ml`, detected language skills |Model training/inference pipeline definition |
-|Mobile app strategy (`product.md` MOBILE, `structure.md` CLIENT) |`implementation-planner`, `moai-domain-mobile-app`, detected language skills (e.g. `moai-lang-dart`, `moai-lang-swift`) |Mobile client structure design |
-|Strengthening coding standards/review process (`tech.md` REVIEW) |`quality-gate`, `moai-essentials-review`, `moai-alfred-code-reviewer` |Strengthening review checklist and quality reporting |
-|Requires onboarding/training mode (`tech.md` STACK description, etc.) |`moai-alfred-tui-survey`, `moai-adk-learning`, `agentic-coding` Output style |Enhanced interview TUI and automatically provided onboarding materials |
-
-> **Language/Domain Skill Selection Rules**
-> - Select and add one relevant language skill (`moai-lang-python`, `moai-lang-java`, …) based on the `moai-alfred-language-detection` results or the stack recorded in the Tech section of the briefing.
-> - Skills listed in the domain row are automatically included by cc-manager in the `selected_skills` list when the conditions are met.
-> - The skill directory is always copied in its entirety, and only actual activation is recorded in `skill_pack` and `CLAUDE.md`.
-
-If multiple conditions are met, the candidates are merged without duplicates and organized into sets of `candidate_agents`, `candidate_skills`, and `candidate_styles`.
-
-#### 2.6.2 User confirmation flow
-
-`Skill("moai-alfred-tui-survey")` asks “whether to enable recommended items.”
-- Provides three options: **Install all** / **Install selectively** / **Do not install**.
-Selecting “Selective Install” presents the list of candidates again as multiple choices, allowing the user to select only the items they need.
-
-#### 2.6.3 Activation and Recording Steps
-
-1. **Preparing briefing**: Organize the results of user selection (install all/install selectively) and the full text of `cc_manager_briefing`.
-2. **Call the cc-manager agent**:
-- Call `subagent_type: "cc-manager"` with the `Task` tool and include a briefing and user selections in the prompt.
-- cc-manager determines the necessary sub-agents and skills based on the briefing, and copies and updates `CLAUDE.md`, `.claude/agents/alfred/*.md`, and `.claude/skills/*.md` as customized for the project.
-3. **Check for configuration updates**: Review the results reflected by cc-manager.
-- Sub-Agents: Keep the `.claude/agents/alfred/` template active and list it in the `CLAUDE.md` “Agents” section.
-- Skills: Check the `.claude/skills/` document and add it to the `CLAUDE.md` “Skills” section.
-- Output style: Apply `.claude/output-styles/alfred/` and record the activation in `CLAUDE.md` “Output Styles”.
-4. **Update config.json**
-   ```json
-   {
-     "project": {
-       "optimized": true,
-       "agent_pack": ["tdd-implementer", "doc-syncer"],
-       "skill_pack": ["moai-alfred-git-workflow", "moai-alfred-tag-scanning"],
-       "output_styles": ["moai-adk-learning"]
-     }
-   }
+### Step 4: Update Confirmation and Completion (in confirmed language)
+1. **Display Update Results** (in confirmed language):
+   ```
+   ✅ **템플릿 최적화 완료!**
+   📊 **업데이트된 파일**: [number]개
+   🔧 **사용자 정의 유지**: [number]개
+   📝 **생성된 보고서**: [report location]
    ```
-Merge existing properties, if any.
-5. **Final Report**: Add a list of “Activated Sub-Agents/Skills/Style” and a `cc_manager_briefing` summary at the top of the Completion Report, and reflect the same contents in the `CLAUDE.md` table so that they are automatically searched in subsequent commands.
-
-## Interview guide by project type
-
-### New project interview area
-
-**Product Discovery** (product.md)
-- Core mission and value proposition 
- - Key user bases and needs 
- - 3 key problems to solve 
- - Differentiation compared to competing solutions 
- - Measurable indicators of success
-
-**Structure Blueprint** (structure.md)
-- System architecture strategy
-- Separation of modules and division of responsibilities
-- External system integration plan
-- @TAG-based traceability strategy
-
-**Tech Stack Mapping** (tech.md)
-- Language/runtime selection and version
-- Framework and libraries
-- Quality gate policy (coverage, linter)
-- Security policy and distribution channel
-
-### Existing project interview area
-
-**Legacy Analysis**
-- Identify current code structure and modules
-- Status of build/test pipeline
-- Identify technical debt and constraints
-- External integration and authentication methods
-- MoAI-ADK transition priority plan
-
-**Retention Policy**: Preserve existing documents in the "Legacy Context" section and mark items needing improvement with @CODE/TODO tags
-
-## 🏷️ TAG system application rules
-
-**Automatically create @TAGs per section**:
 
-- Mission/Vision → @DOC:MISSION-XXX, @DOC:STRATEGY-XXX
-- Customization → @SPEC:USER-XXX, @SPEC:PERSONA-XXX
-- Problem analysis → @SPEC:PROBLEM-XXX, @SPEC:SOLUTION-XXX
-- Architecture → @DOC:ARCHITECTURE-XXX, @SPEC:PATTERN-XXX
-- Technology Stack → @DOC:STACK-XXX, @DOC:FRAMEWORK-XXX
+2. **Ask for Next Steps** (in confirmed language):
+   - Option 1: "업데이트 내용 검토" → Show detailed changes
+   - Option 2: "설정 수정" → Go to settings mode
+   - Option 3: "종료" → End command
 
-**Legacy Project Tags**:
+3. **Exit after completion**
+4. **Do NOT proceed** to any other workflows
+5. **End command execution**
 
-- Technical debt → @CODE:REFACTOR-XXX, @CODE:TEST-XXX, @CODE:MIGRATION-XXX
-- Resolution plan → @CODE:MIGRATION-XXX, TODO:SPEC-BACKLOG-XXX
-- Quality improvement → TODO:TEST-COVERAGE-XXX, TODO:DOCS-SYNC-XXX
+---
 
-## Error handling
+## 🚀 INITIALIZATION MODE: First-time Project Setup
 
-### Common errors and solutions
+**When to execute**: `/alfred:0-project` with no existing config.json
 
-**Error 1**: Project language detection failed
-```
-Symptom: “Language not detected” message
-Solution: Specify language manually or create language-specific settings file
-```
+### Step 1: Language-First Initialization (CRITICAL)
+**IMPORTANT**: Language selection MUST happen BEFORE any other configuration.
 
-**Error 2**: Conflict with existing document
-```
-Symptom: product.md already exists and has different contents
-Solution: Preserve existing contents and add new contents in “Legacy Context” section
+1. **Display**: "🚀 Starting first-time project initialization..."
+2. **Immediate Language Selection**: Use Language Initializer Skill FIRST
+   ```python
+   Skill("moai-project-language-initializer", mode="language_first")
+   ```
+3. **Language Detection Strategy**:
+   - Check environment variables (LANG, locale)
+   - Detect from system settings
+   - Present language options immediately
+4. **Language Confirmation**: Display selected language and confirm
+5. **Set Language Context**: ALL subsequent interactions MUST use selected language
+
+### Step 2: Contextual Fresh Install Flow
+**After language selection, proceed with fresh install workflow**:
+
+```python
+Skill("moai-project-language-initializer", mode="fresh_install", language=selected_language)
 ```
 
-**Error 3**: Failed to create config.json
-```
-Symptom: JSON syntax error or permission denied
-Solution: Check file permissions (chmod 644) or create config.json manually
-```
+**Fresh Install Process**:
+1. **User Profile Collection** (in selected language):
+   - Nickname and user preferences
+   - Experience level and role
+   - Team vs personal mode selection
+
+2. **Project Analysis** (language-aware):
+   - Detect project type and codebase language
+   - Analyze existing structure (if any)
+   - Identify technology stack
+
+3. **Comprehensive Configuration** (in selected language):
+   - Team settings (if team mode)
+   - Domain selection
+   - Report generation preferences
+   - GitHub and Git workflow configuration
+
+4. **Create Initial Configuration**:
+   - Generate complete `.moai/config.json`
+   - Validate all settings
+   - Set up language-specific configurations
+
+### Step 3: Project Documentation Creation (Language-Aware)
+1. **Invoke**: `Task` with `project-manager` agent
+2. **Pass Language Context**: Ensure all documentation in selected language
+3. **Parameters**: Language, user preferences, project context
+4. **The agent will**:
+   - Conduct environmental analysis
+   - Create interview strategy in selected language
+   - Generate project documentation in selected language
+
+### Step 4: Completion and Next Steps (in selected language)
+1. **Print**: "✅ 프로젝트 초기화가 완료되었습니다!" (or equivalent in selected language)
+2. **Ask user what to do next** using AskUserQuestion (in selected language):
+   - Option 1: "사양서 작성" → Guide to `/alfred:1-plan`
+   - Option 2: "프로젝트 구조 검토" → Show current state
+   - Option 3: "새 세션 시작" → Guide to `/clear`
+3. **End command execution**
 
 ---
 
-## /alfred:0-project update: Template optimization (subcommand)
-
-> **Purpose**: After running moai-adk update, compare the backup and new template to optimize the template while preserving user customization.
-
-### Execution conditions
-
-This subcommand is executed under the following conditions:
-
-1. **After executing moai-adk update**: `optimized=false` status in `config.json`
-2. **Template update required**: When there is a difference between the backup and the new template
-3. **User explicit request**: User directly executes `/alfred:0-project update`
+## 🔍 AUTO-DETECT MODE: Handle Already Initialized Projects
 
-### Execution flow
+**When to execute**: `/alfred:0-project` with existing config.json
 
-#### Phase 1: Backup analysis and comparison
+### Step 1: Language-First Context Detection
+**IMPORTANT**: Always confirm/establish language context FIRST.
 
-1. **Make sure you have the latest backup**:
-   ```bash
-# Browse the latest backups in the .moai-backups/ directory
-   ls -lt .moai-backups/ | head -1
+1. **Read `.moai/config.json`** to get current language settings
+2. **Display Language Confirmation** (in current language):
    ```
-
-2. **Change Analysis**:
- - Compare `.claude/` directory from backup with current template
- - Compare `.moai/project/` document from backup with current document
- - Identify user customization items
-
-3. **Create Comparison Report**:
-   ```markdown
-## 📊 Template optimization analysis
-
-### Changed items
- - CLAUDE.md: "## Project Information" section needs to be preserved
- - settings.json: 3 env variables need to be preserved
- - product.md: Has user-written content
-
-### Recommended Action
- - Run Smart Merge
- - Preserve User Customizations
- - Set optimized=true
+   ✅ **현재 언어 설정**: [language.conversation_language_name]
+   ✅ **대화 언어**: [language.conversation_language]
    ```
-
-4. **Waiting for user approval**  
-`Skill("moai-alfred-tui-survey")` asks “Do you want to proceed with template optimization?” and provides the following options.
-- **Proceed** → Phase 2 execution
-- **Preview** → Display change details and recheck
-- **Skip** → keep optimized=false
-
-#### Phase 2: Run smart merge (after user approval)
-
-1. **Execute smart merge logic**:
- - Run `TemplateProcessor.copy_templates()`
- - CLAUDE.md: Preserve "## Project Information" section
- - settings.json: env variables and permissions.allow merge
-
-2. Set **optimized=true**:
+3. **Language Confirmation Question** (in current language):
+   - "현재 언어 설정을 계속 사용하시겠습니까?" (in Korean)
+   - "Continue using current language settings?" (in English)
+   - Options: "Continue" | "Change Language" | "Show Current Settings"
+
+### Step 2: Language Context Handling
+**IF user selects "Change Language"**:
+1. **Immediate Language Selection**:
    ```python
-   # update config.json
-   config_data["project"]["optimized"] = True
+   Skill("moai-project-language-initializer", mode="language_change_only")
    ```
+2. **Update Language Context**: Switch ALL subsequent interactions to new language
+3. **Update Configuration**: Save new language settings
+4. **Continue with new language context**
 
-3. **Optimization completion report**:
-   ```markdown
-✅ Template optimization completed!
+**IF user selects "Continue" or "Show Current Settings"**:
+1. **Maintain Current Language Context**
+2. **Proceed to Step 3** with confirmed language
 
-📄 Merged files:
- - CLAUDE.md (preserves project information)
- - settings.json (preserves env variables)
-
-⚙️ config.json: optimized=true Configuration complete
+### Step 3: Display Current Configuration (in confirmed language)
+1. **Read `.moai/config.json`** to get all current settings
+2. **Display current project status** (in confirmed language):
+   ```
+   ✅ **언어**: [language.conversation_language_name]
+   ✅ **닉네임**: [user.nickname]
+   ✅ **에이전트 프롬프트 언어**: [language.agent_prompt_language]
+   ✅ **GitHub 자동 브랜치 삭제**: [github.auto_delete_branches]
+   ✅ **SPEC Git 워크플로우**: [github.spec_git_workflow]
+   ✅ **보고서 생성**: [report_generation.user_choice]
+   ✅ **선택된 도메인**: [stack.selected_domains]
    ```
 
-### Alfred Automation Strategy
-
-**Alfred automatic decision**:
-- Automatically call project-manager agent
-- Check backup freshness (within 24 hours)
-- Automatically analyze changes
-
-**Auto-activation of Skills**:
-- moai-alfred-tag-scanning: TAG chain verification
-- moai-alfred-trust-validation: Verification of compliance with TRUST principles
-
-### Running example
-
-```bash
-# After running moai-adk update
-moai-adk update
-
-# Output:
-# ✓ Update complete!
-# ℹ️  Next step: Run /alfred:0-project update to optimize template changes
-
-# Run Alfred
-/alfred:0-project update
-
-# → Phase 1: Generate backup analysis and comparison report
-# → Wait for user approval
-# → Phase 2: Run smart merge, set optimized=true
-```
-
-### caution
-
-- **Backup required**: Cannot run without backup in `.moai-backups/` directory
-- **Manual review recommended**: Preview is required if there are important customizations
-- **Conflict resolution**: Request user selection in case of merge conflict
-
----
-
-## 🚀 STEP 3: Project Custom Optimization (Optional)
-
-**Execution conditions**:
-- After completion of Phase 2 (project initialization)
-- or after completion of Phase 1.1 (backup merge)
-- Explicitly requested by the user or automatically determined by Alfred
-
-**Purpose**: Lightweight by selecting only Commands, Agents, and Skills that fit the project characteristics (37 skills → 3~5)
-
-### 3.1 Automatic execution of Feature Selection
-
-**Alfred automatically calls the moai-alfred-feature-selector skill**:
+### Step 4: Ask what user wants to do (in confirmed language)
+**Present these 4 options** to the user (in confirmed language):
 
-**Skill Entry**:
-- `.moai/project/product.md` (project category hint)
-- `.moai/project/tech.md` (main language, framework)
-- `.moai/config.json` (project settings)
+1. **"🔧 설정 수정"** - Change language, nickname, GitHub settings, or reports config
+2. **"📋 현재 설정 검토"** - Display full current project configuration
+3. **"🔄 다시 초기화"** - Run full initialization again (with warning)
+4. **"⏸️ 취소"** - Exit without making any changes
 
-**Skill Output**:
-```json
-{
-  "category": "web-api",
-  "language": "python",
-  "framework": "fastapi",
-  "commands": ["1-spec", "2-build", "3-sync"],
-  "agents": ["spec-builder", "code-builder", "doc-syncer", "git-manager", "debug-helper"],
-  "skills": ["moai-lang-python", "moai-domain-web-api", "moai-domain-backend"],
-  "excluded_skills_count": 34,
-  "optimization_rate": "87%"
-}
-```
+### Step 6: Handle user selection
 
-**How ​​to Run**:
-```
-Alfred: Skill("moai-alfred-feature-selector")
-```
+**IF user selected: "🔧 Modify Settings"**:
+1. Print: "🔧 Entering Settings Mode..."
+2. **Jump to SETTINGS MODE** above
+3. Let SETTINGS MODE handle the rest
+4. Stop after SETTINGS MODE completes
 
----
+**ELSE IF user selected: "📋 Review Current Setup"**:
+1. Print this header: `## Current Project Configuration`
+2. Show all current settings (from config.json)
+3. Print: "✅ Configuration review complete."
+4. Exit (stop the command)
 
-### 3.2 Automatic execution of Template Generation
-
-**Alfred automatically calls the moai-alfred-template-generator skill**:
-
-**Skill input**:
-- `.moai/.feature-selection.json` (feature-selector output)
-- `CLAUDE.md` template
-- Entire commands/agents/skills file
+**ELSE IF user selected: "🔄 Re-initialize"**:
+1. Print this warning:
+   ```
+   ⚠️ WARNING: This will re-run the full project initialization
 
-**Skill Output**:
-- `CLAUDE.md` (custom agent table - selected agents only)
-- `.claude/commands/` (selected commands only)
-- `.claude/agents/` (selected agents only)
-- `.claude/skills/` (selected skills only)
-- `.moai/config.json` (updates `optimized: true`)
+   Your existing files will be preserved in:
+   - Backup: .moai-backups/[TIMESTAMP]/
+   - Current: .moai/project/*.md (will be UPDATED)
+   ```
+2. **Ask the user**: "Are you sure you want to continue? Type 'yes' to confirm or anything else to cancel"
+3. **IF user typed 'yes'**:
+   - Print: "🔄 Starting full re-initialization..."
+   - **Jump to INITIALIZATION MODE** above
+   - Let INITIALIZATION MODE handle the rest
+4. **ELSE** (user typed anything else):
+   - Print: "✅ Re-initialization cancelled."
+   - Exit (stop the command)
+
+**ELSE IF user selected: "⏸️ Cancel"**:
+1. Print:
+   ```
+   ✅ Exiting without changes.
 
-**How ​​to Run**:
-```
-Alfred: Skill("moai-alfred-template-generator")
-```
+   Your project remains initialized with current settings.
+   To modify settings later, run: /alfred:0-project setting
+   ```
+2. Exit immediately (stop the command)
 
 ---
 
-### 3.3 Optimization completion report
-
-**Report Format**:
-```markdown
-✅ Project customized optimization completed!
-
-📊 Optimization results:
-- **Project**: {{PROJECT_NAME}}
-- **Category**: web-api
-- **Main language**: python
-- **Framework**: fastapi
-
-🎯 Selected capabilities:
-- Commands: 4 items (0-project, 1-spec, 2-build, 3-sync)
-- Agents: 5 items (spec-builder, code-builder, doc-syncer, git-manager, debug-helper)
-- Skills: 3 items (moai-lang-python, moai-domain-web-api, moai-domain-backend)
-
-💡 Lightweight effect:
-- Skills excluded: 34
-- Lightweight: 87%
-- CLAUDE.md: Create custom agent table
-
-📋 Next steps:
-1. Check the CLAUDE.md file (only 5 agents are displayed)
-2. Run /alfred:1-plan "first function"
-3. Start the MoAI-ADK workflow
+## 📊 Command Completion Pattern
+
+**CRITICAL**: When any Alfred command completes, **ALWAYS use `AskUserQuestion` tool** to ask the user what to do next.
+
+### Implementation Example
+```python
+AskUserQuestion(
+    questions=[
+        {
+            "question": "Project initialization is complete. What would you like to do next?",
+            "header": "Next Step",
+            "options": [
+                {"label": "Write Specifications", "description": "Run /alfred:1-plan to define requirements"},
+                {"label": "Review Project Structure", "description": "Check current project state"},
+                {"label": "Start New Session", "description": "Run /clear to start fresh"}
+            ]
+        }
+    ]
+)
 ```
 
----
-
-### 3.4 Skip Phase 3 (optional)
-
-**Users can skip Phase 3**:
-
-**Skip condition**:
-- User explicitly selects “Skip”
-- “Simple project” when Alfred automatically determines (only basic features required)
-
-**Skip effect**:
-- Maintain all 37 skills (no lightweighting)
-- Maintain default 9 agents in CLAUDE.md template
-- Maintain `optimized: false` in config.json
+**Rules**:
+1. **NO EMOJIS** in JSON fields (causes API errors)
+2. **Always use AskUserQuestion** - Never suggest next steps in prose
+3. **Provide 3-4 clear options** - Not open-ended
+4. **Language**: Present options in user's `conversation_language`
 
 ---
 
-## Next steps
-
-**Recommendation**: For better performance and context management, start a new chat session with the `/clear` or `/new` command before proceeding to the next step.
-
-After initialization is complete:
-
-- **New project**: Run `/alfred:1-plan` to create design-based SPEC backlog
-- **Legacy project**: Review @CODE/@CODE/TODO items in product/structure/tech document and confirm priority
-- **Set Change**: Run `/alfred:0-project` again to update document
-- **Template optimization**: Run `/alfred:0-project update` after `moai-adk update`
-
-## Related commands
-
-- `/alfred:1-plan` - Start writing SPEC
-- `/alfred:9-update` - MoAI-ADK update
-- `moai doctor` - System diagnosis
-- `moai status` - Check project status
+## 🎯 Key Improvements Achieved
+
+### ✅ Language-First Architecture
+- **Core Principle**: Language selection ALWAYS happens before any other configuration
+- **Context Persistence**: Once selected, ALL subsequent interactions use that language
+- **Flow Adaptation**: Each flow (fresh install/update/settings) adapts based on language context
+- **Improvement**: Eliminates language confusion and ensures consistent user experience
+
+### ✅ Contextual Flow Differentiation
+- **Fresh Install**: Language selection → Installation questionnaire → Setup completion
+- **Update Mode**: Language confirmation → Update/merge options → Optimization
+- **Existing Project**: Language confirmation → Settings options or re-initialization
+- **Improvement**: Clear separation between installation types with appropriate workflows
+
+### ✅ Modular Architecture
+- **Original**: 3,647 lines in single monolithic file
+- **Optimized**: ~600 lines main router + 4 specialized skills
+- **Improvement**: 83% size reduction in main file with enhanced functionality
+
+### ✅ Skills-Based Delegation
+- **Language Initializer**: Handles language-first project setup workflows
+- **Config Manager**: Manages all configuration operations with language context
+- **Template Optimizer**: Handles template comparison and optimization
+- **Batch Questions**: Standardizes user interaction patterns with language support
+
+### ✅ Enhanced User Experience
+- **Language-First Interactions**: All user-facing content respects language selection
+- **Contextual Workflows**: Each flow type provides appropriate options and guidance
+- **Faster Execution**: Skills optimized for specific tasks with language awareness
+- **Better Error Handling**: Specialized error recovery with language-appropriate messages