aiwf 0.1.0 → 0.3.0

package/claude-code/aiwf/ko/.claude/commands/aiwf/aiwf_yolo.md

@@ -0,0 +1,300 @@
+# YOLO 모드에서 모든 열린 태스크 실행
+
+This mode is meant to be run without user interaction.
+You **DO NOT** ask the user any questions or ask for confirmation
+If in doubt you **RESEARCH** and **ULTRATHINK** about the best solution.
+
+**IMPORTANT** you try not to stop at any certain point but do so if you need after thoughtful consideration.
+
+Priority is to get the work completed.
+
+## Mode Selection
+
+Check <$ARGUMENTS>:
+
+- If sprint ID provided (e.g., S03): Work ONLY on that sprint
+- If `sprint-all` provided: Execute ALL sprints sequentially until completion
+- If `milestone-all` provided: Execute ALL milestones (including all their sprints) until completion
+- If `worktree` provided: Use worktree mode (no branch creation, direct push)
+- If empty: Work on general tasks first, then active sprint tasks
+
+**Report Mode** to the User!
+
+## Safety Guidelines
+
+- **NEVER** modify critical files (.env, alembic migrations, production configs)
+- **STOP** if you encounter database schema changes
+- **STOP** if you need to delete more than 5 files
+- **STOP** if tests are failing after your changes
+- **ALWAYS** run tests after implementing a task
+
+## Follow this exact process
+
+You need to stick to this process and **PRECISELY** follow it
+
+Before you start:
+
+- Run tests to ensure clean baseline using test.md command (@.claude/commands/aiwf/aiwf_test.md)
+- **If** FAIL rate is above 10% asses if a fix is possible. If so, fix and move on. If not, move on anyways.
+
+- Check git status to ensure clean working directory
+- **If** git status is not clean just remember and report to the user at the end, but move on.
+
+Also consider <$ARGUMENTS> - if anything between <> can be considered additional instructions, prioritize them in the process.
+
+Get the current datetime stamp from the system and remember it
+
+### FIND OPEN WORK
+
+Execute based on mode:
+
+**If Sprint ID provided in arguments:**
+
+- Navigate to .aiwf/03_SPRINTS/{sprint_id}/
+- Check if sprint has tasks (T\*.md files)
+- If NO tasks exist:
+  - Check for sprint meta file
+  - If meta exists: Jump to ### CREATE SPRINT TASKS
+  - If no meta: Exit with error - sprint doesn't exist
+- If tasks exist: Continue to **Task selection** section below
+
+**If `sprint-all` in arguments:**
+
+- Scan ALL sprints in .aiwf/03_SPRINTS/ directory
+- Create ordered list of ALL sprints (S01, S02, S03, ...)
+- For each sprint in sequence:
+  - Check if sprint has tasks, if not create them
+  - Execute ALL tasks in current sprint before moving to next
+  - Mark sprint as completed when all tasks done
+- Continue until ALL sprints are 100% completed
+- Priority: Complete current sprint entirely before starting next
+
+**If `milestone-all` in arguments:**
+
+- Scan ALL milestones in .aiwf/01_MILESTONES/ directory
+- For each milestone in sequence:
+  - Identify all related sprints for this milestone
+  - Execute ALL sprints related to current milestone
+  - Execute ALL tasks in each sprint
+  - Mark milestone as completed when all related work done
+- Continue until ALL milestones are 100% completed
+- Priority: Complete current milestone entirely before starting next
+
+**If NO arguments (general mode):**
+
+- Use PARALLEL SUBAGENTS to check:
+  - .aiwf/04_GENERAL_TASKS for open general tasks
+  - .aiwf/00_PROJECT_MANIFEST.md for currently active sprint
+  - .aiwf/03_SPRINTS/ for any sprint with only meta file
+- Priority order:
+  1. General tasks (if any open)
+  2. Active sprint tasks (if any open)
+  3. Sprint needing task creation (if found) - maintain order of Sprints
+
+**Task Selection:**
+
+- From found tasks, select ONE that is not completed. Take the lowest ID in Sprint or General Tasks
+- Skip tasks you've previously attempted (check OUTPUT LOG)
+- If no suitable task found and no sprint needs tasks: Exit gracefully
+
+### CREATE SPRINT TASKS
+
+**ONLY EXECUTE** if sprint needs task creation
+
+- Use a **SUBAGENT** and have it include @.claude/commands/aiwf/aiwf_create_sprint_tasks.md with Sprint ID as argument
+- Wait for completion
+- After task creation move back to `### FIND OPEN WORK`
+
+### WORK ON TASK
+
+- if you have touched this task before ignore it and jump to the next task
+- if you can't find a task that you have not tried fixing before jump to ### EXECUTE PROJECT REVIEW
+- if you find a task that you cannot fix because the work was done already, close the task and note in Output Log of task.
+- **BEFORE STARTING**:
+  - **If** `worktree` NOT in arguments: Create a git branch for the task: `git checkout -b task/<task-id>`
+  - **If** `worktree` in arguments: Skip branch creation (worktree mode)
+- **GitHub Issue Creation (Optional):**
+  - If task doesn't have a `github_issue` field
+  - Use SUBAGENT to include @.claude/commands/aiwf/aiwf_issue_create.md to create issue
+- **USE A SUBAGENT** and have it include @.claude/commands/aiwf/aiwf_do_task.md with the Task ID as Argument to execute the Task.
+- **AFTER TASK COMPLETION**: Run tests to verify nothing broke using test.md command (@.claude/commands/aiwf/aiwf_test.md)
+- on any failure in the task execution assess the severity of the error:
+  - CRITICAL errors (breaking tests, security issues, data loss risk): **FIX PROBLEMS**
+  - NON-CRITICAL errors (linting, formatting, minor issues): note in OUTPUT LOG and continue
+- on success move on
+
+### COMMIT WORK
+
+- **ONLY IF** tests are passing and no critical issues exist
+- **USE A SUBAGENT** and have it include @.claude/commands/aiwf/aiwf_commit.md with the Task ID as Argument and YOLO as additional argument
+- on any failure when committing, note the problem in the OUTPUT LOG of the task and continue
+- after successful commit,
+  - **If** `worktree` NOT in arguments: after successful commit, merge to main: `git checkout main && git merge task/<task-id>`
+  - **If** `worktree` in arguments: after successful commit, push changes: `git push`
+- **Pull Request Creation (Optional):**
+  - If GitHub issue is linked to the task
+  - Use SUBAGENT to include @.claude/commands/aiwf/aiwf_pr_create.md to create PR
+- **IMMEDIATELY** go back to `### FIND OPEN WORK` to continue with next task
+
+### CONTINUOUS EXECUTION LOOP
+
+**⚡ YOLO MODE: NO STOPPING UNTIL COMPLETION**
+
+**This is the main execution loop - DO NOT EXIT EARLY**
+
+**Sprint-specific mode:**
+
+- **LOOP UNTIL** ALL tasks in the specified sprint are completed
+- After each commit, **IMMEDIATELY** go back to `### FIND OPEN WORK`
+- **ONLY** move to project review when sprint is 100% complete
+- **NEVER** ask for user input or confirmation
+
+**Sprint-all mode:**
+
+- **LOOP UNTIL** ALL sprints are 100% completed
+- For each sprint: Complete ALL tasks before moving to next sprint
+- After each commit, **IMMEDIATELY** go back to `### FIND OPEN WORK`
+- Track progress: Current sprint X of Y total sprints
+- **NEVER** skip incomplete sprints
+- **ONLY** exit when ALL sprints are fully completed
+
+**Milestone-all mode:**
+
+- **LOOP UNTIL** ALL milestones are 100% completed
+- For each milestone: Complete ALL related sprints and tasks
+- After each commit, **IMMEDIATELY** go back to `### FIND OPEN WORK`
+- Track progress: Current milestone X of Y total milestones
+- **NEVER** skip incomplete milestones or their dependencies
+- **ONLY** exit when ALL milestones are fully achieved
+
+**General mode:**
+
+- **LOOP CONTINUOUSLY** through:
+  1. Complete ALL available general tasks
+  2. Then move to active sprint tasks
+  3. Complete ALL active sprint tasks
+  4. Check for new sprints or tasks created
+  5. Repeat until NO more work available
+- After each commit, **IMMEDIATELY** go back to `### FIND OPEN WORK`
+- **ONLY** exit when absolutely no work remains
+
+**Stopping Conditions (ONLY stop if ALL are true):**
+
+- NO pending tasks in target scope
+- NO tasks that can be auto-fixed
+- NO sprints needing task creation
+- Project review passes with NO new tasks created
+
+## EXECUTE PROJECT REVIEW
+
+- **USE A SUBAGENT** and have it include @.claude/commands/aiwf/aiwf_project_review.md
+- Depending on the results of the review:
+  - On FAIL: Think about possible fixes.
+  - If fixes are quickly done, fix right away and repeat `## EXECUTE PROJECT REVIEW``
+  - If fixes are more complex **USE A SUBAGENT** and have it include @.claude/commands/aiwf/aiwf_create_general_task.md to create new general tasks as needed.
+  - Go back to `### FIND OPEN WORK` to work on these fixes
+  - On PASS: move on
+
+## CONTINUATION CHECK
+
+**⚡ MANDATORY CONTINUATION LOGIC**
+
+**Check for remaining work:**
+
+- Scan for ANY pending tasks in current scope
+- Check if project review created new tasks
+- Verify if any sprints need task creation
+
+**Decision Matrix:**
+
+**Sprint-specific mode:**
+
+- **IF** sprint has ANY pending tasks → Go back to `### FIND OPEN WORK`
+- **IF** sprint is 100% complete → Move to `## CREATE SUMMARY`
+
+**Sprint-all mode:**
+
+- **IF** ANY sprint has pending tasks → Go back to `### FIND OPEN WORK`
+- **IF** ANY sprint needs task creation → Go back to `### FIND OPEN WORK`
+- **IF** ALL sprints are 100% complete → Move to `## CREATE SUMMARY`
+
+**Milestone-all mode:**
+
+- **IF** ANY milestone has incomplete sprints → Go back to `### FIND OPEN WORK`
+- **IF** ANY milestone-related tasks pending → Go back to `### FIND OPEN WORK`
+- **IF** ALL milestones are 100% complete → Move to `## CREATE SUMMARY`
+
+**General mode:**
+
+- **IF** ANY general tasks pending → Go back to `### FIND OPEN WORK`
+- **IF** ANY sprint tasks pending → Go back to `### FIND OPEN WORK`
+- **IF** ANY sprints need task creation → Go back to `### FIND OPEN WORK`
+- **IF** project review failed and created new tasks → Go back to `### FIND OPEN WORK`
+- **ONLY IF** absolutely NO work remains → Move to `## CREATE SUMMARY`
+
+**🚨 CRITICAL: Do NOT move to summary unless 100% certain no work remains**
+
+## CREATE SUMMARY
+
+- Get current datetime stamp from the system and compare to initially remembered timestamp. Calculate duration of the process.
+
+### GENERATE PROJECT STATUS REPORT
+
+**Gather Project Status Data:**
+
+- Scan `.aiwf/01_MILESTONES/` for milestone completion status
+- Scan `.aiwf/03_SPRINTS/` for all sprint status and task completion
+- Scan `.aiwf/04_GENERAL_TASKS/` for general task completion
+- Count completed vs total tasks for each category
+
+**Create Visual Progress Report:**
+
+```
+=== MOONKLABS PROJECT STATUS REPORT ===
+
+🎯 MILESTONES PROGRESS:
+[▓▓▓▓▓▓▓░░░] 70% (7/10 completed)
+M01: ✅ Setup & Architecture
+M02: ✅ Core Features
+M03: ✅ Authentication
+M04: 🔄 In Progress - API Development
+M05: ⏳ Pending - Frontend Integration
+
+📊 SPRINT PROGRESS:
+[▓▓▓▓▓▓░░░░] 60% (3/5 sprints completed)
+S01: ✅ Complete (12/12 tasks)
+S02: ✅ Complete (8/8 tasks)
+S03: 🔄 Active (5/9 tasks completed)
+S04: ⏳ Planned (0/0 tasks)
+S05: ⏳ Planned (0/0 tasks)
+
+⚡ GENERAL TASKS:
+[▓▓▓▓▓▓▓▓░░] 80% (16/20 completed)
+
+📈 OVERALL PROJECT HEALTH:
+[▓▓▓▓▓▓▓░░░] 73% Complete
+```
+
+**Create Summary Report including:**
+
+- Mode executed (Sprint-specific, Sprint-all, Milestone-all, or General)
+- Sprint tasks created (if applicable)
+- Number of tasks completed this session
+- Number of tasks skipped/failed this session
+- Total duration of YOLO session
+- Current project completion percentage
+- Sprints completed (if sprint-all mode)
+- Milestones achieved (if milestone-all mode)
+- Any critical issues encountered
+- Current test status
+- Next recommended action
+- Top 3 priority items for next session
+
+**Report the complete status to the user including:**
+
+- Visual progress graphs
+- Session summary
+- Project health overview
+- Recommended next steps
+
+Your work is done. Thank you.

