moai-adk 0.9.0__py3-none-any.whl → 0.15.1__py3-none-any.whl

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

@@ -1,25 +1,22 @@
 ---
 name: alfred:0-project
-description: "Initialize project document - create product/structure/tech.md and set optimization for each language"
-# Translations:
-# - ko: "프로젝트 문서 초기화 - product/structure/tech.md 생성 및 언어별 최적화 설정"
-# - ja: "プロジェクト文書の初期化 - product/structure/tech.mdの作成と言語別最適化設定"
-# - zh: "初始化项目文档 - 创建product/structure/tech.md并设置语言优化"
+description: "Initialize project metadata and documentation"
 allowed-tools:
-- Read
-- Write
-- Edit
-- MultiEdit
-- Grep
-- Glob
-- TodoWrite
-- Bash(ls:*)
-- Bash(find:*)
-- Bash(cat:*)
-- Task
+  - Read
+  - Write
+  - Edit
+  - MultiEdit
+  - Grep
+  - Glob
+  - TodoWrite
+  - Bash(ls:*)
+  - Bash(find:*)
+  - Bash(cat:*)
+  - Task
 ---
 
 # 📋 MoAI-ADK Step 0: Initialize/Update Universal Language Support Project Documentation
+
 > **Note**: Interactive prompts use `AskUserQuestion tool (documented in moai-alfred-interactive-questions skill)` for TUI selection menus. The skill is loaded on-demand when user interaction is required.
 
 ## 🎯 Command Purpose
@@ -52,7 +49,7 @@ Automatically analyzes the project environment to create/update product/structur
 
 ## 💡 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
 
@@ -65,9 +62,10 @@ It is a systematic initialization system that analyzes the project environment a
 
 ## 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
@@ -79,7 +77,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**:
@@ -96,6 +94,8 @@ The user executes the `/alfred:8-project` command to start analyzing the project
 
 **목적**: 프로젝트 초기화 시작 전에 대화 언어를 설정하고 사용자 닉네임을 등록합니다. 이 설정은 모든 Alfred 프롬프트, 인터뷰 질문 및 생성된 문서에 적용됩니다.
 
+**UX 개선**: 2개 질문을 **1회 배치 호출**로 통합 (50% 상호작용 감소: 2 turns → 1 turn)
+
 ### 0.0 Alfred 자기소개 및 환영 인사
 
 Alfred가 첫 상호작용으로 다음과 같이 인사합니다:
