claude-symphony 0.0.4 → 0.0.6

package/template/scripts/context-manager.sh

@@ -63,11 +63,62 @@ get_current_stage() {
     fi
 }
 
-# Estimate tokens (simple estimation)
+# Estimate tokens (content-based estimation)
+# Token estimation rules:
+# - English: word count × 1.3
+# - Korean: character count × 0.5
+# - Code: line count × 10
 estimate_tokens() {
-    # In practice, conversation logs should be analyzed, but this is a placeholder
-    # Actual implementation would reference Claude API or log files
-    echo "45000"  # placeholder
+    local total_tokens=0
+    local current_stage=$(get_current_stage)
+
+    # Scan stage outputs for token estimation
+    local stage_dir="$PROJECT_ROOT/stages/$current_stage/outputs"
+    if [ -d "$stage_dir" ]; then
+        for file in "$stage_dir"/*.md "$stage_dir"/*.txt 2>/dev/null; do
+            [ -f "$file" ] || continue
+
+            local content=$(cat "$file")
+
+            # Count English words (ASCII alphanumeric sequences)
+            local english_words=$(echo "$content" | grep -oE '[a-zA-Z]+' | wc -w | tr -d ' ')
+
+            # Count Korean characters (Hangul range: AC00-D7AF)
+            local korean_chars=$(echo "$content" | grep -oE '[\xEA-\xED][\x80-\xBF][\x80-\xBF]' 2>/dev/null | wc -c | tr -d ' ')
+            korean_chars=$((korean_chars / 3))  # UTF-8 Korean chars are 3 bytes
+
+            # Calculate tokens for this file
+            local file_tokens=$(( (english_words * 13 / 10) + (korean_chars / 2) ))
+            total_tokens=$((total_tokens + file_tokens))
+        done
+    fi
+
+    # Scan code files
+    local project_src="$PROJECT_ROOT/src"
+    if [ -d "$project_src" ]; then
+        local code_lines=$(find "$project_src" -type f \( -name "*.js" -o -name "*.ts" -o -name "*.tsx" -o -name "*.py" -o -name "*.go" \) -exec wc -l {} + 2>/dev/null | tail -1 | awk '{print $1}')
+        if [ -n "$code_lines" ] && [ "$code_lines" -gt 0 ]; then
+            total_tokens=$((total_tokens + code_lines * 10))
+        fi
+    fi
+
+    # Scan HANDOFF files
+    for handoff in "$PROJECT_ROOT"/stages/*/HANDOFF.md 2>/dev/null; do
+        [ -f "$handoff" ] || continue
+        local handoff_words=$(wc -w < "$handoff" 2>/dev/null | tr -d ' ')
+        total_tokens=$((total_tokens + handoff_words * 13 / 10))
+    done
+
+    # Add base context overhead (conversation history estimate)
+    local base_overhead=10000
+    total_tokens=$((total_tokens + base_overhead))
+
+    # Minimum floor for realistic estimation
+    if [ "$total_tokens" -lt 15000 ]; then
+        total_tokens=15000
+    fi
+
+    echo "$total_tokens"
 }
 
 # Generate progress bar

package/template/scripts/goto-stage.sh