package/claude-code/aiwf/ko/.claude/mcp.json

@@ -0,0 +1,31 @@
+{
+    "mcpServers": {
+        "git": {
+            "command": "uvx",
+            "args": [
+                "mcp-server-git"
+            ]
+        },
+        "sequential-thinking": {
+            "command": "npx",
+            "args": [
+                "-y",
+                "@modelcontextprotocol/server-sequential-thinking"
+            ]
+        },
+        "time": {
+            "command": "npx",
+            "args": [
+                "-y",
+                "@modelcontextprotocol/server-time"
+            ]
+        },
+        "memory": {
+            "command": "npx",
+            "args": [
+                "-y",
+                "@modelcontextprotocol/server-memory"
+            ]
+        }
+    }
+}

package/claude-code/aiwf/ko/.claude/settings.json

@@ -0,0 +1,102 @@
+{
+    "permissions": {
+        "allow": [
+            "Bash(deno task *)",
+            "Bash(npm run *)",
+            "Bash(cargo *)",
+            "Bash(go *)",
+            "Bash(git *)",
+            "Bash(git worktree *)",
+            "Bash(gh *)",
+            "Bash(docker *)",
+            "Bash(kubectl *)",
+            "Bash(terraform *)",
+            "Bash(rg *)",
+            "Bash(ripgrep *)",
+            "Bash(fd *)",
+            "Bash(fzf *)",
+            "Bash(bat *)",
+            "Bash(exa *)",
+            "Bash(eza *)",
+            "Bash(delta *)",
+            "Bash(zoxide *)",
+            "Bash(duf *)",
+            "Bash(htop *)",
+            "Bash(btop *)",
+            "Bash(jq *)",
+            "Bash(yq *)",
+            "Bash(hexyl *)",
+            "Bash(prettier *)",
+            "Bash(eslint *)",
+            "Bash(tsc *)",
+            "Bash(pnpm *)",
+            "Bash(yarn *)",
+            "Bash(mkdir -p /tmp/claude-scratch*)",
+            "Bash(touch /tmp/claude-*)",
+            "Bash(echo * > /tmp/claude-*)",
+            "Bash(cat /tmp/claude-*)"
+        ],
+        "deny": [
+            "Bash(rm -rf /)",
+            "Bash(:(){ :|:& };:)",
+            "Bash(dd if=/dev/zero of=/dev/*)",
+            "Bash(mkfs.*)",
+            "Bash(> /dev/sda*)"
+        ]
+    },
+    "env": {
+        "CLAUDE_CODE_ENABLE_TELEMETRY": "0",
+        "EDITOR": "zed",
+        "GIT_EDITOR": "zed --wait"
+    },
+    "preferredNotifChannel": "terminal_bell",
+    "verbose": true,
+    "cleanupPeriodDays": 90,
+    "includeCoAuthoredBy": false,
+    "hooks": {
+        "beforeFileEdit": [
+            {
+                "command": "npm run lint:fix --silent || true",
+                "description": "파일 수정 전 자동 린트 수정 실행"
+            }
+        ],
+        "afterFileEdit": [
+            {
+                "command": "prettier --write {file} || true",
+                "description": "파일 수정 후 자동 포맷팅 실행"
+            }
+        ],
+        "beforeCommit": [
+            {
+                "command": "npm run lint || echo '린트 검사 실패'",
+                "description": "커밋 전 린트 검사"
+            },
+            {
+                "command": "npm run test || echo '테스트 실패'",
+                "description": "커밋 전 테스트 실행"
+            }
+        ],
+        "Stop": [
+            {
+                "matcher": "",
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": "afplay /System/Library/Sounds/Glass.aiff"
+                    }
+                ]
+            }
+        ],
+        "PostToolUse": [
+            {
+                "matcher": "Write|Edit|MultiEdit",
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": "aiwf_test"
+                    }
+                ]
+            }
+        ]
+    }
+}

