aiwf 0.3.0 → 0.3.2

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

@@ -1,189 +1,189 @@
-# 스프린트를 위한 Task 생성 - 탑 다운 실행
+# 스프린트 태스크 생성 - 탑 다운 실행
 
-Create detailed tasks for an existing sprint with integrated implementation guidance.
+통합된 구현 가이드와 함께 기존 스프린트에 대한 상세한 태스크를 생성합니다.
 
-## Create a TODO with EXACTLY these 8 Items
+## 정확히 다음 8개 항목으로 TODO 생성
 
-1. Identify target sprint and verify it exists
-2. Load sprint context and related documentation
-3. Check for existing ADRs and technical guidance
-4. Analyze sprint deliverables for task breakdown
-5. Create individual task files with implementation guidance
-6. Link ADRs to relevant tasks
-7. Update sprint meta with task references
-8. Check quality of your work
+1. 대상 스프린트 식별 및 존재 확인
+2. 스프린트 컨텍스트 및 관련 문서 로드
+3. 기존 ADR 및 기술 가이드 확인
+4. 태스크 분할을 위한 스프린트 결과물 분석
+5. 구현 가이드와 함께 개별 태스크 파일 생성
+6. 관련 태스크에 ADR 연결
+7. 태스크 참조로 스프린트 메타 업데이트
+8. 작업 품질 확인
 
-Follow step by step and adhere closely to the following instructions for each step.
+단계별로 따라가며 각 단계에 대한 다음 지침을 엄격히 준수하세요.
 
-## DETAILS on every TODO item
+## 모든 TODO 항목에 대한 세부사항
 
-### 1. Identify target sprint and verify it exists
+### 1. 대상 스프린트 식별 및 존재 확인
 
-Check: <$ARGUMENTS>
+확인: <$ARGUMENTS>
 
-**REQUIRED:** Sprint ID must be provided (e.g., S02). If empty, ask user to specify which sprint to detail.
+**필수:** 스프린트 ID가 제공되어야 함 (예: S02). 비어있다면 사용자에게 상세화할 스프린트를 지정하도록 요청.
 
-- VERIFY sprint directory exists in `.aiwf/03_SPRINTS/`
-- CHECK sprint meta file exists (e.g., `S02_sprint_meta.md`)
-- VERIFY sprint status is not already "completed"
-- If tasks already exist, ask user if they want to recreate them or any other guidance
+- `.aiwf/03_SPRINTS/`에 스프린트 디렉토리 존재 확인
+- 스프린트 메타 파일 존재 확인 (예: `S02_sprint_meta.md`)
+- 스프린트 상태가 이미 "completed"가 아닌지 확인
+- 태스크가 이미 존재한다면, 사용자에게 재생성할지 또는 다른 가이드가 필요한지 문의
 
-### 2. Load sprint context and related documentation
+### 2. 스프린트 컨텍스트 및 관련 문서 로드
 
-Use PARALLEL SUBAGENTS to READ and UNDERSTAND the project's context:
+병렬 서브에이전트를 사용하여 프로젝트 컨텍스트를 읽고 이해:
 
-- READ `.aiwf/00_PROJECT_MANIFEST.md` for project context
-- READ sprint meta file completely to understand goals and deliverables
-- READ parent milestone requirements from `.aiwf/02_REQUIREMENTS/`
-- READ `.aiwf/01_PROJECT_DOCS/ARCHITECTURE.md` for technical context
-- READ `.aiwf/01_PROJECT_DOCS/LONG_TERM_VISION.md` to understand architectural decisions
+- 프로젝트 컨텍스트를 위해 `.aiwf/00_PROJECT_MANIFEST.md` 읽기
+- 목표와 결과물을 이해하기 위해 스프린트 메타 파일 완전히 읽기
+- `.aiwf/02_REQUIREMENTS/`에서 상위 마일스톤 요구사항 읽기
+- 기술적 컨텍스트를 위해 `.aiwf/01_PROJECT_DOCS/ARCHITECTURE.md` 읽기
+- 아키텍처 결정을 이해하기 위해 `.aiwf/01_PROJECT_DOCS/LONG_TERM_VISION.md` 읽기
 