@@ -108,100 +108,404 @@ MoAI-ADK의 SuperAgent로서 당신의 프로젝트를 함께 만들어갈 준
 먼저 기본 설정을 진행하겠습니다.
 ```
 
-### 0.1 언어 선택
+### 0.1 배치 설계: 언어 선택 + 사용자 닉네임 + GitHub 설정 확인 (1-3회 호출)
+
+Alfred가 `AskUserQuestion tool (documented in moai-alfred-interactive-questions skill)` 를 사용하여 **배치 호출**로 필수 정보를 수집합니다:
+
+**기본 배치 (항상 실행)**:
+
+- 언어 선택
+- 사용자 닉네임
+
+**추가 배치 (팀 모드 감지 시)**:
+
+- GitHub "Automatically delete head branches" 설정 확인
+
+#### 0.1.1 팀 모드 감지
+
+```bash
+# config.json에서 mode 확인
+grep "mode" .moai/config.json
+
+# 결과: "mode": "team" → 추가 질문 포함
+#      "mode": "personal" → 기본 질문만 실행
+```
+
+#### 0.1.2 기본 배치: 언어 선택 + 에이전트 프롬프트 언어 + 닉네임 (3개 질문, 1회 배치 호출)
+
+**배치 설계**: 3개 질문을 1회 호출로 통합 (UX 개선: 3 turns → 1 turn)
+
+**Example AskUserQuestion Call**:
+
+```python
+AskUserQuestion(
+    questions=[
+        {
+            "question": "Which language would you like to use for the project initialization and documentation?",
+            "header": "Language",
+            "multiSelect": false,
+            "options": [
+                {
+                    "label": "🌍 English",
+                    "description": "All dialogs and documentation in English"
+                },
+                {
+                    "label": "🇰🇷 한국어",
+                    "description": "All dialogs and documentation in Korean"
+                },
+                {
+                    "label": "🇯🇵 日本語",
+                    "description": "All dialogs and documentation in Japanese"
+                },
+                {
+                    "label": "🇨🇳 中文",
+                    "description": "All dialogs and documentation in Chinese"
+                }
+            ]
+        },
+        {
+            "question": "In which language should Alfred's sub-agent prompts be written?",
+            "header": "Agent Prompt Language",
+            "multiSelect": false,
+            "options": [
+                {
+                    "label": "🌐 English (Global Standard)",
+                    "description": "All sub-agent prompts in English for global consistency and team collaboration. Recommended for Claude Pro $20 users: reduces token usage by ~15-20%, lowering API costs"
+                },
+                {
+                    "label": "🗣️ Selected Language (Localized)",
+                    "description": "All sub-agent prompts in the language you selected above for local team efficiency"
+                }
+            ]
+        },
+        {
+            "question": "How would you like to be called in our conversations? (e.g., GOOS, Team Lead, Developer, or custom name - max 20 chars)",
+            "header": "Nickname",
+            "multiSelect": false,
+            "options": [
+                {
+                    "label": "Enter custom nickname",
+                    "description": "Type your preferred name using the 'Other' option below"
+                }
+            ]
+        }
+    ]
+)
+```
+
+**응답 처리**:
+
+**Q1 (사용자 언어)**:
+
+- Selected option stored as: `conversation_language: "ko"` (or "en", "ja", "zh", etc.)
+
+**Q2 (에이전트 프롬프트 언어)** - **NEW**:
+
+- **"English (Global Standard)"** → `agent_prompt_language: "english"`
+  - All sub-agent prompts written in English
+  - Recommended for global teams, code consistency, and international collaboration
+  - Project-manager, spec-builder, code-builder use English prompts internally
+- **"Selected Language (Localized)"** → `agent_prompt_language: "localized"`
+  - All sub-agent prompts written in the user-selected language
+  - Recommended for local teams, local documentation, and native language efficiency
+  - Project-manager receives prompts in selected language (e.g., Korean, Japanese)
+
+**Q3 (사용자 닉네임)**:
+
+- Custom nickname stored as: `user.nickname: "GOOS"` (or custom input)
+
+#### 0.1.3 팀 모드 추가 배치: GitHub 설정 & Git 워크플로우 선택 (팀 모드만)
+
+**조건**: `config.json`에서 `"mode": "team"` 감지 시 실행
+
+**배치 구성**: 2개 질문 (1회 호출로 통합)
+
+**Example AskUserQuestion Call**:
+
+```python
+AskUserQuestion(
+    questions=[
+        {
+            "question": "[Team Mode] Is 'Automatically delete head branches' enabled in your GitHub repository settings?",
+            "header": "GitHub Branch Settings",
+            "multiSelect": false,
+            "options": [
+                {
+                    "label": "✅ Yes, already enabled",
+                    "description": "PR merge 후 자동으로 원격 브랜치 삭제됨"
+                },
+                {
+                    "label": "❌ No, not enabled (Recommended: Enable)",
+                    "description": "Settings → General → '자동 삭제' 체크박스 확인 필요"
+                },
+                {
+                    "label": "🤔 Not sure / Need to check",
+                    "description": "GitHub Settings → General 확인 후 다시 진행"
+                }
+            ]
+        },
+        {
+            "question": "[Team Mode] Which Git workflow should we use when creating SPEC documents?",
+            "header": "SPEC Git Workflow",
+            "multiSelect": false,
+            "options": [
+                {
+                    "label": "📋 Feature Branch + PR",
+                    "description": "매 SPEC마다 feature 브랜치 생성 → PR 리뷰 → develop 병합. 팀 협업과 코드 리뷰에 최적"
+                },
+                {
+                    "label": "🔄 Direct Commit to Develop",
+                    "description": "브랜치 생성 없이 develop에 직접 커밋. 빠른 프로토타이핑과 단순 워크플로우에 최적"
+                },
+                {
+                    "label": "🤔 Decide per SPEC",
+                    "description": "SPEC 생성 시마다 매번 선택. 유연성이 높지만 매번 결정 필요"
+                }
+            ]
+        }
+    ]
+)
+```
+
+**응답 처리**:
+
+**Q1 (GitHub 설정)**:
+
+- **"Yes, already enabled"** → `auto_delete_branches: true` 저장
+- **"No, not enabled"** → `auto_delete_branches: false` + 권장사항 저장
+- **"Not sure"** → `auto_delete_branches: null` + 경고 메시지
+
+**Q2 (Git 워크플로우)**:
 
-Alfred가 `AskUserQuestion tool (documented in moai-alfred-interactive-questions skill)` 를 사용하여 **첫 번째 상호작용**으로 언어 선택 메뉴를 표시합니다:
+- **"Feature Branch + PR"** → `spec_git_workflow: "feature_branch"` 저장
+  - `/alfred:1-plan` 실행 시 자동으로 feature 브랜치 생성
+  - git-manager가 PR 기반 워크플로우 적용
+- **"Direct Commit to Develop"** → `spec_git_workflow: "develop_direct"` 저장
+  - `/alfred:1-plan` 실행 시 develop 브랜치에 직접 커밋
+  - 브랜치 생성 과정 생략
+- **"Decide per SPEC"** → `spec_git_workflow: "per_spec"` 저장
+  - `/alfred:1-plan` 실행 시마다 git-manager가 사용자에게 선택 요청
+
+**User Response Example**:
 
-**Question**:
 ```
