aiwf 0.1.0 → 0.3.0

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

@@ -0,0 +1,189 @@
+# 스프린트를 위한 Task 생성 - 탑 다운 실행
+
+Create detailed tasks for an existing sprint with integrated implementation guidance.
+
+## Create a TODO with EXACTLY these 8 Items
+
+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
+
+Follow step by step and adhere closely to the following instructions for each step.
+
+## DETAILS on every TODO item
+
+### 1. Identify target sprint and verify it exists
+
+Check: <$ARGUMENTS>
+
+**REQUIRED:** Sprint ID must be provided (e.g., S02). If empty, ask user to specify which sprint to detail.
+
+- 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
+
+### 2. Load sprint context and related documentation
+
+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
+
+**IMPORTANT:** Sprint tasks must align with documented sprint goals, not expand scope.
+
+### 3. Check for existing ADRs and technical guidance
+
+**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
+
+**If conflict in Scope** Between ADR and Sprint goal, try to think about it and ask the user to resolve the conflict.
+
+**If no ADRs found:** Proceed but note that tasks may need clarification during implementation.
+
+### 4. Analyze sprint deliverables for task breakdown
+
+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
+
+### 5. Create individual task files with implementation guidance
+
+**NOW** For each identified Task spin up a Parallel Subagent with these Instructions:
+
+    #### Create a TODO for EACH task
+
+    1. Create basic task structure
+    2. Research codebase interfaces
+    3. Add technical guidance
+    4. Validate task completeness
+
+    ### 1. Create basic task structure
+
+    - 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
+
+    ### 2. Research codebase interfaces
+
+    - 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
+
+    ### 3. Add technical guidance
+
+    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
+
+    **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
+
+    - 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
+
+### 6. Link ADRs to relevant tasks
+
+- 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
+
+### 7. Update sprint meta with task references
+
+- 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
+
+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
+
+**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
+
+**Output format:**
+
+    ```Markdown
+    ## Sprint Detailed - [YYYY-MM-DD HH:MM]
+
+    **Sprint:** [Sprint ID] - [Sprint Name]
+    **Status:** Planning Complete
+
+    **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]
+
+    **Final Task List:**
+    1. T01_S02 - [Title] (Complexity: [Level])
+    2. T02_S02 - [Title] (Complexity: [Level])
+    [Continue for all tasks]
+
+    **Next Steps:**
+    - Review tasks for completeness
+    - Run `/do_task [FIRST_TASK_IN_SPRINT]` to begin implementation
+    ```

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

@@ -0,0 +1,121 @@
+# 마일스톤에서 스프린트 계획하기 - 탑 다운 실행
+
+Follow these instructions to sprint the scope of a Milestone into Sprints
+
+## Create a TODO with EXACTLY these 8 items
+
+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 · Analyze current milestone state
+
+**CRITICAL:** You are given additional 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)
+
+## 2 · Assess completed work vs milestone requirements
+
+- 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
+
+## 3 · Identify remaining work and dependencies
+
+- 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)
+
+## 4 · Design logical sprint boundaries
+
+- 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
+
+## 5 · Create sprint directories and meta files
+
+- 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"
+
+## 6 · Update PROJECT_MANIFEST with sprint roadmap
+
+- 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
+
+## 7 · Validate sprint coherence and dependencies
+
+- 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
+
+## 8 · Report milestone plan
+
+Provide comprehensive summary:
+
+**Milestone Status:**
+
+- Target milestone: $milestone_id
+- Sprints completed: $count
+- Sprints planned: $count
+- Estimated completion: $sprint_sequence
+
+**Sprint Roadmap:**
+
+For each sprint (existing and planned):
+
+- **$Sprint_ID**: $status - $focus_description
+- Key deliverables: $bullet_list
+- Dependencies: $if_any
+
+**Next Steps:**
+
+- Immediate next sprint to detail: $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

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