-**IMPORTANT:** Sprint tasks must align with documented sprint goals, not expand scope.
+**중요:** 스프린트 태스크는 문서화된 스프린트 목표와 일치해야 하며, 범위를 확장하면 안 됨.
 
-### 3. Check for existing ADRs and technical guidance
+### 3. 기존 ADR 및 기술 가이드 확인
 
-**USE PARALLEL SUBAGENTS** to execute these commands:
+**병렬 서브에이전트 사용**하여 다음 명령 실행:
 
-- SEARCH `.aiwf/05_ARCHITECTURE_DECISIONS/` for ADRs matching sprint ID (e.g., `ADR*_S02_*.md`)
-- READ all found ADRs to understand technical decisions
-- CHECK sprint meta for ADR references section
-- NOTE which technical decisions will affect task implementation
-- BUILD RELATIONSHIP in task and subtasks and make clear what to implement
+- 스프린트 ID와 일치하는 ADR을 위해 `.aiwf/05_ARCHITECTURE_DECISIONS/` 검색 (예: `ADR*_S02_*.md`)
+- 기술적 결정을 이해하기 위해 발견된 모든 ADR 읽기
+- ADR 참조 섹션에 대한 스프린트 메타 확인
+- 태스크 구현에 영향을 줄 기술적 결정 주목
+- 태스크와 서브태스크에서 관계 구축하고 구현할 내용을 명확히 하기
 
-**If conflict in Scope** Between ADR and Sprint goal, try to think about it and ask the user to resolve the conflict.
+**범위에서 충돌**이 ADR과 스프린트 목표 사이에 있다면, 고민해보고 사용자에게 충돌 해결을 요청.
 
-**If no ADRs found:** Proceed but note that tasks may need clarification during implementation.
+**ADR이 발견되지 않은 경우:** 진행하되 구현 중에 태스크가 명확화가 필요할 수 있음을 주목.
 
-### 4. Analyze sprint deliverables for task breakdown
+### 4. 태스크 분할을 위한 스프린트 결과물 분석
 
-Based on sprint goals and deliverables (execute in Parallel Subagents):
+스프린트 목표와 결과물을 바탕으로 (병렬 서브에이전트에서 실행):
 
-- BREAK DOWN high-level deliverables into concrete, implementable tasks
-- ENSURE each task represents a coherent feature or component
-- CONSIDER logical dependencies between tasks
-- MAP tasks to relevant ADRs for technical guidance
-- DEFER complexity assessment until after tasks are fully created with subtasks
+- 고수준 결과물을 구체적이고 구현 가능한 태스크로 분할
+- 각 태스크가 일관된 기능이나 구성요소를 나타내도록 보장
+- 태스크 간의 논리적 종속성 고려
+- 기술 가이드를 위해 태스크를 관련 ADR에 매핑
+- 서브태스크와 함께 태스크가 완전히 생성된 후까지 복잡성 평가 연기
 
-### 5. Create individual task files with implementation guidance
+### 5. 구현 가이드와 함께 개별 태스크 파일 생성
 
-**NOW** For each identified Task spin up a Parallel Subagent with these Instructions:
+**이제** 식별된 각 태스크에 대해 다음 지침과 함께 병렬 서브에이전트를 시작:
 
-    #### Create a TODO for EACH task
+    #### 각 태스크에 대한 TODO 생성
 
-    1. Create basic task structure
-    2. Research codebase interfaces
-    3. Add technical guidance
-    4. Validate task completeness
+    1. 기본 태스크 구조 생성
+    2. 코드베이스 인터페이스 조사
+    3. 기술 가이드 추가
+    4. 태스크 완전성 검증
 