-Which language would you like to use for the project initialization and documentation?
+Selected Language: 🇰🇷 한국어
+Selected Nickname: GOOS (typed via "Other" option)
 ```
 
-**Options** (AskUserQuestion with moai-alfred-interactive-questions):
-- **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.1.4 Domain Selection (Optional - All Modes)
+
+**Purpose**: Identify project domains to activate domain-expert agents for specialized guidance.
+
+**When to ask**: After language/nickname/GitHub settings complete
+
+**Batched Design**: Domain selection integrated into initial batch OR asked separately based on user preference
+
+**Example AskUserQuestion Call**:
+
+```python
+AskUserQuestion(
+    questions=[
+        {
+            "question": "Which domains does your project involve? (Select all that apply)",
+            "header": "Project Domains",
+            "multiSelect": true,
+            "options": [
+                {
+                    "label": "🎨 Frontend",
+                    "description": "React, Vue, Angular, Next.js, Nuxt, SvelteKit, Astro, Remix, SolidJS"
+                },
+                {
+                    "label": "⚙️ Backend",
+                    "description": "FastAPI, Flask, Django, Express, Fastify, NestJS, Spring Boot, Gin, Axum"
+                },
+                {
+                    "label": "🚀 DevOps",
+                    "description": "Railway, Vercel, Docker, Kubernetes, AWS, GCP, Azure, CI/CD"
+                },
+                {
+                    "label": "🗄️ Database",
+                    "description": "PostgreSQL, MySQL, MongoDB, Redis, database design and optimization"
+                },
+                {
+                    "label": "📊 Data Science",
+                    "description": "Data analysis, machine learning, data pipelines, notebooks"
+                },
+                {
+                    "label": "📱 Mobile",
+                    "description": "React Native, Flutter, iOS, Android app development"
+                },
+                {
+                    "label": "⚡ Skip",
+                    "description": "No domain selection (can add later via /alfred:1-plan)"
+                }
+            ]
+        }
+    ]
+)
+```
+
+**Response Processing**:
+
+When user selects domains, Alfred processes the response as follows:
+
+**Selected Domain Processing** (`answers["0"]` contains selected domain labels):
 
-### 0.2 Store Language Preference
+- Extract selected domain codes from labels: "Frontend" → "frontend", "Backend" → "backend", etc.
+- Store selected domains in `.moai/config.json`:
+  ```json
+  {
+    "stack": {
+      "selected_domains": ["frontend", "backend"],
+      "domain_selection_date": "2025-10-23T12:34:56Z"
+    }
+  }
+  ```
+
+**Skip Domain Selection** (if user selects "⚡ Skip"):
+
+- Store in config.json:
+  ```json
+  {
+    "stack": {
+      "selected_domains": [],
+      "domain_selection_skipped": true,
+      "domain_selection_date": "2025-10-23T12:34:56Z"
+    }
+  }
+  ```
+- Display: "✅ Domain selection skipped. You can add domains later during `/alfred:1-plan`"
+
+**Domain Expert Activation**:
+
+- Selected domains stored in `.moai/config.json`
+- Domain-expert agents activated during `/alfred:1-plan` (automatic keyword detection)
+- Domain-expert agents available as advisors during `/alfred:2-run`
+- Domain-specific sync routing enabled in `/alfred:3-sync`
+- If domains skipped: Default agent lineup used (can be customized later in `/alfred:1-plan`)
+
+---
+
+### 0.2 사용자 정보 저장
 
-Alfred records the selected language:
+Alfred가 선택된 언어, 닉네임, 그리고 팀 모드 설정을 다음과 같이 저장합니다:
+
+#### 0.2.1 기본 정보 저장 (항상) - 에이전트 프롬프트 언어 추가
 
 ```json
 {
-  "conversation_language": "ko",
-  "conversation_language_name": "한국어",
-  "selected_at": "2025-10-22T12:34:56Z"
+  "language": {
+    "conversation_language": "ko",
+    "conversation_language_name": "한국어",
+    "agent_prompt_language": "localized",
+    "agent_prompt_language_description": "All sub-agent prompts written in the selected language (localized)"
+  },
+  "user": {
+    "nickname": "GOOS",
+    "selected_at": "2025-10-23T12:34:56Z"
+  },
+  "stack": {
+    "selected_domains": ["frontend", "backend"],
+    "domain_selection_date": "2025-10-23T12: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.2.5 사용자 닉네임 선택
+- **`"english"`** (Global Standard) - **💰 Claude Pro $20 사용자 추천**:
 
-언어 선택 완료 후, Alfred가 `AskUserQuestion tool (documented in moai-alfred-interactive-questions skill)` 를 사용하여 사용자 닉네임을 요청합니다:
+  - All sub-agent prompts and internal communication in English
+  - Best for: International teams, global collaboration, code consistency
+  - Impact: Project-manager, spec-builder, code-builder all use English task prompts
+  - **Cost Benefit**: Reduces token usage by ~15-20% compared to non-English prompts
+    - English prompts are more efficient and use fewer tokens
+    - Significant cost savings for continuous API usage
+    - Example: 100,000 tokens in English ≈ 115,000-120,000 tokens in Korean/Japanese
 
-**질문**:
-```
-앞으로 대화에서 당신을 어떻게 부르면 좋을까요?
-(예: GOOS, 팀장님, 개발자님, 또는 자유롭게 입력)
+- **`"localized"`** (Localized - Default for non-English):
+  - All sub-agent prompts and internal communication in selected language
+  - Best for: Local teams, native language efficiency, culturally-specific guidance
+  - Impact: Project-manager, spec-builder, code-builder all use localized task prompts
+  - Note: Uses ~15-20% more tokens due to language characteristics
+
+#### 0.2.2 GitHub & Git 워크플로우 설정 저장 (팀 모드만)
+
+**팀 모드 감지 시 추가 저장 - Feature Branch + PR 선택 시**:
+
+```json
+{
+  "github": {
+    "auto_delete_branches": true,
+    "spec_git_workflow": "feature_branch",
+    "checked_at": "2025-10-23T12:34:56Z",
+    "workflow_recommendation": "Feature branch를 사용한 PR 기반 협업 워크플로우. 매 SPEC마다 feature/spec-* 브랜치 생성, PR 리뷰 후 develop 병합"
+  }
+}
 ```
 
-**입력 방식**:
-- 텍스트 직접 입력 가능 (자유 형식)
-- 예시: "GOOS", "팀장", "개발자" 등
-- 최대 20자 한도
+**또는 - Direct Commit to Develop 선택 시**:
 
-### 0.2.6 사용자 정보 저장
+```json
+{
+  "github": {
+    "auto_delete_branches": false,
+    "spec_git_workflow": "develop_direct",
+    "checked_at": "2025-10-23T12:34:56Z",
+    "workflow_recommendation": "develop 브랜치에 직접 커밋하는 단순 워크플로우. 브랜치 생성 과정 생략, 빠른 개발 속도"
+  }
+}
+```
 
-Alfred가 선택된 닉네임을 다음과 같이 저장합니다:
+**또는 - Decide per SPEC 선택 시**:
 
 ```json
 {
-  "conversation_language": "ko",
-  "conversation_language_name": "한국어",
-  "user_nickname": "GOOS",
-  "selected_at": "2025-10-23T12:34:56Z"
+  "github": {
+    "auto_delete_branches": true,
+    "spec_git_workflow": "per_spec",
+    "checked_at": "2025-10-23T12:34:56Z",
+    "workflow_recommendation": "SPEC 생성 시마다 워크플로우 선택. /alfred:1-plan 실행 시 git-manager가 선택 요청"
+  }
 }
 ```
 
+#### 0.2.3 저장된 정보 활용
+
 이 정보는:
+
 - 모든 sub-agents 에게 컨텍스트 파라미터로 전달됨
-- `.moai/config.json` 의 `user` 필드에 저장됨
-- CLAUDE.md의 `{{USER_NICKNAME}}` 변수로 치환됨
+- `.moai/config.json` 의 `language`, `user`, `github` 필드에 저장됨
+- CLAUDE.md의 `{{CONVERSATION_LANGUAGE}}` 및 `{{USER_NICKNAME}}` 변수로 치환됨
 - 모든 Alfred 대화에서 사용됨
+- **팀 모드**: git-manager가 다음 워크플로우를 자동으로 적용:
+  - **`spec_git_workflow: "feature_branch"`**: `/alfred:1-plan` 실행 시 feature/spec-\* 브랜치 생성, PR 기반 리뷰 프로세스 적용
+  - **`spec_git_workflow: "develop_direct"`**: `/alfred:1-plan` 실행 시 develop 브랜치에 직접 커밋, 브랜치 생성 과정 생략
+  - **`spec_git_workflow: "per_spec"`**: `/alfred:1-plan` 실행 시마다 사용자에게 워크플로우 선택 요청
 
-**예시**:
-```
-안녕하세요, GOOS님! 👋
+**설정 완료 출력 예시**:
+
+```markdown
+✅ 초기 설정 완료!
+
+언어: 한국어 (ko)
+닉네임: GOOS
 
-이제 프로젝트 환경 분석으로 진행하겠습니다...
+이제 GOOS님의 프로젝트 환경 분석으로 진행하겠습니다...
 ```
 
 ### 0.3 STEP 1로 전환
 
 언어 및 사용자 정보 설정 완료 후, 모든 후속 상호작용이 선택된 언어로 진행됩니다:
+
 - Alfred의 모든 프롬프트가 선택된 언어로 번역됨
 - project-manager sub-agent이 언어 및 사용자 정보 파라미터를 수신
 - 인터뷰 질문이 선택된 언어로 진행됨
 - 생성된 문서 (product.md, structure.md, tech.md)가 선택된 언어로 작성됨
 - CLAUDE.md가 선택된 언어와 사용자 닉네임을 표시함
 
-**한국어 선택 시 출력 예시**:
-```markdown
-✅ 설정 완료!
-
-언어: 한국어 (ko)
-닉네임: GOOS
-
-이제 GOOS님의 프로젝트 환경 분석으로 진행하겠습니다...
-```
-
 ---
 
 ## 🚀 STEP 1: Environmental analysis and interview plan development
@@ -223,33 +527,83 @@ 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)
+- User's existing project files can be merged (regardless of optimized flag)
+
+**Backup Detection Result**:
+
+- **Backup Found**: Latest backup is `.moai-backups/[TIMESTAMP]/`
+- **No Backup**: Proceed directly to Phase 1.2 (project environment analysis)
+
+**Select user if backup exists**
+
+When a backup is detected, call `AskUserQuestion tool (documented in moai-alfred-interactive-questions skill)` to present a TUI decision:
+
+**Example AskUserQuestion Call**:
+
+```python
+AskUserQuestion(
+    questions=[
+        {
+            "question": "Previous project configuration found in backup. How would you like to proceed?",
+            "header": "Backup Merge Decision",
+            "multiSelect": false,
+            "options": [
+                {
+                    "label": "🔄 Merge (Recommended)",
+                    "description": "Restore your previous customizations with latest template structure"
+                },
+                {
+                    "label": "📋 New Interview",
+                    "description": "Start fresh interview, ignore previous configuration"
+                },
+                {
+                    "label": "⏸️ Skip (Keep Current)",
+                    "description": "Keep existing project files without changes"
+                }
+            ]
+        }
+    ]
+)
+```
+
+**Response Processing**:
+
+- **"Merge (Recommended)"** (`answers["0"] === "Merge"`) → Proceed to Phase 1.1 (backup merge workflow)
+
+  - Extract user customizations from backup
+  - Combine with latest template structure
+  - Update version in HISTORY section
+  - Set `optimized: true` in config.json
+
+- **"New Interview"** (`answers["0"] === "New Interview"`) → Proceed to Phase 1.2 (Project environment analysis)
+
+  - Archive existing backup for reference
+  - Begin fresh interview without prior customizations
+  - Create new product/structure/tech.md from interview results
 
-**Select user if backup exists**  
-Call `AskUserQuestion tool (documented in moai-alfred-interactive-questions skill)` 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)
+- **"Skip (Keep Current)"** (`answers["0"] === "Skip"`) → End task
+  - Terminate /alfred:0-project execution
+  - Preserve all existing files unchanged
+  - User must manually run if changes needed
 