@@ -0,0 +1,264 @@
+#!/bin/bash
+# goto-stage.sh - Jump to previous stage (loop-back)
+# claude-symphony workflow pipeline
+
+set -e
+
+PROJECT_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+PROGRESS_FILE="$PROJECT_ROOT/state/progress.json"
+STAGES_DIR="$PROJECT_ROOT/stages"
+CONFIG_FILE="$PROJECT_ROOT/config/pipeline.yaml"
+
+# Color definitions
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+WHITE='\033[1;37m'
+GRAY='\033[0;90m'
+NC='\033[0m' # No Color
+
+# Stage info
+declare -a STAGE_IDS=("01-brainstorm" "02-research" "03-planning" "04-ui-ux" "05-task-management" "06-implementation" "07-refactoring" "08-qa" "09-testing" "10-deployment")
+
+# Option handling
+TARGET_STAGE=""
+LIST_MODE=false
+HISTORY_MODE=false
+REASON=""
+
+print_usage() {
+    echo "Usage: goto-stage.sh <stage-id> [--reason \"reason\"]"
+    echo "       goto-stage.sh --list"
+    echo "       goto-stage.sh --history"
+    echo ""
+    echo "Options:"
+    echo "  <stage-id>          Target stage to jump to (e.g., 06-implementation)"
+    echo "  --reason \"text\"     Reason for loop-back (required)"
+    echo "  --list              Show available stages for loop-back"
+    echo "  --history           Show loop-back history"
+    echo ""
+    echo "Examples:"
+    echo "  ./goto-stage.sh 06-implementation --reason \"BUG-002 fix required\""
+    echo "  ./goto-stage.sh --list"
+}
+
+while [[ "$#" -gt 0 ]]; do
+    case $1 in
+        --list) LIST_MODE=true ;;
+        --history) HISTORY_MODE=true ;;
+        --reason) REASON="$2"; shift ;;
+        --help|-h) print_usage; exit 0 ;;
+        *)
+            if [[ -z "$TARGET_STAGE" ]]; then
+                TARGET_STAGE="$1"
+            fi
+            ;;
+    esac
+    shift
+done
+
+# Check jq
+if ! command -v jq &> /dev/null; then
+    echo -e "${RED}Error:${NC} jq is required."
+    exit 1
+fi
+
+# Check progress.json
+if [ ! -f "$PROGRESS_FILE" ]; then
+    echo -e "${RED}Error:${NC} Cannot find progress.json."
+    exit 1
+fi
+
+# Get current stage
+CURRENT_STAGE=$(jq -r '.current_stage // "none"' "$PROGRESS_FILE")
+
+if [ "$CURRENT_STAGE" == "none" ] || [ -z "$CURRENT_STAGE" ]; then
+    echo -e "${RED}Error:${NC} No stage in progress."
+    exit 1
+fi
+
+# Find current stage index
+get_stage_index() {
+    local STAGE_ID=$1
+    for i in "${!STAGE_IDS[@]}"; do
+        if [ "${STAGE_IDS[$i]}" == "$STAGE_ID" ]; then
+            echo "$i"
+            return
+        fi
+    done
+    echo "-1"
+}
+
+CURRENT_IDX=$(get_stage_index "$CURRENT_STAGE")
+
+# Handle --list
+if [ "$LIST_MODE" = true ]; then
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo -e "📋 ${WHITE}Available Loop-back Targets${NC}"
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo -e "Current stage: ${CYAN}$CURRENT_STAGE${NC}"
+    echo ""
+    echo "Available targets (max 3 stages back):"
+
+    # Check max_stages_back from config (default 3)
+    MAX_BACK=3
+    if command -v yq &> /dev/null && [ -f "$CONFIG_FILE" ]; then
+        MAX_BACK=$(yq '.sprint_mode.loop_back.max_stages_back // 3' "$CONFIG_FILE" 2>/dev/null)
+    fi
+
+    for ((i = CURRENT_IDX - 1; i >= 0 && i >= CURRENT_IDX - MAX_BACK; i--)); do
+        STAGE_STATUS=$(jq -r ".stages[\"${STAGE_IDS[$i]}\"].status // \"pending\"" "$PROGRESS_FILE")
+        if [ "$STAGE_STATUS" == "completed" ]; then
+            echo -e "  ${GREEN}✓${NC} ${STAGE_IDS[$i]}"
+        fi
+    done
+
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    exit 0
+fi
+
+# Handle --history
+if [ "$HISTORY_MODE" = true ]; then
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo -e "📜 ${WHITE}Loop-back History${NC}"
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+
+    HISTORY_COUNT=$(jq '.loop_back_history | length' "$PROGRESS_FILE" 2>/dev/null || echo "0")
+
+    if [ "$HISTORY_COUNT" == "0" ]; then
+        echo "No loop-back history found."
+    else
+        jq -r '.loop_back_history[] | "[\(.timestamp)] \(.from_stage) → \(.to_stage): \(.reason)"' "$PROGRESS_FILE" 2>/dev/null
+    fi
+
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    exit 0
+fi
+
+# Validate target stage
+if [ -z "$TARGET_STAGE" ]; then
+    echo -e "${RED}Error:${NC} Target stage is required."
+    print_usage
+    exit 1
+fi
+
+# Find target stage index
+TARGET_IDX=$(get_stage_index "$TARGET_STAGE")
+
+if [ "$TARGET_IDX" == "-1" ]; then
+    echo -e "${RED}Error:${NC} Unknown stage: $TARGET_STAGE"
+    exit 1
+fi
+
+# Validate loop-back (must go backwards)
+if [ "$TARGET_IDX" -ge "$CURRENT_IDX" ]; then
+    echo -e "${RED}Error:${NC} Can only loop back to previous stages."
+    echo "  Current: $CURRENT_STAGE (index $CURRENT_IDX)"
+    echo "  Target:  $TARGET_STAGE (index $TARGET_IDX)"
+    exit 1
+fi
+
+# Check max stages back
+MAX_BACK=3
+if command -v yq &> /dev/null && [ -f "$CONFIG_FILE" ]; then
+    MAX_BACK=$(yq '.sprint_mode.loop_back.max_stages_back // 3' "$CONFIG_FILE" 2>/dev/null)
+fi
+
+STAGES_BACK=$((CURRENT_IDX - TARGET_IDX))
+if [ "$STAGES_BACK" -gt "$MAX_BACK" ]; then
+    echo -e "${RED}Error:${NC} Cannot loop back more than $MAX_BACK stages."
+    echo "  Attempted: $STAGES_BACK stages back"
+    exit 1
+fi
+
+# Require reason
+if [ -z "$REASON" ]; then
+    echo -e "${RED}Error:${NC} Reason is required for loop-back."
+    echo "  Use: --reason \"your reason\""
+    exit 1
+fi
+
+# Execute loop-back
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo -e "🔙 ${WHITE}Stage Loop-back${NC}"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo -e "$CURRENT_STAGE → $TARGET_STAGE"
+echo ""
+
+# 1. Create checkpoint
+TIMESTAMP=$(date +%Y%m%d_%H%M%S)
+CHECKPOINT_ID="checkpoint_loopback_${TIMESTAMP}"
+CHECKPOINT_DIR="$PROJECT_ROOT/state/checkpoints/$CHECKPOINT_ID"
+
+mkdir -p "$CHECKPOINT_DIR"
+echo -e "${GREEN}✓${NC} Checkpoint: $CHECKPOINT_ID"
+
+# 2. Record loop-back in progress.json
+LOOP_BACK_ENTRY=$(cat << EOF
+{
+  "timestamp": "$(date -u +"%Y-%m-%dT%H:%M:%SZ")",
+  "from_stage": "$CURRENT_STAGE",
+  "to_stage": "$TARGET_STAGE",
+  "reason": "$REASON",
+  "checkpoint_id": "$CHECKPOINT_ID"
+}
+EOF
+)
+
+jq ".loop_back_history += [$LOOP_BACK_ENTRY]" "$PROGRESS_FILE" > "${PROGRESS_FILE}.tmp" \
+    && mv "${PROGRESS_FILE}.tmp" "$PROGRESS_FILE"
+echo -e "${GREEN}✓${NC} Reason: $REASON"
+
+# 3. Generate loop-back HANDOFF
+HANDOFF_FILE="$STAGES_DIR/$CURRENT_STAGE/LOOPBACK_HANDOFF.md"
+cat > "$HANDOFF_FILE" << EOF
+# Loop-back Handoff: $CURRENT_STAGE → $TARGET_STAGE
+
+Created: $(date "+%Y-%m-%d %H:%M")
+
+## Reason
+
+$REASON
+
+## Context
+
+This is an intentional loop-back to address issues discovered during $CURRENT_STAGE.
+
+## Checkpoint
+
+- ID: $CHECKPOINT_ID
+- Location: state/checkpoints/$CHECKPOINT_ID
+
+## Instructions
+
+1. Review the reason for loop-back
+2. Address the issues in $TARGET_STAGE
+3. Return to $CURRENT_STAGE after resolution
+4. Reference this file for context
+
+## Previous Stage Status
+
+- Stage: $CURRENT_STAGE
+- Status at loop-back: in_progress
+EOF
+
+# Copy to handoffs archive
+cp "$HANDOFF_FILE" "$PROJECT_ROOT/state/handoffs/loopback_${TIMESTAMP}_handoff.md"
+
+# 4. Update progress.json - change stages
+jq ".current_stage = \"$TARGET_STAGE\" | \
+    .stages[\"$TARGET_STAGE\"].status = \"in_progress\" | \
+    .stages[\"$TARGET_STAGE\"].started_at = \"$(date -u +"%Y-%m-%dT%H:%M:%SZ")\"" \
+    "$PROGRESS_FILE" > "${PROGRESS_FILE}.tmp" && mv "${PROGRESS_FILE}.tmp" "$PROGRESS_FILE"
+
+echo ""
+echo -e "${GREEN}✅${NC} Moved to ${WHITE}$TARGET_STAGE${NC}!"
+echo ""
+echo "Next steps:"
+echo "  1. Reference stages/$TARGET_STAGE/CLAUDE.md"
+echo "  2. Address: $REASON"
+echo "  3. Use /next to proceed after resolution"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"