-    ### 1. Create basic task structure
+    ### 1. 기본 태스크 구조 생성
 
-    - ALL TASK FILES must to be created in the Sprint Directory (where the sprint meta file is)
-    - CREATE file with naming: `T<NN>_S<NN>_<Descriptive_Name>.md`
-    - USE sequential numbering starting from T01
-    - FOLLOW task template structure exactly from `.aiwf/99_TEMPLATES/task_template.md`
-    - ADD basic description and objectives from sprint goals
+    - 모든 태스크 파일은 스프린트 디렉토리(스프린트 메타 파일이 있는 곳)에 생성되어야 함
+    - `T<NN>_S<NN>_<설명적_이름>.md` 명명으로 파일 생성
+    - T01부터 시작하는 순차적 번호 사용
+    - `.aiwf/99_TEMPLATES/task_template.md`의 태스크 템플릿 구조를 정확히 따름
+    - 스프린트 목표에서 기본 설명과 목표 추가
 
-    ### 2. Research codebase interfaces
+    ### 2. 코드베이스 인터페이스 조사
 
-    - EXAMINE existing codebase for similar patterns and interfaces
-    - IDENTIFY specific classes, functions, and imports that will be needed
-    - FIND integration points with existing modules
-    - NOTE database models, API endpoints, or services to interface with
-    - CHECK existing error handling and logging patterns
+    - 유사한 패턴과 인터페이스를 위해 기존 코드베이스 검토
+    - 필요한 특정 클래스, 함수, 임포트 식별
+    - 기존 모듈과의 통합 지점 찾기
+    - 인터페이스할 데이터베이스 모델, API 엔드포인트 또는 서비스 주목
+    - 기존 오류 처리 및 로깅 패턴 확인
 
-    ### 3. Add technical guidance
+    ### 3. 기술 가이드 추가
 
-    Add these sections to the task file (add to template if not present):
+    태스크 파일에 다음 섹션 추가 (템플릿에 없으면 추가):
 
-    **Technical Guidance section:**
+    **기술 가이드 섹션:**
 
-    - Key interfaces and integration points in the codebase
-    - Specific imports and module references
-    - Existing patterns to follow
-    - Database models or API contracts to work with
-    - Error handling approach used in similar code
+    - 코드베이스의 주요 인터페이스 및 통합 지점
+    - 특정 임포트 및 모듈 참조
+    - 따라야 할 기존 패턴
+    - 작업할 데이터베이스 모델 또는 API 계약
+    - 유사한 코드에서 사용되는 오류 처리 접근법
 
-    **Implementation Notes section:**
+    **구현 노트 섹션:**
 
-    - Step-by-step implementation approach
-    - Key architectural decisions to respect
-    - Testing approach based on existing test patterns
-    - Performance considerations if relevant
+    - 단계별 구현 접근법
+    - 존중해야 할 주요 아키텍처 결정
+    - 기존 테스트 패턴을 바탕으로 한 테스트 접근법
+    - 관련된 경우 성능 고려사항
 
-    **IMPORTANT:** Do NOT include code examples. Provide structural guidance and references only.
+    **중요:** 코드 예제를 포함하지 마세요. 구조적 가이드와 참조만 제공.
 
-    #### 4. Validate task completeness
+    #### 4. 태스크 완전성 검증
 
-    - ENSURE task has clear implementation path
-    - VERIFY all integration points are documented
-    - CHECK that guidance references actual codebase elements
-    - CONFIRM task is self-contained and actionable
+    - 태스크가 명확한 구현 경로를 가지는지 확인
+    - 모든 통합 지점이 문서화되었는지 확인
+    - 가이드가 실제 코드베이스 요소를 참조하는지 확인
+    - 태스크가 자체 완결적이고 실행 가능한지 확인
 