-**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 found**:
 
-**No backup or optimized: true**:
+- Display: "✅ No previous backup detected. Starting fresh interview..."
 - Proceed directly to Phase 1.2 (project environment analysis)
 
 ---
 
-### 1.1 Backup merge workflow (when user selects “Merge”)
+### 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)
@@ -264,6 +618,7 @@ 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"
@@ -273,34 +628,36 @@ The following patterns are considered "template defaults" (not merged):
 **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
+- 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
+- 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)
+  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)
@@ -309,6 +666,7 @@ Version update (v0.1.x → v0.1.x+1)
 **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)
@@ -320,6 +678,7 @@ After the merge is complete, add history to the HISTORY section of each file:
 **STEP 6: Update config.json**
 
 Set optimization flags after the merge is complete:
+
 ```json
 {
   "project": {
@@ -336,27 +695,32 @@ Set optimization flags after the merge is complete:
 ✅ 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)
 
 💾 Backup file location:
+
 - Original backup: .moai-backups/20251018-003638/
 - Retention period: Permanent (until manual deletion)
 
 📋 Next steps:
+
 1. Review the merged document
 2. Additional modifications if necessary
 3. Create your first SPEC with /alfred:1-plan
 
 ---
+
 **Task completed: /alfred:0-project terminated**
 ```
 
@@ -369,9 +733,10 @@ Set optimization flags after the merge is complete:
 **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
+   Alfred classifies new vs existing projects by analyzing the directory structure:
+
+- Empty directory → New project
+- Code/documentation present → Existing project
 
 2. **Auto-detect language/framework**: Detects the main language of your project based on file patterns
    - pyproject.toml, requirements.txt → Python
@@ -379,19 +744,22 @@ Set optimization flags after the merge is complete:
    - pom.xml, build.gradle → Java
    - go.mod → Go
    - Cargo.toml → Rust
+
 - backend/ + frontend/ → full stack
 
 3. **Document status analysis**