package/{AI-WORKFLOW.md → docs/AI-WORKFLOW.ko.md}

@@ -1,38 +1,45 @@
-# Claude Code를 위한 Moonklabs
+# Claude Code를 위한 AIWF
 
 ## 이것은 무엇인가요?
 
-Moonklabs은 Claude Code, Gemini-CLI 와 더 효과적으로 작업하기 위해 만든 디렉토리 기반 프로젝트 관리 시스템입니다. 기본적으로 폴더, 마크다운 파일 및 AI가 효과적으로 처리할 수 있는 관리 가능한 단위로 소프트웨어 프로젝트를 분할하는 데 도움이 되는 사용자 정의 명령의 집합입니다.
+AIWF은 Claude Code, Gemini-CLI 와 더 효과적으로 작업하기 위해 만든 디렉토리 기반 프로젝트 관리 시스템입니다. 기본적으로 폴더, 마크다운 파일 및 AI가 효과적으로 처리할 수 있는 관리 가능한 단위로 소프트웨어 프로젝트를 분할하는 데 도움이 되는 사용자 정의 명령의 집합입니다.
 
 **🚀 NEW**: 강화된 YOLO 모드로 전체 스프린트나 마일스톤을 한 번에 자동 완료할 수 있습니다!
 
-**⚠️ 복잡성 경고**: Moonklabs은 제대로 이해하는 데 시간이 필요한 정교한 시스템입니다. 단순한 플러그 앤 플레이 솔루션이 아니라, 작동 방식을 배우고 워크플로에 적응하는 데 시간을 투자할 때 가장 잘 작동하는 프레임워크입니다.
+**⚠️ 복잡성 경고**: AIWF은 제대로 이해하는 데 시간이 필요한 정교한 시스템입니다. 단순한 플러그 앤 플레이 솔루션이 아니라, 작동 방식을 배우고 워크플로에 적응하는 데 시간을 투자할 때 가장 잘 작동하는 프레임워크입니다.
 
 **📋 최신 업데이트**: 최근 변경 사항 및 개선 사항은 [CHANGELOG.md](CHANGELOG.md)를 참조하세요.
 
 ## 시작하는 방법
 