-    **REPEAT** `### 5. Create individual task files with implementation guidance` for every Task
+    **반복** `### 5. 구현 가이드와 함께 개별 태스크 파일 생성`을 모든 태스크에 대해
 
-### 6. Link ADRs to relevant tasks
+### 6. 관련 태스크에 ADR 연결
 
-- IF relevant ADRs exist
-- REFERENCE ADRs that are related
-- ADD explanation in Technical Guidance section for how each ADR applies
-- ENSURE tasks ONLY reference ADRs that affect their implementation
+- 관련 ADR이 존재하는 경우
+- 관련된 ADR 참조
+- 각 ADR이 어떻게 적용되는지에 대한 설명을 기술 가이드 섹션에 추가
+- 태스크가 구현에 영향을 주는 ADR만 참조하도록 보장
 
-### 7. Update sprint meta with task references
+### 7. 태스크 참조로 스프린트 메타 업데이트
 
-- EDIT sprint meta file to add/update task list
-- ORGANIZE tasks by logical grouping or dependency order
-- ADD brief description for each task
+- 태스크 목록을 추가/업데이트하기 위해 스프린트 메타 파일 편집
+- 논리적 그룹화 또는 종속성 순서로 태스크 구성
+- 각 태스크에 대한 간단한 설명 추가
 
-### 8. Check quality of your work
+### 8. 작업 품질 확인
 
-Review all created tasks for complexity and split any High complexity tasks:
+복잡성에 대해 생성된 모든 태스크를 검토하고 높은 복잡성 태스크를 분할:
 
-**Complexity Assessment Process:**
+**복잡성 평가 프로세스:**
 
-- READ each task file completely including description, goals, acceptance criteria, and subtasks
-- ASSESS complexity using your judgment about the overall scope and challenge
-- DO NOT base complexity on simple metrics like file counts or estimated hours
-- CONSIDER the conceptual difficulty, integration challenges, and unknowns
-- MARK complexity as Low, Medium, or High in the task frontmatter
+- 설명, 목표, 수용 기준, 서브태스크를 포함하여 각 태스크 파일을 완전히 읽기
+- 전체 범위와 도전에 대한 판단을 사용하여 복잡성 평가
+- 파일 수나 예상 시간과 같은 단순한 지표를 기반으로 복잡성을 평가하지 마세요
+- 개념적 어려움, 통합 도전, 미지수 고려
+- 태스크 프론트매터에서 복잡성을 낮음, 보통, 높음으로 표시
 
-**If ANY task is marked as High complexity:**
+**어떤 태스크든 높은 복잡성으로 표시된 경우:**
 
-- SPLIT the task into 2-3 smaller tasks of Low or Medium complexity
-- CREATE new task files with proper sequential numbering
-- UPDATE the original high-complexity task file or DELETE it
-- ENSURE the split tasks together achieve the original goal
-- MAINTAIN logical grouping and dependencies
+- 태스크를 낮음 또는 보통 복잡성의 2-3개 작은 태스크로 분할
+- 적절한 순차적 번호로 새 태스크 파일 생성
+- 원래 높은 복잡성 태스크 파일을 업데이트하거나 삭제
+- 분할된 태스크들이 함께 원래 목표를 달성하도록 보장
+- 논리적 그룹화와 종속성 유지
 
-**After all tasks are finalized:**
+**모든 태스크가 완료된 후:**
 
-- VERIFY all tasks are Low or Medium complexity only
-- CHECK task numbering is sequential (T01, T02, T03...)
-- UPDATE sprint meta file with final task list
-- UPDATE project manifest sprint section to reflect actual tasks created
-- GENERATE completion report
+- 모든 태스크가 낮음 또는 보통 복잡성만 있는지 확인
+- 태스크 번호가 순차적인지 확인 (T01, T02, T03...)
+- 최종 태스크 목록으로 스프린트 메타 파일 업데이트
+- 실제로 생성된 태스크를 반영하도록 프로젝트 매니페스트 스프린트 섹션 업데이트
+- 완료 보고서 생성
 