- - Check the status of existing `.moai/project/*.md` files
- - Identify areas of insufficient information
- - Organize items that need supplementation
+
+- Check the status of existing `.moai/project/*.md` files
+- Identify areas of insufficient information
+- Organize items that need supplementation
 
 4. **Project structure evaluation**
- - Directory structure complexity
- - Monolingual vs. hybrid vs. microservice
- - Code base size estimation
 
-### 1.3 Establish interview strategy (when user selects “New”)
+- Directory structure complexity
+- Monolingual vs. hybrid vs. microservice
+- Code base size estimation
+
+### 1.3 Establish interview strategy (when user selects "New")
 
 **Select question tree by project type**:
 
@@ -402,62 +770,134 @@ Set optimization flags after the merge is complete:
 | **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”)
+### 1.4 Generate Interview Plan Report (when user selects "Create New")
+
+**Purpose**: Present user with a clear interview plan before execution, allowing review and modification.
 
 **Format of plan to be presented to users**:
 
 ```markdown
-## 📊 Project initialization plan: [PROJECT-NAME]
+## 📊 Project Initialization Plan: [PROJECT-NAME]
 
 ### Environmental Analysis Results
+
 - **Project Type**: [New/Existing/Hybrid]
-- **Languages ​​Detected**: [Language List]
+- **Languages Detected**: [Language List]
 - **Current Document Status**: [Completeness Rating 0-100%]
 - **Structure Complexity**: [Simple/Medium/Complex]
 
-### 🎯 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]
+### 🎯 Interview Strategy
 
-### ⚠️ Notes
-- **Existing document**: [Overwrite vs supplementation strategy]
-- **Language settings**: [Automatic detection vs manual setting]
-- **Configuration conflicts**: [Compatibility with existing config.json]
+- **Question Category**: Product Discovery / Structure / Tech
+- **Expected Number of Questions**: [N questions (M required + K optional)]
+- **Estimated Time Required**: [Time estimation, e.g., 15-20 minutes]
+- **Priority Areas**: [Key focus areas to be covered]
 
-### ✅ Expected deliverables
-- **product.md**: [Business requirements document]
-- **structure.md**: [System architecture document]
-- **tech.md**: [Technology stack and policy document]
-- **config.json**: [Project configuration file]
+### 📋 Interview Phases
+
+1. **Product Discovery** (product.md)
+
+   - Core mission and value proposition
+   - Key user bases and success metrics
+
+2. **Structure Blueprint** (structure.md)
+
+   - System architecture strategy
+   - Module boundaries and responsibility
+
+3. **Tech Stack Mapping** (tech.md)
+   - Language/framework selection
+   - Quality and deployment policies
+
+### ⚠️ Important Notes
+
+- **Existing Document**: [Overwrite/Merge/Supplement strategy]
+- **Language Settings**: [Conversation language: {{CONVERSATION_LANGUAGE_NAME}}]
+- **Team Mode**: [Personal/Team workflow configured]
+- **Configuration**: [Compatibility with existing config.json]
+
+### ✅ Expected Deliverables
+
+- **product.md**: Business requirements and strategy document
+- **structure.md**: System architecture and design document
+- **tech.md**: Technology stack and quality policy document
+- **config.json**: Project settings and configurations
 
 ---
-**Approval Request**: Would you like to proceed with the interview using the above plan?
- (Choose “Proceed,” “Modify [Content],” or “Abort”)
+
+**Please review the plan above and confirm whether to proceed.**
 ```
 
-### 1.5 Wait for user approval (moai-alfred-interactive-questions) (when user selects "New")
+### 1.5 User Approval with AskUserQuestion (when user selects "New")
+
+After Alfred generates the interview plan report, call `AskUserQuestion` tool (documented in moai-alfred-interactive-questions skill) to get explicit user approval before starting the interview.
+
+**Example AskUserQuestion Call**:
+
+```python
+AskUserQuestion(
+    questions=[
+        {
+            "question": "Please review the interview plan above. Would you like to proceed with this plan?",
+            "header": "Interview Plan Approval",
+            "multiSelect": false,
+            "options": [
+                {
+                    "label": "✅ Proceed with Plan",
+                    "description": "Start interview following the plan above (Phase 2)"
+                },
+                {
+                    "label": "📋 Modify Plan",
+                    "description": "Revise strategy and re-run analysis (back to Phase 1)"
+                },
+                {
+                    "label": "⏹️ Cancel",
+                    "description": "Exit initialization, keep existing files unchanged"
+                }
+            ]
+        }
+    ]
+)
+```
+
+**Response Processing**:
+
+- **"Proceed with Plan"** (`answers["0"] === "Proceed"`) → Execute Phase 2
+
+  - Call project-manager agent with approved plan parameters
+  - Conduct interview according to the plan
+  - Generate product/structure/tech.md documents
+  - Save config.json with all settings
 
-After Alfred receives the project-manager's interview plan report, uses `AskUserQuestion` tool (documented in moai-alfred-interactive-questions skill) 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
+- **"Modify Plan"** (`answers["0"] === "Modify"`) → Repeat Phase 1
 
-**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
+  - Return to environmental analysis
+  - Re-run project type detection
+  - Re-run language detection
+  - Generate new interview plan with user feedback
+  - Ask for approval again with modified plan
+
+- **"Cancel"** (`answers["0"] === "Cancel"`) → End task
+  - Terminate /alfred:0-project execution
+  - Do not modify any existing files
+  - User can re-run command later
+
+**Phase 2 Execution Condition**:
+
+- Only proceed to Phase 2 (project initialization) if user confirms "Proceed with Plan"
+- All other responses lead to re-planning or task termination
 
 ---
 
-## 🚀 STEP 2: Execute project initialization (after user approves “New”)
+## 🚀 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
@@ -469,51 +909,89 @@ After user approval, the project-manager agent performs initialization.
 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")
+- **agent_prompt_language** (from STEP 0.1.2) - **NEW**:
+  - `"english"` = All sub-agent prompts in English (Global Standard)
+  - `"localized"` = All sub-agent prompts in selected conversation_language (Localized)
 - Detected Languages: [Language List from codebase detection]
 - Project Type: [New/Existing]
 - Existing Document Status: [Existence/Absence]
 - Approved Interview Plan: [Plan Summary]
