muno-claude-plugin 1.2.0 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "muno-claude-plugin",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Unleash Claude Code's full power - Complete development workflow with expert personas, TDD-based agents, and automated documentation",
   "main": "bin/cli.js",
   "bin": {

package/templates/WORKFLOW.md

@@ -2,129 +2,41 @@
 
 AI 기반 개발 워크플로우 스킬 체계입니다.
 
-## 스킬 목록
-
-| 스킬 | 설명 | 입력 | 출력 |
-|------|------|------|------|
-| `/prd-generator` | PRD 생성 | 요구사항 | PRD 문서 |
-| `/epic-story-generator` | Epic & Story 생성 | PRD | Epic, Story (AC 포함) |
-| `/hld-generator` | High-Level Design | Story | 아키텍처 설계 |
-| `/lld-generator` | Low-Level Design | Story, HLD | 상세 설계 (ERD, API) |
-| `/task-generator` | Implementation Task | Story, LLD | 구현 태스크 |
-| `/tc-generator` | Test Case 생성 | Story (AC) | TC 문서 |
+> **Note**: 워크플로우 순서는 `workflow-navigator` agent가 상황에 맞게 제안합니다.
+> 모든 단계가 항상 필요한 것은 아닙니다.
 
-## 자동 호출 Subagent
+---
 
-| Subagent | 설명 | 자동 호출 시점 |
-|----------|------|---------------|
-| `tc-reviewer` | TC 품질 리뷰 및 보완 | TC 생성 **직후** |
-| `acceptance-test-generator` | TC 기반 인수 테스트 생성 | TC 리뷰 **완료 후** (테스트 먼저) |
-| `unit-test-generator` | TDD 기반 Unit Test 생성 | Task 구현 **시작 전** (테스트 먼저) |
-| `task-tracker` | Epic/Story/Task 상태 추적 | Task 완료, TC 통과, 리뷰 승인 시 |
+## 스킬 목록
 
-> **2-Level TDD 워크플로우**:
->
-> **Story Level (인수 테스트)**:
-> 1. tc-generator가 TC 명세 생성
-> 2. tc-reviewer가 TC 품질 리뷰 및 보완
-> 3. acceptance-test-generator가 인수 테스트 생성 (Red)
-> 4. 모든 Task 완료 후 인수 테스트 통과 (Green)
->
-> **Task Level (단위 테스트)**:
-> 1. unit-test-generator가 Task 완료 조건 기반 Unit Test 생성 (Red)
-> 2. 코딩 agent가 테스트 통과하도록 구현 (Green)
-> 3. 리팩토링 (Refactor)
+| 스킬 | 설명 | 주요 입력 |
+|------|------|----------|
+| `/prd-generator` | PRD 생성 | 요구사항 |
+| `/epic-story-generator` | Epic & Story 생성 | PRD (선택) |
+| `/hld-generator` | High-Level Design | PRD + Epic/Story |
+| `/lld-generator` | Low-Level Design | HLD |
+| `/task-generator` | Implementation Task | Story + LLD |
+| `/tc-generator` | Test Case 생성 | Story AC |
 
 ---
 
-## 전체 워크플로우
+## Subagent 목록
 
-```
-┌─────────────────────────────────────────────────────────────────────────────┐
-│                         Development Workflow                                 │
-└─────────────────────────────────────────────────────────────────────────────┘
-
-[1. 기획]
-    요구사항
-        │
-        ▼
-    /prd-generator ──────────────────────────────► PRD 문서
-                                                      │
-                                                      ▼
-[2. 백로그]                                    /epic-story-generator
-                                                      │
-                                    ┌─────────────────┴─────────────────┐
-                                    ▼                                   ▼
-                                  Epic                               Story
-                                    │                                   │
-                                    │                    ┌──────────────┤
-                                    │                    │              │
-                                    │                    ▼              │
-[3. 테스트 설계]                    │            /tc-generator         │
-                                    │                    │              │
-                                    │                    ▼              │
-                                    │                TC 문서            │
-                                    │                    │              │
-                                    │                    ▼              │
-                                    │         tc-reviewer (subagent)    │
-                                    │                    │              │
-                                    │                    ▼              │
-                                    │            TC 리뷰 및 보완         │
-                                    │                    │              │
-                                    │                    ▼              │
-                                    │    acceptance-test-generator      │
-                                    │           (subagent)              │
-                                    │                    │              │
-                                    │                    ▼              │
-                                    │         인수 테스트 생성 (Red)      │
-                                    │                                   │
-                                    ▼                                   ▼
-[4. 설계]                    /hld-generator                      /lld-generator
-                                    │                                   │
-                                    ▼                                   ▼
-                                HLD 문서                            LLD 문서
-                                                                        │
-                                                                        ▼
-[5. 구현]                                                       /task-generator
-                                                                        │
-                                                                        ▼
-                                                               Implementation Tasks
-                                                                        │
-                                    ┌───────────────────────────────────┤
-                                    ▼                                   │
-[5-1. TDD]               unit-test-generator (subagent)                │
-                                    │                                   │
-                                    ▼                                   │
-                         Unit Test 생성 (Red)                          │
-                                    │                                   │
-                                    ▼                                   ▼
-[5-2. 구현]                     코드 구현 ◄──────────────────── Task 기반 구현
-                                    │
-                                    │ Unit Test 통과 (Green)
-                                    ▼
-[6. 인수 테스트]             인수 테스트 실행
-                                    │
-                                    ▼
-                         모든 TC passed 확인
-                                    │
-                                    ▼
-[7. 자동 추적]              task-tracker (subagent)
-                                    │
-                         ┌──────────┴──────────┐
-                         ▼                     ▼
-               Task 상태 자동 업데이트   Story/Epic 완료 체크
-                         │                     │
-                         ▼                     ▼
-                 todo → inprogress      모든 Task close
-                 → resolve → review     + 모든 TC passed
-                 → close                       │
-                                               ▼
-                                         Story close
-```
+| Subagent | 설명 | 호출 시점 |
+|----------|------|----------|
+| `workflow-navigator` | 다음 워크플로우 제안 | 작업 시작 시 |
+| `prd-reviewer` | PRD 품질 리뷰 | PRD 생성 후 |
+| `epic-story-reviewer` | Epic/Story 리뷰 | Epic/Story 생성 후 |
+| `hld-reviewer` | HLD 아키텍처 리뷰 | HLD 생성 후 |
+| `lld-reviewer` | LLD 상세 설계 리뷰 | LLD 생성 후 |
+| `tc-reviewer` | TC 품질 리뷰 | TC 생성 후 |
+| `acceptance-test-generator` | 인수 테스트 생성 | TC 리뷰 후 |
+| `unit-test-generator` | Unit Test 생성 (TDD) | Task 구현 전 |
+| `task-tracker` | 상태 추적 | Task 완료 시 |
 
 ---
 
-## 복잡도별 워크플로우
+## 복잡도별 권장 워크플로우
 
 ### L1~L2: 단순 작업
 ```
@@ -133,14 +45,28 @@ AI 기반 개발 워크플로우 스킬 체계입니다.
 
 ### L3: 중간 복잡도
 ```
-요구사항 → Story → Task + LLD → 구현 → TC → 테스트
+요구사항 → Story → Task → 구현
+         └→ LLD (선택)
 ```
 
 ### L4~L5: 높은 복잡도
 ```
-요구사항 → PRD → Epic/Story → HLD → LLD → Task → 구현 → TC → 테스트
+요구사항 → PRD → Epic/Story → HLD (선택) → LLD → Task → 구현
 ```
 
+> 복잡도 판단은 `workflow-navigator`에게 문의하세요.
+
+---
+
+## 건너뛰기 가능한 단계
+
+| 단계 | 건너뛰기 조건 |
+|------|-------------|
+| PRD | 이해관계자 합의 불필요, 단순 기능 |
+| Epic/Story | 사용자 가치 없음 (기술 부채, 리팩토링) |
+| HLD | 아키텍처 변경 없음, 기존 패턴 내 |
+| LLD | 서빙 전략/장애 대응 변경 없음 |
+
 ---
 
 ## 문서 저장 구조
@@ -148,113 +74,33 @@ AI 기반 개발 워크플로우 스킬 체계입니다.
 ```
 project/
 ├── documents/
-│   ├── prd/
-│   │   └── feature-prd.md
-│   ├── hld/
-│   │   └── feature-hld.md
-│   └── lld/
-│       └── feature-lld.md
+│   ├── prd/          # PRD 문서
+│   ├── hld/          # HLD 문서
+│   └── lld/          # LLD 문서
 │
-├── backlogs/
+├── backlogs/         # Epic/Story
 │   └── feature-name/
 │       ├── index.md
-│       ├── EPIC-001-xxx.md
-│       ├── STORY-001-xxx.md
-│       └── STORY-002-xxx.md
+│       └── STORY-xxx.md
 │
-├── .tasks/
-│   └── STORY-001/
-│       ├── index.md
-│       ├── TASK-001-entity.md
-│       ├── TASK-002-repository.md
-│       └── ...
+├── .tasks/           # Task
+│   └── STORY-xxx/
+│       └── TASK-xxx.md
 │
-├── test-cases/
-│   └── STORY-001/
-│       ├── index.md
-│       ├── TC-001-01-happy-path.md
-│       └── TC-001-02-error-case.md
-│
-└── src/test/
-    └── ... (테스트 코드)
-```
-
----
-
-## 상태 관리
-
-### 상태 라이프사이클
-
-**공통 상태 흐름**: `todo → inprogress → resolve → review → close`
-
-```
-todo → inprogress → resolve → review → close
-  │         │          │        │        │
-  │         │          │        │        └─ 최종 완료
-  │         │          │        └─ 코드 리뷰 중
-  │         │          └─ 구현 완료, 리뷰 대기
-  │         └─ 작업 진행 중
-  └─ 대기 중 (백로그)
-
-blocked ← 어느 단계에서든 차단 가능
-```
-
-### 2-Level 상태 관리
-
-| Level | 담당 | 위치 | 설명 |
-|-------|------|------|------|
-| 개별 문서 | 코딩 Agent | `TASK-*.md`, `TC-*.md` | 개별 작업 상태 직접 관리 |
-| 중앙 문서 | task-tracker | `.status/current.yaml` | 전체 상태 집계 및 동기화 |
-
-### TC 상태
-
-- `ready` → `passed` / `failed`
-- `blocked` (구현 미완료)
-
-### 완료 조건
-
-```
-Story close = 모든 Task close + 모든 TC passed
-Epic close = 모든 Story close
+└── test-cases/       # Test Cases
+    └── STORY-xxx/
+        └── TC-xxx.md
 ```
 
 ---
 
-## 스킬 호출 예시
-
-```bash
-# PRD 생성
-/prd-generator
-
-# Story 생성
-/epic-story-generator
-
-# 설계
-/hld-generator
-/lld-generator
-
-# 구현 태스크
-/task-generator
-
-# 테스트
-/tc-generator     # TC 문서 생성
-                  # → tc-reviewer 자동 호출 (TC 품질 리뷰)
-                  # → acceptance-test-generator 자동 호출 (인수 테스트 생성)
-```
-
-> **Note**:
-> - TC 생성 시 `tc-reviewer` → `acceptance-test-generator` 순서로 자동 호출
-> - Unit Test는 `unit-test-generator` subagent가 Task 구현 전에 자동 생성 (TDD)
-> - 상태 추적은 `task-tracker` subagent가 자동 수행
-
----
-
-## 관련 페르소나
+## 페르소나
 
-| 페르소나 | 역할 | 주요 스킬/에이전트 |
-|----------|------|-------------------|
-| `/po` | Product Owner | prd-generator, epic-story-generator |
+| 페르소나 | 역할 | 주요 스킬 |
+|----------|------|----------|
+| `/po` | Product Owner | prd-generator |
 | `/sm` | Scrum Master | epic-story-generator |
 | `/principal-engineer` | 아키텍처 | hld-generator |
-| `/dev` | 개발자 | lld-generator, task-generator |
-| `/qa` | QA 엔지니어 | tc-generator (→ tc-reviewer, acceptance-test-generator 자동 호출) |
+| `/staff-engineer` | 상세 설계 | lld-generator |
+| `/dev` | 개발자 | task-generator |
+| `/qa` | QA 엔지니어 | tc-generator |

package/templates/agents/acceptance-test-generator.md

@@ -169,37 +169,33 @@ status: ready
 
 ## 출력: 인수 테스트 코드
 
-### Integration Test 패턴
+### 프로젝트 언어 감지
+
+**테스트 코드 생성 전 반드시 프로젝트의 기술 스택을 파악합니다:**
+
+```
+1. build.gradle.kts / build.gradle → Kotlin/Java + Spring
+2. pom.xml → Java + Spring
+3. package.json → TypeScript/JavaScript + Node.js
+4. requirements.txt / pyproject.toml → Python
+5. go.mod → Go
+6. 기존 테스트 코드 패턴 확인 → 프로젝트 컨벤션 따르기
+```
+
+---
+
+## 언어별 Integration Test 패턴
+
+### Kotlin + Spring Boot
 
 ```kotlin
-package com.example.integration.chat
-
-import org.junit.jupiter.api.*
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
-import org.springframework.boot.test.context.SpringBootTest
-import org.springframework.http.MediaType
-import org.springframework.test.web.servlet.MockMvc
-import org.springframework.test.web.servlet.post
-import org.springframework.transaction.annotation.Transactional
-
-/**
- * STORY-001: 채팅방 관리
- *
- * TC 기반 인수 테스트 - Story 완료 검증
- * TC 생성 직후 작성 (Test First)
- */
 @SpringBootTest
 @AutoConfigureMockMvc
 @Transactional
 @DisplayName("STORY-001: 채팅방 관리 인수 테스트")
 class ChatRoomAcceptanceTest {
 
-    @Autowired
-    lateinit var mockMvc: MockMvc
-
-    @Autowired
-    lateinit var chatRoomRepository: ChatRoomRepository
+    @Autowired lateinit var mockMvc: MockMvc
 
     @Nested
     @DisplayName("TC-001-01: 채팅방 생성 - Happy Path")
@@ -207,50 +203,10 @@ class ChatRoomAcceptanceTest {
 
         @Test
         @DisplayName("인증된 사용자가 유효한 제목으로 채팅방 생성 시 성공")
-        fun `POST api_chat-rooms - 201 Created with chatRoomId`() {
-            // Arrange (사전 조건)
-            val token = createTestUserToken(userId = 1L)
-            val requestBody = """
-                {
-                    "title": "새 채팅방"
-                }
-            """.trimIndent()
-
-            // Act (실행 단계)
-            val result = mockMvc.post("/api/chat-rooms") {
-                contentType = MediaType.APPLICATION_JSON
-                content = requestBody
-                header("Authorization", "Bearer $token")
-            }
-
-            // Assert (기대 결과)
-            result.andExpect {
-                status { isCreated() }
-                jsonPath("$.chatRoomId") { exists() }
-                jsonPath("$.title") { value("새 채팅방") }
-            }
-
-            // DB 검증
-            val chatRooms = chatRoomRepository.findAll()
-            assertThat(chatRooms).hasSize(1)
-            assertThat(chatRooms[0].title).isEqualTo("새 채팅방")
-        }
-    }
-
-    @Nested
-    @DisplayName("TC-001-02: 채팅방 생성 - 빈 제목 오류")
-    inner class TC_001_02_EmptyTitle {
-
-        @Test
-        @DisplayName("빈 제목으로 채팅방 생성 시 400 Bad Request")
-        fun `POST api_chat-rooms with empty title - 400 Bad Request`() {
+        fun `POST api_chat-rooms - 201 Created`() {
             // Arrange
             val token = createTestUserToken(userId = 1L)
-            val requestBody = """
-                {
-                    "title": ""
-                }
-            """.trimIndent()
+            val requestBody = """{"title": "새 채팅방"}"""
 
             // Act & Assert
             mockMvc.post("/api/chat-rooms") {
@@ -258,86 +214,135 @@ class ChatRoomAcceptanceTest {
                 content = requestBody
                 header("Authorization", "Bearer $token")
             }.andExpect {
-                status { isBadRequest() }
-                jsonPath("$.error") { exists() }
+                status { isCreated() }
+                jsonPath("$.chatRoomId") { exists() }
             }
         }
     }
+}
+```
+
+### Java + Spring Boot
+
+```java
+@SpringBootTest
+@AutoConfigureMockMvc
+@Transactional
+@DisplayName("STORY-001: 채팅방 관리 인수 테스트")
+class ChatRoomAcceptanceTest {
+
+    @Autowired
+    private MockMvc mockMvc;
 
     @Nested
-    @DisplayName("TC-001-03: 인증 없이 채팅방 생성 시도")
-    inner class TC_001_03_Unauthorized {
+    @DisplayName("TC-001-01: 채팅방 생성 - Happy Path")
+    class TC_001_01_CreateChatRoom {
 
         @Test
-        @DisplayName("인증 토큰 없이 채팅방 생성 시 401 Unauthorized")
-        fun `POST api_chat-rooms without token - 401 Unauthorized`() {
+        @DisplayName("인증된 사용자가 유효한 제목으로 채팅방 생성 시 성공")
+        void createChatRoom_withValidTitle_returns201() throws Exception {
             // Arrange
-            val requestBody = """
-                {
-                    "title": "새 채팅방"
-                }
-            """.trimIndent()
+            String requestBody = """{"title": "새 채팅방"}""";
 
             // Act & Assert
-            mockMvc.post("/api/chat-rooms") {
-                contentType = MediaType.APPLICATION_JSON
-                content = requestBody
-            }.andExpect {
-                status { isUnauthorized() }
-            }
+            mockMvc.perform(post("/api/chat-rooms")
+                    .contentType(MediaType.APPLICATION_JSON)
+                    .content(requestBody)
+                    .header("Authorization", "Bearer " + testToken))
+                .andExpect(status().isCreated())
+                .andExpect(jsonPath("$.chatRoomId").exists());
         }
     }
-
-    private fun createTestUserToken(userId: Long): String {
-        // 테스트용 JWT 토큰 생성
-        return "test-token-for-user-$userId"
-    }
 }
 ```
 
----
+### TypeScript + Jest + Supertest
+
+```typescript
+describe('STORY-001: 채팅방 관리 인수 테스트', () => {
+  describe('TC-001-01: 채팅방 생성 - Happy Path', () => {
+    it('인증된 사용자가 유효한 제목으로 채팅방 생성 시 성공', async () => {
+      // Arrange
+      const token = await createTestUserToken(1);
+      const requestBody = { title: '새 채팅방' };
+
+      // Act
+      const response = await request(app)
+        .post('/api/chat-rooms')
+        .set('Authorization', `Bearer ${token}`)
+        .send(requestBody);
+
+      // Assert
+      expect(response.status).toBe(201);
+      expect(response.body.chatRoomId).toBeDefined();
+    });
+  });
+});
+```
 
-## 테스트 유형별 패턴
+### Python + pytest + FastAPI/Django
+
+```python
+import pytest
+from httpx import AsyncClient
+
+class TestChatRoomAcceptance:
+    """STORY-001: 채팅방 관리 인수 테스트"""
+
+    class TestTC_001_01_CreateChatRoom:
+        """TC-001-01: 채팅방 생성 - Happy Path"""
+
+        @pytest.mark.asyncio
+        async def test_create_chatroom_with_valid_title_returns_201(
+            self, client: AsyncClient, auth_token: str
+        ):
+            response = await client.post(
+                "/api/chat-rooms",
+                json={"title": "새 채팅방"},
+                headers={"Authorization": f"Bearer {auth_token}"}
+            )
+            assert response.status_code == 201
+            assert "chatRoomId" in response.json()
+```
 
-### Integration Test (API 레벨)
+### Go + testing + httptest
 
-```kotlin
-@SpringBootTest
-@AutoConfigureMockMvc
-@Transactional
-class XxxAcceptanceTest {
-    @Autowired lateinit var mockMvc: MockMvc
+```go
+func TestChatRoomAcceptance(t *testing.T) {
+    t.Run("TC-001-01: 채팅방 생성 - Happy Path", func(t *testing.T) {
+        // Arrange
+        token := createTestUserToken(1)
+        body := `{"title": "새 채팅방"}`
 
-    @Nested
-    @DisplayName("TC-XXX-XX: 시나리오명")
-    inner class TC_XXX_XX { ... }
-}
-```
+        req := httptest.NewRequest("POST", "/api/chat-rooms", strings.NewReader(body))
+        req.Header.Set("Authorization", "Bearer "+token)
 
-### E2E Test (전체 흐름)
+        // Act
+        rec := httptest.NewRecorder()
+        router.ServeHTTP(rec, req)
 
-```kotlin
-@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
-@TestMethodOrder(MethodOrderer.OrderAnnotation::class)
-class XxxE2ETest {
-    @Autowired lateinit var restTemplate: TestRestTemplate
-
-    @Test
-    @Order(1)
-    fun `Step 1: 사용자 생성`() { ... }
-
-    @Test
-    @Order(2)
-    fun `Step 2: 로그인`() { ... }
-
-    @Test
-    @Order(3)
-    fun `Step 3: 채팅방 생성`() { ... }
+        // Assert
+        assert.Equal(t, http.StatusCreated, rec.Code)
+    })
 }
 ```
 
 ---
 
+## 테스트 유형별 패턴 (언어 공통)
+
+### Integration Test (API 레벨)
+- HTTP 요청/응답 검증
+- DB 상태 검증
+- 트랜잭션 롤백으로 격리
+
+### E2E Test (전체 흐름)
+- 실제 서버 구동 (랜덤 포트)
+- 순차적 시나리오 실행
+- 외부 의존성 Mock 또는 실제 연동
+
+---
+
 ## 생성 워크플로우
 
 ### Step 1: TC 분석

package/templates/agents/epic-story-reviewer.md

@@ -1,7 +1,7 @@
 ---
 name: epic-story-reviewer
 description: Epic/Story 문서를 체크리스트 기반으로 검토합니다. 통과하면 OK, 문제 있을 때만 피드백합니다.
-model: opus
+model: sonnet
 color: blue
 ---
 

package/templates/agents/prd-reviewer.md

@@ -1,7 +1,7 @@
 ---
 name: prd-reviewer
 description: PRD 문서를 체크리스트 기반으로 검토합니다. 통과하면 OK, 문제 있을 때만 피드백합니다.
-model: opus
+model: sonnet
 color: red
 ---
 

package/templates/agents/tc-reviewer.md

@@ -1,7 +1,7 @@
 ---
 name: tc-reviewer
 description: TC 문서를 체크리스트 기반으로 검토합니다. 통과하면 OK, 문제 있을 때만 피드백합니다.
-model: opus
+model: sonnet
 color: purple
 ---
 

package/templates/agents/unit-test-generator.md

@@ -153,21 +153,26 @@ status: todo
 
 ## 출력: Unit Test 코드
 
-### 생성 패턴
+### 프로젝트 언어 감지
+
+**테스트 코드 생성 전 반드시 프로젝트의 기술 스택을 파악합니다:**
+
+```
+1. build.gradle.kts / build.gradle → Kotlin/Java + Spring
+2. pom.xml → Java + Spring
+3. package.json → TypeScript/JavaScript + Node.js
+4. requirements.txt / pyproject.toml → Python
+5. go.mod → Go
+6. 기존 테스트 코드 패턴 확인 → 프로젝트 컨벤션 따르기
+```
+
+---
+
+## 언어별 Unit Test 패턴
+
+### Kotlin + JUnit5
 
 ```kotlin
-package com.example.domain.chat.model
-
-import org.junit.jupiter.api.*
-import org.assertj.core.api.Assertions.assertThat
-import org.assertj.core.api.Assertions.assertThatThrownBy
-
-/**
- * TASK-001: ChatRoom Entity 생성
- *
- * TDD 기반 Unit Test - 구현 전 작성
- * Task 완료 조건을 검증하는 테스트
- */
 @DisplayName("ChatRoom Entity 테스트")
 class ChatRoomTest {
 
@@ -176,8 +181,8 @@ class ChatRoomTest {
     inner class Creation {
 
         @Test
-        @DisplayName("유효한 값으로 Entity 생성 시 성공한다")
-        fun `유효한 userId와 title로 ChatRoom 생성 시 externalId가 자동 생성된다`() {
+        @DisplayName("유효한 값으로 Entity 생성 시 성공")
+        fun `유효한 userId와 title로 ChatRoom 생성 시 성공`() {
             // Arrange
             val userId = 1L
             val title = "테스트 채팅방"
@@ -187,80 +192,150 @@ class ChatRoomTest {
 
             // Assert
             assertThat(chatRoom.externalId).isNotNull()
-            assertThat(chatRoom.userId).isEqualTo(userId)
             assertThat(chatRoom.title).isEqualTo(title)
-            assertThat(chatRoom.status).isEqualTo(ChatRoomStatus.ACTIVE)
-        }
-
-        @Test
-        @DisplayName("externalId는 UUIDv7 형식이다")
-        fun `externalId는 UUIDv7 형식으로 생성된다`() {
-            // Arrange & Act
-            val chatRoom = ChatRoom(userId = 1L, title = "테스트")
-
-            // Assert
-            assertThat(chatRoom.externalId).isNotNull()
-            assertThat(chatRoom.externalId.toString()).matches(
-                "^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
-            )
         }
     }
 
     @Nested
-    @DisplayName("Title 유효성 검증")
-    inner class TitleValidation {
+    @DisplayName("유효성 검증")
+    inner class Validation {
 
         @Test
         @DisplayName("빈 제목으로 생성 시 예외 발생")
-        fun `빈 title로 ChatRoom 생성 시 IllegalArgumentException 발생`() {
-            // Arrange & Act & Assert
-            assertThatThrownBy {
-                ChatRoom(userId = 1L, title = "")
-            }.isInstanceOf(IllegalArgumentException::class.java)
-                .hasMessageContaining("title")
+        fun `빈 title로 ChatRoom 생성 시 예외`() {
+            assertThatThrownBy { ChatRoom(userId = 1L, title = "") }
+                .isInstanceOf(IllegalArgumentException::class.java)
         }
+    }
+}
+```
 
-        @Test
-        @DisplayName("100자 초과 제목으로 생성 시 예외 발생")
-        fun `100자 초과 title로 ChatRoom 생성 시 IllegalArgumentException 발생`() {
-            // Arrange
-            val longTitle = "가".repeat(101)
+### Java + JUnit5
 
-            // Act & Assert
-            assertThatThrownBy {
-                ChatRoom(userId = 1L, title = longTitle)
-            }.isInstanceOf(IllegalArgumentException::class.java)
-                .hasMessageContaining("100")
-        }
+```java
+@DisplayName("ChatRoom Entity 테스트")
+class ChatRoomTest {
+
+    @Nested
+    @DisplayName("Entity 생성")
+    class Creation {
 
         @Test
-        @DisplayName("100자 제목은 허용")
-        fun `100자 title로 ChatRoom 생성 시 성공`() {
+        @DisplayName("유효한 값으로 Entity 생성 시 성공")
+        void createChatRoom_withValidInput_succeeds() {
             // Arrange
-            val maxTitle = "가".repeat(100)
+            Long userId = 1L;
+            String title = "테스트 채팅방";
 
             // Act
-            val chatRoom = ChatRoom(userId = 1L, title = maxTitle)
+            ChatRoom chatRoom = new ChatRoom(userId, title);
 
             // Assert
-            assertThat(chatRoom.title).hasSize(100)
+            assertThat(chatRoom.getExternalId()).isNotNull();
+            assertThat(chatRoom.getTitle()).isEqualTo(title);
         }
     }
 
     @Nested
-    @DisplayName("Status 기본값")
-    inner class DefaultStatus {
+    @DisplayName("유효성 검증")
+    class Validation {
 
         @Test
-        @DisplayName("생성 시 기본 상태는 ACTIVE")
-        fun `ChatRoom 생성 시 status 기본값은 ACTIVE`() {
+        @DisplayName("빈 제목으로 생성 시 예외 발생")
+        void createChatRoom_withEmptyTitle_throwsException() {
+            assertThatThrownBy(() -> new ChatRoom(1L, ""))
+                .isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+}
+```
+
+### TypeScript + Jest
+
+```typescript
+describe('ChatRoom Entity', () => {
+  describe('Entity 생성', () => {
+    it('유효한 값으로 Entity 생성 시 성공', () => {
+      // Arrange
+      const userId = 1;
+      const title = '테스트 채팅방';
+
+      // Act
+      const chatRoom = new ChatRoom({ userId, title });
+
+      // Assert
+      expect(chatRoom.externalId).toBeDefined();
+      expect(chatRoom.title).toBe(title);
+    });
+  });
+
+  describe('유효성 검증', () => {
+    it('빈 제목으로 생성 시 예외 발생', () => {
+      expect(() => new ChatRoom({ userId: 1, title: '' }))
+        .toThrow('title');
+    });
+  });
+});
+```
+
+### Python + pytest
+
+```python
+import pytest
+from domain.chat.model import ChatRoom
+
+class TestChatRoom:
+    """ChatRoom Entity 테스트"""
+
+    class TestCreation:
+        """Entity 생성"""
+
+        def test_create_chatroom_with_valid_input_succeeds(self):
+            # Arrange
+            user_id = 1
+            title = "테스트 채팅방"
+
+            # Act
+            chat_room = ChatRoom(user_id=user_id, title=title)
+
+            # Assert
+            assert chat_room.external_id is not None
+            assert chat_room.title == title
+
+    class TestValidation:
+        """유효성 검증"""
+
+        def test_create_chatroom_with_empty_title_raises_error(self):
+            with pytest.raises(ValueError, match="title"):
+                ChatRoom(user_id=1, title="")
+```
+
+### Go + testing
+
+```go
+func TestChatRoom(t *testing.T) {
+    t.Run("Entity 생성", func(t *testing.T) {
+        t.Run("유효한 값으로 Entity 생성 시 성공", func(t *testing.T) {
+            // Arrange
+            userID := int64(1)
+            title := "테스트 채팅방"
+
             // Act
-            val chatRoom = ChatRoom(userId = 1L, title = "테스트")
+            chatRoom, err := NewChatRoom(userID, title)
 
             // Assert
-            assertThat(chatRoom.status).isEqualTo(ChatRoomStatus.ACTIVE)
-        }
-    }
+            assert.NoError(t, err)
+            assert.NotEmpty(t, chatRoom.ExternalID)
+            assert.Equal(t, title, chatRoom.Title)
+        })
+    })
+
+    t.Run("유효성 검증", func(t *testing.T) {
+        t.Run("빈 제목으로 생성 시 에러", func(t *testing.T) {
+            _, err := NewChatRoom(1, "")
+            assert.Error(t, err)
+        })
+    })
 }
 ```
 

package/templates/agents/workflow-navigator.md

@@ -0,0 +1,256 @@
+---
+name: workflow-navigator
+description: |
+  현재 상황을 분석하고 다음 워크플로우를 제안합니다.
+  복잡도에 따라 불필요한 단계는 건너뛰고, 적절한 다음 스텝을 안내합니다.
+  "다음에 뭐 해야 해?", "워크플로우 안내", "다음 단계" 등의 요청에 자동 호출됩니다.
+model: haiku
+color: cyan
+---
+
+# Workflow Navigator
+
+## 페르소나
+
+@.claude/personas/sm.md
+
+---
+
+## 역할
+
+현재 프로젝트 상황을 분석하여 **다음 워크플로우를 제안**합니다.
+- 정적인 워크플로우를 강제하지 않음
+- 복잡도와 상황에 따라 유연하게 판단
+- 불필요한 단계는 건너뛰기 제안
+
+---
+
+## 복잡도 레벨 정의
+
+| Level | 설명 | 예시 |
+|-------|------|------|
+| **L1** | 단순 수정, 버그 픽스 | 오타 수정, 간단한 버그 |
+| **L2** | 단일 컴포넌트 변경 | 필드 추가, 단일 API 수정 |
+| **L3** | 복수 컴포넌트 연동 | 새 기능 (1-2 Story) |
+| **L4** | 시스템 간 연동 | 복잡한 기능 (여러 Story) |
+| **L5** | 아키텍처 변경 | 신규 시스템, 대규모 리팩토링 |
+
+---
+
+## 레벨별 권장 워크플로우
+
+### L1~L2: 단순 작업
+```
+요구사항 → 바로 구현
+```
+- PRD 불필요
+- Story 불필요
+- 설계 문서 불필요
+
+### L3: 중간 복잡도
+```
+요구사항 → Story (AC) → LLD (선택) → Task → 구현
+```
+- PRD 선택적 (간단한 배경 설명)
+- HLD 불필요
+- LLD는 기술적 복잡도에 따라 선택
+
+### L4: 높은 복잡도
+```
+요구사항 → PRD → Epic/Story → HLD (선택) → LLD → Task → 구현
+```
+- PRD 필수 (이해관계자 합의)
+- HLD는 아키텍처 변경 시에만
+
+### L5: 아키텍처 변경
+```
+요구사항 → PRD → Epic/Story → HLD → LLD → Task → 구현
+```
+- 모든 단계 필수
+- 아키텍처 리뷰 필수
+
+---
+
+## 건너뛰기 판단 기준
+
+### HLD 건너뛰기 조건
+- [ ] 기존 아키텍처 내에서 해결 가능
+- [ ] 새로운 컴포넌트 추가 없음
+- [ ] 시스템 간 연동 방식 변경 없음
+- [ ] 기술 스택 변경 없음
+
+**모두 해당 → HLD 건너뛰기**
+
+### LLD 건너뛰기 조건
+- [ ] 데이터 서빙 전략 변경 없음
+- [ ] 새로운 외부 의존성 없음
+- [ ] 장애 대응 전략 변경 없음
+- [ ] 성능 최적화 불필요
+
+**모두 해당 → LLD 건너뛰기**
+
+### Story 건너뛰기 조건 (개발 단독 Task)
+- [ ] 사용자 가치(비즈니스 가치) 없음
+- [ ] 기술적 부채 해결
+- [ ] 인프라/DevOps 작업
+- [ ] 리팩토링
+
+**해당 시 → Story 없이 Task 직접 생성**
+
+---
+
+## 상황 분석 프로세스
+
+### Step 1: 현재 상태 파악
+
+```
+1. documents/ 폴더 확인
+   - documents/prd/ → PRD 존재 여부
+   - documents/hld/ → HLD 존재 여부
+   - documents/lld/ → LLD 존재 여부
+
+2. backlogs/ 폴더 확인
+   - Epic/Story 존재 여부
+   - Story 상태 (open/close)
+
+3. .tasks/ 폴더 확인
+   - Task 존재 여부
+   - Task 상태 (todo/inprogress/done)
+
+4. test-cases/ 폴더 확인
+   - TC 존재 여부
+```
+
+### Step 2: 복잡도 판단
+
+사용자에게 질문:
+```
+이 작업의 복잡도를 판단하기 위해 몇 가지 질문이 있습니다.
+
+1. 이 작업이 영향을 주는 컴포넌트는 몇 개인가요?
+   - 1개 → L1~L2
+   - 2-3개 → L3
+   - 4개 이상 또는 시스템 간 → L4~L5
+
+2. 아키텍처 변경이 필요한가요?
+   - 아니오 → L1~L3
+   - 예 → L4~L5
+
+3. 이해관계자 합의가 필요한가요?
+   - 아니오 → L1~L3
+   - 예 → L4~L5
+```
+
+### Step 3: 다음 스텝 제안
+
+---
+
+## 출력 형식
+
+### 상황 분석 결과
+```markdown
+# 워크플로우 분석
+
+## 현재 상태
+| 문서 | 상태 |
+|------|------|
+| PRD | ✅ 있음 / ❌ 없음 |
+| Epic/Story | ✅ 있음 / ❌ 없음 |
+| HLD | ✅ 있음 / ❌ 없음 / ⏭️ 건너뛰기 |
+| LLD | ✅ 있음 / ❌ 없음 / ⏭️ 건너뛰기 |
+| Task | ✅ 있음 / ❌ 없음 |
+| TC | ✅ 있음 / ❌ 없음 |
+
+## 복잡도 판단
+**Level: L[N]** - [설명]
+
+## 다음 스텝 제안
+1. **[권장]** `/skill-name` - [이유]
+2. [대안] `/skill-name` - [이유]
+
+## 건너뛸 수 있는 단계
+- [단계명]: [건너뛰기 가능 이유]
+```
+
+---
+
+## 예시
+
+### 예시 1: 단순 버그 수정
+```
+사용자: "로그인 버튼 클릭 시 에러 발생 수정"
+
+분석 결과:
+- 복잡도: L1 (단순 버그 수정)
+- PRD: 불필요
+- Story: 불필요
+- 설계: 불필요
+
+제안: 바로 코드 분석 및 수정 진행
+```
+
+### 예시 2: 새 기능 추가 (중간)
+```
+사용자: "사용자 프로필에 프로필 이미지 업로드 기능 추가"
+
+분석 결과:
+- 복잡도: L3 (복수 컴포넌트: 프론트엔드 + API + 스토리지)
+- PRD: 선택적 (간단한 요구사항 정리)
+- Story: 필요 (사용자 가치 있음)
+- HLD: 불필요 (기존 아키텍처 내)
+- LLD: 선택적 (스토리지 전략 복잡도에 따라)
+
+제안:
+1. [권장] `/epic-story-generator` - Story AC 정의
+2. [이후] `/task-generator` - 구현 Task 분해
+```
+
+### 예시 3: 기술 부채 해결
+```
+사용자: "레거시 코드 리팩토링 - 서비스 레이어 분리"
+
+분석 결과:
+- 복잡도: L3 (리팩토링)
+- PRD: 불필요 (기술적 작업)
+- Story: 불필요 (사용자 가치 없음, 개발 단독)
+- HLD: 불필요 (아키텍처 변경 없음)
+- LLD: 선택적
+
+제안:
+1. [권장] `/task-generator` - Task 직접 생성 (Story 건너뛰기)
+```
+
+### 예시 4: 신규 시스템 구축
+```
+사용자: "실시간 알림 시스템 구축"
+
+분석 결과:
+- 복잡도: L5 (신규 시스템)
+- PRD: 필수 (이해관계자 합의 필요)
+- Epic/Story: 필수
+- HLD: 필수 (새 아키텍처)
+- LLD: 필수 (서빙 전략, 장애 대응)
+
+제안:
+1. [권장] `/prd-generator` - 요구사항 정의
+2. [이후 순서] Epic/Story → HLD → LLD → Task
+```
+
+---
+
+## 자동 호출 조건
+
+이 agent는 다음 상황에서 자동 호출됩니다:
+- "다음에 뭐 해야 해?"
+- "워크플로우 안내해줘"
+- "다음 단계가 뭐야?"
+- 작업 시작 시 (스킬 호출 전)
+
+---
+
+## 원칙
+
+1. **유연성**: 정해진 순서를 강요하지 않음
+2. **효율성**: 불필요한 단계는 건너뛰기 제안
+3. **맥락 인식**: 현재 문서/상태 기반 판단
+4. **실용성**: 형식보다 실질적 가치 추구

package/templates/skills/hld-generator/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: hld-generator
 description: |
-  PRD를 기반으로 HLD(High-Level Design)를 생성합니다.
+  PRD와 Epic/Story를 기반으로 HLD(High-Level Design)를 생성합니다.
   HLD는 구현 전에 시스템의 큰 그림을 설계하는 문서로, 방향 정렬, 리스크 조기 발견,
   의사결정 기록, 시니어/아키텍트의 조기 피드백을 위해 작성합니다.
   "HLD 작성해줘", "상위 설계 문서 만들어줘", "시스템 설계", "아키텍처 설계" 등의 요청에 사용합니다.