claude-symphony 0.0.1 → 0.0.2

package/template/.claude/hooks/output-validator.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 # claude-symphony Output Validator Hook
-# 스테이지 산출물 검증
+# Stage output validation
 
 set -e
 
@@ -10,32 +10,32 @@ CONFIG_FILE="$PROJECT_ROOT/config/output_validation.yaml"
 PROGRESS_FILE="$PROJECT_ROOT/state/progress.json"
 VALIDATIONS_DIR="$PROJECT_ROOT/state/validations"
 
-# 색상 정의
+# Color definitions
 RED='\033[0;31m'
 GREEN='\033[0;32m'
 YELLOW='\033[1;33m'
 BLUE='\033[0;34m'
 NC='\033[0m'
 
-# 결과 아이콘
+# Result icons
 PASS="✅"
 FAIL="❌"
 WARN="⚠️"
 INFO="ℹ️"
 
-# 로그 함수
+# Log functions
 log_pass() { echo -e "${GREEN}${PASS}${NC} $1"; }
 log_fail() { echo -e "${RED}${FAIL}${NC} $1"; }
 log_warn() { echo -e "${YELLOW}${WARN}${NC} $1"; }
 log_info() { echo -e "${BLUE}${INFO}${NC} $1"; }
 
-# 검증 결과 저장
+# Validation results storage
 TOTAL_CHECKS=0
 PASSED_CHECKS=0
 FAILED_CHECKS=0
 WARNINGS=0
 