@@ -0,0 +1,29 @@
+# 리뷰 결과 논의
+
+Engage in technical discussion about recent review findings based on discussion starter.
+
+Discussion Starter: <$ARGUMENTS>
+
+## Discussion Primer
+
+**IMPORTANT:** Maintain John Carmack perspective - brutally honest, practical, focused on shipping working software.
+
+### Discussion Tone
+
+- **Be conversational** but maintain technical depth
+- **Challenge assumptions** - question if issues are real problems for current development stage
+- **Explore trade-offs** - suggest multiple approaches with pros/cons
+- **Focus on decisions** - what to do next, not just analysis
+- **Consider context** - balance technical perfection vs delivery timeline
+
+### Potential Discussion Outcomes
+
+Based on the conversation, you may suggest:
+
+- **Amending review findings** if new context changes severity/priority
+- **Updating documentation** in `.aiwf/01_PROJECT_DOCS/` if architectural decisions need clarification
+- **Revising requirements** in `.aiwf/02_REQUIREMENTS/` if scope understanding was incorrect
+- **Creating tasks** for specific technical debt items that need addressing
+- **Adjusting sprint priorities** based on refined understanding
+
+**IMPORTANT:** Help make practical engineering decisions. Be John Carmack: direct, experienced, and focused on what actually matters for shipping.

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

@@ -0,0 +1,109 @@
+# $Argument 기반 AIWF 태스크 처리
+
+**IMPORTANT:** Follow from Top to Bottom - don't skip anything!
+
+**CREATE A TODO LIST** with exactly these 8 items
+
+1. Analyse scope from argument
+2. Identify task file
+3. Analyse the task
+4. Set status to in_progress
+5. Execute task work
+6. Placeholder
+7. Execute Code review
+8. Finalize Task status
+
+## 1 · Analyse scope from argument
+
+<$ARGUMENTS> ⇒ Task ID, Sprint ID, or empty (select next open task in current sprint).
+
+## 2 · Identify task file
+
+Search .aiwf/03_SPRINTS/ and .aiwf/04_GENERAL_TASKS/.
+If no open task matches, pause and ask the user how to proceed.
+
+## 3 · Analyse the task
+
+Read the task description. If anything is unclear, ask clarifying questions before continuing.
+
+**CRITICAL CONTEXT VALIDATION:** Before executing any task spin up Parallel Subagents for these tasks:
+
+1. **Sprint Context:** Confirm task belongs to current sprint scope
+2. **Dependencies:** Check if any dependent tasks need to be completed first
+3. **Requirements:** Read relevant requirements docs in `.aiwf/02_REQUIREMENTS/`
+4. **Scope Verification:** Ensure task aligns with current sprint objectives
+5. **GitHub Issue Check:** Check if task file has a `github_issue` field
+
+**IMPORTANT:** If task references functionality from future sprints or has unmet dependencies, pause and ask for clarification.
+
+**GitHub Issue Creation (Optional):**
+
+- If task doesn't have a GitHub issue and user wants issue tracking
+- Suggest using `/project:aiwf:issue_create {task_id}` command
+
+## 4 · Set status to in_progress
+
+- Find out the current local timestamp (YYYY-MM-DD HH:MM).
+- Update front-matter to **status: in_progress** and set Updated time
+- Update ./aiwf/00_PROJECT_MANIFEST.md to set task in progress, updated time and current Sprint Status.
+- **GitHub Issue Update (if exists):**
+  ```bash
+  gh issue comment {issue_number} --body "🚀 Task work has started."
+  gh issue edit {issue_number} --add-label "in-progress"
+  ```
+
+## 5 · Execute task work
+
+- Follow Description, Goal and Acceptance Criteria.
+- Consult supporting docs in .aiwf/01_PROJECT_DOCS/ and .aiwf/02_REQUIREMENTS/.
+- Iterate over subtasks:
+  1. Pick the next incomplete subtask.
+  2. Implement the required changes, consulting docs as needed.
+  3. Mark the subtask done.
+  4. Append a log entry to **## Output Log** using the format `[YYYY-MM-DD HH:MM]: <message>`.
+  5. Repeat until all subtasks are complete.
+
+## 6 · Placeholder
+
+Placeholder - just move on to the next step
+
+## 7 · Execute Code Review
+
+Follow these steps for a Code Review (in order)
+
+- include @.claude/commands/aiwf/aiwf_code_review.md and use the Task ID as Scope.
+- Follow the instructions in the file to run a code review in **PARALLEL SUBAGENTS**
+- When done continue acting on the results accordingly
+- Understand and think about the results
+- on **FAIL**
+  - thoroughly understand the problem
+  - extend the Current Task with the Subtasks identified by the review
+  - go back to "5 · Execute task work"
+- on **PASS**
+  - move on to next step
+
+## 8 · Finalize task status
+
+- set the Task status to **completed**
+- Rename the Task file accordingly to enable proper Completed recognition from the filename (TX[TASK_ID]...)
+- Update .aiwf/00_PROJECT_MANIFEST.md to reflect the new status
+- **GitHub Issue Update (if exists):**
+  ```bash
+  gh issue comment {issue_number} --body "✅ Task has been completed."
+  gh issue edit {issue_number} --remove-label "in-progress" --add-label "completed"
+  ```
+- **Report** the result to the user
+
+  ✅ **Result**: Quick statement of success
+
+  🔎 **Scope**: Identified task or reason none was processed
+
+  💬 **Summary**: One-paragraph recap of what was done or why blocked
+
+  ⏭️ **Next steps**: Recommended follow-up actions
+
+- **Suggestions** for the User:
+
+  - 🛠️ Use /project:aiwf:commit `TASK_ID` to commit the changes to git
+  - 🔀 Use /project:aiwf:pr_create `TASK_ID` to create a Pull Request
+  - 🧹 Use /clear to clear the context before starting the next Task

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