package/template/scripts/next-stage.sh

@@ -22,17 +22,142 @@ NC='\033[0m' # No Color
 FORCE_MODE=false
 PREVIEW_MODE=false
 NO_HANDOFF=false
+STAGE_FORCE=false
 
 while [[ "$#" -gt 0 ]]; do
     case $1 in
         --force) FORCE_MODE=true ;;
         --preview) PREVIEW_MODE=true ;;
         --no-handoff) NO_HANDOFF=true ;;
+        --stage) STAGE_FORCE=true ;;
         *) ;;
     esac
     shift
 done
 
+# Check for yq (YAML parser)
+check_yq() {
+    if command -v yq &> /dev/null; then
+        return 0
+    fi
+    return 1
+}
+
+# Sprint-aware transition logic
+handle_sprint_transition() {
+    local CONFIG_FILE="$PROJECT_ROOT/config/pipeline.yaml"
+
+    # Check if yq is available
+    if ! check_yq; then
+        return 1  # Proceed with stage transition
+    fi
+
+    # Check if sprint mode is enabled
+    local SPRINT_ENABLED=$(yq '.sprint_mode.enabled // false' "$CONFIG_FILE" 2>/dev/null)
+    if [ "$SPRINT_ENABLED" != "true" ]; then
+        return 1  # Proceed with stage transition
+    fi
+
+    # Check if current stage is iterative
+    local STAGE_ITERATIVE=$(yq ".sprint_mode.stage_iterations[\"$CURRENT_STAGE\"].iterative // false" "$CONFIG_FILE" 2>/dev/null)
+    if [ "$STAGE_ITERATIVE" != "true" ]; then
+        return 1  # Proceed with stage transition
+    fi
+
+    # Get current sprint info
+    local CURRENT_SPRINT=$(jq -r '.current_iteration.current_sprint // 1' "$PROGRESS_FILE")
+    local TOTAL_SPRINTS=$(jq -r '.current_iteration.total_sprints // 3' "$PROGRESS_FILE")
+
+    if [ "$CURRENT_SPRINT" -lt "$TOTAL_SPRINTS" ]; then
+        # Sprint transition
+        echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+        echo -e "🔄 ${WHITE}Sprint Transition${NC}"
+        echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+        echo -e "Sprint $CURRENT_SPRINT → Sprint $((CURRENT_SPRINT + 1))"
+        echo ""
+
+        # Generate Sprint HANDOFF
+        generate_sprint_handoff "$CURRENT_SPRINT"
+
+        # Create Sprint checkpoint
+        create_sprint_checkpoint "$CURRENT_SPRINT"
+
+        # Advance sprint
+        advance_sprint "$CURRENT_SPRINT"
+
+        echo ""
+        echo -e "${GREEN}✅${NC} Sprint $((CURRENT_SPRINT + 1)) started!"
+        echo "Remaining Sprints: $((TOTAL_SPRINTS - CURRENT_SPRINT - 1))"
+        echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+
+        return 0  # Sprint transition completed
+    fi
+
+    return 1  # All sprints complete, proceed with stage transition
+}
+
+# Generate Sprint HANDOFF
+generate_sprint_handoff() {
+    local SPRINT_NUM=$1
+    local HANDOFF_FILE="$STAGES_DIR/$CURRENT_STAGE/outputs/SPRINT_HANDOFF_${SPRINT_NUM}.md"
+    local TIMESTAMP=$(date "+%Y-%m-%d %H:%M")
+
+    mkdir -p "$STAGES_DIR/$CURRENT_STAGE/outputs"
+
+    cat > "$HANDOFF_FILE" << EOF
+# Sprint Handoff: Sprint $SPRINT_NUM → Sprint $((SPRINT_NUM + 1))
+
+Created: $TIMESTAMP
+
+## Completed Tasks (Sprint $SPRINT_NUM)
+
+$(jq -r ".sprints[\"Sprint $SPRINT_NUM\"].completed_tasks // [] | .[]" "$PROGRESS_FILE" 2>/dev/null | while read -r task; do echo "- [x] $task"; done)
+
+## Sprint Summary
+
+- Tasks completed: $(jq -r ".sprints[\"Sprint $SPRINT_NUM\"].tasks_completed // 0" "$PROGRESS_FILE")
+- Test results: lint ✓, typecheck ✓
+- Checkpoint: sprint_${SPRINT_NUM}_$(date +%Y%m%d)
+
+## Next Sprint Focus
+
+- Reference Sprint $((SPRINT_NUM + 1)) tasks in sprint_plan.md
+
+EOF
+
+    # Archive copy
+    mkdir -p "$PROJECT_ROOT/state/handoffs"
+    cp "$HANDOFF_FILE" "$PROJECT_ROOT/state/handoffs/sprint_${SPRINT_NUM}_handoff.md"
+
+    echo -e "${GREEN}✓${NC} SPRINT_HANDOFF_${SPRINT_NUM}.md generated"
+}
+
+# Create Sprint checkpoint
+create_sprint_checkpoint() {
+    local SPRINT_NUM=$1
+    local CHECKPOINT_DIR="$PROJECT_ROOT/state/checkpoints"
+    local CHECKPOINT_ID="sprint_${SPRINT_NUM}_$(date +%Y%m%d_%H%M%S)"
+
+    mkdir -p "$CHECKPOINT_DIR/$CHECKPOINT_ID"
+
+    # Update progress.json with checkpoint
+    jq ".sprints[\"Sprint $SPRINT_NUM\"].checkpoint_id = \"$CHECKPOINT_ID\"" \
+        "$PROGRESS_FILE" > "${PROGRESS_FILE}.tmp" && mv "${PROGRESS_FILE}.tmp" "$PROGRESS_FILE"
+
+    echo -e "${GREEN}✓${NC} Checkpoint: $CHECKPOINT_ID"
+}
+
+# Advance sprint counter
+advance_sprint() {
+    local CURRENT=$1
+    local NEXT=$((CURRENT + 1))
+
+    jq ".current_iteration.current_sprint = $NEXT | \
+        .sprints[\"Sprint $CURRENT\"].status = \"completed\" | \
+        .sprints[\"Sprint $NEXT\"].status = \"in_progress\"" \
+        "$PROGRESS_FILE" > "${PROGRESS_FILE}.tmp" && mv "${PROGRESS_FILE}.tmp" "$PROGRESS_FILE"
+}
+
 # Check jq
 if ! command -v jq &> /dev/null; then
     echo -e "${RED}Error:${NC} jq is required."