+- **Team Mode Git Workflow** (from STEP 0.1.3):
+  - `spec_git_workflow: "feature_branch" | "develop_direct" | "per_spec"` (팀 모드만)
 
 **Execution**:
+
 ```
 Call the Task tool:
 - subagent_type: "project-manager"
 - description: "Initialize project with conversation language support"
-- prompt: """You are project-manager agent.
-
-LANGUAGE CONFIGURATION:
-- conversation_language: {{CONVERSATION_LANGUAGE}}
-- language_name: {{CONVERSATION_LANGUAGE_NAME}}
-
-PROJECT_TYPE: [new|existing]
-DETECTED_LANGUAGES: [detected codebase languages]
-
-CRITICAL INSTRUCTION:
-All interviews and generated documentation MUST be in conversation_language:
-- product.md: Generate in {{CONVERSATION_LANGUAGE}}
-- structure.md: Generate in {{CONVERSATION_LANGUAGE}}
-- tech.md: Generate in {{CONVERSATION_LANGUAGE}}
-
-If conversation_language is 'ko': All narrative content in Korean
-If conversation_language is 'ja': All narrative content in Japanese
-If conversation_language is other: Follow the specified language
-
-After project initialization, update .moai/config.json with nested language structure:
+- prompt: """당신은 project-manager 에이전트입니다.
+
+언어 설정:
+- 대화_언어: {{CONVERSATION_LANGUAGE}} (모든 대화, 문서에 사용)
+- 언어명: {{CONVERSATION_LANGUAGE_NAME}}
+- 에이전트_프롬프트_언어: {{AGENT_PROMPT_LANGUAGE}} (내부 sub-agent 통신 언어)
+
+에이전트 프롬프트 언어에 따른 작업 방식:
+
+1. **agent_prompt_language = "english"** (Global Standard):
+   - 당신(project-manager)은 **영어**로 사고하고 작업합니다
+   - 모든 내부 분석과 계획을 영어로 진행합니다
+   - 생성된 product.md, structure.md, tech.md는 **{{CONVERSATION_LANGUAGE}}**로 작성합니다
+   - Sub-agent들(spec-builder 등)에게 전달하는 프롬프트는 **영어**입니다
+
+2. **agent_prompt_language = "localized"** (Localized):
+   - 당신(project-manager)은 **{{CONVERSATION_LANGUAGE}}**로 사고하고 작업합니다
+   - 모든 내부 분석과 계획을 {{CONVERSATION_LANGUAGE}}로 진행합니다
+   - 생성된 product.md, structure.md, tech.md는 **{{CONVERSATION_LANGUAGE}}**로 작성합니다
+   - Sub-agent들(spec-builder 등)에게 전달하는 프롬프트도 **{{CONVERSATION_LANGUAGE}}**입니다
+
+중요: 대화_언어(conversation_language)와 에이전트_프롬프트_언어(agent_prompt_language)는 다를 수 있습니다!
+- 대화_언어는 **사용자와의 대화**, **생성 문서**에 사용
+- 에이전트_프롬프트_언어는 **sub-agents 통신**, **내부 prompt**에 사용
+
+GIT 워크플로우 설정 (팀 모드):
+- spec_git_workflow: [feature_branch | develop_direct | per_spec]
+  - "feature_branch": feature/spec-* 브랜치 생성, PR 기반 리뷰, develop 병합
+  - "develop_direct": develop에 직접 커밋, 브랜치 생성 안 함
+  - "per_spec": SPEC별로 사용자에게 물어봄 (/alfred:1-plan 실행 중)
+- 참고: 이 값을 .moai/config.json github.spec_git_workflow에 저장하여 git-manager가 참조하도록
+
+프로젝트_타입: [new|existing]
+감지된_언어들: [감지된 코드베이스 언어들]
+
+중요 지시사항:
+모든 인터뷰와 생성된 문서는 대화_언어(conversation_language)로 작성되어야 합니다:
+- product.md: {{CONVERSATION_LANGUAGE}}로 생성
+- structure.md: {{CONVERSATION_LANGUAGE}}로 생성
+- tech.md: {{CONVERSATION_LANGUAGE}}로 생성
+
+conversation_language가 'ko'인 경우: 모든 설명 내용을 한국어로
+conversation_language가 'ja'인 경우: 모든 설명 내용을 일본어로
+다른 언어인 경우: 지정된 언어를 따릅니다
+
+프로젝트 초기화 후, 다음과 같이 .moai/config.json 업데이트:
 {
   "language": {
     "conversation_language": "{{CONVERSATION_LANGUAGE}}",
-    "conversation_language_name": "{{CONVERSATION_LANGUAGE_NAME}}"
+    "conversation_language_name": "{{CONVERSATION_LANGUAGE_NAME}}",
+    "agent_prompt_language": "{{AGENT_PROMPT_LANGUAGE}}"
+  },
+  "github": {
+    "spec_git_workflow": "[feature_branch|develop_direct|per_spec]"
   }
 }
 
-SKILL INVOCATION:
-Use explicit Skill() calls when needed:
-- Skill("moai-alfred-language-detection") for codebase language detection
-- Skill("moai-foundation-langs") for multi-language project setup
+스킬 호출:
+필요 시 명시적 Skill() 호출 사용:
+- Skill("moai-alfred-language-detection") - 코드베이스 언어 감지
+- Skill("moai-foundation-langs") - 다국어 프로젝트 설정
 
-TASK: Conduct project interviews and create/update product/structure/tech.md documents."""
+작업: 프로젝트 인터뷰를 진행하고 product/structure/tech.md 문서를 생성/업데이트합니다.
+에이전트_프롬프트_언어 설정에 따라 sub-agent들과의 통신 언어를 결정합니다."""
 ```
 
 **Outcome**: The project-manager agent conducts structured interviews entirely in the selected language and creates/updates product/structure/tech.md documents in that language.