@@ -0,0 +1,202 @@
+# 무한 에이전틱 루프 명령
+
+이 무한 생성 작업에 대해 깊이 생각하세요. 당신은 정교한 반복 생성 프로세스를 시작하려고 합니다. deep think
+
+**변수:**
+
+spec_file: $ARGUMENTS
+output_dir: $ARGUMENTS
+count: $ARGUMENTS
+
+**인자 파싱:**
+"$ARGUMENTS"에서 다음 인자들을 파싱합니다:
+
+1. `spec_file` - 마크다운 명세 파일 경로
+2. `output_dir` - 반복 결과가 저장될 디렉토리
+3. `count` - 반복 횟수 (1-N 또는 "infinite")
+
+**1단계: 명세 분석**
+`spec_file`의 명세 파일을 읽고 깊이 이해합니다. 이 파일은 다음을 정의합니다:
+
+- 생성할 콘텐츠 유형
+- 형식과 구조 요구사항
+- 특정 매개변수나 제약사항
+- 반복 간의 의도된 진화 패턴
+
+명세의 의도와 각 반복이 이전 작업을 어떻게 기반으로 해야 하는지 신중히 생각하세요.
+
+**2단계: 출력 디렉토리 탐색**
+현재 상태를 이해하기 위해 `output_dir`을 철저히 분석합니다:
+
+- 모든 기존 파일과 명명 패턴 나열
+- 현재 존재하는 가장 높은 반복 번호 식별
+- 기존 반복들 간의 콘텐츠 진화 분석
+- 이전 생성의 궤적 이해
+- 새로운 반복을 위한 격차나 기회 파악
+
+**3단계: 반복 전략**
+명세 분석과 기존 반복을 기반으로:
+
+- 시작 반복 번호 결정 (최고 기존 번호 + 1)
+- 각 새로운 반복이 독특하고 진화적일 방법 계획
+- 새로움을 유지하면서 이전 반복을 기반으로 구축하는 방법 고려
+- count가 "infinite"인 경우, 컨텍스트 제한까지 지속적 생성 준비
+
+**4단계: 병렬 에이전트 조율**
+최대 효율성과 창의적 다양성을 위해 여러 서브 에이전트를 병렬로 배포합니다:
+
+**서브 에이전트 배포 전략:**
+
+- count 1-5: 모든 에이전트 동시 실행
+- count 6-20: 5개 에이전트씩 배치로 실행하여 조율 관리
+- "infinite": 3-5개 에이전트의 웨이브를 실행하고, 컨텍스트를 모니터링하며 새로운 웨이브 생성
+
+**에이전트 할당 프로토콜:**
+각 서브 에이전트는 다음을 받습니다:
+
+1. **명세 컨텍스트**: 완전한 명세 파일 분석
+2. **디렉토리 스냅샷**: 실행 시점의 output_dir 현재 상태
+3. **반복 할당**: 특정 반복 번호 (시작*번호 + 에이전트*인덱스)
+4. **독특성 지시**: 기존 반복의 개념을 중복하지 않도록 명시적 지시
+5. **품질 기준**: 명세의 상세 요구사항
+
+**에이전트 작업 명세:**
+
+```
+작업: [OUTPUT_DIR]에 [SPEC_FILE]의 반복 [NUMBER] 생성
+
+당신은 반복 [NUMBER]를 생성하는 서브 에이전트 [X]입니다.
+
+컨텍스트:
+- 명세: [전체 명세 분석]
+- 기존 반복: [현재 output_dir 내용 요약]
+- 당신의 반복 번호: [NUMBER]
+- 할당된 창의적 방향: [탐색할 특정 혁신 차원]
+
+요구사항:
+1. 명세를 완전히 읽고 이해
+2. 기존 반복을 분석하여 출력이 독특한지 확인
+3. 명세 형식을 정확히 따라 콘텐츠 생성
+4. 명세 준수를 유지하면서 [할당된 혁신 차원]에 집중
+5. 지정된 정확한 이름 패턴으로 파일 생성
+6. 반복이 진정한 가치와 새로움을 추가하는지 확인
+
+산출물: 명세에 따른 단일 파일, 독특하고 혁신적인 콘텐츠 포함
+```
+
+**병렬 실행 관리:**
+
+- Task 도구를 사용하여 모든 할당된 서브 에이전트를 동시에 실행
+- 에이전트 진행과 완료 모니터링
+- 에이전트 실패 시 반복 번호 재할당으로 처리
+- 중복 반복 번호가 생성되지 않도록 보장
+- 완료된 모든 반복 수집 및 검증
+
+**5단계: 무한 모드 오케스트레이션**
+무한 생성 모드의 경우, 지속적인 병렬 웨이브를 조율합니다:
+
+**웨이브 기반 생성:**
+
+1. **웨이브 계획**: 컨텍스트 용량에 따라 다음 웨이브 크기(3-5 에이전트) 결정
+2. **에이전트 준비**: 각 새로운 웨이브를 위한 신선한 컨텍스트 스냅샷 준비
+3. **점진적 정교화**: 각 웨이브는 더 발전된 혁신 차원을 탐색해야 함
+4. **컨텍스트 모니터링**: 모든 에이전트와 메인 오케스트레이터의 총 컨텍스트 사용량 추적
+5. **우아한 종료**: 컨텍스트 한계에 접근하면 현재 웨이브를 완료하고 요약
+
+**무한 실행 사이클:**
+
+```
+WHILE 컨텍스트_용량 > 임계값:
+    1. 현재 output_dir 상태 평가
+    2. 다음 에이전트 웨이브 계획 (남은 컨텍스트에 따른 크기)
+    3. 점점 정교한 창의적 방향 할당
+    4. 병렬 서브 에이전트 웨이브 실행
+    5. 웨이브 완료 모니터링
+    6. 디렉토리 상태 스냅샷 업데이트
+    7. 남은 컨텍스트 용량 평가
+    8. 충분한 용량 있으면: 다음 웨이브로 계속
+    9. 한계에 접근하면: 최종 웨이브 완료하고 요약
+```
+
+**점진적 정교화 전략:**
+
+- **웨이브 1**: 단일 혁신 차원의 기본 기능 대체
+- **웨이브 2**: 향상된 상호작용이 있는 다차원 혁신
+- **웨이브 3**: 적응형 행동이 있는 복잡한 패러다임 조합
+- **웨이브 N**: 명세의 경계를 확장하는 혁명적 개념
+
+**컨텍스트 최적화:**
+
+- 각 웨이브는 컨텍스트 누적을 피하기 위해 신선한 에이전트 인스턴스 사용
+- 메인 오케스트레이터는 경량 상태 추적 유지
+- 컨텍스트 관리를 위한 완료된 반복의 점진적 요약
+- 후반 웨이브에서 덜 필수적인 세부사항의 전략적 제거
+
+**실행 원칙:**
+
+**품질 & 독특성:**
+
+- 각 반복은 진정으로 독특하고 가치있어야 함
+- 새로운 요소를 도입하면서 이전 작업을 기반으로 구축
+- 원래 명세와의 일관성 유지
+- 적절한 파일 구성과 명명 보장
+
+**병렬 조율:**
+
+- 창의적 다양성을 극대화하기 위해 서브 에이전트를 전략적으로 배포
+- 중복을 피하기 위해 각 에이전트에 독특한 혁신 차원 할당
+- 파일 명명 충돌을 방지하기 위한 타이밍 조정
+- 성공적인 완료와 품질을 위한 모든 에이전트 모니터링
+
+**확장성 & 효율성:**
+
+- 병렬 스트림 전체의 진화 궤적에 대해 깊이 생각 deep think
+- 무한 모드의 경우, 컨텍스트 소진 전 최대 가치있는 출력 최적화
+- 컨텍스트 한계를 지능적으로 관리하기 위한 웨이브 기반 생성 사용
+- 병렬 속도와 품질 및 조율 오버헤드의 균형
+
+**에이전트 관리:**
+
+- 각 서브 에이전트에 완전한 컨텍스트와 명확한 할당 제공
+- 반복 재할당으로 에이전트 실패를 우아하게 처리
+- 모든 병렬 출력이 전체 진행과 일관되게 통합되도록 보장
+
+**울트라 씽킹 지시:**
+생성을 시작하기 전에, 다음에 대해 확장된 사고를 수행하세요:
+
+**명세 & 진화:**
+
+- 명세의 더 깊은 의미
+- 반복 간 의미있는 진행을 만드는 방법
+- 각 반복을 가치있고 독특하게 만드는 것
+- 일관성과 혁신의 균형을 맞추는 방법
+
+**병렬 전략:**
+
+- 요청된 수에 대한 최적의 서브 에이전트 배포
+- 다양성을 극대화하기 위해 독특한 창의적 방향을 할당하는 방법
+- 무한 모드의 웨이브 크기와 타이밍
+- 여러 병렬 에이전트 간의 컨텍스트 관리
+
+**조율 과제:**
+
+- 병렬 스트림 간 중복 개념 방지 방법
+- 각 에이전트가 진정으로 독특한 출력을 생산하도록 보장하는 전략
+- 동시 쓰기가 있는 파일 명명과 디렉토리 구성 관리
+- 병렬 출력의 품질 관리 메커니즘
+
+**무한 모드 최적화:**
+
+- 지속적인 출력을 위한 웨이브 기반 생성 패턴
+- 여러 웨이브에 걸친 점진적 정교화 전략
+- 컨텍스트 용량 모니터링과 우아한 종료 계획
+- 병렬 생성 속도와 혁신 깊이의 균형
+
+**위험 완화:**
+
+- 에이전트 실패와 반복 재할당 처리
+- 병렬 실행에도 불구하고 일관된 전체 진행 보장
+- 전체 시스템의 컨텍스트 창 한계 관리
+- 모든 병렬 출력의 명세 준수 유지
+
+이러한 병렬 조율 과제에 대한 깊은 분석으로 실행을 시작하고, 최대 창의적 출력과 효율성을 위해 서브 에이전트를 활용하여 각 단계를 체계적으로 진행하세요.