@@ -92,6 +217,13 @@ NEXT_STAGE="${STAGE_IDS[$NEXT_IDX]}"
 CURRENT_STAGE_DIR="$STAGES_DIR/$CURRENT_STAGE"
 NEXT_STAGE_DIR="$STAGES_DIR/$NEXT_STAGE"
 
+# Check for sprint transition (unless --stage flag is used)
+if [ "$STAGE_FORCE" = false ]; then
+    if handle_sprint_transition; then
+        exit 0  # Sprint transition completed, exit
+    fi
+fi
+
 echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
 echo -e "🔄 ${WHITE}Stage Transition${NC}"
 echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"

package/template/stages/01-brainstorm/HANDOFF.md.template

@@ -1,102 +1,102 @@
 # Stage Handoff: 01-brainstorm → 02-research
 
-**생성일**: {{TIMESTAMP}}
-**생성자**: {{MODEL}}
-**소요 시간**: {{DURATION}}
+**Created**: {{TIMESTAMP}}
+**Creator**: {{MODEL}}
+**Duration**: {{DURATION}}
 
 ---
 
-## 완료된 작업
+## Completed Tasks
 
-- [ ] 프로젝트 브리프 분석
-- [ ] 브레인스토밍 ({{IDEA_COUNT}}개 아이디어)
-- [ ] 사용자 페르소나 생성 ({{PERSONA_COUNT}}개)
-- [ ] 요구사항 분석
-- [ ] MVP 범위 정의
-- [ ] HANDOFF.md 생성
+- [ ] Project brief analysis
+- [ ] Brainstorming ({{IDEA_COUNT}} ideas)
+- [ ] User persona creation ({{PERSONA_COUNT}} personas)
+- [ ] Requirements analysis
+- [ ] MVP scope definition
+- [ ] HANDOFF.md generation
 
 ---
 