-# 현재 스테이지 확인
+# Get current stage
 get_current_stage() {
     if [ -f "$PROGRESS_FILE" ]; then
         cat "$PROGRESS_FILE" 2>/dev/null | grep -o '"current_stage"[[:space:]]*:[[:space:]]*"[^"]*"' | cut -d'"' -f4
@@ -44,7 +44,7 @@ get_current_stage() {
     fi
 }
 
-# 파일 존재 확인
+# Check file exists
 check_file_exists() {
     local file_path="$1"
     local required="$2"
@@ -53,23 +53,23 @@ check_file_exists() {
     TOTAL_CHECKS=$((TOTAL_CHECKS + 1))
 
     if [ -e "$full_path" ]; then
-        log_pass "$file_path 존재"
+        log_pass "$file_path exists"
         PASSED_CHECKS=$((PASSED_CHECKS + 1))
         return 0
     else
         if [ "$required" = "true" ]; then
-            log_fail "$file_path 누락"
+            log_fail "$file_path missing"
             FAILED_CHECKS=$((FAILED_CHECKS + 1))
             return 1
         else
-            log_warn "$file_path 누락 (선택사항)"
+            log_warn "$file_path missing (optional)"
             WARNINGS=$((WARNINGS + 1))
             return 0
         fi
     fi
 }
 
-# 디렉토리 확인
+# Check directory exists
 check_directory_exists() {
     local dir_path="$1"
     local full_path="$PROJECT_ROOT/$dir_path"
@@ -77,17 +77,17 @@ check_directory_exists() {
     TOTAL_CHECKS=$((TOTAL_CHECKS + 1))
 
     if [ -d "$full_path" ]; then
-        log_pass "$dir_path 디렉토리 존재"
+        log_pass "$dir_path directory exists"
         PASSED_CHECKS=$((PASSED_CHECKS + 1))
         return 0
     else
-        log_fail "$dir_path 디렉토리 누락"
+        log_fail "$dir_path directory missing"
         FAILED_CHECKS=$((FAILED_CHECKS + 1))
         return 1
     fi
 }
 
-# 파일 최소 크기 확인
+# Check file minimum size
 check_file_size() {
     local file_path="$1"
     local min_size="$2"
@@ -98,18 +98,18 @@ check_file_size() {
         TOTAL_CHECKS=$((TOTAL_CHECKS + 1))
 
         if [ "$size" -ge "$min_size" ]; then
-            log_pass "$file_path 크기 충족 (${size} bytes >= ${min_size})"
+            log_pass "$file_path size met (${size} bytes >= ${min_size})"
             PASSED_CHECKS=$((PASSED_CHECKS + 1))
             return 0
         else
-            log_fail "$file_path 크기 미달 (${size} bytes < ${min_size})"
+            log_fail "$file_path size insufficient (${size} bytes < ${min_size})"
             FAILED_CHECKS=$((FAILED_CHECKS + 1))
             return 1
         fi
     fi
 }
 
-# 마크다운 섹션 확인
+# Check markdown sections
 check_markdown_sections() {
     local file_path="$1"
     shift
@@ -121,43 +121,43 @@ check_markdown_sections() {
             TOTAL_CHECKS=$((TOTAL_CHECKS + 1))
 
             if grep -q "^#.*$section" "$full_path" || grep -q "^##.*$section" "$full_path"; then
-                log_pass "$file_path: '$section' 섹션 존재"
+                log_pass "$file_path: '$section' section exists"
                 PASSED_CHECKS=$((PASSED_CHECKS + 1))
             else
-                log_fail "$file_path: '$section' 섹션 누락"
+                log_fail "$file_path: '$section' section missing"
                 FAILED_CHECKS=$((FAILED_CHECKS + 1))
             fi
         done
     fi
 }
 
-# 명령어 실행 검증
+# Run validation command
 run_validation_command() {
     local name="$1"
     local command="$2"
     local required="$3"
 
     TOTAL_CHECKS=$((TOTAL_CHECKS + 1))
-    log_info "실행 중: $name ($command)"
+    log_info "Running: $name ($command)"
 
     if eval "$command" > /dev/null 2>&1; then
-        log_pass "$name 통과"
+        log_pass "$name passed"
         PASSED_CHECKS=$((PASSED_CHECKS + 1))
         return 0
     else
         if [ "$required" = "true" ]; then
-            log_fail "$name 실패"
+            log_fail "$name failed"
             FAILED_CHECKS=$((FAILED_CHECKS + 1))
             return 1
         else
-            log_warn "$name 실패 (선택사항)"
+            log_warn "$name failed (optional)"
             WARNINGS=$((WARNINGS + 1))
             return 0
         fi
     fi
 }
 
-# 스테이지별 검증
+# Stage-specific validation
 validate_stage() {
     local stage="$1"
     local stage_dir="$PROJECT_ROOT/stages/$stage"
@@ -165,11 +165,11 @@ validate_stage() {
 
     echo ""
     echo "=========================================="
-    echo "  산출물 검증: $stage"
+    echo "  Output Validation: $stage"
     echo "=========================================="
     echo ""
 
-    # HANDOFF.md 확인 (모든 스테이지 공통)
+    # HANDOFF.md check (common for all stages)
     check_file_exists "stages/$stage/HANDOFF.md" "true"
 
     case "$stage" in
@@ -177,7 +177,7 @@ validate_stage() {
             check_file_exists "stages/$stage/outputs/ideas.md" "true"
             check_file_size "stages/$stage/outputs/ideas.md" 500
             check_file_exists "stages/$stage/outputs/requirements_analysis.md" "true"
-            check_markdown_sections "stages/$stage/outputs/requirements_analysis.md" "기능" "비기능"
+            check_markdown_sections "stages/$stage/outputs/requirements_analysis.md" "Functional" "Non-functional"
             ;;
 
         "02-research")
@@ -196,7 +196,7 @@ validate_stage() {
             check_directory_exists "stages/$stage/outputs/source_code"
             check_file_exists "stages/$stage/outputs/implementation_log.md" "true"
 
-            # 빌드 검증
+            # Build validation
             if [ -f "$PROJECT_ROOT/package.json" ]; then
                 run_validation_command "lint" "npm run lint --prefix $PROJECT_ROOT" "true"
                 run_validation_command "typecheck" "npm run typecheck --prefix $PROJECT_ROOT" "true"
@@ -208,47 +208,47 @@ validate_stage() {
             check_file_exists "stages/$stage/outputs/test_report.md" "true"
             check_file_exists "stages/$stage/outputs/coverage_report.md" "true"
 
-            # 테스트 검증
+            # Test validation
             if [ -f "$PROJECT_ROOT/package.json" ]; then
                 run_validation_command "test" "npm run test --prefix $PROJECT_ROOT" "true"
             fi
             ;;
 
         *)
-            log_info "스테이지 $stage에 대한 특정 검증 규칙 없음"
+            log_info "No specific validation rules for stage $stage"
             ;;
     esac
 }
 
-# 결과 요약 출력
+# Print result summary
 print_summary() {
     echo ""
     echo "=========================================="
-    echo "  검증 결과 요약"
+    echo "  Validation Result Summary"
     echo "=========================================="
     echo ""
-    echo "총 검사: $TOTAL_CHECKS"
-    echo -e "${GREEN}통과: $PASSED_CHECKS${NC}"
-    echo -e "${RED}실패: $FAILED_CHECKS${NC}"
-    echo -e "${YELLOW}경고: $WARNINGS${NC}"
+    echo "Total checks: $TOTAL_CHECKS"
+    echo -e "${GREEN}Passed: $PASSED_CHECKS${NC}"
+    echo -e "${RED}Failed: $FAILED_CHECKS${NC}"
+    echo -e "${YELLOW}Warnings: $WARNINGS${NC}"
     echo ""
 
-    # 점수 계산
+    # Calculate score
     if [ "$TOTAL_CHECKS" -gt 0 ]; then
         local score=$(echo "scale=2; $PASSED_CHECKS / $TOTAL_CHECKS" | bc)
-        echo "점수: $score"
+        echo "Score: $score"
 
         if [ "$FAILED_CHECKS" -eq 0 ]; then
-            echo -e "${GREEN}${PASS} 검증 통과${NC}"
+            echo -e "${GREEN}${PASS} Validation passed${NC}"
             return 0
         else
-            echo -e "${RED}${FAIL} 검증 실패 - 스테이지 전환 차단됨${NC}"
+            echo -e "${RED}${FAIL} Validation failed - Stage transition blocked${NC}"
             return 1
         fi
     fi
 }
 
-# 결과 저장
+# Save results
 save_results() {
     local stage="$1"
     local timestamp=$(date +%Y%m%d_%H%M%S)
@@ -268,13 +268,13 @@ save_results() {
 EOF
 }
 
-# 메인 실행
+# Main execution
 main() {
     local stage="${1:-$(get_current_stage)}"
     local verbose="${2:-false}"
 
     if [ "$stage" = "unknown" ]; then
-        log_fail "현재 스테이지를 확인할 수 없습니다."
+        log_fail "Cannot determine current stage."
         exit 1
     fi
 
@@ -283,7 +283,7 @@ main() {
     print_summary
 }
 
-# 직접 실행 시에만 main 호출
+# Call main only when executed directly
 if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
     main "$@"
 fi

package/template/.claude/hooks/post-stage.sh

@@ -1,5 +1,5 @@
 #!/bin/bash
-# post-stage.sh - 스테이지 완료 후 훅
+# post-stage.sh - Post-stage completion hook
 # claude-symphony workflow pipeline
 
 set -e
@@ -9,7 +9,7 @@ PROJECT_ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
 PROGRESS_FILE="$PROJECT_ROOT/state/progress.json"
 TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
 
-# 색상 정의
+# Color definitions
 RED='\033[0;31m'
 GREEN='\033[0;32m'
 YELLOW='\033[1;33m'
@@ -20,47 +20,47 @@ echo "━━━━━━━━━━━━━━━━━━━━━━━━
 echo "📋 Post-Stage Hook: $STAGE_ID"
 echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
 
-# 1. 완료 조건 검증
+# 1. Validate completion criteria
 validate_completion() {
     local stage_dir="$PROJECT_ROOT/stages/$STAGE_ID"
     local config_file="$stage_dir/config.yaml"
 
-    echo "완료 조건 검증 중..."
+    echo "Validating completion criteria..."
 
-    # outputs 디렉토리 확인
+    # Check outputs directory
     if [ -d "$stage_dir/outputs" ]; then
         local output_count=$(ls -1 "$stage_dir/outputs" 2>/dev/null | wc -l)
-        echo -e "  ${GREEN}✓${NC} 출력 파일: $output_count 개"
+        echo -e "  ${GREEN}✓${NC} Output files: $output_count"
     fi
 
     return 0
 }
 
-# 2. HANDOFF.md 생성 알림
+# 2. HANDOFF.md generation notification
 check_handoff() {
     local handoff_file="$PROJECT_ROOT/stages/$STAGE_ID/HANDOFF.md"
 
     if [ ! -f "$handoff_file" ]; then
-        echo -e "  ${YELLOW}⚠${NC} HANDOFF.md 미생성"
-        echo "     /handoff 를 실행하여 핸드오프 문서를 생성해주세요."
+        echo -e "  ${YELLOW}⚠${NC} HANDOFF.md not generated"
+        echo "     Please run /handoff to generate the handoff document."
         return 1
     fi
 
-    echo -e "  ${GREEN}✓${NC} HANDOFF.md 존재"
+    echo -e "  ${GREEN}✓${NC} HANDOFF.md exists"
 
-    # 핸드오프 아카이브
+    # Archive handoff
     local archive_name="${STAGE_ID}-$(date +%Y%m%d-%H%M).md"
     cp "$handoff_file" "$PROJECT_ROOT/state/handoffs/$archive_name"
-    echo -e "  ${GREEN}✓${NC} 핸드오프 아카이브: state/handoffs/$archive_name"
+    echo -e "  ${GREEN}✓${NC} Handoff archived: state/handoffs/$archive_name"
 
     return 0
 }
 
-# 3. progress.json 업데이트
+# 3. Update progress.json
 update_progress() {
-    echo "상태 업데이트 중..."
+    echo "Updating status..."
 
-    # jq로 상태 업데이트
+    # Update status with jq
     if command -v jq &> /dev/null; then
         local tmp_file=$(mktemp)
         jq ".stages.\"$STAGE_ID\".status = \"completed\" | \
@@ -69,27 +69,27 @@ update_progress() {
             .pipeline.updated_at = \"$TIMESTAMP\"" \
             "$PROGRESS_FILE" > "$tmp_file" && mv "$tmp_file" "$PROGRESS_FILE"
 
-        echo -e "  ${GREEN}✓${NC} progress.json 업데이트됨"
+        echo -e "  ${GREEN}✓${NC} progress.json updated"
     else
-        echo -e "  ${YELLOW}⚠${NC} jq 미설치 - 수동 업데이트 필요"
+        echo -e "  ${YELLOW}⚠${NC} jq not installed - Manual update required"
     fi
 
     return 0
 }
 
-# 4. 체크포인트 생성 알림 (필수 스테이지)
+# 4. Checkpoint creation reminder (required stages)
 remind_checkpoint() {
     local stage_num=$(echo "$STAGE_ID" | cut -d'-' -f1)
 
     if [ "$stage_num" == "06" ] || [ "$stage_num" == "07" ]; then
         echo ""
-        echo -e "${BLUE}📌 체크포인트 알림${NC}"
-        echo "  이 스테이지는 체크포인트 생성이 권장됩니다."
-        echo "  /checkpoint \"스테이지 완료\" 를 실행해주세요."
+        echo -e "${BLUE}📌 Checkpoint Reminder${NC}"
+        echo "  Checkpoint creation is recommended for this stage."
+        echo "  Please run /checkpoint \"Stage completed\""
     fi
 }
 
-# 5. 다음 스테이지 안내
+# 5. Show next stage guidance
 show_next_stage() {
     local config_file="$PROJECT_ROOT/stages/$STAGE_ID/config.yaml"
     local next_stage=""
@@ -102,19 +102,19 @@ show_next_stage() {
     echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
 
     if [ -z "$next_stage" ] || [ "$next_stage" == "null" ]; then
-        echo -e "${GREEN}🎉 파이프라인 완료!${NC}"
-        echo "  모든 스테이지가 완료되었습니다."
+        echo -e "${GREEN}🎉 Pipeline Complete!${NC}"
+        echo "  All stages have been completed."
     else
-        echo -e "${GREEN}✓${NC} 스테이지 $STAGE_ID 완료"
+        echo -e "${GREEN}✓${NC} Stage $STAGE_ID completed"
         echo ""
-        echo -e "${BLUE}다음 스테이지: $next_stage${NC}"
-        echo "  실행: /run-stage $next_stage"
+        echo -e "${BLUE}Next stage: $next_stage${NC}"
+        echo "  Run: /run-stage $next_stage"
     fi
 
     echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
 }
 
-# 실행
+# Execute
 echo ""
 validate_completion
 check_handoff

package/template/.claude/hooks/pre-stage.sh

@@ -1,5 +1,5 @@
 #!/bin/bash
-# pre-stage.sh - 스테이지 실행 전 훅
+# pre-stage.sh - Pre-stage execution hook
 # claude-symphony workflow pipeline
 
 set -e
@@ -8,7 +8,7 @@ STAGE_ID="$1"
 PROJECT_ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
 PROGRESS_FILE="$PROJECT_ROOT/state/progress.json"
 
-# 색상 정의
+# Color definitions
 RED='\033[0;31m'
 GREEN='\033[0;32m'
 YELLOW='\033[1;33m'
@@ -21,45 +21,45 @@ echo "━━━━━━━━━━━━━━━━━━━━━━━━
 echo "🔍 Pre-Stage Hook: $STAGE_ID"
 echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
 
-# 1. 이전 스테이지 완료 여부 확인
+# 1. Check if previous stage is completed
 check_prerequisites() {
     local stage_num=$(echo "$STAGE_ID" | cut -d'-' -f1)
 
-    # 01 스테이지는 전제조건 없음
+    # Stage 01 has no prerequisites
     if [ "$stage_num" == "01" ]; then
-        echo -e "${GREEN}✓${NC} 첫 번째 스테이지 - 전제조건 없음"
+        echo -e "${GREEN}✓${NC} First stage - No prerequisites"
         return 0
     fi
 
-    # 이전 스테이지 번호 계산
+    # Calculate previous stage number
     local prev_num=$(printf "%02d" $((10#$stage_num - 1)))
     local prev_stage=$(ls "$PROJECT_ROOT/stages/" | grep "^${prev_num}-" | head -1)
 
     if [ -z "$prev_stage" ]; then
-        echo -e "${RED}✗${NC} 이전 스테이지를 찾을 수 없습니다: $prev_num"
+        echo -e "${RED}✗${NC} Cannot find previous stage: $prev_num"
         return 1
     fi
 
-    # 이전 스테이지 상태 확인
+    # Check previous stage status
     local prev_status=$(jq -r ".stages.\"$prev_stage\".status" "$PROGRESS_FILE" 2>/dev/null || echo "pending")
 
     if [ "$prev_status" != "completed" ]; then
-        echo -e "${RED}✗${NC} 이전 스테이지 미완료: $prev_stage (상태: $prev_status)"
-        echo "  먼저 이전 스테이지를 완료해주세요."
+        echo -e "${RED}✗${NC} Previous stage not completed: $prev_stage (status: $prev_status)"
+        echo "  Please complete the previous stage first."
         return 1
     fi
 
-    echo -e "${GREEN}✓${NC} 이전 스테이지 완료: $prev_stage"
+    echo -e "${GREEN}✓${NC} Previous stage completed: $prev_stage"
     return 0
 }
 
-# 2. HANDOFF.md 존재 확인
+# 2. Check HANDOFF.md exists
 check_handoff() {
     local stage_num=$(echo "$STAGE_ID" | cut -d'-' -f1)
 
-    # 01 스테이지는 핸드오프 불필요
+    # Stage 01 doesn't need handoff
     if [ "$stage_num" == "01" ]; then
-        echo -e "${GREEN}✓${NC} 첫 번째 스테이지 - 핸드오프 불필요"
+        echo -e "${GREEN}✓${NC} First stage - No handoff needed"
         return 0
     fi
 
@@ -68,62 +68,62 @@ check_handoff() {
     local handoff_file="$PROJECT_ROOT/stages/$prev_stage/HANDOFF.md"
 
     if [ ! -f "$handoff_file" ]; then
-        echo -e "${RED}✗${NC} HANDOFF.md 없음: $handoff_file"
-        echo "  이전 스테이지에서 /handoff 를 실행해주세요."
+        echo -e "${RED}✗${NC} HANDOFF.md missing: $handoff_file"
+        echo "  Please run /handoff in the previous stage."
         return 1
     fi
 
-    echo -e "${GREEN}✓${NC} HANDOFF.md 존재: $prev_stage/HANDOFF.md"
+    echo -e "${GREEN}✓${NC} HANDOFF.md exists: $prev_stage/HANDOFF.md"
     return 0
 }
 
-# 3. 필수 입력 파일 확인
+# 3. Check required input files
 check_inputs() {
     local config_file="$PROJECT_ROOT/stages/$STAGE_ID/config.yaml"
 
     if [ ! -f "$config_file" ]; then
-        echo -e "${YELLOW}⚠${NC} config.yaml 없음 - 입력 파일 검증 스킵"
+        echo -e "${YELLOW}⚠${NC} config.yaml missing - Skipping input file validation"
         return 0
     fi
 
-    # YAML에서 required inputs 추출 (간단한 파싱)
+    # Extract required inputs from YAML (simple parsing)
     local inputs=$(grep -A100 "^inputs:" "$config_file" | grep -A50 "required:" | grep "name:" | head -5)
 
     if [ -z "$inputs" ]; then
-        echo -e "${GREEN}✓${NC} 필수 입력 파일 없음"
+        echo -e "${GREEN}✓${NC} No required input files"
         return 0
     fi
 
-    echo "필수 입력 파일 확인 중..."
-    # 실제 구현에서는 YAML 파서 사용 권장
-    echo -e "${GREEN}✓${NC} 입력 파일 검증 완료"
+    echo "Checking required input files..."
+    # In actual implementation, YAML parser recommended
+    echo -e "${GREEN}✓${NC} Input file validation complete"
     return 0
 }
 
-# 4. 체크포인트 확인 (필수 스테이지)
+# 4. Check checkpoint (required stages)
 check_checkpoint() {
     local stage_num=$(echo "$STAGE_ID" | cut -d'-' -f1)
 
-    # 06, 07 스테이지는 이전 체크포인트 확인
+    # Stage 06, 07 check for previous checkpoint
     if [ "$stage_num" == "07" ]; then
         local cp_count=$(jq '.checkpoints | length' "$PROGRESS_FILE" 2>/dev/null || echo "0")
 
         if [ "$cp_count" == "0" ]; then
-            echo -e "${YELLOW}⚠${NC} 경고: 체크포인트가 없습니다."
-            echo "  리팩토링 전 체크포인트 생성을 권장합니다."
-            echo "  /checkpoint 를 실행해주세요."
+            echo -e "${YELLOW}⚠${NC} Warning: No checkpoints exist."
+            echo "  Checkpoint creation before refactoring is recommended."
+            echo "  Please run /checkpoint"
         else
-            echo -e "${GREEN}✓${NC} 체크포인트 존재: $cp_count 개"
+            echo -e "${GREEN}✓${NC} Checkpoints exist: $cp_count"
         fi
     fi
 
     return 0
 }
 
-# 5. 컨텍스트 상태 확인 (50% 이하 경고)
+# 5. Check context status (warning if 50% or below)
 check_context_status() {
     if [ ! -f "$CONTEXT_TRIGGER_FILE" ]; then
-        echo -e "${GREEN}✓${NC} 컨텍스트 상태 정상"
+        echo -e "${GREEN}✓${NC} Context status normal"
         return 0
     fi
 
@@ -136,43 +136,43 @@ check_context_status() {
         echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
 
         if [ "$LEVEL" = "critical" ]; then
-            echo -e "${RED}⚠️ 컨텍스트 크리티컬 상태 (${REMAINING}% 남음)${NC}"
+            echo -e "${RED}⚠️ Context critical state (${REMAINING}% remaining)${NC}"
             echo ""
-            echo "자동 스냅샷이 저장되었습니다."
-            echo "스테이지 시작 전 /compact 또는 /clear를 권장합니다."
+            echo "Auto-snapshot has been saved."
+            echo "Running /compact or /clear before starting is recommended."
             echo ""
-            echo -e "${YELLOW}계속 진행하시겠습니까? (y/n)${NC}"
+            echo -e "${YELLOW}Do you want to continue? (y/n)${NC}"
         else
-            echo -e "${YELLOW}⚠️ 컨텍스트 부족 경고 (${REMAINING}% 남음)${NC}"
+            echo -e "${YELLOW}⚠️ Context low warning (${REMAINING}% remaining)${NC}"
             echo ""
-            echo "자동 스냅샷이 저장되었습니다."
-            echo "긴 작업 스테이지의 경우 /compact 실행을 권장합니다."
+            echo "Auto-snapshot has been saved."
+            echo "Running /compact is recommended for long work stages."
             echo ""
-            echo -e "${CYAN}계속 진행하시겠습니까? (y/n)${NC}"
+            echo -e "${CYAN}Do you want to continue? (y/n)${NC}"
         fi
 
         read -r response </dev/tty 2>/dev/null || response="y"
 
         if [ "$response" != "y" ] && [ "$response" != "Y" ]; then
             echo ""
-            echo "스테이지 시작이 취소되었습니다."
-            echo "  → /compact 실행 후 다시 시도해주세요."
-            echo "  → 스냅샷 위치: state/context/"
+            echo "Stage start cancelled."
+            echo "  → Run /compact and try again."
+            echo "  → Snapshot location: state/context/"
             echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
             return 1
         fi
 
         echo ""
-        echo -e "${GREEN}✓${NC} 사용자 확인 완료 - 스테이지 진행"
+        echo -e "${GREEN}✓${NC} User confirmation complete - Proceeding with stage"
         echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
         return 0
     fi
 
-    echo -e "${GREEN}✓${NC} 컨텍스트 상태 정상"
+    echo -e "${GREEN}✓${NC} Context status normal"
     return 0
 }
 
-# 실행
+# Execute
 echo ""
 check_context_status || exit 1
 check_prerequisites || exit 1
@@ -182,5 +182,5 @@ check_checkpoint
 
 echo ""
 echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-echo -e "${GREEN}✓${NC} Pre-Stage Hook 완료 - 스테이지 실행 가능"
+echo -e "${GREEN}✓${NC} Pre-Stage Hook complete - Stage execution ready"
 echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"