-**Output format:**
+**출력 형식:**
 
     ```Markdown
-    ## Sprint Detailed - [YYYY-MM-DD HH:MM]
+    ## 스프린트 상세화 완료 - [YYYY-MM-DD HH:MM]
 
-    **Sprint:** [Sprint ID] - [Sprint Name]
-    **Status:** Planning Complete
+    **스프린트:** [스프린트 ID] - [스프린트 이름]
+    **상태:** 계획 완료
 
-    **Tasks Created:** [final count after any splits]
-    - Medium Complexity: [count]
-    - Low Complexity: [count]
+    **생성된 태스크:** [분할 후 최종 개수]
+    - 보통 복잡성: [개수]
+    - 낮은 복잡성: [개수]
 
-    **Task Splitting Summary:**
-    - [Original T03 split into T03 and T04 due to scope]
-    - [No other splits needed]
+    **태스크 분할 요약:**
+    - [원래 T03이 범위로 인해 T03과 T04로 분할됨]
+    - [다른 분할 필요 없음]
 
-    **Final Task List:**
-    1. T01_S02 - [Title] (Complexity: [Level])
-    2. T02_S02 - [Title] (Complexity: [Level])
-    [Continue for all tasks]
+    **최종 태스크 목록:**
+    1. T01_S02 - [제목] (복잡성: [수준])
+    2. T02_S02 - [제목] (복잡성: [수준])
+    [모든 태스크에 대해 계속]
 
-    **Next Steps:**
-    - Review tasks for completeness
-    - Run `/do_task [FIRST_TASK_IN_SPRINT]` to begin implementation
-    ```
+    **다음 단계:**
+    - 완전성에 대한 태스크 검토
+    - 구현을 시작하기 위해 `/do_task [스프린트의_첫_번째_태스크]` 실행
+    ```

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

@@ -1,121 +1,121 @@
-# 마일스톤에서 스프린트 계획하기 - 탑 다운 실행
+# 마일스톤에서 스프린트 생성 - 탑 다운 실행
 
-Follow these instructions to sprint the scope of a Milestone into Sprints
+마일스톤의 범위를 스프린트로 분할하기 위해 다음 지침을 따르세요
 
-## Create a TODO with EXACTLY these 8 items
+## 정확히 다음 8개 항목으로 TODO 생성
 
-1. Analyze current milestone state
-2. Assess completed work vs milestone requirements
-3. Identify remaining work and dependencies
-4. Design logical sprint boundaries
-5. Create sprint directories and meta files
-6. Update PROJECT_MANIFEST with sprint roadmap
-7. Validate sprint coherence and dependencies
-8. Report milestone plan
+1. 현재 마일스톤 상태 분석
+2. 완료된 작업과 마일스톤 요구사항 평가
+3. 남은 작업과 종속성 식별
+4. 논리적 스프린트 경계 설계
+5. 스프린트 디렉토리와 메타 파일 생성
+6. 스프린트 로드맵으로 PROJECT_MANIFEST 업데이트
+7. 스프린트 일관성과 종속성 검증
+8. 마일스톤 계획 보고
 
 ---
 
-## 1 · Analyze current milestone state
+## 1 · 현재 마일스톤 상태 분석
 
-**CRITICAL:** You are given additional Arguments: <$ARGUMENTS>
+**치명적:** 추가 인수가 제공됩니다: <$ARGUMENTS>
 
-**USE PARALLEL SUBAGENTS** to do these tasks:
+**병렬 서브에이전트 사용**하여 다음 태스크 수행:
 
-- Parse arguments for milestone ID (defaults to current milestone from PROJECT_MANIFEST)
-- Read `.aiwf/00_PROJECT_MANIFEST.md` to understand current progress
-- Scan `.aiwf/03_SPRINTS/` to identify existing sprints for the target milestone
-- For each existing sprint, read its sprint meta file to determine status from YAML frontmatter
-- Analyze the Tasks in Sprints to understand that work that has been done (from Subtasks)
+- 마일스톤 ID에 대한 인수 파싱 (PROJECT_MANIFEST의 현재 마일스톤이 기본값)
+- 현재 진행 상황을 이해하기 위해 `.aiwf/00_PROJECT_MANIFEST.md` 읽기
+- 대상 마일스톤의 기존 스프린트를 식별하기 위해 `.aiwf/03_SPRINTS/` 스캔
+- 각 기존 스프린트에 대해, YAML 프론트매터에서 상태를 확인하기 위해 스프린트 메타 파일 읽기
+- 완료된 작업을 이해하기 위해 스프린트의 태스크를 분석 (서브태스크에서)
 
-## 2 · Assess completed work vs milestone requirements
+## 2 · 완료된 작업과 마일스톤 요구사항 평가
 
-- Read milestone meta file from `.aiwf/02_REQUIREMENTS/$MILESTONE_ID/`
-- **CRITICAL:** Follow and read ALL linked documents in the milestone meta:
-  - Product Requirements (PRD.md)
-  - Database Specifications (SPECS_DB.md)
-  - API Specifications (SPECS_API.md)
-  - Tool Specifications (SPECS_TOOLS.md)
-  - Any other linked specifications
-- Study the milestone's Definition of Done (DoD) carefully and **think deeply** about what each DoD criterion actually requires in terms of specific deliverables
-- For each existing sprint, analyze what deliverables have been completed by reading sprint meta and task files
-- **Think more carefully** about the gap analysis: map each completed deliverable against specific DoD requirements and identify what's genuinely missing vs what might already be covered
-- Create clear picture: "What's done vs what's required for milestone completion" with specific justification for each gap identified
+- `.aiwf/02_REQUIREMENTS/$MILESTONE_ID/`에서 마일스톤 메타 파일 읽기
+- **치명적:** 마일스톤 메타에서 연결된 모든 문서를 따라가며 읽기:
+  - 제품 요구사항 (PRD.md)
+  - 데이터베이스 사양 (SPECS_DB.md)
+  - API 사양 (SPECS_API.md)
+  - 도구 사양 (SPECS_TOOLS.md)
+  - 기타 연결된 사양들
+- 마일스톤의 완료 정의(DoD)를 신중히 학습하고 각 DoD 기준이 실제로 특정 결과물 측면에서 무엇을 요구하는지 **깊이 생각**하기
+- 각 기존 스프린트에 대해, 스프린트 메타와 태스크 파일을 읽어 완료된 결과물 분석
+- 격차 분석에 대해 **더 신중히 생각하기**: 완료된 각 결과물을 특정 DoD 요구사항에 대응시키고 진정으로 누락된 것과 이미 다뤄진 것을 식별
+- 명확한 그림 생성: "완료된 것 vs 마일스톤 완성을 위해 필요한 것"에 대해 식별된 각 격차에 대한 구체적 근거 제시
 
-## 3 · Identify remaining work and dependencies
+## 3 · 남은 작업과 종속성 식별
 
-- Based on gap analysis, identify remaining deliverables for milestone completion
-- Group related deliverables that have natural dependencies
-- **CRITICAL:** Each deliverable group should be:
-  - **Independently valuable** (shippable increment)
-  - **Completable in ~1 week** by one person
-  - **Has clear validation criteria**
-- Consider technical dependencies (e.g., auth before UI, LLM integration before tools)
+- 격차 분석을 바탕으로, 마일스톤 완성을 위한 남은 결과물 식별
+- 자연스러운 종속성을 가진 관련 결과물을 그룹화
+- **치명적:** 각 결과물 그룹은 다음과 같아야 함:
+  - **독립적으로 가치 있음** (배포 가능한 증분)
+  - **한 사람이 ~1주일 내에 완료 가능**
+  - **명확한 검증 기준 보유**
+- 기술적 종속성 고려 (예: UI 전에 인증, 도구 전에 LLM 통합)
 
-## 4 · Design logical sprint boundaries
+## 4 · 논리적 스프린트 경계 설계
 
-- Design sprint structure to complete the milestone
-- Each sprint should have:
-  - **Clear focus**: One main deliverable theme
-  - **Natural boundaries**: Minimal dependencies between sprints
-  - **Incremental value**: Each sprint advances toward milestone DoD
-- Sprint naming: `S<nn>_$milestone_id_$focus_slug`
-- **IMPORTANT:** Don't create sprints for work that's already completed
+- 마일스톤을 완성하기 위한 스프린트 구조 설계
+- 각 스프린트는 다음을 보유해야 함:
+  - **명확한 집중점**: 하나의 주요 결과물 테마
+  - **자연스러운 경계**: 스프린트 간 최소한의 종속성
+  - **점진적 가치**: 각 스프린트가 마일스톤 DoD를 향해 전진
+- 스프린트 명명: `S<nn>_$milestone_id_$focus_slug`
+- **중요:** 이미 완료된 작업에 대한 스프린트를 생성하지 마세요
 
-## 5 · Create sprint directories and meta files
+## 5 · 스프린트 디렉토리와 메타 파일 생성
 
-- For each planned sprint that doesn't exist:
-  - Create directory `.aiwf/03_SPRINTS/$FULL_SPRINT_NAME/` (using complete sprint name like "S02_M01_LLM_Integration")
-  - Use template from `.aiwf/99_TEMPLATES/sprint_meta_template.md`
-  - Fill in sprint meta with:
-    - High-level goal and scope
-    - Key deliverables (bullet points, not detailed tasks)
-    - Clear Definition of Done for the sprint
-    - Status: "planned"
+- 존재하지 않는 각 계획된 스프린트에 대해:
+  - 디렉토리 생성 `.aiwf/03_SPRINTS/$FULL_SPRINT_NAME/` ("S02_M01_LLM_Integration"과 같은 완전한 스프린트 이름 사용)
+  - `.aiwf/99_TEMPLATES/sprint_meta_template.md`에서 템플릿 사용
+  - 스프린트 메타를 다음으로 채우기:
+    - 고수준 목표와 범위
+    - 주요 결과물 (자세한 태스크가 아닌 불릿 포인트)
+    - 스프린트에 대한 명확한 완료 정의
+    - 상태: "planned"
 
-## 6 · Update PROJECT_MANIFEST with sprint roadmap
+## 6 · 스프린트 로드맵으로 PROJECT_MANIFEST 업데이트
 
-- Update `.aiwf/00_PROJECT_MANIFEST.md`:
-  - Set `highest_sprint_in_milestone` to the highest planned sprint
-  - Update sprint summary section with overview of remaining sprints
-  - Mark completed sprints as ✅ COMPLETED
-  - Show planned sprints with their focus areas
-  - Update `last_updated` timestamp
+- `.aiwf/00_PROJECT_MANIFEST.md` 업데이트:
+  - `highest_sprint_in_milestone`을 계획된 가장 높은 스프린트로 설정
+  - 남은 스프린트의 개요로 스프린트 요약 섹션 업데이트
+  - 완료된 스프린트를 ✅ COMPLETED로 표시
+  - 계획된 스프린트를 그들의 집중 영역과 함께 표시
+  - `last_updated` 타임스탬프 업데이트
 
-## 7 · Validate sprint coherence and dependencies
+## 7 · 스프린트 일관성과 종속성 검증
 
-- Review the planned sprint sequence for logical flow
-- Ensure each sprint builds naturally on previous work
-- Verify no sprint has impossible dependencies
-- Check that sprint sequence leads to milestone DoD completion
-- **Think about** whether each sprint is independently testable and valuable
+- 논리적 흐름을 위해 계획된 스프린트 순서 검토
+- 각 스프린트가 이전 작업을 자연스럽게 구축하는지 확인
+- 불가능한 종속성을 가진 스프린트가 없는지 확인
+- 스프린트 순서가 마일스톤 DoD 완성으로 이어지는지 확인
+- 각 스프린트가 독립적으로 테스트 가능하고 가치 있는지 **생각하기**
 
-## 8 · Report milestone plan
+## 8 · 마일스톤 계획 보고
 
-Provide comprehensive summary:
+포괄적인 요약 제공:
 
-**Milestone Status:**
+**마일스톤 상태:**
 
-- Target milestone: $milestone_id
-- Sprints completed: $count
-- Sprints planned: $count
-- Estimated completion: $sprint_sequence
+- 대상 마일스톤: $milestone_id
+- 완료된 스프린트: $count
+- 계획된 스프린트: $count
+- 예상 완료: $sprint_sequence
 
-**Sprint Roadmap:**
+**스프린트 로드맵:**
 
-For each sprint (existing and planned):
+각 스프린트에 대해 (기존 및 계획된):
 
 - **$Sprint_ID**: $status - $focus_description
-- Key deliverables: $bullet_list
-- Dependencies: $if_any
+- 주요 결과물: $bullet_list
+- 종속성: $if_any
 
-**Next Steps:**
+**다음 단계:**
 
-- Immediate next sprint to detail: $sprint_id
+- 상세화할 즉시 다음 스프린트: $sprint_id
 
-**Validation:**
+**검증:**
 
-Summarize your validation analysis covering:
+다음을 포함한 검증 분석 요약:
 
-- All milestone DoD items are covered by sprint plan
-- Sprint dependencies are logical and minimal
-- Each sprint delivers independent value
+- 모든 마일스톤 DoD 항목이 스프린트 계획에 포함됨
+- 스프린트 종속성이 논리적이고 최소한임
+- 각 스프린트가 독립적인 가치를 제공함

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

@@ -0,0 +1,44 @@
+# 기본 모드로 복원
+
+AI를 기본 모드로 복원합니다.
+
+```bash
+cd .aiwf && node ../claude-code/aiwf/ko/commands/ai-persona.js default
+```
+
+## 설명
+이 명령어는 현재 활성화된 페르소나를 비활성화하고 AI를 기본 범용 모드로 복원합니다.
+
+## 동작
+- 현재 페르소나 비활성화
+- 페르소나별 컨텍스트 규칙 해제
+- 기본 AI 동작 모드로 전환
+- 세션 통계 저장
+
+## 사용 시나리오
+- 특정 페르소나가 더 이상 필요하지 않을 때
+- 일반적인 개발 작업으로 돌아갈 때
+- 다른 페르소나로 전환하기 전
+- 페르소나 관련 문제 해결 시
+
+## 출력 예시
+```
+🎭 페르소나 모드 해제
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+이전 페르소나: [페르소나명]
+세션 시간: [시간]
+기본 모드로 복원되었습니다.
+```
+
+## 참고사항
+- 페르소나 세션 통계는 자동으로 저장됩니다
+- 언제든지 다른 페르소나를 활성화할 수 있습니다
+- 기본 모드에서도 모든 AI 기능을 사용할 수 있습니다
+
+## 관련 명령어
+- `/project:aiwf:persona_status` - 페르소나 상태 확인
+- `/project:aiwf:architect` - Architect 페르소나 활성화
+- `/project:aiwf:security` - Security 페르소나 활성화
+- `/project:aiwf:frontend` - Frontend 페르소나 활성화
+- `/project:aiwf:backend` - Backend 페르소나 활성화
+- `/project:aiwf:data_analyst` - Data Analyst 페르소나 활성화