-## 다음 에이전트를 위한 컨텍스트
+## Context for Next Agent
 
-### 핵심 결정사항
+### Key Decisions
 
-| 결정 | 이유 | 되돌릴 수 있음 |
-|------|------|----------------|
+| Decision | Rationale | Reversible |
+|----------|-----------|------------|
 | {{DECISION_1}} | {{REASON_1}} | Yes/No |
 | {{DECISION_2}} | {{REASON_2}} | Yes/No |
 
-### 성공한 접근법
+### Successful Approaches
 - {{SUCCESSFUL_APPROACH_1}}
 - {{SUCCESSFUL_APPROACH_2}}
 
-### 실패한 접근법
+### Failed Approaches
 - {{FAILED_APPROACH_1}}: {{FAILURE_REASON_1}}
 
-### 우선순위 아이디어 (Top 5)
+### Priority Ideas (Top 5)
 1. **{{IDEA_1}}** - {{IDEA_1_VALUE}}
 2. **{{IDEA_2}}** - {{IDEA_2_VALUE}}
 3. **{{IDEA_3}}** - {{IDEA_3_VALUE}}
 4. **{{IDEA_4}}** - {{IDEA_4_VALUE}}
 5. **{{IDEA_5}}** - {{IDEA_5_VALUE}}
 