-### 1. Moonklabs 설치하기
+### 1. AIWF 설치하기
 
 ```bash
 npx aiwf
 ```
 
+**다국어 지원**: 설치 시 영어와 한국어 중 선택할 수 있습니다. 선택한 언어에 따라 해당 언어의 명령어와 문서가 설치됩니다.
+
 이것은 폴더 구조를 설정하고 프로젝트에 명령 파일을 설치/업데이트합니다. 기존 설치를 업데이트하는 데도 사용할 수 있으며, 명령 파일은 자동으로 백업됩니다.
 
+**설치 옵션**:
+
+- 대화형 설치: 언어 선택 후 설치
+- 강제 설치: `npx aiwf --force` (기본값: 영어)
+
 ### 2. 프로젝트 초기화하기
 
 Claude Code에서 프로젝트를 열고 다음을 실행하세요:
 
 ```
-/project:moonklabs:initialize
+/project:aiwf:initialize
 ```
 
 이것은 기본 설정 과정을 안내합니다. 새로운 코드베이스나 기존 코드베이스와 함께 작동하며, 프로젝트 문서(PRD, 아키텍처 문서)를 생성하거나 이미 가지고 있는 문서와 함께 작업하는 데 도움을 줍니다.
 
 ### 3. 첫 번째 마일스톤 설정하기
 
