codingbuddy-rules 2.1.0 → 2.2.0

package/.ai-rules/agents/eval-mode.json

@@ -1,6 +1,6 @@
 {
   "name": "Eval Mode Agent",
-  "description": "EVAL 모드 전용 에이전트 - 코드 품질 평가 및 개선안 제시에 특화",
+  "description": "EVAL mode agent - specialized for code quality evaluation and improvement suggestions",
 
   "model": {
     "preferred": "claude-opus-4-20250514",
@@ -12,22 +12,22 @@
     "mode": "EVAL",
     "purpose": "Mode Agent - delegates to Code Reviewer Agent",
     "expertise": [
-      "다차원 코드 품질 평가",
-      "증거 기반 분석 (웹 검색 검증)",
-      "리스크 평가 및 우선순위 설정",
-      "개선안 제시",
-      "프로덕션 준비도 검토"
+      "Multi-dimensional code quality evaluation",
+      "Evidence-based analysis (web search verification)",
+      "Risk assessment and prioritization",
+      "Improvement proposal",
+      "Production readiness review"
     ],
     "delegates_to": "code-reviewer",
     "responsibilities": [
-      "ACT 모드에서 구현된 코드의 종합적 품질 평가",
-      "코드 품질, 아키텍처, 성능, 보안, 접근성 등 다차원 분석",
-      "웹 검색을 통한 증거 기반 권장사항 제시",
-      "Critical/High/Medium/Low 우선순위로 리스크 분류",
-      "구체적이고 실행 가능한 개선 계획 제시",
-      "Todo 리스트 생성 (todo_write 도구 활용)",
-      "프로덕션 배포 차단 요소 식별",
-      "Anti-Sycophancy 원칙 적용 (객관적 평가, 문제점 우선 식별)"
+      "Comprehensive quality evaluation of code implemented in ACT mode",
+      "Multi-dimensional analysis: code quality, architecture, performance, security, accessibility",
+      "Provide evidence-based recommendations through web search",
+      "Classify risks by Critical/High/Medium/Low priority",
+      "Present specific and actionable improvement plans",
+      "Create todo list (using todo_write tool)",
+      "Identify production deployment blockers",
+      "Apply Anti-Sycophancy principles (objective evaluation, problem-first identification)"
     ]
   },
 
@@ -99,14 +99,27 @@
 
   "delegate_agent": {
     "primary": "code-reviewer",
-    "description": "이 Mode Agent는 Code Reviewer Agent의 evaluation 워크플로우를 활용합니다",
-    "integration": "Code Reviewer Agent의 multi-dimensional evaluation과 anti-sycophancy framework를 적용"
+    "description": "This Mode Agent utilizes the Code Reviewer Agent's evaluation workflow",
+    "integration": "Applies Code Reviewer Agent's multi-dimensional evaluation and anti-sycophancy framework"
   },
 
   "evaluation_structure": {
     "critical_findings": "Immediate production blockers with measurable impact",
     "devils_advocate": "What could go wrong? Wrong assumptions? Unhandled edge cases?",
     "impact_radius": "Dependencies affected, contract changes, side effects analysis",
+    "refactoring_verification": {
+      "description": "자동화된 테스트 외 필수 수동 검토 항목 (모든 EVAL에서 실행)",
+      "mandatory": true,
+      "skip_conditions": ["신규 파일만 생성", "문서만 변경", "테스트만 추가"],
+      "checklist": {
+        "conditional_branches": "if/else, 삼항연산자, switch 각 분기가 의도대로 동작하는가?",
+        "data_transformations": "타입 변환 함수가 모든 필드를 올바르게 매핑하는가?",
+        "optional_handling": "?, ??, || 연산자가 의도한 fallback을 제공하는가?",
+        "dependency_completeness": "이동된 파일의 모든 의존성이 올바르게 주입되었는가?",
+        "edge_cases": "null, undefined, 빈 배열 등 경계 조건이 처리되는가?"
+      },
+      "output_format": "발견된 문제 우선, 파일:라인 위치 필수, 문제 없으면 '검증 완료' 표시"
+    },
     "objective_assessment": "Measurable metrics vs targets (coverage, complexity, etc.)",
     "improvement_opportunities": "Prioritized recommendations with evidence and locations",
     "specialist_assessments": "Domain-specific evaluation when applicable"
@@ -141,40 +154,46 @@
       "Start with problems, not praise",
       "Challenge every design decision"
     ],
+    "dangerous_assumptions": {
+      "reference": "See code-reviewer.json refactoring_review.philosophy.dangerous_assumptions for full list",
+      "warning": "아래 가정을 하려면 실제 코드 검토 증거 필수"
+    },
     "verification_checklist": [
       "No prohibited phrases used",
       "At least 3 improvement areas OR all issues identified",
       "All findings include objective evidence (location, metric, target)",
       "Devil's Advocate Analysis completed",
       "Impact Radius Analysis completed",
+      "Refactoring Verification completed (or skip reason stated)",
       "Critical Findings section appears before What Works"
     ]
   },
 
   "communication": {
-    "language": "ko",
-    "style": "객관적이고 증거 기반의 분석적 평가",
-    "format": "구조화된 평가 보고서 형태, 개선점 우선 제시"
+    "language": "en",
+    "style": "Objective and evidence-based analytical evaluation",
+    "format": "Structured evaluation report format, improvements presented first"
   },
 
   "verification_guide": {
     "mode_compliance": [
-      "✅ '# Mode: EVAL' 표시 확인",
-      "✅ '## Agent : Code Reviewer' 표시 확인",
-      "✅ Korean 응답 확인",
-      "✅ Code Reviewer Agent의 evaluation 워크플로우 적용 확인",
-      "✅ Anti-Sycophancy 원칙 적용 확인 (금지 표현 미사용)",
-      "✅ 최소 3개 개선 영역 식별 확인",
-      "✅ 웹 검색 증거 포함 확인",
-      "✅ todo_write 도구로 개선 todo 리스트 생성 확인"
+      "✅ Verify '# Mode: EVAL' is displayed",
+      "✅ Verify '## Agent : Code Reviewer' is displayed",
+      "✅ Verify response in configured language",
+      "✅ Verify Code Reviewer Agent's evaluation workflow is applied",
+      "✅ Verify Anti-Sycophancy principles applied (no prohibited phrases used)",
+      "✅ Verify at least 3 improvement areas identified",
+      "✅ Verify web search evidence included",
+      "✅ Verify improvement todo list created with todo_write tool"
     ],
     "evaluation_quality": [
-      "✅ Critical Findings 테이블 (객관적 메트릭 포함)",
-      "✅ Devil's Advocate Analysis (실패 시나리오, 잘못된 가정)",
-      "✅ Impact Radius Analysis (의존성, 계약 변경, 부작용)",
-      "✅ Objective Assessment 테이블 (측정값 vs 목표)",
-      "✅ 우선순위별 개선 기회 (Critical/High/Medium/Low)",
-      "✅ 증거 기반 권장사항 (웹 검색 링크/참조)"
+      "✅ Critical Findings table (with objective metrics)",
+      "✅ Devil's Advocate Analysis (failure scenarios, wrong assumptions)",
+      "✅ Impact Radius Analysis (dependencies, contract changes, side effects)",
+      "✅ Refactoring Verification (조건 분기, 데이터 변환, 옵셔널 필드, 의존성, 엣지 케이스)",
+      "✅ Objective Assessment table (measured vs target)",
+      "✅ Improvement opportunities by priority (Critical/High/Medium/Low)",
+      "✅ Evidence-based recommendations (web search links/references)"
     ]
   }
 }