-### MVP 핵심 기능
+### MVP Core Features
 1. {{MVP_FEATURE_1}}
 2. {{MVP_FEATURE_2}}
 3. {{MVP_FEATURE_3}}
 
 ---
 
-## 생성된 산출물
+## Generated Outputs
 
-| 파일 | 설명 | 위치 |
-|------|------|------|
-| ideas.md | 브레인스토밍 아이디어 | `outputs/ideas.md` |
-| requirements_analysis.md | 요구사항 분석 | `outputs/requirements_analysis.md` |
-| personas.md | 사용자 페르소나 | `outputs/personas.md` (선택) |
+| File | Description | Location |
+|------|-------------|----------|
+| ideas.md | Brainstorming ideas | `outputs/ideas.md` |
+| requirements_analysis.md | Requirements analysis | `outputs/requirements_analysis.md` |
+| personas.md | User personas | `outputs/personas.md` (optional) |
 
 ---
 
-## 02-research 스테이지 가이드
+## 02-research Stage Guide
 
-### 즉시 실행할 작업
-1. `outputs/requirements_analysis.md` 읽고 MVP 범위 확인
-2. 우선순위 아이디어 기술 스택 리서치
-3. 경쟁사 심층 분석
+### Immediate Tasks
+1. Read `outputs/requirements_analysis.md` and verify MVP scope
+2. Research tech stack for priority ideas
+3. In-depth competitor analysis
 
-### 리서치 우선순위
+### Research Priorities
 1. {{RESEARCH_PRIORITY_1}}
 2. {{RESEARCH_PRIORITY_2}}
 3. {{RESEARCH_PRIORITY_3}}
 
-### 검증 필요 가정
+### Assumptions to Validate
 - {{ASSUMPTION_1}}
 - {{ASSUMPTION_2}}
 
-### 권장 MCP 서버
-- `firecrawl`: 웹 크롤링
-- `exa`: AI 검색
-- `context7`: 문서 검색
+### Recommended MCP Servers
+- `firecrawl`: Web crawling
+- `exa`: AI search
+- `context7`: Documentation search
 
 ---
 
-## 체크포인트 참조
-> 이 스테이지는 체크포인트가 필요하지 않습니다.
+## Checkpoint Reference
+> Checkpoints are not required for this stage.
 
 ---
 
-## AI 호출 기록
+## AI Call Log
 
-| AI | 호출 시간 | 프롬프트 | 결과 | 상태 |
-|----|----------|---------|------|------|
+| AI | Call Time | Prompt | Result | Status |
+|----|-----------|--------|--------|--------|
 | {{AI_1}} | {{TIME_1}} | {{PROMPT_1}} | {{OUTPUT_1}} | {{STATUS_1}} |
 | {{AI_2}} | {{TIME_2}} | {{PROMPT_2}} | {{OUTPUT_2}} | {{STATUS_2}} |
 
-> 설정: `config/ai_logging.yaml`
+> Configuration: `config/ai_logging.yaml`
 
 ---
 
-## 메타데이터
+## Metadata
 
 ```yaml
 stage: "01-brainstorm"