-`.moonklabs/02_REQUIREMENTS/`에 `M01_Your_Milestone_Name`(예: `M01_Basic_Application`)이라는 이름의 마일스톤 폴더를 생성하세요. 최소한 다음을 포함하세요:
+`.aiwf/02_REQUIREMENTS/`에 `M01_Your_Milestone_Name`(예: `M01_Basic_Application`)이라는 이름의 마일스톤 폴더를 생성하세요. 최소한 다음을 포함하세요:
 
 - `M01_PRD.md` - 제품 요구사항 문서
 - 필요에 따른 기타 사양: `M01_Database_Schema.md`, `M01_API_Specs.md` 등
@@ -42,7 +49,7 @@ _참고: 아직 이를 위한 명령어는 없습니다. 2단계의 기존 채
 ### 4. 스프린트로 분할하기
 
 ```
-/project:moonklabs:create_sprints_from_milestone
+/project:aiwf:create_sprints_from_milestone
 ```
 
 이것은 마일스톤을 분석하고 논리적인 스프린트로 분할합니다. 전체 범위를 살펴보고 아직 세부 작업 없이 의미 있는 스프린트 경계를 생성합니다.
@@ -50,7 +57,7 @@ _참고: 아직 이를 위한 명령어는 없습니다. 2단계의 기존 채
 ### 5. 첫 번째 작업 생성하기
 
 ```
-/project:moonklabs:create_sprint_tasks
+/project:aiwf:create_sprint_tasks
 ```
 
 이것은 스프린트를 분석하고, 문서를 검토하며, 필요한 정보를 조사하고, 프로젝트에 대한 포괄적인 이해를 얻기 위한 지식 격차를 식별합니다. 현재 스프린트에 대한 상세하고 실행 가능한 작업을 생성합니다.