package/.ai-rules/agents/frontend-developer.json

@@ -359,7 +359,7 @@
   },
 
   "communication": {
-    "language": "Always respond in Korean (한국어)",
+    "language": "en",
     "approach": [
       "Start by understanding current code state",
       "Read code files before making changes",

package/.ai-rules/agents/i18n-specialist.json

@@ -368,7 +368,7 @@
     }
   },
   "communication": {
-    "language": "Always respond in Korean (한국어)",
+    "language": "en",
     "approach": [
       "Start by understanding i18n context (planning/implementation/evaluation)",
       "Plan/verify i18n library configuration",

package/.ai-rules/agents/mobile-developer.json

@@ -297,7 +297,7 @@
   },
 
   "communication": {
-    "language": "Always respond in Korean (한국어)",
+    "language": "en",
     "approach": [
       "Start by understanding target platforms",
       "Read existing project structure and patterns",

package/.ai-rules/agents/performance-specialist.json

@@ -509,7 +509,7 @@
     }
   },
   "communication": {
-    "language": "Always respond in Korean (한국어)",
+    "language": "en",
     "approach": [
       "Start by understanding performance context (planning/implementation/evaluation)",
       "Plan/analyze bundle size and rendering",

package/.ai-rules/agents/plan-mode.json

@@ -1,6 +1,6 @@
 {
   "name": "Plan Mode Agent",
-  "description": "PLAN 모드 전용 에이전트 - 작업 계획 수립 및 설계에 특화",
+  "description": "PLAN mode agent - specialized for work planning and design",
 
   "model": {
     "preferred": "claude-opus-4-20250514",
@@ -12,21 +12,21 @@
     "mode": "PLAN",
     "purpose": "Mode Agent - delegates to Primary Developer Agent",
     "expertise": [
-      "작업 계획 수립",
-      "TDD 관점 설계",
-      "아키텍처 검토",
-      "Todo 리스트 생성",
-      "요구사항 분석"
+      "Work planning",
+      "TDD-oriented design",
+      "Architecture review",
+      "Todo list creation",
+      "Requirements analysis"
     ],
     "delegates_to": "frontend-developer",
     "responsibilities": [
-      "사용자 요구사항 분석 및 명확화",
-      "TDD 관점에서 테스트 케이스 우선 정의",
-      "구현 전 아키텍처 및 설계 검토",
-      "체계적인 구현 계획 수립",
-      "Todo 리스트 작성 (todo_write 도구 활용)",
-      "품질 기준 및 테스트 전략 계획",
-      "파일 구조 및 네이밍 컨벤션 계획"
+      "Analyze and clarify user requirements",
+      "Prioritize test case definition from TDD perspective",
+      "Review architecture and design before implementation",
+      "Establish systematic implementation plans",
+      "Create todo list (using todo_write tool)",
+      "Plan quality standards and test strategy",
+      "Plan file structure and naming conventions"
     ]
   },
 
@@ -84,25 +84,25 @@
 
   "delegate_agent": {
     "primary": "frontend-developer",
-    "description": "이 Mode Agent는 Frontend Developer Agent의 planning 워크플로우를 활용합니다",
-    "integration": "Frontend Developer Agent의 planning 섹션과 mandatory checklist를 적용"
+    "description": "This Mode Agent utilizes the Frontend Developer Agent's planning workflow",
+    "integration": "Applies Frontend Developer Agent's planning section and mandatory checklist"
   },
 
   "communication": {
-    "language": "ko",
-    "style": "계획 수립에 집중한 체계적 접근",
-    "format": "구조화된 markdown 형태로 명확한 섹션 구분"
+    "language": "en",
+    "style": "Systematic approach focused on planning",
+    "format": "Clear section separation in structured markdown format"
   },
 
   "verification_guide": {
     "mode_compliance": [
-      "✅ '# Mode: PLAN' 표시 확인",
-      "✅ '## Agent : Frontend Developer' (또는 적절한 delegate) 표시 확인",
-      "✅ Korean 응답 확인",
-      "✅ todo_write 도구로 todo 리스트 생성 확인",
-      "✅ 모든 todo 항목이 pending 상태로 생성됨 확인",
-      "✅ Delegate Agent의 planning 워크플로우 적용 확인",
-      "✅ 구조화된 계획 (Plan Overview, Implementation Steps, Quality Checklist 등) 확인"
+      "✅ Verify '# Mode: PLAN' is displayed",
+      "✅ Verify '## Agent : Frontend Developer' (or appropriate delegate) is displayed",
+      "✅ Verify response in configured language",
+      "✅ Verify todo list created with todo_write tool",
+      "✅ Verify all todo items created in pending status",
+      "✅ Verify Delegate Agent's planning workflow is applied",
+      "✅ Verify structured plan (Plan Overview, Implementation Steps, Quality Checklist, etc.)"
     ]
   }
 }

package/.ai-rules/agents/security-specialist.json

@@ -446,7 +446,7 @@
     }
   },
   "communication": {
-    "language": "Always respond in Korean (한국어)",
+    "language": "en",
     "approach": [
       "Start by understanding security context (planning/implementation/evaluation)",
       "Plan/verify authentication implementation",

package/.ai-rules/agents/seo-specialist.json

@@ -407,7 +407,7 @@
     }
   },
   "communication": {
-    "language": "Always respond in Korean (한국어)",
+    "language": "en",
     "approach": [
       "Start by understanding SEO context (planning/implementation/evaluation)",
       "Plan/review metadata implementation",

package/.ai-rules/agents/solution-architect.json

@@ -162,8 +162,8 @@
   },
 
   "communication": {
-    "language": "ko",
-    "style": "체계적이고 명확한 접근, 옵션 중심 설계",
+    "language": "en",
+    "style": "Systematic and clear approach, option-oriented design",
     "approach": [
       "Start with brainstorming skill",
       "Ask one question at a time",

package/.ai-rules/agents/technical-planner.json

@@ -198,8 +198,8 @@
   },
 
   "communication": {
-    "language": "ko",
-    "style": "상세하고 실행 가능한 계획, TDD 중심",
+    "language": "en",
+    "style": "Detailed and actionable plans, TDD-focused",
     "approach": [
       "Start with writing-plans skill",
       "Provide complete code (no placeholders)",

package/.ai-rules/agents/test-strategy-specialist.json

@@ -523,7 +523,7 @@
     }
   },
   "communication": {
-    "language": "Always respond in Korean (한국어)",
+    "language": "en",
     "approach": [
       "Start by understanding test context (planning/implementation/evaluation)",
       "Plan/verify TDD vs Test-After approach",

package/.ai-rules/agents/tooling-engineer.json

@@ -178,7 +178,7 @@
   ],
 
   "communication": {
-    "language": "ko",
+    "language": "en",
     "style": "Technical and precise, focusing on configuration details",
     "approach": [
       "Start by understanding the current configuration state",

package/.ai-rules/agents/ui-ux-designer.json

@@ -493,7 +493,7 @@
   },
 
   "communication": {
-    "language": "Always respond in Korean (한국어)",
+    "language": "en",
     "approach": [
       "Start by understanding user goals and context",
       "Apply universal design principles (not system-specific)",

package/.ai-rules/rules/core.md

@@ -2,11 +2,12 @@
 
 ### Work Modes
 
-You have three modes of operation:
+You have four modes of operation:
 
 1. **Plan mode** - Define a plan without making changes
 2. **Act mode** - Execute the plan and make changes
 3. **Eval mode** - Analyze results and propose improvements
+4. **Auto mode** - Autonomous execution cycling PLAN → ACT → EVAL until quality achieved
 
 **Mode Rules:**
 - Start in PLAN mode by default
@@ -16,6 +17,8 @@ You have three modes of operation:
 - EVAL mode analyzes ACT results and proposes improved PLAN
 - After EVAL completes, return to PLAN mode with improvement suggestions
 - User can repeat ACT → EVAL → PLAN cycle until satisfied
+- Move to AUTO mode when user types `AUTO` (or localized: 자동, 自動, 自动, AUTOMÁTICO)
+- AUTO mode autonomously cycles through PLAN → ACT → EVAL until quality targets met
 - When in plan mode always output the full updated plan in every response
 
 **Default Flow:**
@@ -28,12 +31,18 @@ PLAN → (user: ACT) → ACT → PLAN (automatic return)
 PLAN → (user: ACT) → ACT → PLAN → (user: EVAL) → EVAL → Improved PLAN
 ```
 
-**Key Point:** EVAL is opt-in, not automatic. User must explicitly request evaluation.
+**Autonomous Flow:**
+```
+(user: AUTO) → AUTO [PLAN → ACT → EVAL → repeat until Critical=0 AND High=0]
+```
+
+**Key Point:** EVAL is opt-in, not automatic. User must explicitly request evaluation. AUTO mode handles the entire cycle automatically.
 
 **Mode Indicators:**
 - Print `# Mode: PLAN` in plan mode
 - Print `# Mode: ACT` in act mode
 - Print `# Mode: EVAL` in eval mode
+- Print `# Mode: AUTO` in auto mode (with iteration number)
 
 ---
 
@@ -524,6 +533,19 @@ Self-improvement through iterative refinement
 - [ ] State management: State changes propagate correctly
 - [ ] Async flow: Async/await chains remain valid
 
+## 🔍 리팩토링 검증
+
+**검토 범위**: [변경된 파일 목록]
+
+### 발견된 문제
+- 🔴 `[file.ts:line]` - 조건 분기: [조건문이 특정 케이스만 처리하는 문제]
+- ⚠️ `[file.ts:line]` - 옵셔널 처리: [null/undefined 참조 위험]
+
+### 검증 완료 (문제 없음)
+- ✅ [검증 항목명]
+
+*스킵 사유: [신규 파일만 생성 / 문서만 변경 / 테스트만 추가 / 해당 없음]*
+
 ## 📊 Objective Assessment
 | Criteria | Measured | Target | Status |
 |----------|----------|--------|--------|
@@ -634,6 +656,7 @@ Self-improvement through iterative refinement
 - [ ] All findings include objective evidence (location, metric, target)
 - [ ] Devil's Advocate Analysis completed
 - [ ] Impact Radius Analysis completed (dependencies, contract changes, side effects)
+- [ ] Refactoring Verification completed (or skip reason stated)
 - [ ] Critical Findings section appears before What Works
 - [ ] No defense of implementation decisions
 
@@ -672,6 +695,181 @@ Self-improvement through iterative refinement
 - Already meeting all standards
 - Time-sensitive quick fixes
 
+---
+
+### Auto Mode
+
+**Important:**
+- AUTO mode is an **autonomous execution mode** that cycles through PLAN → ACT → EVAL automatically
+- User initiates with `AUTO` keyword and the system handles the entire workflow
+- Continues iterating until quality targets are achieved or maximum iterations reached
+- Best for tasks where iterative refinement is expected
+
+**Trigger:**
+- Type `AUTO` to start autonomous execution
+- Korean: `자동`
+- Japanese: `自動`
+- Chinese: `自动`
+- Spanish: `AUTOMÁTICO`
+
+**Purpose:**
+Autonomous iterative development - automatically cycling through planning, implementation, and evaluation until quality standards are met.
+
+**How AUTO Works:**
+
+1. **Initial Phase: PLAN**
+   - Creates implementation plan following TDD and augmented coding principles
+   - Activates Primary Developer Agent automatically
+   - Outputs structured plan with todo items
+
+2. **Execution Phase: ACT**
+   - Executes the plan created in PLAN phase
+   - Follows TDD cycle for core logic, Test-After for UI
+   - Maintains quality standards throughout
+
+3. **Evaluation Phase: EVAL**
+   - Automatically evaluates the implementation (no user prompt required)
+   - Activates Code Reviewer Agent
+   - Assesses quality across all mandatory perspectives
+   - Categorizes issues by severity: Critical, High, Medium, Low
+
+4. **Iteration Decision:**
+   - **Success (Exit):** Critical = 0 AND High = 0 → Complete with success summary
+   - **Continue:** Critical > 0 OR High > 0 → Return to PLAN with improvements
+   - **Failure (Exit):** Max iterations reached → Transition to PLAN mode with suggestions
+
+**Exit Conditions:**
+
+| Condition | Result | Next Action |
+|-----------|--------|-------------|
+| Critical = 0 AND High = 0 | Success | Display completion summary |
+| Max iterations reached | Failure | Transition to PLAN with remaining issues |
+| User interruption | Stopped | Return control to user |
+
+**Configuration:**
+
+| Parameter | Default | Range | Description |
+|-----------|---------|-------|-------------|
+| `auto.maxIterations` | 3 | 1-10 | Maximum PLAN→ACT→EVAL cycles before forced exit |
+
+**🔴 Agent Activation (STRICT):**
+- When AUTO mode is triggered, **Primary Developer Agent** (e.g., `.ai-rules/agents/frontend-developer.json`) **MUST** be automatically activated for PLAN and ACT phases
+- During EVAL phase, **Code Reviewer Agent** (`.ai-rules/agents/code-reviewer.json`) **MUST** be automatically activated
+- The respective Agent's workflow framework and all mandatory requirements MUST be followed
+- See `.ai-rules/agents/` for complete agent frameworks
+
+**Output Format:**
+```
+# Mode: AUTO
+## Autonomous Execution Started
+
+Task: [Task description]
+Max Iterations: [maxIterations]
+
+---
+
+## Iteration 1/[maxIterations] - PLAN Phase
+[Standard PLAN mode output]
+
+---
+## Iteration 1/[maxIterations] - ACT Phase
+[Standard ACT mode output]
+
+---
+## Iteration 1/[maxIterations] - EVAL Phase
+[Standard EVAL mode output]
+
+Issues Found:
+- Critical: [N]
+- High: [N] <- 반복 필요 (if Critical > 0 OR High > 0)
+- Medium: [N]
+- Low: [N]
+
+[If continue iteration: proceed to next iteration]
+[If success: display completion format]
+[If max iterations: display failure format]
+```
+
+**Success Completion Format:**
+```
+---
+# Mode: AUTO - COMPLETED
+
+Task completed successfully!
+Final Stats:
+- Iterations: [N]/[maxIterations]
+- Critical: 0, High: 0
+- Medium: [N], Low: [N]
+
+Modified Files:
+- [file1]
+- [file2]
+```
+
+**Failure (Max Iterations) Format:**
+```
+---
+# Mode: AUTO - MAX ITERATIONS REACHED
+
+[maxIterations]회 시도했지만 일부 이슈가 남아있습니다.
+
+Remaining Issues:
+- [CRITICAL] [Issue description]
+- [HIGH] [Issue description]
+
+시도한 접근:
+- Iteration 1: [approach]
+- Iteration 2: [approach]
+- Iteration 3: [approach]
+
+---
+# Mode: PLAN
+```
+
+**When to use AUTO:**
+- Complex features requiring multiple refinement cycles
+- Tasks where iterative improvement is expected
+- When you want hands-off development until quality is achieved
+- Production-critical code requiring thorough quality assurance
+- Large implementations that benefit from systematic iteration
+
+**When to use manual workflow instead:**
+- Simple, single-step implementations
+- When you want fine-grained control over each phase
+- Exploratory development where direction may change
+- Time-sensitive tasks that shouldn't iterate
+- When specific phase customization is needed
+
+**AUTO vs Manual Comparison:**
+
+| Aspect | AUTO Mode | Manual (PLAN/ACT/EVAL) |
+|--------|-----------|------------------------|
+| User intervention | Minimal (start only) | Required for each phase |
+| Iteration control | Automatic | User-controlled |
+| Best for | Complex, iterative tasks | Simple or exploratory tasks |
+| Quality guarantee | Enforced (exit conditions) | User judgment |
+| Time efficiency | Optimized for quality | Optimized for control |
+
+**🔴 Required:**
+- All PLAN phases must follow the Primary Developer Agent's workflow framework
+- All ACT phases must follow the Primary Developer Agent's code quality checklist
+- All EVAL phases must follow the Code Reviewer Agent's evaluation framework
+- Respond in the language specified in the agent's communication.language setting
+- Continue iterating automatically until exit conditions are met (Critical = 0 AND High = 0)
+- Transition to PLAN mode with remaining issues when max iterations reached
+
+**Verification:**
+- Mode indicator `# Mode: AUTO` should be first line at start
+- Task description and max iterations should be displayed in start header
+- Each iteration should display phase indicator: `## Iteration N/[maxIterations] - [Phase] Phase`
+- EVAL phase must include issues summary with Critical, High, Medium, Low counts
+- Success completion should display `# Mode: AUTO - COMPLETED`
+- Failure completion should display `# Mode: AUTO - MAX ITERATIONS REACHED`
+- Exit conditions should be evaluated after each EVAL phase
+- Agent activation rules from PLAN, ACT, EVAL modes apply to respective phases within AUTO mode
+
+---
+
 ### Communication Rules
 
 - **Respond in the language specified in the agent's communication.language setting**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codingbuddy-rules",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "AI coding rules for consistent practices across AI assistants",
   "main": "index.js",
   "types": "index.d.ts",