@@ -526,9 +1004,10 @@ After the project-manager has finished creating the document, **Alfred can optio
 
 | Conditions                           | Automatic selection Skill    | Purpose                                |
 | ------------------------------------ | ---------------------------- | -------------------------------------- |
-| User Requests “Quality Verification” | moai-alfred-trust-validation | Initial project structure verification |
+| User Requests "Quality Verification" | moai-alfred-trust-validation | Initial project structure verification |
 
 **Execution flow** (optional):
+
 ```
 1. project-manager completion
     ↓
@@ -544,14 +1023,17 @@ After the project-manager has finished creating the document, **Alfred can optio
 **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 `AskUserQuestion tool (documented in moai-alfred-interactive-questions skill)`,
+
 - 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?"
 
@@ -562,26 +1044,30 @@ After the project-manager has finished creating the document, **Alfred can optio
 **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)
+
+- 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)
+
+- 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)
+
+- 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",
@@ -602,11 +1088,13 @@ After the project-manager has finished creating the document, **Alfred can optio
 **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.
+- 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.)
@@ -614,12 +1102,14 @@ Alfred identifies the entire project structure:
 **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*
+
+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
@@ -629,50 +1119,59 @@ Alfred identifies groups of files by the Glob pattern:
 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
+
+- 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
+
+- 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
+
+- 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
+
+- 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
@@ -683,50 +1182,60 @@ As each file is read, the following information is collected:
 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”
+
+- 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)
+
+- 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)
+
+- 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
+- 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)
+
+- 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)
+
+- 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
@@ -735,12 +1244,14 @@ Based on the collected information, it is reflected in three major documents:
 ### 2.3 Document creation and verification
 
 **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)
 
 **Quality Verification**:
+
 - [ ] Verify existence of all required @TAG sections
 - [ ] Verify compliance with EARS syntax format
 - [ ] Verify config.json syntax validity
@@ -752,20 +1263,23 @@ Based on the collected information, it is reflected in three major documents:
 ✅ Project initialization complete!
 
 📁 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)
 
 🔍 Detected environments:
+
 - Language: [List of languages]
 - Frameworks: [List of frameworks]
 - Test tools: [List of tools]
 
 📋 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
+3. If necessary, readjust with /alfred:0-project update
 ```
 
 ### 2.5: Initial structural verification (optional)
@@ -775,6 +1289,7 @@ After project initialization is complete, you can optionally run quality verific
 **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
@@ -783,6 +1298,7 @@ After project initialization is complete, you can optionally run quality verific
 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
@@ -793,18 +1309,22 @@ Alfred only calls the trust-checker agent to perform project initial structural
 **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”
+- User choice: "Revalidate after fix" or "Skip"
 
 **Skip verification**:
+
 - Verification is not run by default
 - Run only when explicitly requested by the user
 
@@ -829,11 +1349,11 @@ cc-manager selects the required sub-agents and skills based on the briefing.The
 
 | 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            |
+| 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-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        |
+| Refactoring legacy modules (`product.md` BACKLOG, `tech.md` TODO)                  | `implementation-planner`, `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                  |
@@ -844,6 +1364,7 @@ cc-manager selects the required sub-agents and skills based on the briefing.The
 | Requires onboarding/training mode (`tech.md` STACK description, etc.)              | `moai-alfred-interactive-questions`, `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`.
@@ -852,20 +1373,25 @@ If multiple conditions are met, the candidates are merged without duplicates and
 
 #### 2.6.2 User confirmation flow
 
-`AskUserQuestion tool (documented in moai-alfred-interactive-questions skill)` asks “whether to enable recommended items.”
+`AskUserQuestion tool (documented in moai-alfred-interactive-questions skill)` 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.
+  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”.
+
+- 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
    {
@@ -877,27 +1403,30 @@ Selecting “Selective Install” presents the list of candidates again as multi
      }
    }
    ```
-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.
+   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
+
+- 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)
@@ -906,6 +1435,7 @@ Merge existing properties, if any.
 ### Existing project interview area
 
 **Legacy Analysis**
+
 - Identify current code structure and modules
 - Status of build/test pipeline
 - Identify technical debt and constraints
@@ -935,18 +1465,21 @@ Merge existing properties, if any.
 ### Common errors and solutions
 
 **Error 1**: Project language detection failed
+
 ```
-Symptom: “Language not detected” message
+Symptom: "Language not detected" message
 Solution: Specify language manually or create language-specific settings file
 ```
 
 **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
+Solution: Preserve existing contents and add new contents in "Legacy Context" section
 ```
 
 **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
@@ -971,45 +1504,99 @@ This subcommand is executed under the following conditions:
 #### Phase 1: Backup analysis and comparison
 
 1. **Make sure you have the latest backup**:
+
    ```bash
-# Browse the latest backups in the .moai-backups/ directory
-   ls -lt .moai-backups/ | head -1
+
    ```
 
+# Browse the latest backups in the .moai-backups/ directory
+
+ls -lt .moai-backups/ | head -1
+
+````
+
 2. **Change Analysis**:
- - Compare `.claude/` directory from backup with current template
- - Compare `.moai/project/` document from backup with current document
- - Identify user customization items
+- 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
+```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
+- 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
-   ```
+- Run Smart Merge
+- Preserve User Customizations
+- Set optimized=true
+````
+
+4. **Waiting for user approval**
+
+Call `AskUserQuestion` tool (documented in moai-alfred-interactive-questions skill) to obtain user approval for template optimization.
+
+**Example AskUserQuestion Call**:
+
+```python
+AskUserQuestion(
+    questions=[
+        {
+            "question": "Template optimization analysis complete. Changes detected in backup vs current template. How would you like to proceed?",
+            "header": "Template Optimization",
+            "multiSelect": false,
+            "options": [
+                {
+                    "label": "✅ Proceed",
+                    "description": "Run smart merge: preserve customizations with latest template (Phase 2)"
+                },
+                {
+                    "label": "👀 Preview",
+                    "description": "Show detailed change list before proceeding"
+                },
+                {
+                    "label": "⏸️ Skip",
+                    "description": "Keep current template unchanged (optimized: false)"
+                }
+            ]
+        }
+    ]
+)
+```
+
+**Response Processing**:
 
-4. **Waiting for user approval**  
-`AskUserQuestion tool (documented in moai-alfred-interactive-questions skill)` 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
+- **"Proceed"** (`answers["0"] === "Proceed"`) → Execute Phase 2
+
+  - Run smart merge logic
+  - Preserve user customizations from backup
+  - Combine with latest template structure
+  - Set `optimized: true` in config.json
+
+- **"Preview"** (`answers["0"] === "Preview"`) → Display detailed changes
+
+  - Show file-by-file comparison
+  - Highlight customization sections
+  - Ask approval again with "Proceed" or "Skip" only
+
+- **"Skip"** (`answers["0"] === "Skip"`) → Keep current state
+  - Do not modify any files
+  - Keep `optimized: false` in config.json
+  - User can run again with `moai-adk update` later
 
 #### 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
+
+- Run `TemplateProcessor.copy_templates()`
+- CLAUDE.md: Preserve "## Project Information" section
+- settings.json: env variables and permissions.allow merge
 
 2. Set **optimized=true**:
+
    ```python
    # update config.json
    config_data["project"]["optimized"] = True