@@ -60,22 +67,22 @@ _중요: 모든 스프린트에 대한 작업을 미리 생성하지 말고 다
 ### 6. 작업 시작하기
 
 ```
-/project:moonklabs:do_task
+/project:aiwf:do_task
 ```
 
 이것은 일반 작업이나 스프린트에서 작업을 자동으로 선택합니다. 더 빠른 실행을 위해 작업 ID를 지정하세요:
 
 ```
-/project:moonklabs:do_task T01_S01
+/project:aiwf:do_task T01_S01
 ```
 
 그러면 Claude는 전체 프로젝트 컨텍스트와 함께 지정된 작업을 수행합니다.
 
 이것이 시작하기 위한 기본 워크플로입니다! 또한 다음과 같은 작업도 가능합니다:
 
-- `/project:moonklabs:create_general_task`로 일반 작업 생성
+- `/project:aiwf:create_general_task`로 일반 작업 생성
 - YOLO 모드를 사용하여 전체 스프린트 또는 마일스톤을 자율적으로 실행
-- `.claude/commands/moonklabs/`에서 다른 명령어 탐색
+- `.claude/commands/aiwf/`에서 다른 명령어 탐색
 
 ### 7. YOLO 모드 - 자율 실행
 
@@ -84,7 +91,7 @@ YOLO 모드는 사용자 개입 없이 연속적으로 작업을 실행하는
 **기본 YOLO 모드:**
 
 ```
-/project:moonklabs:yolo
+/project:aiwf:yolo
 ```
 
 일반 작업을 먼저 처리한 후 활성 스프린트 작업을 실행합니다.
@@ -92,7 +99,7 @@ YOLO 모드는 사용자 개입 없이 연속적으로 작업을 실행하는
 **스프린트별 실행:**
 
 ```
-/project:moonklabs:yolo S03
+/project:aiwf:yolo S03
 ```
 
 지정된 스프린트(S03)의 모든 작업을 완료할 때까지 실행합니다.
@@ -100,7 +107,7 @@ YOLO 모드는 사용자 개입 없이 연속적으로 작업을 실행하는
 **🚀 NEW: 전체 스프린트 실행:**
 
 ```
-/project:moonklabs:yolo sprint-all
+/project:aiwf:yolo sprint-all
 ```
 
 모든 스프린트를 순차적으로 완료할 때까지 멈추지 않고 실행합니다.
