moai-adk 0.8.0__py3-none-any.whl → 0.15.0__py3-none-any.whl

{moai_adk-0.8.0.dist-info → moai_adk-0.15.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moai-adk
-Version: 0.8.0
+Version: 0.15.0
 Summary: MoAI Agentic Development Kit - SPEC-First TDD with Alfred SuperAgent & Complete Skills v2.0
 Project-URL: Homepage, https://github.com/modu-ai/moai-adk
 Project-URL: Repository, https://github.com/modu-ai/moai-adk
@@ -14,17 +14,21 @@ Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Quality Assurance
 Classifier: Topic :: Software Development :: Testing
-Requires-Python: >=3.13
+Requires-Python: >=3.11
 Requires-Dist: click>=8.1.0
 Requires-Dist: gitpython>=3.1.45
+Requires-Dist: jinja2>=3.0.0
 Requires-Dist: packaging>=21.0
 Requires-Dist: pyfiglet>=1.0.2
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: questionary>=2.0.0
+Requires-Dist: requests>=2.28.0
 Requires-Dist: rich>=13.0.0
 Provides-Extra: dev
 Requires-Dist: mypy>=1.7.0; extra == 'dev'
@@ -40,7 +44,7 @@ Description-Content-Type: text/markdown
 
 # MoAI-ADK (Agentic Development Kit)
 
-[한국어](README.ko.md) |[English](README.md) | [ไทย](README.th.md) | [日本語](README.ja.md) | [中文](README.zh.md) | [हिन्दी](README.hi.md)
+[한국어](README.ko.md) | [English](README.md)
 
 [![PyPI version](https://img.shields.io/pypi/v/moai-adk)](https://pypi.org/project/moai-adk/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
@@ -111,7 +115,7 @@ Write SPECs first with the `/alfred:1-plan` command. A vague request like "login
 A single `/alfred:3-sync` command **synchronizes** all code, tests, and documentation. README, CHANGELOG, API docs, and Living Documents all update automatically. Six months later, code and docs still match.
 
 **4️⃣ Tracking with @TAG System**
-Every piece of code, test, and documentation gets a `@TAG:ID`. When requirements change later, one command—`rg "@SPEC:AUTH-001"`—**finds all related tests, implementations, and docs**. You gain confidence during refactoring.
+Every piece of code, test, and documentation gets a `@TAG:ID`. When requirements change later, one command—`rg "@SPEC:EX-AUTH-001"`—**finds all related tests, implementations, and docs**. You gain confidence during refactoring.
 
 **5️⃣ Alfred Remembers Context**
 A team of AI agents collaborate to **remember** your project's structure, decision rationale, and work history. No need to repeat the same questions.
@@ -158,61 +162,364 @@ From the moment you adopt MoAI-ADK, you'll feel:
 
 ---
 
-## 5-Minute Quick Start
+## 🖥️ Platform Support
 
-Now let's start your first project with MoAI-ADK. Follow these 5 steps and in just **5 minutes** you'll have a project with SPEC, TDD, and documentation all connected.
+### Supported Platforms
+- ✅ **macOS** (11.0+)
+- ✅ **Linux** (Ubuntu 20.04+, Debian 11+, etc.)
+- ✅ **Windows** (10/11) - Full support as of v0.11.0
+  - Note: Hooks system requires Python 3.11+
+  - All hook features work seamlessly on Windows with cross-platform timeout handling
 
-### Step 1: Install uv (about 30 seconds)
+### System Requirements
+- **Python**: 3.11 or higher
+- **Git**: 2.30+
+- **GitHub CLI** (`gh`): Optional, required for PR automation in team mode
 
-First, install `uv`. `uv` is an ultra-fast Python package manager written in Rust. It's **10+ times faster** than traditional `pip` and works perfectly with MoAI-ADK.
+---
+
+## ⚡ 3-Minute Lightning Start
+
+Get your first MoAI-ADK project running in **3 simple steps**. Beginners can finish in under 5 minutes.
+
+### Step 1: Install uv (about 1 minute)
+
+#### Command
+
+**Choose your platform**:
 
 ```bash
 # macOS/Linux
 curl -LsSf https://astral.sh/uv/install.sh | sh
 
-# Windows (PowerShell)
+# Windows (PowerShell) - RECOMMENDED FOR WINDOWS USERS
 powershell -c "irm https://astral.sh/uv/install.ps1 | iex"
 
+# Windows (Git Bash) - Alternative
+curl -LsSf https://astral.sh/uv/install.sh | bash
+
+# WSL (Windows Subsystem for Linux)
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
 # Verify installation
 uv --version
-# Output: uv 0.x.x
 ```
 
-**Why uv?** MoAI-ADK is optimized to leverage uv's fast installation speed and stability. Perfect project isolation means no impact on other Python environments.
+**Platform Selection Guide**:
+
+| Platform | Method | Notes |
+|----------|--------|-------|
+| **macOS** | bash | Native UNIX-based, use standard installation |
+| **Linux** | bash | Native Linux support |
+| **Windows (Native)** | ⭐ PowerShell | **RECOMMENDED** - Most stable, native Windows support |
+| **Windows (Git Bash)** | bash | Alternative if PowerShell unavailable |
+| **WSL** | bash | Use Linux installation within WSL2 |
 
-### Step 2: Install MoAI-ADK (about 1 minute)
+**Important Notes on Windows**:
+- 🟢 **PowerShell (Native)**: Most reliable and stable method. No WSL or Git Bash needed.
+- 🟡 **Git Bash / WSL**: Works, but may encounter path issues. Try PowerShell first.
+- ❌ **Do NOT use WSL if**: You're testing on Windows—PowerShell native is easier and faster.
+
+**Why PowerShell for Windows?**
+- Fewer environment setup issues
+- Better Windows integration
+- Faster execution
+- No WSL overhead
+
+#### Expected Output
+```
+✓ uv 0.5.1 is already installed
+$ uv --version
+uv 0.5.1
+```
 
-Install MoAI-ADK as a global tool. This won't affect your project dependencies.
+#### Next: Install MoAI-ADK
 
 ```bash
-# Install in tool mode (recommended: runs in isolated environment)
 uv tool install moai-adk
 
-# Verify installation
+# Result: ✅ Installed moai-adk v0.14.0
+```
+
+**Verification**:
+```bash
 moai-adk --version
-# Output: MoAI-ADK v1.0.0
+# Output: MoAI-ADK v0.14.0
+```
+
+---
+
+### Step 2: Create Your First Project (about 1 minute)
+
+#### Command
+
+```bash
+moai-adk init hello-world
+cd hello-world
+```
+
+#### What Gets Created
+
+```
+hello-world/
+├── .moai/              ✅ Alfred configuration
+├── .claude/            ✅ Claude Code automation
+├── CLAUDE.md           ✅ Project guide
+└── README.md           ✅ Project documentation
+```
+
+#### Verification: Check Core Files
+
+```bash
+# Verify core config file exists
+ls -la .moai/config.json  # ✅ Should exist
+ls -la .claude/commands/  # ✅ Should have commands
+
+# Or all at once
+moai-adk doctor
+```
+
+**Expected Output**:
+```
+✅ Python 3.13.0
+✅ uv 0.5.1
+✅ .moai/ directory initialized
+✅ .claude/ directory ready
+✅ 16 agents configured
+✅ 74 skills loaded
+```
+
+---
+
+### Step 3: Start Alfred (about 1 minute)
+
+#### Run Claude Code
+
+```bash
+claude
+```
+
+#### Enter in Claude Code
+
+```
+/alfred:0-project
+```
+
+#### Alfred Will Ask
+
+```
+Q1: Project name?
+A: hello-world
+
+Q2: Project goal?
+A: Learning MoAI-ADK
+
+Q3: Main development language?
+A: python
+
+Q4: Mode?
+A: personal (for local development)
+```
+
+#### Result: Project Ready! ✅
+
+```
+✅ Project initialized
+✅ Config saved to .moai/config.json
+✅ Documents created in .moai/project/
+✅ Alfred recommends skills
+
+Next: Run /alfred:1-plan "your feature description"
+```
+
+---
+
+## Next: Complete Your First Feature in 10 Minutes
+
+You're now ready to build your first complete feature with SPEC, TDD, and auto-generated docs!
+
+> **→ Continue to: ["First 10-Minute Hands-On: Hello World API"](#-first-10-minute-hands-on-hello-world-api)**
+
+In this section you'll experience:
+- ✅ Define an API using SPEC
+- ✅ Complete TDD cycle (RED → GREEN → REFACTOR)
+- ✅ Auto-generate documentation
+- ✅ Understand @TAG system
+
+---
+
+## Language Support
+
+MoAI-ADK automatically detects and supports **15 programming languages** with dedicated CI/CD workflows:
+
+### Core Languages (v0.11.0+)
+- **Python** (pytest, mypy, ruff, 85% coverage target)
+- **JavaScript** (npm/yarn/pnpm/bun auto-detect, 80% coverage target)
+- **TypeScript** (tsc type checking, biome/eslint, 85% coverage target)
+- **Go** (golangci-lint, gofmt, 75% coverage target)
+
+### Extended Languages (v0.11.1+)
+- **Ruby** (RSpec, Rubocop, bundle)
+- **PHP** (PHPUnit, PHPCS, composer)
+- **Java** (JUnit 5, Jacoco, Maven/Gradle auto-detection)
+- **Rust** (cargo test, clippy, rustfmt)
+- **Dart** (flutter test, dart analyze)
+- **Swift** (XCTest, SwiftLint, SPM)
+- **Kotlin** (JUnit 5, ktlint, Gradle)
+- **C#** (xUnit, StyleCop, dotnet CLI)
+- **C** (gcc/clang, cppcheck, CMake)
+- **C++** (g++/clang++, Google Test, cpplint)
+- **Shell** (shellcheck, bats-core)
+
+### How Language Detection Works
+
+When you run `/alfred:2-run SPEC-XXX`, MoAI-ADK automatically:
+1. Scans your project for configuration files (package.json, pyproject.toml, go.mod, Cargo.toml, pom.xml, build.gradle, etc.)
+2. Detects your project's primary language using priority-based detection (Rust → Dart → Swift → ... → Shell)
+3. Auto-detects build tools (Maven/Gradle for Java, CMake for C/C++, SPM for Swift, etc.)
+4. Selects the appropriate CI/CD workflow template
+5. Generates language-specific testing and linting configuration
+
+### Supported Languages
+
+For detailed language detection priority and build tool detection, see [Language Detection Guide](.moai/docs/language-detection-guide.md)
+
+### Customization
+
+For advanced workflow customization, see [Workflow Templates Guide](.moai/docs/workflow-templates.md)
+
+---
+
+## Language Localization Architecture (v0.7.0+)
+
+### Hybrid Language Model
+
+MoAI-ADK v0.7.0 introduced a **two-layer language architecture** that enables global teams to work in their preferred language while keeping the infrastructure in English for consistency and maintainability.
+
+### Layer 1: User Conversation & Dynamic Content
+
+**All user-facing content uses your configured `conversation_language`** (set during `/alfred:0-project`):
+
+- ✅ **Responses & Explanations**: Your language (Korean, Japanese, Spanish, English, Chinese, etc.)
+- ✅ **Generated Documents**: SPEC, test files, implementation guides in your language
+- ✅ **Code Comments**: Function docstrings and inline comments in your language
+- ✅ **Git Commit Messages**: All commits in your language
+- ✅ **Sub-agent Communication**: All task prompts in your language
+
+### Layer 2: Static Infrastructure (English Only)
+
+**System infrastructure stays in English** for global consistency:
+
+- 🔒 `.claude/agents/` — Agent templates (English)
+- 🔒 `.claude/commands/` — Command templates (English)
+- 🔒 `.claude/skills/` — Skill content (English, industry standard)
+- 🔒 `.moai/memory/` — Internal guidelines (English)
+- 🔒 @TAG identifiers — Technical markers (English)
+- 🔒 Package code in `src/moai_adk/` — Source code comments (English for global distribution)
+
+### Configuration Example
+
+```json
+{
+  "language": {
+    "conversation_language": "ko",
+    "conversation_language_name": "Korean"
+  }
+}
 ```
 
-Once installed, you can use the `moai-adk` command anywhere.
+When configured, Alfred will:
+- Respond in Korean (모든 대화)
+- Generate SPECs in Korean
+- Write code comments in Korean
+- Create Git commits in Korean
+- All while using English-only Skill() invocations internally
+
+### Supported Languages
+
+- 🇬🇧 English
+- 🇰🇷 Korean (한국어)
+- 🇯🇵 Japanese (日本語)
+- 🇨🇳 Chinese (中文)
+- 🇪🇸 Spanish (Español)
+
+### Implementation Status (v0.7.0+)
+
+| Component | Status | Details |
+|-----------|--------|---------|
+| **Config System** | ✅ Complete | Nested language structure in `.moai/config.json` |
+| **Sub-agent Instructions** | ✅ Complete | All 16 agents support language parameter |
+| **Code Generation** | ✅ Complete | Comments/docs in user language |
+| **Git Integration** | ✅ Complete | Commit messages in user language |
+| **Dynamic Content** | ✅ Complete | All reports/explanations in user language |
+
+### Why This Matters
 
-### Step 3: Create Project (about 1 minute)
+1. **Global Accessibility**: Support teams in any language without translating infrastructure
+2. **Developer Experience**: Write code comments in your native language
+3. **Maintainability**: Infrastructure stays in English (single source of truth)
+4. **Scalability**: Add new languages instantly without code changes
 
-**To start a new project:**
+### How to Change Language
 
+**During Project Initialization**:
+```bash
+/alfred:0-project
+# Select your language when prompted
+```
+
+**After Project Creation**:
+Edit `.moai/config.json`:
+```json
+{
+  "language": {
+    "conversation_language": "ja",
+    "conversation_language_name": "Japanese"
+  }
+}
+```
+
+Then restart Claude Code for changes to take effect.
+
+---
+
+## Earlier Detailed Guide (Optional Reading)
+
+Need more explanations? See detailed guides below.
+
+### Detailed Installation Guide
+
+**After installing uv, verify PATH is set**:
+```bash
+# If uv command not found, set PATH manually (macOS/Linux)
+export PATH="$HOME/.cargo/bin:$PATH"
+
+# Verify again
+uv --version
+```
+
+**Available moai-adk commands**:
+```bash
+moai-adk init          # Initialize new project
+moai-adk doctor        # System diagnostics
+moai-adk update        # Update to latest version
+```
+
+### Detailed Project Creation
+
+**Create a new project**:
 ```bash
 moai-adk init my-project
 cd my-project
 ```
 
-**To add to an existing project:**
-
+**Add to existing project**:
 ```bash
 cd your-existing-project
 moai-adk init .
 ```
 
-This one command automatically generates:
-
+Complete directory structure created:
 ```
 my-project/
 ├── .moai/                          # MoAI-ADK project configuration
@@ -255,7 +562,7 @@ my-project/
 │   │       ├── 1-plan.md           # SPEC authoring
 │   │       ├── 2-run.md            # TDD implementation
 │   │       └── 3-sync.md           # Documentation sync
-│   ├── skills/                     # 58 Claude Skills
+│   ├── skills/                     # 55+ Claude Skills
 │   │   ├── moai-foundation-*       # 6 Foundation tier
 │   │   ├── moai-essentials-*       # 4 Essentials tier
 │   │   ├── moai-alfred-*           # 7 Alfred tier
@@ -267,11 +574,6 @@ my-project/
 │   ├── hooks/                      # Event-driven automation
 │   │   └── alfred/
 │   │       └── alfred_hooks.py     # 5 hooks (Session, PreTool, etc.)
-│   ├── output-styles/              # Response styles
-│   │   └── alfred/
-│   │       ├── agentic-coding.md       # Professional development mode
-│   │       ├── moai-adk-learning.md    # Educational explanations mode
-│   │       └── study-with-alfred.md    # Interactive learning mode
 │   └── settings.json               # Claude Code settings
 ├── src/                            # Implementation code
 ├── tests/                          # Test code
@@ -280,107 +582,300 @@ my-project/
 └── README.md
 ```
 
-### Step 4: Start Alfred in Claude Code (about 2 minutes)
+---
+
+## Core Concept: 3-Step Repeating Cycle
+
+After initial setup, every feature follows this cycle:
+
+| Step | Command | What It Does | Output |
+|------|---------|-------------|--------|
+| 🚀 **INIT** | `/alfred:0-project` | Collect project description, create config/docs, recommend Skills | `.moai/config.json`, `.moai/project/*`, initial report |
+| 📋 **PLAN** | `/alfred:1-plan "feature description"` | Analyze requirements, draft SPEC, create Plan Board | `.moai/specs/SPEC-*/spec.md`, plan/acceptance docs, feature branch |
+| 💻 **RUN** | `/alfred:2-run SPEC-ID` | Execute TDD, run tests/implementation/refactor, verify quality | `tests/`, `src/` implementation, quality report, TAG links |
+| 📚 **SYNC** | `/alfred:3-sync` | Auto-sync docs/README/CHANGELOG, organize TAG/PR status | `docs/`, `.moai/reports/sync-report.md`, Ready PR |
+| 💬 **FEEDBACK** | `/alfred:9-feedback` | Interactive GitHub Issue creation (type → title → description → priority) | GitHub Issue + auto labels + priority + URL |
+
+> ✅ All commands follow the **Phase 0(optional) → Phase 1 → Phase 2 → Phase 3** cycle. Alfred automatically reports status and suggests next steps.
+>
+> 💡 **New in v0.7.0+**: Use `/alfred:9-feedback` to create GitHub Issues on-the-fly during development. Keep your team in sync without interrupting your workflow.
+
+---
+
+## Original Detailed Guide (Complete 7-Step Analysis)
+
+For comprehensive explanation, see the previous version in [GitHub History](https://github.com/modu-ai/moai-adk/blob/main/README.md).
+
+---
+
+---
+
+## 🚀 First 10-Minute Hands-On: Hello World API
 
-Run Claude Code and invoke the Alfred SuperAgent:
+**Goal**: Experience the complete MoAI-ADK workflow in 10 minutes
+**Learn**: SPEC writing, TDD implementation, documentation automation, @TAG system
 
+> Already completed the 3-minute quick start? Start here!
+
+### Prerequisites
+- ✅ MoAI-ADK installed
+- ✅ Project created (`moai-adk init hello-world`)
+- ✅ Claude Code running
+
+---
+
+### Step 1: Write SPEC (2 minutes)
+
+#### Command
 ```bash
-# Run Claude Code
-claude
+/alfred:1-plan "GET /hello endpoint - receive query parameter 'name' and return greeting"
 ```
 
-Then enter this in Claude Code's command input:
+#### Alfred Automatically Creates
+```
+✅ SPEC ID: HELLO-001
+✅ File: .moai/specs/SPEC-HELLO-001/spec.md
+✅ Branch: feature/SPEC-HELLO-001
+```
 
+#### Check Generated SPEC
+```bash
+cat .moai/specs/SPEC-HELLO-001/spec.md
 ```
-/alfred:0-project
+
+**Example Content**:
+```yaml
+---
+id: HELLO-001
+version: 0.0.1
+status: draft
+priority: high
+---
+
+# `@SPEC:EX-HELLO-001: Hello World API
+
+## Ubiquitous Requirements
+- System SHALL provide HTTP GET /hello endpoint
+
+## Event-driven Requirements
+- WHEN query parameter 'name' is provided, THEN return "Hello, {name}!"
+- WHEN name is absent, THEN return "Hello, World!"
+
+## Constraints
+- name limited to 50 characters max
+- Response format: JSON
 ```
 
-This command performs:
+✅ **Verify**: `ls .moai/specs/SPEC-HELLO-001/`
+
+---
 
-1. **Collect Project Info**: "Project name?", "Goals?", "Main language?"
-2. **Auto-detect Tech Stack**: Automatically recognizes Python/JavaScript/Go, etc.
-3. **Deploy Skill Packs**: Prepares necessary Skills for your project
-4. **Generate Initial Report**: Project structure, suggested next steps
+### Step 2: TDD Implementation (5 minutes)
+
+#### Command
+```bash
+/alfred:2-run HELLO-001
+```
 
-### Step 5: Write First SPEC (about 1 minute)
+#### 🔴 RED Phase: Write Failing Test
 
-After project initialization completes, write your first feature as a SPEC:
+**File Created**: `tests/test_hello.py`
 
+```python
+# `@TEST:EX-HELLO-001 | SPEC: SPEC-HELLO-001.md
+
+import pytest
+from fastapi.testclient import TestClient
+from src.hello.api import app
+
+client = TestClient(app)
+
+def test_hello_with_name_should_return_personalized_greeting():
+    """WHEN name provided, THEN return personalized greeting"""
+    response = client.get("/hello?name=Alice")
+    assert response.status_code == 200
+    assert response.json() == {"message": "Hello, Alice!"}
+
+def test_hello_without_name_should_return_default_greeting():
+    """WHEN name absent, THEN return default greeting"""
+    response = client.get("/hello")
+    assert response.status_code == 200
+    assert response.json() == {"message": "Hello, World!"}
 ```
-/alfred:1-plan "User registration feature"
+
+**Run**:
+```bash
+pytest tests/test_hello.py -v
 ```
 
-Automatically generated:
+**Result**: ❌ FAILED (app doesn't exist yet - expected!)
 
-- `@SPEC:USER-001` - Unique ID assigned
-- `.moai/specs/SPEC-USER-001/spec.md` - Professional SPEC in EARS format
-- `feature/spec-user-001` - Git branch auto-created
+**Commit**:
+```bash
+git add tests/test_hello.py
+git commit -m "🔴 test(HELLO-001): add failing hello API tests"
+```
 
-### Step 6: TDD Implementation (about 3 minutes)
+---
 
-Once SPEC is written, implement using TDD:
+#### 🟢 GREEN Phase: Minimal Implementation
+
+**File Created**: `src/hello/api.py`
+
+```python
+# `@CODE:EX-HELLO-001:API | SPEC: SPEC-HELLO-001.md | TEST: tests/test_hello.py
+
+from fastapi import FastAPI
+
+app = FastAPI()
 
+@app.get("/hello")
+def hello(name: str = "World"):
+    """@CODE:EX-HELLO-001:API - Hello endpoint"""
+    return {"message": f"Hello, {name}!"}
 ```
-/alfred:2-run USER-001
+
+**Run**:
+```bash
+pytest tests/test_hello.py -v
+```
+
+**Result**: ✅ PASSED (all tests pass!)
+
+**Commit**:
+```bash
+git add src/hello/api.py
+git commit -m "🟢 feat(HELLO-001): implement hello API"
 ```
 
-This command handles:
+---
+
+#### ♻️ REFACTOR Phase: Add Validation
 
-- 🔴 **RED**: Automatically write failing test (`@TEST:USER-001`)
-- 🟢 **GREEN**: Minimal implementation to pass test (`@CODE:USER-001`)
-- ♻️ **REFACTOR**: Improve code quality
+**Enhanced Code**:
 
-### Step 7: Documentation Sync (about 1 minute)
+```python
+from fastapi import FastAPI, HTTPException
 
-Finally, auto-sync all documentation:
+app = FastAPI()
 
+@app.get("/hello")
+def hello(name: str = "World"):
+    """@CODE:EX-HELLO-001:API - Hello endpoint with validation"""
+    if len(name) > 50:
+        raise HTTPException(status_code=400, detail="Name too long (max 50 chars)")
+    return {"message": f"Hello, {name}!"}
 ```
-/alfred:3-sync
+
+**Add Test**:
+```python
+def test_hello_with_long_name_should_return_400():
+    """WHEN name exceeds 50 chars, THEN return 400 error"""
+    long_name = "a" * 51
+    response = client.get(f"/hello?name={long_name}")
+    assert response.status_code == 400
 ```
 
-Automatically generated/updated:
+**Run**:
+```bash
+pytest tests/test_hello.py -v
+```
+
+**Result**: ✅ PASSED (all tests pass!)
+
+**Commit**:
+```bash
+git add tests/test_hello.py src/hello/api.py
+git commit -m "♻️ refactor(HELLO-001): add name length validation"
+```
+
+---
+
+### Step 3: Documentation Sync (2 minutes)
+
+#### Command
+```bash
+/alfred:3-sync
+```
 
-- Living Document (API documentation)
-- README updates
-- CHANGELOG generation
-- @TAG chain validation
+#### Alfred Automatically
+```
+✅ docs/api/hello.md - API documentation generated
+✅ README.md - Usage examples added
+✅ CHANGELOG.md - Release notes added
+✅ TAG chain validated - All @TAG verified
+```
 
-### Complete!
+#### Check Generated API Documentation
+```bash
+cat docs/api/hello.md
+```
 
-After these 7 steps, everything is ready:
+**Example Content**:
+```markdown
+# Hello API Documentation
 
-✅ Requirements specification (SPEC)
-✅ Test code (85%+ coverage)
-✅ Implementation code (tracked with @TAG)
-✅ API documentation (auto-generated)
-✅ Change history (CHANGELOG)
-✅ Git commit history (RED/GREEN/REFACTOR)
+## GET /hello
 
-**Everything completes in 15 minutes!**
+### Description
+Returns a personalized greeting based on provided name.
 
-### Verify Generated Results
+### Parameters
+- `name` (query, optional): Person's name (default: "World", max 50 chars)
 
-Check if the generated results were properly created:
+### Responses
+- **200**: Success
+  ```json
+  { "message": "Hello, Alice!" }
+  ```
+- **400**: Name too long
 
+### Examples
 ```bash
-# 1. Check TAG chain (SPEC → TEST → CODE → DOC)
-rg '@(SPEC|TEST|CODE):USER-001' -n
+curl "http://localhost:8000/hello?name=Alice"
+# → {"message": "Hello, Alice!"}
 
-# 2. Run tests
-pytest tests/ -v
+curl "http://localhost:8000/hello"
+# → {"message": "Hello, World!"}
+```
 
-# 3. Check generated documentation
-cat docs/api/user.md
-cat README.md
+### Traceability
+- `@SPEC:EX-HELLO-001` - Requirements
+- `@TEST:EX-HELLO-001` - Tests
+- `@CODE:EX-HELLO-001:API` - Implementation
 ```
 
-> 🔍 **Verification Command**: `moai-adk doctor` — Checks if Python/uv versions, `.moai/` structure, and agent/Skills configuration are all ready.
->
-> ```bash
-> moai-adk doctor
-> ```
->
-> All green checkmarks mean perfect readiness!
+---
+
+### Step 4: Verify TAG Chain (1 minute)
+
+#### Command
+```bash
+rg '@(SPEC|TEST|CODE|DOC):HELLO-001' -n
+```
+
+#### Output (Complete Traceability)
+```
+.moai/specs/SPEC-HELLO-001/spec.md:7:# `@SPEC:EX-HELLO-001: Hello World API
+tests/test_hello.py:3:# `@TEST:EX-HELLO-001 | SPEC: SPEC-HELLO-001.md
+src/hello/api.py:3:# `@CODE:EX-HELLO-001:API | SPEC: SPEC-HELLO-001.md
+docs/api/hello.md:24:- `@SPEC:EX-HELLO-001`
+```
+
+✅ **Complete chain**: SPEC → TEST → CODE → DOC (fully traceable!)
+
+---
+
+### Summary: What You've Accomplished
+
+In just 10 minutes:
+
+✅ **SPEC** - Clear requirements documented
+✅ **TDD** - Red → Green → Refactor cycle
+✅ **Implementation** - Simple, testable code with @CODE TAG
+✅ **Documentation** - Auto-generated from code
+✅ **Traceability** - Complete @TAG chain: SPEC → TEST → CODE → DOC
+✅ **Git History** - Clean, semantic commits (🔴 🟢 ♻️)
 
 ---
 
@@ -432,6 +927,39 @@ When you run MoAI-ADK, Alfred loads configuration from **4 coordinated documents
 
 > ⚠️ **Important**: These are internal configuration files for Alfred, not user guides. Keep them concise and decision-focused. Most teams don't modify them.
 
+### Language Policy in CLAUDE.md (v0.7.0+)
+
+**Key Language Rules**:
+
+1. **User Conversation**: Your configured language (Korean, Japanese, Spanish, etc.)
+   - All responses, explanations, and guidance use your `conversation_language`
+   - Alfred reads this from `.moai/config.json`
+
+2. **Code & Git History**: Your configured language
+   - Code comments: Your language
+   - Commit messages: Your language
+   - Documentation: Your language
+
+3. **Infrastructure Only**: English
+   - `.claude/agents/`, `.claude/commands/`, `.claude/skills/` stay in English
+   - `@TAG` identifiers and technical terms use English
+   - `.moai/memory/` files remain in English
+
+**Example**:
+```
+Your CLAUDE.md talks to you in Korean (한국어)
+Your code comments are in Korean (한국어)
+Your git commits are in Korean (한국어)
+Your SPEC documents are in Korean (한국어)
+
+But Alfred's internal commands use English:
+  ✅ Skill("moai-foundation-trust")
+  ✅ @CODE:EX-AUTH-001 (TAG format)
+  ✅ .claude/skills/ (infrastructure)
+```
+
+**See Also**: [Language Localization Architecture](#language-localization-architecture-v070) for complete details on the hybrid language model.
+
 ---
 
 ## Alfred's Memory Files (.moai/memory/)
@@ -597,52 +1125,421 @@ Previously, all updates would sync templates even if nothing changed. Now, confi
 ```
 This field allows MoAI-ADK to accurately determine if templates need synchronization without re-syncing everything.
 
-#### Method 2: Upgrade with uv tool command
+#### Method 2: Upgrade with uv tool command
+
+**Upgrade specific tool (recommended)**
+
+```bash
+# Upgrade only moai-adk to latest version
+uv tool upgrade moai-adk
+```
+
+**Upgrade all installed tools**
+
+```bash
+# Upgrade all uv tool installations to latest versions
+uv tool update
+```
+
+**Install specific version**
+
+```bash
+# Reinstall specific version (e.g., 0.4.2)
+uv tool install moai-adk
+```
+
+### Verify After Update
+
+```bash
+# 1. Check installed version
+moai-adk --version
+
+# 2. Verify project works correctly
+moai-adk doctor
+
+# 3. Check updated features in Alfred
+cd your-project
+claude
+/alfred:0-project  # Verify new features like language selection
+```
+
+> 💡 **New 2-Stage Update Workflow**:
+>
+> - **Stage 1**: `moai-adk update` detects installer (uv tool, pipx, or pip) and upgrades package
+> - **Stage 2**: `moai-adk update` again to sync templates, config, and agent/Skills
+> - **Smart detection**: Auto-detects whether package upgrade is needed based on version comparison
+> - **CI/CD ready**: Use `moai-adk update --yes` for fully automated updates in pipelines
+> - **Manual upgrade path**: Use `moai-adk update --templates-only` after manually upgrading the package
+> - **Rollback safe**: Automatic backups in `.moai-backups/` before template sync
+
+### Optimize Project Templates with `/alfred:0-project update` (v0.9.0+)
+
+After upgrading MoAI-ADK with `moai-adk update`, your project templates and configurations may need optimization to stay in sync with the latest package version. Use the **dedicated Alfred command** to automatically merge template updates while preserving your customizations.
+
+#### When to Run `/alfred:0-project update`
+
+**Automatic Trigger**: After running `moai-adk update`, your project's `optimized` flag is set based on template changes:
+
+```bash
+# 1. Upgrade MoAI-ADK package
+moai-adk update
+# Output: ✓ Package upgraded to v0.9.0!
+# ℹ️  Next: Run `/alfred:0-project update` in Claude Code to optimize templates
+
+# 2. Open Claude Code
+claude
+
+# 3. Run optimization command
+/alfred:0-project update
+```
+
+#### What `/alfred:0-project update` Does
+
+**Phase 1: Smart Backup & Analysis**
+- ✅ Creates automatic backup in `.moai-backups/` (preserves all customizations)
+- ✅ Compares backup version with new template version
+- ✅ Generates comparison report showing changed sections
+- ✅ Presents user-friendly analysis with merge recommendations
+
+**Phase 2: Smart Merge (User Approval)**
+After reviewing the analysis, you can choose:
+- **"Proceed"** → Execute smart merge (merge backup + latest template)
+- **"Preview"** → View detailed change summary before proceeding
+- **"Skip"** → Keep current files unchanged (safe to proceed later)
+
+**Phase 3: Preserve Customizations**
+- ✅ Maintains latest template structure (sections, headers, @TAG format)
+- ✅ Inserts only your customizations (actual content you wrote)
+- ✅ Preserves HISTORY sections cumulatively
+- ✅ Updates version numbers automatically
+
+#### Complete Example
+
+```bash
+# Terminal: Upgrade MoAI-ADK
+$ moai-adk update
+✓ Package upgraded to v0.9.0!
+
+# Claude Code
+/alfred:0-project update
+
+# Alfred displays:
+# 📊 Project Update Analysis
+#
+# Current: CLAUDE.md v0.8.1 (248 lines, template + your customizations)
+# Latest:  Template v0.9.0 (787 lines, expanded guidelines)
+#
+# Changes Detected:
+# ✅ Alfred Persona System (new)
+# ✅ Language Boundary Rules (enhanced)
+# ✅ Report Style Standards (new)
+# ✅ Your Customizations: Preserved (한국어, GOOS🪿엉아, etc.)
+
+# User selects: 🔄 Smart Merge Proceed
+
+# Result:
+# ✅ Merge Complete!
+# - CLAUDE.md updated (v0.8.1 → v0.9.0)
+# - User customizations preserved
+# - config.json updated with optimization metadata
+# - Backup saved to .moai-backups/20251102-221000/
+```
+
+#### Key Features
+
+1. **Automatic Backup**: Always creates backup before merge (safe rollback available)
+2. **Smart Detection**: Identifies template defaults vs. your customizations
+3. **Preservation Policy**: Never overwrites your custom content
+4. **Version Tracking**: Automatically updates template_version in config.json
+5. **HISTORY Section**: Cumulative merge history preserved
+
+#### Command Reference
+
+| Operation | Command |
+|-----------|---------|
+| **Optimize** | `/alfred:0-project update` |
+| **Review First** | Select "Preview" option when prompted |
+| **Keep Current** | Select "Skip" option (safe—run later anytime) |
+| **Check Status** | `cat .moai/config.json \| grep -A2 optimization` |
+
+#### Rollback If Needed
+
+If something goes wrong, restore from automatic backup:
+
+```bash
+# List available backups
+ls -lt .moai-backups/
+
+# Restore from backup (example)
+cp -r .moai-backups/20251102-221000/CLAUDE.md ./CLAUDE.md
+cp -r .moai-backups/20251102-221000/.moai/config.json ./.moai/config.json
+```
+
+#### Why This Matters
+
+- **Stay Current**: Get latest Alfred improvements, fixes, and features
+- **Keep Your Work**: All customizations preserved through merges
+- **No Manual Editing**: Smart merge handles complex version synchronization
+- **Trust the Process**: Automatic backups ensure safe rollback anytime
+
+---
+
+## Development Setup for Contributors
+
+If you're developing **MoAI-ADK itself**, follow these steps to set up your development environment.
+
+### Prerequisites
+
+- Python 3.13+
+- `uv` package manager
+- Git
+
+### Setup Steps
+
+#### Step 1: Clone and Install in Editable Mode
+
+```bash
+# Clone the repository
+git clone https://github.com/modu-ai/moai-adk.git
+cd moai-adk
+
+# Install in editable mode (creates symlink, not a copy)
+uv pip install -e .
+
+# Or with pip (also works)
+pip install -e .
+```
+
+The editable install allows your local changes to be immediately reflected when using `moai-adk` command.
+
+#### Step 2: Initialize Development Configuration
+
+After the editable install, initialize the development repository's configuration:
+
+```bash
+# Run the initialization script
+bash .moai/scripts/init-dev-config.sh
+```
+
+**What this script does:**
+- Extracts the actual version from `pyproject.toml`
+- Replaces template placeholders (`{{MOAI_VERSION}}`) with actual version values in `.moai/config.json`
+- Sets up `project.template_version` field
+- Ensures the `moai-adk update` command works correctly on first run
+
+**Why is this necessary?**
+
+When you install MoAI-ADK in editable mode, the `.moai/config.json` file contains unsubstituted template placeholders. This causes the first `moai-adk update` command to fail with version comparison errors. The init script resolves these placeholders so everything works seamlessly.
+
+#### Step 3: Verify Setup
+
+```bash
+# Check that moai-adk works
+moai-adk --version
+
+# Run the health check
+moai-adk doctor
+
+# Expected output:
+# ✅ Python version: 3.13+
+# ✅ UV installed
+# ✅ Project structure: Valid
+# ✅ Configuration: Ready
+```
+
+#### Step 4: Run Tests
+
+```bash
+# Run all tests with coverage
+pytest tests/
+
+# Run specific test module
+pytest tests/unit/test_update.py -v
+
+# Run with coverage report
+pytest tests/ --cov=src/moai_adk --cov-report=html
+
+# Check coverage thresholds
+pytest tests/ --cov=src/moai_adk --cov-report=term-missing
+```
+
+### Common Development Workflow
+
+#### After Making Code Changes
+
+```bash
+# 1. Run tests to ensure nothing broke
+pytest tests/ -v
+
+# 2. Check code style
+ruff check src/
+ruff format src/
+
+# 3. Type checking
+mypy src/
+
+# 4. If you modified update.py, test the update command
+moai-adk update --check
+```
+
+#### Testing the Update Command
+
+The update command has been fixed to handle invalid version strings gracefully. To test it in development:
+
+```bash
+# Test update without applying it
+moai-adk update --check
+
+# Test with force mode (skips backup)
+moai-adk update --force
+
+# Test with specific version
+moai-adk update --templates-only
+```
+
+### Understanding the Init Script
+
+The `.moai/scripts/init-dev-config.sh` script performs these operations:
+
+1. **Extracts Version**: Reads `pyproject.toml` to get the current version
+2. **Updates Config**: Modifies `.moai/config.json` to set:
+   - `moai.version` → actual version value
+   - `project.template_version` → actual version value
+3. **Validates**: Ensures the JSON structure is preserved correctly
+4. **Provides Feedback**: Shows what was updated and verifies the changes
+
+### Troubleshooting Development Setup
+
+#### Problem: `moai-adk` command not found
+
+```bash
+# Solution 1: Reinstall in editable mode
+uv pip install -e .
+
+# Solution 2: Verify uv environment
+uv pip list | grep moai-adk
+
+# Solution 3: Use full path
+python -m moai_adk --version
+```
+
+#### Problem: `.moai/config.json` still has placeholders after running init script
+
+```bash
+# Manually check the config
+cat .moai/config.json | grep -i moai_version
+
+# If still showing {{MOAI_VERSION}}, rerun the script:
+bash .moai/scripts/init-dev-config.sh
+
+# Or manually update using Python:
+python3 << 'EOF'
+import json
+from pathlib import Path
+
+config_path = Path(".moai/config.json")
+config = json.loads(config_path.read_text())
+
+# Update manually
+config['moai']['version'] = "0.8.1"
+config['project']['template_version'] = "0.8.1"
+
+config_path.write_text(json.dumps(config, indent=2) + '\n')
+print("✅ Config updated manually")
+EOF
+```
+
+#### Problem: `moai-adk update` requires running twice
+
+This issue has been **fixed** in v0.8.1+. If you're experiencing this:
+
+1. Ensure you've run the init script: `bash .moai/scripts/init-dev-config.sh`
+2. Update to the latest version: `pip install -e --upgrade .`
+3. Verify the config has actual versions: `cat .moai/config.json | grep version`
+
+**What was the issue?**
+- Development installations had unsubstituted `{{MOAI_VERSION}}` placeholders in config
+- First `moai-adk update` would fail comparing "0.8.1" vs "{{MOAI_VERSION}}"
+- Second run might partially work after partial sync
+
+**How it's fixed:**
+- `init-dev-config.sh` replaces placeholders with actual versions
+- Code now gracefully handles InvalidVersion exceptions
+- Added comprehensive unit tests for placeholder detection
+
+#### Problem: UV Tool Upgrade Shows "Nothing to upgrade" Despite New Version
+
+**Status**: Automatically fixed in v0.9.1+ with cache refresh retry
 
-**Upgrade specific tool (recommended)**
+**Symptoms:**
+- `moai-adk update` shows "Nothing to upgrade"
+- PyPI has a newer version available
+- Caused by stale UV cache metadata
 
+**Automatic Fix (v0.9.1+):**
+The system now automatically detects stale cache and retries:
+1. Detects "Nothing to upgrade" message
+2. Compares installed version vs PyPI latest version
+3. Clears UV cache: `uv cache clean moai-adk`
+4. Automatically retries upgrade
+5. Completes in a single command run
+
+**Manual Workaround (if needed):**
 ```bash
-# Upgrade only moai-adk to latest version
-uv tool upgrade moai-adk
+# Clear UV cache and retry
+uv cache clean moai-adk && moai-adk update
 ```
 
-**Upgrade all installed tools**
+**Technical Details:**
+- Root cause: UV caches PyPI metadata that can become outdated
+- Detection: Compares version strings when "Nothing to upgrade" appears
+- Retry limit: Maximum 1 retry to prevent infinite loops
+- Timeout: 10 seconds for cache clear operation
 
-```bash
-# Upgrade all uv tool installations to latest versions
-uv tool update
-```
+**References:**
+- SPEC: @SPEC:EX-UPDATE-001
+- Implementation: @CODE:EX-UPDATE-001-001, @CODE:EX-UPDATE-001-002, @CODE:EX-UPDATE-001-003
+- Tests: @TEST:EX-UPDATE-001
 
-**Install specific version**
+### Contributing Tests
+
+When adding new features, always include tests:
 
 ```bash
-# Reinstall specific version (e.g., 0.4.2)
-uv tool install moai-adk==0.4.2
+# Add tests to tests/unit/ or tests/integration/
+# Follow existing test patterns in test_update.py
+
+# Run your new tests
+pytest tests/unit/test_*.py -v
+
+# Ensure coverage remains ≥ 85%
+pytest tests/ --cov=src/moai_adk --cov-report=term-missing
 ```
 
-### Verify After Update
+### Making a Pull Request
+
+Before opening a PR, ensure:
 
 ```bash
-# 1. Check installed version
-moai-adk --version
+# 1. All tests pass
+pytest tests/ -v
 
-# 2. Verify project works correctly
-moai-adk doctor
+# 2. Coverage is adequate
+pytest tests/ --cov=src/moai_adk --cov-report=term-missing
 
-# 3. Check updated features in Alfred
-cd your-project
-claude
-/alfred:0-project  # Verify new features like language selection
-```
+# 3. Code is formatted
+ruff format src/
+ruff check src/
 
-> 💡 **New 2-Stage Update Workflow**:
->
-> - **Stage 1**: `moai-adk update` detects installer (uv tool, pipx, or pip) and upgrades package
-> - **Stage 2**: `moai-adk update` again to sync templates, config, and agent/Skills
-> - **Smart detection**: Auto-detects whether package upgrade is needed based on version comparison
-> - **CI/CD ready**: Use `moai-adk update --yes` for fully automated updates in pipelines
-> - **Manual upgrade path**: Use `moai-adk update --templates-only` after manually upgrading the package
-> - **Rollback safe**: Automatic backups in `.moai-backups/` before template sync
+# 4. Types are valid
+mypy src/
+
+# 5. Init script works
+bash .moai/scripts/init-dev-config.sh
+
+# 6. Update command works
+moai-adk update --check
+```
 
 ---
 
@@ -696,8 +1593,11 @@ graph TD
 | `/alfred:1-plan <description>` | Analyze requirements, draft SPEC, write Plan Board                | `.moai/specs/SPEC-*/spec.md`, plan/acceptance docs, feature branch |
 | `/alfred:2-run <SPEC-ID>`      | Execute TDD, test/implement/refactor, verify quality              | `tests/`, `src/` implementation, quality report, TAG connection    |
 | `/alfred:3-sync`               | Sync docs/README/CHANGELOG, organize TAG/PR status                | `docs/`, `.moai/reports/sync-report.md`, Ready PR                  |
+| `/alfred:9-feedback` | Interactively create GitHub Issues (type → title → description → priority) | GitHub Issue with auto labels, priority, URL        |
 
 > ❗ All commands maintain **Phase 0 (optional) → Phase 1 → Phase 2 → Phase 3** cycle structure. Alfred automatically reports execution status and next-step suggestions.
+>
+> 💡 **New in v0.7.0+**: `/alfred:9-feedback` enables instant GitHub Issue creation during development, keeping your workflow uninterrupted while keeping issues tracked and visible to the team.
 
 ---
 
@@ -814,6 +1714,125 @@ When working in your **local development environment**, CodeRabbit provides auto
 
 ---
 
+## Quick Issue Creation with `/alfred:9-feedback`
+
+MoAI-ADK v0.7.0+ includes the **Quick Issue Creation** feature, allowing developers to instantly create GitHub Issues without interrupting their development workflow.
+
+### Why Quick Issue Creation?
+
+During development, you frequently encounter:
+- 🐛 Bugs that need immediate reporting
+- ✨ Feature ideas that come to mind
+- ⚡ Performance improvements to suggest
+- ❓ Architecture questions that need team discussion
+
+**The old way**: Stop coding, go to GitHub, manually fill issue form, remember what you were working on.
+**The new way**: Type one command, GitHub Issue is created instantly, continue coding.
+
+### Interactive Dialog Flow
+
+When you run `/alfred:9-help`, Alfred guides you through an interactive multi-step dialog:
+
+**Step 1: Select Issue Type**
+```
+Alfred: What type of issue do you want to create?
+[ ] 🐛 Bug Report - Something isn't working
+[ ] ✨ Feature Request - Suggest new functionality
+[ ] ⚡ Improvement - Enhance existing features
+[ ] ❓ Question/Discussion - Ask the team
+```
+
+**Step 2: Enter Issue Title**
+```
+Alfred: What's the issue title?
+Your input: "Login button not responding to clicks"
+```
+
+**Step 3: Enter Description (Optional)**
+```
+Alfred: Provide a detailed description (optional—press Enter to skip)
+Your input: "When I click the login button on iPhone 15, it freezes for 5 seconds then crashes"
+```
+
+**Step 4: Select Priority Level**
+```
+Alfred: What's the priority level?
+[ ] 🔴 Critical - System down, data loss, security breach
+[ ] 🟠 High - Major feature broken, significant impact
+[✓] 🟡 Medium - Normal priority (default)
+[ ] 🟢 Low - Minor issues, nice-to-have
+```
+
+**Step 5: Automatic Issue Creation**
+```
+Alfred automatically:
+1. Determines appropriate labels based on issue type and priority
+2. Formats title with emoji: "🐛 [BUG] Login button not responding..."
+3. Creates GitHub Issue with all information
+4. Returns the issue number and URL
+```
+
+### Key Features
+
+1. **⚡ Instant Creation**: Create GitHub Issues in seconds
+2. **🏷️ Automatic Labels**: Issue type + priority automatically labeled
+3. **🎯 Priority Selection**: Choose from Critical/High/Medium/Low
+4. **🔗 Team Visibility**: Issues immediately visible and discussable
+5. **📋 Standardized Format**: All issues follow consistent structure
+
+### Complete Example: Bug Report During Code Review
+
+```bash
+# During code review, you notice a critical issue and want to report it instantly
+$ /alfred:9-feedback
+
+Alfred: What type of issue do you want to create?
+> 🐛 Bug Report
+
+Alfred: What's the issue title?
+> Login button crash on mobile devices
+
+Alfred: Provide a detailed description (optional—press Enter to skip)
+> Tapping the login button on iPhone 15 causes app to freeze for 5 seconds then crash.
+> Tested on iOS 17.2, Chrome 120 on macOS 14.2.
+> Expected: Login modal should appear
+> Actual: No response then crash
+
+Alfred: What's the priority level?
+> 🟠 High
+
+✅ GitHub Issue #234 created successfully!
+
+📋 Title: 🐛 [BUG] Login button crash on mobile devices
+🟠 Priority: High
+🏷️  Labels: bug, reported, priority-high
+🔗 URL: https://github.com/owner/repo/issues/234
+
+💡 Next: Continue with your work—the issue is now tracked!
+```
+
+### Integration with MoAI-ADK Workflow
+
+1. **During Development**: Use `/alfred:9-help` to report bugs/ideas instantly
+2. **In Code Review**: Convert improvement suggestions to tracked issues
+3. **When Planning**: Reference created issues in SPEC documents
+4. **During Sync**: Link issues to SPEC requirements with `/alfred:3-sync`
+
+### Prerequisites
+
+- GitHub CLI (`gh`) installed and authenticated
+- Repository initialized with Git
+
+### Learn More
+
+See `.moai/docs/quick-issue-creation-guide.md` for comprehensive documentation including:
+- Detailed usage examples
+- Best practices and tips
+- Troubleshooting guide
+- Integration with SPEC documents
+
+---
+
 ## 5 Key Concepts
 
 MoAI-ADK consists of 5 key concepts. Each concept connects to the others, and together they create a powerful development system.
@@ -887,13 +1906,13 @@ MoAI-ADK consists of 5 key concepts. Each concept connects to the others, and to
 **TAG Chain**:
 
 ```
-@SPEC:AUTH-001 (requirements)
+@SPEC:EX-AUTH-001 (requirements)
     ↓
-@TEST:AUTH-001 (test)
+@TEST:EX-AUTH-001 (test)
     ↓
-@CODE:AUTH-001 (implementation)
+@CODE:EX-AUTH-001 (implementation)
     ↓
-@DOC:AUTH-001 (documentation)
+@DOC:EX-AUTH-001 (documentation)
 ```
 
 **TAG ID Rules**: `<Domain>-<3 digits>`
@@ -1029,7 +2048,7 @@ author: @user
 priority: high
 ---
 
-# @SPEC:TODO-001: Todo Management API
+# @SPEC:EX-TODO-001: Todo Management API
 
 ## Ubiquitous Requirements
 - The system SHALL be able to add todos
@@ -1065,7 +2084,7 @@ The **implementation-planner** Sub-agent decides:
 
 - 📚 Libraries: FastAPI + SQLAlchemy
 - 📁 Folder structure: `src/todo/`, `tests/todo/`
-- 🏷️ TAG design: `@CODE:TODO-001:API`, `@CODE:TODO-001:MODEL`, `@CODE:TODO-001:REPO`
+- 🏷️ TAG design: `@CODE:EX-TODO-001:API`, `@CODE:EX-TODO-001:MODEL`, `@CODE:EX-TODO-001:REPO`
 
 **Phase 2: RED → GREEN → REFACTOR**
 
@@ -1073,7 +2092,7 @@ The **implementation-planner** Sub-agent decides:
 
 ```python
 # tests/test_todo_api.py
-# @TEST:TODO-001 | SPEC: SPEC-TODO-001.md
+# @TEST:README-EXAMPLE-TODO | SPEC: SPEC-TODO-001.md
 
 import pytest
 from src.todo.api import create_todo, get_todos
@@ -1115,7 +2134,7 @@ git commit -m "🔴 test(TODO-001): add failing API tests"
 
 ```python
 # src/todo/api.py
-# @CODE:TODO-001:API | SPEC: SPEC-TODO-001.md | TEST: tests/test_todo_api.py
+# @CODE:EX-TODO-001:API | SPEC: SPEC-TODO-001.md | TEST: tests/test_todo_api.py
 
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
@@ -1129,19 +2148,19 @@ class TodoRequest(BaseModel):
 
 @app.post("/todos", status_code=201)
 def create_todo(todo: TodoRequest):
-    """@CODE:TODO-001:API - POST endpoint"""
+    """@CODE:EX-TODO-001:API - POST endpoint"""
     todo_id = str(uuid.uuid4())
     todos_db[todo_id] = {"id": todo_id, "title": todo.title}
     return todos_db[todo_id]
 
 @app.get("/todos")
 def get_todos():
-    """@CODE:TODO-001:API - GET all endpoint"""
+    """@CODE:EX-TODO-001:API - GET all endpoint"""
     return list(todos_db.values())
 
 @app.get("/todos/{todo_id}")
 def get_todo(todo_id: str):
-    """@CODE:TODO-001:API - GET by ID endpoint"""
+    """@CODE:EX-TODO-001:API - GET by ID endpoint"""
     if todo_id not in todos_db:
         raise HTTPException(status_code=404, detail="Todo not found")
     return todos_db[todo_id]
@@ -1160,7 +2179,7 @@ git commit -m "🟢 feat(TODO-001): implement minimal Todo API"
 
 ```python
 # src/todo/models.py
-# @CODE:TODO-001:MODEL | SPEC: SPEC-TODO-001.md
+# @CODE:EX-TODO-001:MODEL | SPEC: SPEC-TODO-001.md
 
 from datetime import datetime
 from sqlalchemy import Column, String, DateTime
@@ -1169,7 +2188,7 @@ from sqlalchemy.ext.declarative import declarative_base
 Base = declarative_base()
 
 class Todo(Base):
-    """@CODE:TODO-001:MODEL - Todo data model"""
+    """@CODE:EX-TODO-001:MODEL - Todo data model"""
     __tablename__ = "todos"
 
     id = Column(String, primary_key=True)
@@ -1177,7 +2196,7 @@ class Todo(Base):
     created_at = Column(DateTime, default=datetime.utcnow)   # Auto creation time
 
     def validate(self):
-        """@CODE:TODO-001:MODEL - Validation"""
+        """@CODE:EX-TODO-001:MODEL - Validation"""
         if not self.title or len(self.title) > 200:
             raise ValueError("Title must be 1-200 characters")
 ```
@@ -1213,10 +2232,10 @@ git commit -m "♻️ refactor(TODO-001): add database models and validation"
 1. **TAG Chain Validation**
 
    ```bash
-   ✅ @SPEC:TODO-001 → .moai/specs/SPEC-TODO-001/spec.md
-   ✅ @TEST:TODO-001 → tests/test_todo_api.py
-   ✅ @CODE:TODO-001 → src/todo/ (3 files)
-   ✅ @DOC:TODO-001 → docs/api/todo.md (auto-generated)
+   ✅ @SPEC:EX-TODO-001 → .moai/specs/SPEC-TODO-001/spec.md
+   ✅ @TEST:README-EXAMPLE-TODO → tests/test_todo_api.py
+   ✅ @CODE:EX-TODO-001 → src/todo/ (3 files)
+   ✅ @DOC:EX-TODO-001 → docs/api/todo.md (auto-generated)
 
    TAG Chain Integrity: 100%
    Orphan TAGs: None
@@ -1225,7 +2244,7 @@ git commit -m "♻️ refactor(TODO-001): add database models and validation"
 2. **Living Document Generation**
 
    ```markdown
-   # @DOC:TODO-001: Todo Management API
+   # @DOC:EX-TODO-001: Todo Management API
 
    ## Overview
 
@@ -1239,8 +2258,8 @@ git commit -m "♻️ refactor(TODO-001): add database models and validation"
    - URL: /todos
    - Request: {"title": "string (1-200 chars)"}
    - Response: 201 Created with todo object
-   - Implemented in: @CODE:TODO-001:API
-   - Tested in: @TEST:TODO-001
+   - Implemented in: @CODE:EX-TODO-001:API
+   - Tested in: @TEST:README-EXAMPLE-TODO
 
    ### Get All Todos
 
@@ -1268,7 +2287,7 @@ git commit -m "♻️ refactor(TODO-001): add database models and validation"
 
    ### Added
 
-   - Todo Management API with CRUD operations (@SPEC:TODO-001)
+   - Todo Management API with CRUD operations (@SPEC:EX-TODO-001)
      - Create new todos
      - List all todos
      - Update existing todos
@@ -1290,11 +2309,11 @@ Let's verify everything generated is properly connected:
 rg '@(SPEC|TEST|CODE|DOC):TODO-001' -n
 
 # Output:
-# .moai/specs/SPEC-TODO-001/spec.md:1: # @SPEC:TODO-001: Todo Management API
-# tests/test_todo_api.py:2: # @TEST:TODO-001 | SPEC: SPEC-TODO-001.md
-# src/todo/api.py:5: # @CODE:TODO-001:API | SPEC: SPEC-TODO-001.md
-# src/todo/models.py:5: # @CODE:TODO-001:MODEL | SPEC: SPEC-TODO-001.md
-# docs/api/todo.md:1: # @DOC:TODO-001: Todo Management API
+# .moai/specs/SPEC-TODO-001/spec.md:1: # @SPEC:EX-TODO-001: Todo Management API
+# tests/test_todo_api.py:2: # @TEST:README-EXAMPLE-TODO | SPEC: SPEC-TODO-001.md
+# src/todo/api.py:5: # @CODE:EX-TODO-001:API | SPEC: SPEC-TODO-001.md
+# src/todo/models.py:5: # @CODE:EX-TODO-001:MODEL | SPEC: SPEC-TODO-001.md
+# docs/api/todo.md:1: # @DOC:EX-TODO-001: Todo Management API
 
 
 # 2️⃣ Run tests
@@ -1324,21 +2343,21 @@ git log --oneline | head -5
 
 ```
 ✅ SPEC written (3 minutes)
-   └─ @SPEC:TODO-001 TAG assigned
+   └─ @SPEC:EX-TODO-001 TAG assigned
    └─ Clear requirements in EARS format
 
 ✅ TDD implementation (5 minutes)
    └─ 🔴 RED: Tests written first
    └─ 🟢 GREEN: Minimal implementation
    └─ ♻️ REFACTOR: Quality improvement
-   └─ @TEST:TODO-001, @CODE:TODO-001 TAGs assigned
+   └─ @TEST:README-EXAMPLE-TODO, @CODE:EX-TODO-001 TAGs assigned
    └─ 87% coverage, TRUST 5 principles verified
 
 ✅ Documentation sync (1 minute)
    └─ Living Document auto-generated
    └─ README, CHANGELOG updated
    └─ TAG chain validation complete
-   └─ @DOC:TODO-001 TAG assigned
+   └─ @DOC:EX-TODO-001 TAG assigned
    └─ PR status: Draft → Ready for Review
 
 Result:
@@ -1364,16 +2383,33 @@ Alfred works by combining multiple specialized agents with Claude Skills.
 | Sub-agent          | Model  | Role                                                                    |
 | ------------------ | ------ | ----------------------------------------------------------------------- |
 | project-manager 📋 | Sonnet | Project initialization, metadata interviews                             |
-| spec-builder 🏗️    | Sonnet | Plan board, EARS SPEC authoring                                         |
+| spec-builder 🏗️    | Sonnet | Plan board, EARS SPEC authoring, expert consultation recommendations    |
 | code-builder 💎    | Sonnet | Performs complete TDD with `implementation-planner` + `tdd-implementer` |
 | doc-syncer 📖      | Haiku  | Living Doc, README, CHANGELOG sync                                      |
-| tag-agent 🏷️       | Haiku  | TAG inventory, orphan detection                                         |
+| tag-agent 🏷️       | Haiku  | TAG inventory, orphan detection, @EXPERT TAG validation                 |
 | git-manager 🚀     | Haiku  | GitFlow, Draft/Ready, Auto Merge                                        |
 | debug-helper 🔍    | Sonnet | Failure analysis, fix-forward strategy                                  |
 | trust-checker ✅   | Haiku  | TRUST 5 quality gate                                                    |
 | quality-gate 🛡️    | Haiku  | Coverage change and release blocker review                              |
 | cc-manager 🛠️      | Sonnet | Claude Code session optimization, Skill deployment                      |
 
+### Expert Agents (Proactively Triggered by SPEC Keywords)
+
+Expert agents activate automatically when `implementation-planner` detects domain-specific keywords in SPEC documents. They provide architecture guidance, technology recommendations, and risk analysis for their specialized domains.
+
+| Expert Agent      | Model  | Specialty                                           | Auto-Trigger Keywords                                                    |
+| ----------------- | ------ | --------------------------------------------------- | ------------------------------------------------------------------------ |
+| backend-expert 🔧 | Sonnet | Backend architecture, API design, database, auth   | 'backend', 'api', 'server', 'database', 'deployment', 'authentication'  |
+| frontend-expert 💻| Sonnet | Frontend architecture, components, state mgmt      | 'frontend', 'ui', 'page', 'component', 'client-side', 'web interface'   |
+| devops-expert 🚀  | Sonnet | DevOps, CI/CD, deployment, containerization        | 'deployment', 'docker', 'kubernetes', 'ci/cd', 'pipeline', 'aws'        |
+| ui-ux-expert 🎨   | Sonnet | UI/UX design, accessibility (WCAG), design systems | 'design', 'ux', 'accessibility', 'a11y', 'figma', 'design system'       |
+
+**How It Works**:
+- When `/alfred:2-run` starts, `implementation-planner` scans the SPEC content
+- Matching keywords trigger automatic expert agent invocation
+- Experts provide domain-specific architecture guidance
+- All expert consultations are tagged with `@EXPERT:DOMAIN` for traceability
+
 ### Skills (Progressive Disclosure - v0.4 New!)
 
 Alfred organizes Claude Skills in a 4-tier architecture using **Progressive Disclosure** to load Just-In-Time only when needed. Each Skill is a production-grade guide stored in `.claude/skills/` directory.
@@ -1426,6 +2462,7 @@ Specialized domain expertise
 | `moai-domain-cli-tool`     | CLI tool development, argument parsing, POSIX compliance, user-friendly help messages    |
 | `moai-domain-data-science` | Data analysis, visualization, statistical modeling, reproducible research workflows      |
 | `moai-domain-database`     | Database design, schema optimization, indexing strategies, migration management          |
+| `moai-domain-design-systems` | Design system architecture, W3C DTCG tokens, WCAG 2.2 accessibility, design-to-code, Figma MCP |
 | `moai-domain-devops`       | CI/CD pipelines, Docker containerization, Kubernetes orchestration, IaC                  |
 | `moai-domain-frontend`     | React/Vue/Angular development, state management, performance optimization, accessibility |
 | `moai-domain-ml`           | Machine learning model training, evaluation, deployment, MLOps workflows                 |
@@ -1521,7 +2558,7 @@ Hooks are **event-driven** scripts that trigger automatically at specific points
 - Editing critical files (`CLAUDE.md`, `config.json`)
 - Mass edits (10+ files at once via MultiEdit)
 
-**TAG Guard (New in v0.4.11)**:
+**TAG Guard**:
 Automatically detects missing @TAG annotations in changed files:
 
 - Scans staged, modified, and untracked files
@@ -1652,15 +2689,335 @@ If you need to temporarily disable hooks, edit `.claude/settings.json`:
 
 | Version     | Key Features                                                                                     | Date       |
 | ----------- | ------------------------------------------------------------------------------------------------ | ---------- |
+| **v0.8.2**  | 📖 EARS terminology update: "Constraints" → "Unwanted Behaviors" for clarity                     | 2025-10-29 |
+| **v0.8.1**  | 🔄 Command rename: `/alfred:9-help` → `/alfred:9-feedback` + User feedback workflow improvements | 2025-10-28 |
+| **v0.8.0**  | 🏷️ @DOC TAG auto-generation system + SessionStart version check enhancement                      | 2025-10-27 |
+| **v0.7.0**  | 🌍 Complete language localization system (English, Korean, Japanese, Chinese, Spanish)           | 2025-10-26 |
+| **v0.6.3**  | ⚡ 3-Stage update workflow: 70-80% performance improvement via parallel operations               | 2025-10-25 |
+| **v0.6.0**  | 🏗️ Major architecture refactor + Enhanced SPEC metadata structure (7 required + 9 optional)      | 2025-10-24 |
 | **v0.5.7**  | 🎯 SPEC → GitHub Issue automation + CodeRabbit integration + Auto PR comments                    | 2025-10-27 |
 | **v0.4.11** | ✨ TAG Guard system + CLAUDE.md formatting improvements + Code cleanup                           | 2025-10-23 |
-| **v0.4.10** | 🔧 Hook robustness improvements + Bilingual documentation + Template language config             | 2025-10-23 |
-| **v0.4.9**  | 🎯 Hook JSON schema validation fixes + Comprehensive tests (468/468 passing)                     | 2025-10-23 |
-| **v0.4.8**  | 🚀 Release automation + PyPI deployment + Skills refinement                                      | 2025-10-23 |
-| **v0.4.7**  | 📖 Korean language optimization + SPEC-First principle documentation                             | 2025-10-22 |
-| **v0.4.6**  | 🎉 Complete Skills v2.0 (100% Production-Ready) + 85,000 lines official docs + 300+ TDD examples | 2025-10-22 |
 
-> 📦 **Install Now**: `uv tool install moai-adk==0.4.11` or `pip install moai-adk==0.4.11`
+> 📦 **Install Now**: `uv tool install moai-adk` or `pip install moai-adk`
+
+---
+
+## 🔧 Beginner's Troubleshooting Guide
+
+Common errors and solutions for getting started with MoAI-ADK.
+
+### 1. uv is Not Installed
+
+**Symptom**:
+```bash
+$ uv --version
+bash: uv: command not found
+```
+
+**Cause**: uv not installed or not in PATH
+
+**Solution**:
+
+**macOS/Linux**:
+```bash
+# Install
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
+# Restart shell
+source ~/.bashrc  # or ~/.zshrc
+
+# Verify
+uv --version
+```
+
+**Windows (PowerShell)**:
+```powershell
+powershell -c "irm https://astral.sh/uv/install.ps1 | iex"
+
+# Verify
+uv --version
+```
+
+**If still not working**:
+```bash
+# Manually add PATH (macOS/Linux)
+export PATH="$HOME/.cargo/bin:$PATH"
+
+# Verify
+uv --version
+```
+
+---
+
+### 2. Python Version Mismatch
+
+**Symptom**:
+```
+Python 3.8 found, but 3.13+ required
+```
+
+**Cause**: Python version is less than 3.13
+
+**Solution**:
+
+**Option A: Using pyenv (Recommended)**:
+```bash
+# Install pyenv
+curl https://pyenv.run | bash
+
+# Install Python 3.13
+pyenv install 3.13
+pyenv global 3.13
+
+# Verify
+python --version  # Python 3.13.x
+```
+
+**Option B: Let uv manage Python**:
+```bash
+# uv automatically downloads Python 3.13
+uv python install 3.13
+uv python pin 3.13
+
+# Verify
+python --version
+```
+
+---
+
+### 3. Git Not Found
+
+**Symptom**:
+```
+✗ Git (runtime): not found
+```
+
+**Cause**: Git not installed on system
+
+**Solution**:
+
+**macOS**:
+```bash
+# Using Homebrew
+brew install git
+
+# Or install Xcode Command Line Tools
+xcode-select --install
+```
+
+**Ubuntu/Debian**:
+```bash
+sudo apt update
+sudo apt install git -y
+```
+
+**Windows**:
+```powershell
+# Using winget
+winget install Git.Git
+
+# Or download from https://git-scm.com/download/win
+```
+
+**Verify**:
+```bash
+git --version  # git version 2.x.x
+```
+
+---
+
+### 4. Claude Code Doesn't Recognize .moai/ Folder
+
+**Symptom**:
+```
+"Project not initialized"
+/alfred:0-project command doesn't work
+```
+
+**Cause**: `.moai/` or `.claude/` folders missing or corrupted
+
+**Solution**:
+
+```bash
+# 1. Verify current directory
+pwd  # /path/to/your-project
+
+# 2. Check if .moai/ exists
+ls -la .moai/config.json
+
+# 3. If missing, reinitialize
+moai-adk init .
+
+# 4. Restart Claude Code
+exit  # Exit Claude Code
+claude  # Restart
+```
+
+**Verify**:
+```bash
+moai-adk doctor
+# All items should show ✅
+```
+
+---
+
+### 5. Module Not Found When Running Tests
+
+**Symptom**:
+```
+FAILED tests/test_hello.py - ModuleNotFoundError: No module named 'fastapi'
+```
+
+**Cause**: Required package not installed
+
+**Solution**:
+
+```bash
+# Install dependencies from project root
+uv sync
+
+# Or install specific packages
+uv add fastapi pytest
+
+# Activate virtual environment
+source .venv/bin/activate  # macOS/Linux
+.venv\Scripts\activate     # Windows
+
+# Run tests
+pytest tests/ -v
+```
+
+---
+
+### 6. `/alfred` Commands Not Working
+
+**Symptom**:
+```
+Unknown command: /alfred:1-plan
+```
+
+**Cause**: Claude Code version issue or `.claude/` folder corrupted
+
+**Solution**:
+
+```bash
+# 1. Check Claude Code version (need v1.5.0+)
+claude --version
+
+# 2. Verify .claude/ folder
+ls -la .claude/commands/
+
+# 3. Reinitialize if needed
+moai-adk init .
+
+# 4. Restart Claude Code
+exit
+claude
+```
+
+---
+
+### 7. TAG Chain Broken
+
+**Symptom**:
+```
+⚠ Orphan TAG detected: @TEST:EX-HELLO-001 (no matching @SPEC)
+```
+
+**Cause**: SPEC deleted or TAGs don't match
+
+**Solution**:
+
+```bash
+# 1. Validate TAG chain
+rg '@(SPEC|TEST|CODE):HELLO-001' -n
+
+# 2. Check if SPEC exists
+rg '@SPEC:EX-HELLO-001' -n .moai/specs/
+
+# 3. If SPEC missing, regenerate
+/alfred:1-plan "feature description"
+
+# Or fix TAG in test file
+# Edit tests/test_hello.py: @TEST:EX-HELLO-001 → @TEST:README-EXAMPLE-HELLO
+
+# 4. Sync
+/alfred:3-sync
+```
+
+---
+
+### 8. General Debugging Commands
+
+**Check System Status**:
+```bash
+moai-adk doctor
+```
+Shows all dependency checks + recommendations
+
+**Check Project Structure**:
+```bash
+tree -L 2 .moai/
+```
+
+**Validate TAG Chain Integrity**:
+```bash
+rg '@(SPEC|TEST|CODE|DOC):' -n | wc -l
+```
+Shows total TAG count
+
+**Check Git Status**:
+```bash
+git status
+git log --oneline -5
+```
+
+---
+
+### Debugging Checklist
+
+When something goes wrong:
+
+1. **Read**: Copy the complete error message
+2. **Search**: Check GitHub Issues for similar errors
+3. **Diagnose**: Run `moai-adk doctor`
+4. **Restart**: Quit and restart Claude Code
+5. **Ask**: Post in GitHub Discussions
+
+Quick diagnosis with details:
+```bash
+moai-adk doctor --verbose
+```
+
+---
+
+### Need More Help?
+
+- **GitHub Issues**: Search for similar problems
+- **GitHub Discussions**: Ask questions
+- **Discord Community**: Real-time chat support
+
+**When reporting issues, include**:
+1. Output from `moai-adk doctor --verbose`
+2. Complete error message (screenshot or text)
+3. Steps to reproduce
+4. Your OS and version
+
+---
+
+### Frequently Asked Questions
+
+**Q. Can I install on an existing project?**
+A. Yes! Run `moai-adk init .` - it only adds `.moai/` structure without touching existing code.
+
+**Q. How do I run tests?**
+A. `/alfred:2-run` runs tests first. You can also run `pytest`, `pnpm test` separately.
+
+**Q. How do I verify documentation is current?**
+A. Run `/alfred:3-sync` which generates a Sync Report. Check the PR to see the report.
+
+**Q. Can I do this manually without Alfred?**
+A. Possible, but remember: SPEC → TEST → CODE → DOC order and keep @TAGs updated.
 
 ---
 
@@ -1668,8 +3025,8 @@ If you need to temporarily disable hooks, edit `.claude/settings.json`:
 
 | Purpose                   | Resource                                                        |
 | ------------------------- | --------------------------------------------------------------- |
-| Skills detailed structure | `.claude/skills/` directory (58 Skills)                         |
-| Sub-agent details         | `.claude/agents/alfred/` directory (12 agents)                  |
+| Skills detailed structure | `.claude/skills/` directory (74 Skills)                         |
+| Sub-agent details         | `.claude/agents/alfred/` directory (16 agents + 4 commands)    |
 | Workflow guide            | `.claude/commands/alfred/` (4 commands: 0-project ~ 3-sync)     |
 | Documentation             | Coming soon (see `.moai/`, `.claude/`, `docs/` in your project) |
 | Release notes             | GitHub Releases: https://github.com/modu-ai/moai-adk/releases   |
@@ -1682,8 +3039,8 @@ If you need to temporarily disable hooks, edit `.claude/settings.json`:
 | ------------------------ | -------------------------------------------------------- |
 | **GitHub Repository**    | https://github.com/modu-ai/moai-adk                      |
 | **Issues & Discussions** | https://github.com/modu-ai/moai-adk/issues               |
-| **PyPI Package**         | https://pypi.org/project/moai-adk/ (Latest: v0.4.11)     |
-| **Latest Release**       | https://github.com/modu-ai/moai-adk/releases/tag/v0.4.11 |
+| **PyPI Package**         | https://pypi.org/project/moai-adk/                       |
+| **Latest Release**       | https://github.com/modu-ai/moai-adk/releases             |
 | **Documentation**        | See `.moai/`, `.claude/`, `docs/` within project         |
 
 ---
@@ -1692,7 +3049,7 @@ If you need to temporarily disable hooks, edit `.claude/settings.json`:
 
 > **"No CODE without SPEC"**
 
-MoAI-ADK is not simply a code generation tool. Alfred SuperAgent with its 19-member team and 56 Claude Skills together guarantee:
+MoAI-ADK is not simply a code generation tool. Alfred SuperAgent with its 19-member team and 55+ Claude Skills together guarantee:
 
 - ✅ **SPEC → TEST (TDD) → CODE → DOCS consistency**
 - ✅ **Complete history tracking with @TAG system**