@@ -1017,14 +1604,17 @@ This subcommand is executed under the following conditions:
 
 3. **Optimization completion report**:
    ```markdown
-✅ Template optimization completed!
+   ✅ Template optimization completed!
+   ```
 
 📄 Merged files:
- - CLAUDE.md (preserves project information)
- - settings.json (preserves env variables)
+
+- CLAUDE.md (preserves project information)
+- settings.json (preserves env variables)
 
 ⚙️ config.json: optimized=true Configuration complete
-   ```
+
+````
 
 ### Alfred Automation Strategy
 
@@ -1053,7 +1643,7 @@ moai-adk update
 # → Phase 1: Generate backup analysis and comparison report
 # → Wait for user approval
 # → Phase 2: Run smart merge, set optimized=true
-```
+````
 
 ### caution
 
@@ -1066,6 +1656,7 @@ moai-adk update
 ## 🚀 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
@@ -1077,18 +1668,26 @@ moai-adk update
 **Alfred automatically calls the moai-alfred-feature-selector skill**:
 
 **Skill Entry**:
+
 - `.moai/project/product.md` (project category hint)
 - `.moai/project/tech.md` (main language, framework)
 - `.moai/config.json` (project settings)
 
 **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"],
+  "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%"
@@ -1096,6 +1695,7 @@ moai-adk update
 ```
 
 **How ​​to Run**:
+
 ```
 Alfred: Skill("moai-alfred-feature-selector")
 ```
@@ -1107,11 +1707,13 @@ Alfred: Skill("moai-alfred-feature-selector")
 **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
 
 **Skill Output**:
+
 - `CLAUDE.md` (custom agent table - selected agents only)
 - `.claude/commands/` (selected commands only)
 - `.claude/agents/` (selected agents only)
@@ -1119,6 +1721,7 @@ Alfred: Skill("moai-alfred-feature-selector")
 - `.moai/config.json` (updates `optimized: true`)
 
 **How ​​to Run**:
+
 ```
 Alfred: Skill("moai-alfred-template-generator")
 ```
@@ -1128,26 +1731,31 @@ Alfred: Skill("moai-alfred-template-generator")
 ### 3.3 Optimization completion report
 
 **Report Format**:
+
 ```markdown
 ✅ Project customized optimization completed!
 
 📊 Optimization results:
+
 - **Project**: MoAI-ADK
 - **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
@@ -1160,10 +1768,12 @@ Alfred: Skill("moai-alfred-template-generator")
 **Users can skip Phase 3**:
 
 **Skip condition**:
-- User explicitly selects “Skip”
-- “Simple project” when Alfred automatically determines (only basic features required)
+
+- 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
@@ -1181,6 +1791,61 @@ After initialization is complete:
 - **Set Change**: Run `/alfred:0-project` again to update document
 - **Template optimization**: Run `/alfred:0-project update` after `moai-adk update`
 
+## Final Step
+
+After project initialization completes, Alfred automatically invokes AskUserQuestion to ask the user what to do next:
+
+```python
+AskUserQuestion(
+    questions=[
+        {
+            "question": "Project initialization complete. What would you like to do next?",
+            "header": "Next Steps",
+            "multiSelect": false,
+            "options": [
+                {
+                    "label": "📋 Start SPEC Creation",
+                    "description": "Begin first SPEC with /alfred:1-plan command"
+                },
+                {
+                    "label": "🔍 Review Project Structure",
+                    "description": "Review and edit generated project documents"
+                },
+                {
+                    "label": "🔄 Start New Session",
+                    "description": "Execute /clear for fresh session (recommended for performance)"
+                }
+            ]
+        }
+    ]
+)
+```
+
+**Response Processing**:
+
+- **"📋 Start SPEC Creation"** (`answers["0"] === "Start SPEC"`) → Proceed to `/alfred:1-plan`
+
+  - Display: "✅ Ready for SPEC creation workflow..."
+  - User can immediately run: `/alfred:1-plan "first feature name"`
+  - Continue to next phase without session break
+
+- **"🔍 Review Project Structure"** (`answers["0"] === "Review"`) → Review generated documents
+
+  - Display: "📁 Open these files for review:"
+    - `.moai/project/product.md` - Business requirements
+    - `.moai/project/structure.md` - System architecture
+    - `.moai/project/tech.md` - Technology stack
+  - After review, user can run `/alfred:1-plan` or `/alfred:0-project` again for updates
+  - Display: "💾 Save changes manually in editor or run `/alfred:0-project` again"
+
+- **"🔄 Start New Session"** (`answers["0"] === "New Session"`) → Start fresh session
+  - Display: "⏳ Preparing to clear session..."
+  - Note: This improves context window management for large projects
+  - Next session can start with: `/alfred:1-plan "next feature"`
+  - Alternative: Type `/clear` in shell to restart manually
+
+---
+
 ## Related commands
 
 - `/alfred:1-plan` - Start writing SPEC