@@ -108,7 +115,7 @@ YOLO 모드는 사용자 개입 없이 연속적으로 작업을 실행하는
 **🚀 NEW: 전체 마일스톤 실행:**
 
 ```
-/project:moonklabs:yolo milestone-all
+/project:aiwf:yolo milestone-all
 ```
 
 모든 마일스톤과 관련된 스프린트, 작업을 완료할 때까지 실행합니다.
@@ -116,8 +123,8 @@ YOLO 모드는 사용자 개입 없이 연속적으로 작업을 실행하는
 **🔧 Worktree 모드:**
 
 ```
-/project:moonklabs:yolo S03 worktree
-/project:moonklabs:yolo sprint-all worktree
+/project:aiwf:yolo S03 worktree
+/project:aiwf:yolo sprint-all worktree
 ```
 
 Git worktree 환경에서 실행 시 브랜치 생성 없이 직접 푸시합니다.
@@ -136,11 +143,11 @@ Git worktree 환경에서 실행 시 브랜치 생성 없이 직접 푸시합니
 - 테스트가 10% 이상 실패하면 평가 후 진행 여부를 결정합니다
 - 데이터베이스 스키마 변경이 필요하면 중단됩니다
 
-**중요**: Moonklabs은 단순한 설정 후 잊어버리는 도구가 아닌 복잡한 시스템입니다. 작동 방식을 이해할 때 가장 효과적으로 작동합니다. 명령어를 읽어보고 워크플로에 맞게 조정하는 시간을 가지세요.
+**중요**: AIWF은 단순한 설정 후 잊어버리는 도구가 아닌 복잡한 시스템입니다. 작동 방식을 이해할 때 가장 효과적으로 작동합니다. 명령어를 읽어보고 워크플로에 맞게 조정하는 시간을 가지세요.
 
 ## 작동 방식
 
-Moonklabs은 프로젝트를 다음과 같이 구성합니다:
+AIWF은 프로젝트를 다음과 같이 구성합니다:
 
 - **마일스톤**: 주요 기능 또는 프로젝트 단계
 - **스프린트**: 마일스톤 내의 관련 작업 그룹
@@ -202,9 +209,9 @@ AI 코딩 도구는 믿을 수 없을 정도로 강력해졌지만, 모두 동
 - 아키텍처 결정을 문서화하기 위한 ADR 템플릿
 - 모든 템플릿은 단순화된 날짜 형식(YYYY-MM-DD HH:MM)을 사용합니다
 
-### .claude/commands/moonklabs/
+### .claude/commands/aiwf/
 
-Moonklabs 워크플로를 구동하는 맞춤형 Claude Code 명령어:
+AIWF 워크플로를 구동하는 맞춤형 Claude Code 명령어:
 
 - `initialize` - 프로젝트 구조와 문서를 설정
 - `create_sprints_from_milestone` - 마일스톤을 논리적 스프린트로 분할
@@ -221,7 +228,7 @@ Moonklabs 워크플로를 구동하는 맞춤형 Claude Code 명령어:
 ## 디렉토리 구조
 
 ```plaintext
-.moonklabs/
+.aiwf/
 ├── 00_PROJECT_MANIFEST.md
 ├── 01_PROJECT_DOCS/
 ├── 02_REQUIREMENTS/
@@ -250,7 +257,7 @@ Moonklabs 워크플로를 구동하는 맞춤형 Claude Code 명령어:
 
 ### 병렬 작업 실행 활성화
 
-`create_sprint_tasks`와 같은 Moonklabs 명령은 `useParallelSubagents` 지시어를 지원하지만, 실제로 작업을 병렬로 실행하려면 Claude Code 설정이 필요합니다. 기본적으로는 한 번에 하나의 작업만 실행됩니다.
+`create_sprint_tasks`와 같은 AIWF 명령은 `useParallelSubagents` 지시어를 지원하지만, 실제로 작업을 병렬로 실행하려면 Claude Code 설정이 필요합니다. 기본적으로는 한 번에 하나의 작업만 실행됩니다.
 
 병렬 실행을 활성화하려면: