jun-claude-code 0.0.17 → 0.1.1

package/README.md

@@ -2,66 +2,6 @@
 
 Claude Code 설정 템플릿 CLI. 미리 정의된 Agents, Skills, Hooks, Workflow를 프로젝트에 설치하여 Claude Code 환경을 빠르게 구축합니다.
 
-## 포함 내용
-
-### Agents (`templates/global/agents/`)
-
-작업별 전문 Subagent 13종. Main Agent의 Context Window를 절약하면서 각 작업을 위임합니다.
-
-| Agent | 역할 |
-|-------|------|
-| `explore` | 코드베이스 탐색 |
-| `task-planner` | 작업 계획 수립 |
-| `code-writer` | 코드 작성 (Opus) |
-| `simple-code-writer` | 단순 수정 (Haiku) |
-| `code-reviewer` | 셀프 코드 리뷰 |
-| `git-manager` | Git 커밋/PR |
-| `impact-analyzer` | 사이드이펙트 분석 |
-| `qa-tester` | 테스트/빌드 검증 |
-| `architect` | 아키텍처 설계 |
-| `designer` | UI/UX 스타일링 |
-| `director` | 작업 총괄 디렉터 |
-| `context-collector` | 소스 코드 기반 Context 수집 |
-| `context-manager` | Context 문서 관리 |
-
-### Skills (`templates/global/skills/`)
-
-| Skill | 설명 |
-|-------|------|
-| `Coding` | 공통 코딩 원칙 (SRP, 응집도, 가독성) |
-| `Git` | Git 커밋/PR 규칙, PR 리뷰, 피드백 적용 |
-| `Backend` | 백엔드 개발 원칙 (레이어, TypeORM) |
-| `React` | React 개발 (TanStack Router, React Hook Form, Tailwind) |
-| `Documentation` | .claude 문서 작성 가이드 |
-| `Director` | 디렉터 Agent 운영 스킬 |
-
-### Hooks (`templates/global/hooks/`)
-
-| Hook | 설명 |
-|------|------|
-| `workflow-enforced.sh` | 워크플로우 순서 강제 프로토콜 |
-| `skill-forced.sh` | Skill/Agent 평가 프로토콜 |
-
-### Project Agents (`templates/project/agents/`)
-
-프로젝트 `.claude/`에 설치되는 프로젝트별 Agent.
-
-| Agent | 역할 |
-|-------|------|
-| `project-task-manager` | GitHub Project 태스크 관리 |
-| `context-generator` | Context 자동 생성 |
-| `project-context-collector` | .claude/context/ 문서 기반 프로젝트 배경 수집 |
-
-### Project Skills (`templates/project/skills/`)
-
-| Skill | 설명 |
-|-------|------|
-| `ContextGeneration` | Context 자동 생성 스킬 |
-
-### Workflow
-
-Planning -> Validation -> Implementation -> Review 순서의 작업 워크플로우와 Context 절약 원칙(Subagent 위임 규칙)을 정의합니다.
-
 ## 설치
 
 ```bash
@@ -79,6 +19,7 @@ npm install -g jun-claude-code
 | 명령어 | 설명 | 활성화되는 기능 |
 |--------|------|----------------|
 | `jun-claude-code` | 전역 설정 (`~/.claude/`) 설치 | Agents 13종, Skills 6종, Hooks 2종, Workflow |
+| `jun-claude-code --project` | 프로젝트 설정 (`.claude/`) 설치 | 전역과 동일 (프로젝트별 오버라이드용) |
 | `jun-claude-code init-project` | GitHub Project 연동 | 세션 시작 시 태스크 자동 로드, 태스크 관리 Agent |
 | `jun-claude-code init-context` | Context 자동 생성 설정 | PR 기반 Context 자동 생성, Codebase/Business 문서화, 별도 브랜치 PR |
 
@@ -92,6 +33,7 @@ jun-claude-code
 
 | 옵션 | 설명 |
 |------|------|
+| `--project`, `-p` | 전역(`~/.claude/`) 대신 프로젝트(`.claude/`)에 설치 |
 | `--dry-run`, `-d` | 실제 복사 없이 복사될 파일 목록만 확인 |
 | `--force`, `-f` | 확인 없이 모든 파일 덮어쓰기 |
 
@@ -176,6 +118,66 @@ jun-claude-code init-context
 2. **CLAUDE_CODE_OAUTH_TOKEN 추가**
    - Settings → Secrets and variables → Actions → New repository secret
 
+## 포함 내용
+
+### Agents (`templates/global/agents/`)
+
+작업별 전문 Subagent 13종. Main Agent의 Context Window를 절약하면서 각 작업을 위임합니다.
+
+| Agent | 역할 |
+|-------|------|
+| `explore` | 코드베이스 탐색 |
+| `task-planner` | 작업 계획 수립 |
+| `code-writer` | 코드 작성 (Opus) |
+| `simple-code-writer` | 단순 수정 (Haiku) |
+| `code-reviewer` | 셀프 코드 리뷰 |
+| `git-manager` | Git 커밋/PR |
+| `impact-analyzer` | 사이드이펙트 분석 |
+| `qa-tester` | 테스트/빌드 검증 |
+| `architect` | 아키텍처 설계 |
+| `designer` | UI/UX 스타일링 |
+| `director` | 작업 총괄 디렉터 |
+| `context-collector` | 소스 코드 기반 Context 수집 |
+| `context-manager` | Context 문서 관리 |
+
+### Skills (`templates/global/skills/`)
+
+| Skill | 설명 |
+|-------|------|
+| `Coding` | 공통 코딩 원칙 (SRP, 응집도, 가독성) |
+| `Git` | Git 커밋/PR 규칙, PR 리뷰, 피드백 적용 |
+| `Backend` | 백엔드 개발 원칙 (레이어, TypeORM) |
+| `React` | React 개발 (TanStack Router, React Hook Form, Tailwind) |
+| `Documentation` | .claude 문서 작성 가이드 |
+| `Director` | 디렉터 Agent 운영 스킬 |
+
+### Hooks (`templates/global/hooks/`)
+
+| Hook | 설명 |
+|------|------|
+| `workflow-enforced.sh` | 워크플로우 순서 강제 프로토콜 |
+| `skill-forced.sh` | Skill/Agent 평가 프로토콜 |
+
+### Project Agents (`templates/project/agents/`)
+
+프로젝트 `.claude/`에 설치되는 프로젝트별 Agent.
+
+| Agent | 역할 |
+|-------|------|
+| `project-task-manager` | GitHub Project 태스크 관리 |
+| `context-generator` | Context 자동 생성 |
+| `project-context-collector` | .claude/context/ 문서 기반 프로젝트 배경 수집 |
+
+### Project Skills (`templates/project/skills/`)
+
+| Skill | 설명 |
+|-------|------|
+| `ContextGeneration` | Context 자동 생성 스킬 |
+
+### Workflow
+
+Planning -> Validation -> Implementation -> Review 순서의 작업 워크플로우와 Context 절약 원칙(Subagent 위임 규칙)을 정의합니다.
+
 ## 프로젝트 구조
 
 ```
@@ -196,7 +198,7 @@ templates/
 
 ## 커스터마이징
 
-설치 후 `~/.claude/`에서 필요에 맞게 수정할 수 있습니다. 프로젝트별로는 프로젝트 루트에 `.claude/`를 만들어 설정을 추가합니다.
+`--project` 옵션을 사용하면 전역 템플릿을 프로젝트 `.claude/`에 바로 설치할 수 있습니다. 설치 후 필요에 맞게 수정하세요.
 
 ```
 your-project/

package/dist/__tests__/merge-settings.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/merge-settings.test.js

@@ -0,0 +1,407 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const utils_1 = require("../utils");
+const copy_1 = require("../copy");
+const init_project_1 = require("../init-project");
+function createTmpDir() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'merge-settings-test-'));
+}
+function cleanupDir(dir) {
+    fs.rmSync(dir, { recursive: true, force: true });
+}
+function readJson(filePath) {
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+}
+function writeJson(filePath, data) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+}
+// ─── getHookKey ───
+(0, vitest_1.describe)('getHookKey', () => {
+    (0, vitest_1.it)('should generate key for flat hook entry', () => {
+        const entry = { type: 'command', command: 'echo hello' };
+        (0, vitest_1.expect)((0, utils_1.getHookKey)(entry)).toBe('command:echo hello');
+    });
+    (0, vitest_1.it)('should generate key for nested hooks entry without matcher', () => {
+        const entry = {
+            hooks: [
+                { type: 'command', command: 'cmd-a' },
+                { type: 'command', command: 'cmd-b' },
+            ],
+        };
+        const key = (0, utils_1.getHookKey)(entry);
+        (0, vitest_1.expect)(key).toBe('command:cmd-a\ncommand:cmd-b');
+    });
+    (0, vitest_1.it)('should sort nested hooks for consistent key', () => {
+        const entry1 = {
+            hooks: [
+                { type: 'command', command: 'cmd-b' },
+                { type: 'command', command: 'cmd-a' },
+            ],
+        };
+        const entry2 = {
+            hooks: [
+                { type: 'command', command: 'cmd-a' },
+                { type: 'command', command: 'cmd-b' },
+            ],
+        };
+        (0, vitest_1.expect)((0, utils_1.getHookKey)(entry1)).toBe((0, utils_1.getHookKey)(entry2));
+    });
+    (0, vitest_1.it)('should include matcher in key when present', () => {
+        const entry = {
+            matcher: 'Bash',
+            hooks: [{ type: 'command', command: 'blocker.sh' }],
+        };
+        (0, vitest_1.expect)((0, utils_1.getHookKey)(entry)).toBe('[Bash]command:blocker.sh');
+    });
+    (0, vitest_1.it)('should generate different keys for same hooks with different matchers', () => {
+        const entryBash = {
+            matcher: 'Bash',
+            hooks: [{ type: 'command', command: 'blocker.sh' }],
+        };
+        const entryWrite = {
+            matcher: 'Write',
+            hooks: [{ type: 'command', command: 'blocker.sh' }],
+        };
+        (0, vitest_1.expect)((0, utils_1.getHookKey)(entryBash)).not.toBe((0, utils_1.getHookKey)(entryWrite));
+    });
+    (0, vitest_1.it)('should generate different keys for same hooks with vs without matcher', () => {
+        const withMatcher = {
+            matcher: 'Bash',
+            hooks: [{ type: 'command', command: 'blocker.sh' }],
+        };
+        const withoutMatcher = {
+            hooks: [{ type: 'command', command: 'blocker.sh' }],
+        };
+        (0, vitest_1.expect)((0, utils_1.getHookKey)(withMatcher)).not.toBe((0, utils_1.getHookKey)(withoutMatcher));
+    });
+    (0, vitest_1.it)('should handle empty matcher as no matcher', () => {
+        const entry = {
+            matcher: '',
+            hooks: [{ type: 'command', command: 'test.sh' }],
+        };
+        const entryNoMatcher = {
+            hooks: [{ type: 'command', command: 'test.sh' }],
+        };
+        (0, vitest_1.expect)((0, utils_1.getHookKey)(entry)).toBe((0, utils_1.getHookKey)(entryNoMatcher));
+    });
+});
+// ─── copy.ts mergeSettingsJson (global) ───
+(0, vitest_1.describe)('copy.ts mergeSettingsJson', () => {
+    let sourceDir;
+    let destDir;
+    (0, vitest_1.beforeEach)(() => {
+        sourceDir = createTmpDir();
+        destDir = createTmpDir();
+    });
+    (0, vitest_1.afterEach)(() => {
+        cleanupDir(sourceDir);
+        cleanupDir(destDir);
+    });
+    (0, vitest_1.it)('should create settings.json on fresh install', () => {
+        const sourceSettings = {
+            statusLine: { type: 'command', command: 'echo test' },
+            hooks: {
+                UserPromptSubmit: [
+                    {
+                        hooks: [{ type: 'command', command: 'skill-forced.sh' }],
+                    },
+                ],
+            },
+        };
+        writeJson(path.join(sourceDir, 'settings.json'), sourceSettings);
+        (0, copy_1.mergeSettingsJson)(sourceDir, destDir);
+        const result = readJson(path.join(destDir, 'settings.json'));
+        (0, vitest_1.expect)(result.statusLine).toBeUndefined();
+        (0, vitest_1.expect)(result.hooks.UserPromptSubmit).toHaveLength(1);
+        (0, vitest_1.expect)(result.hooks.UserPromptSubmit[0].hooks[0].command).toBe('skill-forced.sh');
+    });
+    (0, vitest_1.it)('should skip duplicate hooks on re-run', () => {
+        const sourceSettings = {
+            hooks: {
+                UserPromptSubmit: [
+                    { hooks: [{ type: 'command', command: 'skill-forced.sh' }] },
+                ],
+            },
+        };
+        writeJson(path.join(sourceDir, 'settings.json'), sourceSettings);
+        // First run
+        (0, copy_1.mergeSettingsJson)(sourceDir, destDir);
+        // Second run (re-install)
+        (0, copy_1.mergeSettingsJson)(sourceDir, destDir);
+        const result = readJson(path.join(destDir, 'settings.json'));
+        (0, vitest_1.expect)(result.hooks.UserPromptSubmit).toHaveLength(1);
+    });
+    (0, vitest_1.it)('should distinguish entries with different matchers', () => {
+        const sourceSettings = {
+            hooks: {
+                PreToolUse: [
+                    {
+                        matcher: 'Bash',
+                        hooks: [{ type: 'command', command: 'blocker.sh' }],
+                    },
+                    {
+                        matcher: 'Write',
+                        hooks: [{ type: 'command', command: 'blocker.sh' }],
+                    },
+                ],
+            },
+        };
+        writeJson(path.join(sourceDir, 'settings.json'), sourceSettings);
+        (0, copy_1.mergeSettingsJson)(sourceDir, destDir);
+        const result = readJson(path.join(destDir, 'settings.json'));
+        (0, vitest_1.expect)(result.hooks.PreToolUse).toHaveLength(2);
+        (0, vitest_1.expect)(result.hooks.PreToolUse[0].matcher).toBe('Bash');
+        (0, vitest_1.expect)(result.hooks.PreToolUse[1].matcher).toBe('Write');
+    });
+    (0, vitest_1.it)('should not add duplicate when matcher-entry already exists in dest', () => {
+        const sourceSettings = {
+            hooks: {
+                PreToolUse: [
+                    {
+                        matcher: 'Bash',
+                        hooks: [{ type: 'command', command: 'blocker.sh' }],
+                    },
+                ],
+            },
+        };
+        writeJson(path.join(sourceDir, 'settings.json'), sourceSettings);
+        const destSettings = {
+            hooks: {
+                PreToolUse: [
+                    {
+                        matcher: 'Bash',
+                        hooks: [{ type: 'command', command: 'blocker.sh' }],
+                    },
+                ],
+            },
+        };
+        writeJson(path.join(destDir, 'settings.json'), destSettings);
+        (0, copy_1.mergeSettingsJson)(sourceDir, destDir);
+        const result = readJson(path.join(destDir, 'settings.json'));
+        (0, vitest_1.expect)(result.hooks.PreToolUse).toHaveLength(1);
+    });
+    (0, vitest_1.it)('should preserve existing hooks in dest that are not in source', () => {
+        const sourceSettings = {
+            hooks: {
+                UserPromptSubmit: [
+                    { hooks: [{ type: 'command', command: 'new-hook.sh' }] },
+                ],
+            },
+        };
+        writeJson(path.join(sourceDir, 'settings.json'), sourceSettings);
+        const destSettings = {
+            hooks: {
+                StartSession: [
+                    { hooks: [{ type: 'command', command: 'existing-hook.sh' }] },
+                ],
+            },
+        };
+        writeJson(path.join(destDir, 'settings.json'), destSettings);
+        (0, copy_1.mergeSettingsJson)(sourceDir, destDir);
+        const result = readJson(path.join(destDir, 'settings.json'));
+        // Source hook merged in
+        (0, vitest_1.expect)(result.hooks.UserPromptSubmit).toHaveLength(1);
+        // Existing hook preserved
+        (0, vitest_1.expect)(result.hooks.StartSession).toHaveLength(1);
+        (0, vitest_1.expect)(result.hooks.StartSession[0].hooks[0].command).toBe('existing-hook.sh');
+    });
+    (0, vitest_1.it)('should preserve existing top-level keys in dest', () => {
+        const sourceSettings = {
+            statusLine: { type: 'command', command: 'source-status' },
+            hooks: {},
+        };
+        writeJson(path.join(sourceDir, 'settings.json'), sourceSettings);
+        const destSettings = {
+            statusLine: { type: 'command', command: 'dest-status' },
+            customKey: 'preserved',
+        };
+        writeJson(path.join(destDir, 'settings.json'), destSettings);
+        (0, copy_1.mergeSettingsJson)(sourceDir, destDir);
+        const result = readJson(path.join(destDir, 'settings.json'));
+        // Dest's existing key is preserved (not overwritten)
+        (0, vitest_1.expect)(result.statusLine.command).toBe('dest-status');
+        (0, vitest_1.expect)(result.customKey).toBe('preserved');
+    });
+    (0, vitest_1.it)('should skip merge when source settings.json does not exist', () => {
+        // No settings.json in sourceDir
+        const destSettings = { hooks: { StartSession: [] } };
+        writeJson(path.join(destDir, 'settings.json'), destSettings);
+        (0, copy_1.mergeSettingsJson)(sourceDir, destDir);
+        const result = readJson(path.join(destDir, 'settings.json'));
+        (0, vitest_1.expect)(result).toEqual(destSettings);
+    });
+    (0, vitest_1.it)('should exclude statusLine from source even on fresh install', () => {
+        const sourceSettings = {
+            statusLine: { type: 'command', command: '~/.claude/statusline-command.sh' },
+            hooks: {},
+        };
+        writeJson(path.join(sourceDir, 'settings.json'), sourceSettings);
+        (0, copy_1.mergeSettingsJson)(sourceDir, destDir);
+        const result = readJson(path.join(destDir, 'settings.json'));
+        (0, vitest_1.expect)(result.statusLine).toBeUndefined();
+    });
+    (0, vitest_1.it)('should preserve existing statusLine in dest when source also has statusLine', () => {
+        const sourceSettings = {
+            statusLine: { type: 'command', command: 'source-status' },
+            hooks: {},
+        };
+        writeJson(path.join(sourceDir, 'settings.json'), sourceSettings);
+        const destSettings = {
+            statusLine: { type: 'command', command: 'dest-status' },
+        };
+        writeJson(path.join(destDir, 'settings.json'), destSettings);
+        (0, copy_1.mergeSettingsJson)(sourceDir, destDir);
+        const result = readJson(path.join(destDir, 'settings.json'));
+        (0, vitest_1.expect)(result.statusLine.command).toBe('dest-status');
+    });
+    (0, vitest_1.it)('should convert ~/.claude/ to ./.claude/ in command fields when project=true', () => {
+        const sourceSettings = {
+            hooks: {
+                UserPromptSubmit: [
+                    {
+                        hooks: [
+                            { type: 'command', command: '~/.claude/hooks/skill-forced.sh' },
+                        ],
+                    },
+                ],
+                PreToolUse: [
+                    {
+                        matcher: 'Bash',
+                        hooks: [
+                            { type: 'command', command: '~/.claude/hooks/blocker.sh' },
+                        ],
+                    },
+                ],
+            },
+        };
+        writeJson(path.join(sourceDir, 'settings.json'), sourceSettings);
+        (0, copy_1.mergeSettingsJson)(sourceDir, destDir, { project: true });
+        const result = readJson(path.join(destDir, 'settings.json'));
+        (0, vitest_1.expect)(result.hooks.UserPromptSubmit[0].hooks[0].command).toBe('./.claude/hooks/skill-forced.sh');
+        (0, vitest_1.expect)(result.hooks.PreToolUse[0].hooks[0].command).toBe('./.claude/hooks/blocker.sh');
+    });
+    (0, vitest_1.it)('should keep ~/.claude/ paths unchanged when project option is not set', () => {
+        const sourceSettings = {
+            hooks: {
+                UserPromptSubmit: [
+                    {
+                        hooks: [
+                            { type: 'command', command: '~/.claude/hooks/skill-forced.sh' },
+                        ],
+                    },
+                ],
+            },
+        };
+        writeJson(path.join(sourceDir, 'settings.json'), sourceSettings);
+        (0, copy_1.mergeSettingsJson)(sourceDir, destDir);
+        const result = readJson(path.join(destDir, 'settings.json'));
+        (0, vitest_1.expect)(result.hooks.UserPromptSubmit[0].hooks[0].command).toBe('~/.claude/hooks/skill-forced.sh');
+    });
+});
+// ─── init-project.ts mergeSettingsJson (project) ───
+(0, vitest_1.describe)('init-project.ts mergeSettingsJson', () => {
+    let tmpDir;
+    (0, vitest_1.beforeEach)(() => {
+        tmpDir = createTmpDir();
+    });
+    (0, vitest_1.afterEach)(() => {
+        cleanupDir(tmpDir);
+    });
+    (0, vitest_1.it)('should create settings.json with StartSession hook on fresh init', () => {
+        (0, init_project_1.mergeProjectSettingsJson)(tmpDir);
+        const result = readJson(path.join(tmpDir, 'settings.json'));
+        (0, vitest_1.expect)(result.hooks.StartSession).toHaveLength(1);
+        (0, vitest_1.expect)(result.hooks.StartSession[0].hooks[0].command).toBe('bash .claude/hooks/task-loader.sh');
+    });
+    (0, vitest_1.it)('should skip duplicate StartSession hook on re-run', () => {
+        // First run
+        (0, init_project_1.mergeProjectSettingsJson)(tmpDir);
+        // Second run
+        (0, init_project_1.mergeProjectSettingsJson)(tmpDir);
+        const result = readJson(path.join(tmpDir, 'settings.json'));
+        (0, vitest_1.expect)(result.hooks.StartSession).toHaveLength(1);
+    });
+    (0, vitest_1.it)('should preserve existing StartSession hooks while adding new one', () => {
+        const existingSettings = {
+            hooks: {
+                StartSession: [
+                    {
+                        hooks: [{ type: 'command', command: 'existing-session-hook.sh' }],
+                    },
+                ],
+            },
+        };
+        writeJson(path.join(tmpDir, 'settings.json'), existingSettings);
+        (0, init_project_1.mergeProjectSettingsJson)(tmpDir);
+        const result = readJson(path.join(tmpDir, 'settings.json'));
+        (0, vitest_1.expect)(result.hooks.StartSession).toHaveLength(2);
+        (0, vitest_1.expect)(result.hooks.StartSession[0].hooks[0].command).toBe('existing-session-hook.sh');
+        (0, vitest_1.expect)(result.hooks.StartSession[1].hooks[0].command).toBe('bash .claude/hooks/task-loader.sh');
+    });
+    (0, vitest_1.it)('should preserve other hook events', () => {
+        const existingSettings = {
+            hooks: {
+                UserPromptSubmit: [
+                    { hooks: [{ type: 'command', command: 'prompt-hook.sh' }] },
+                ],
+            },
+        };
+        writeJson(path.join(tmpDir, 'settings.json'), existingSettings);
+        (0, init_project_1.mergeProjectSettingsJson)(tmpDir);
+        const result = readJson(path.join(tmpDir, 'settings.json'));
+        // Existing event preserved
+        (0, vitest_1.expect)(result.hooks.UserPromptSubmit).toHaveLength(1);
+        (0, vitest_1.expect)(result.hooks.UserPromptSubmit[0].hooks[0].command).toBe('prompt-hook.sh');
+        // New hook added
+        (0, vitest_1.expect)(result.hooks.StartSession).toHaveLength(1);
+    });
+    (0, vitest_1.it)('should preserve non-hook settings', () => {
+        const existingSettings = {
+            statusLine: { type: 'command', command: 'echo status' },
+            hooks: {},
+        };
+        writeJson(path.join(tmpDir, 'settings.json'), existingSettings);
+        (0, init_project_1.mergeProjectSettingsJson)(tmpDir);
+        const result = readJson(path.join(tmpDir, 'settings.json'));
+        (0, vitest_1.expect)(result.statusLine.command).toBe('echo status');
+        (0, vitest_1.expect)(result.hooks.StartSession).toHaveLength(1);
+    });
+});

package/dist/cli.js

@@ -45,15 +45,17 @@ const validate_1 = require("./validate");
 const program = new commander_1.Command();
 program
     .name('jun-claude-code')
-    .description('Copy .claude configuration files to your home directory (~/.claude)')
+    .description('Copy .claude configuration files to ~/.claude (global) or .claude/ (project)')
     .version('1.0.0')
     .option('-d, --dry-run', 'Preview files to be copied without actually copying')
     .option('-f, --force', 'Overwrite existing files without confirmation')
+    .option('-p, --project', 'Install to project .claude/ instead of global ~/.claude/')
     .action(async (options) => {
     try {
         await (0, copy_1.copyClaudeFiles)({
             dryRun: options.dryRun,
             force: options.force,
+            project: options.project,
         });
     }
     catch (error) {

package/dist/copy.d.ts

@@ -1,7 +1,18 @@
 export interface CopyOptions {
     dryRun?: boolean;
     force?: boolean;
+    project?: boolean;
 }
+/**
+ * Merge settings.json from source into destination.
+ * Hooks are merged per event key; duplicate hook entries (by deep equality) are skipped.
+ * Non-hook keys are shallow-merged (source wins for new keys, dest preserved for existing).
+ * statusLine is always excluded from merge (personal environment setting).
+ * When project=true, ~/.claude/ paths in command fields are converted to ./.claude/.
+ */
+export declare function mergeSettingsJson(sourceDir: string, destDir: string, options?: {
+    project?: boolean;
+}): void;
 /**
  * Copy .claude files to user's home directory
  */

package/dist/copy.js

@@ -36,12 +36,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeSettingsJson = mergeSettingsJson;
 exports.copyClaudeFiles = copyClaudeFiles;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const readline = __importStar(require("readline"));
 const crypto = __importStar(require("crypto"));
 const chalk_1 = __importDefault(require("chalk"));
+const utils_1 = require("./utils");
 /**
  * Prompt user for confirmation using readline
  */
@@ -123,7 +125,35 @@ function getDestClaudeDir() {
  * Hooks are merged per event key; duplicate hook entries (by deep equality) are skipped.
  * Non-hook keys are shallow-merged (source wins for new keys, dest preserved for existing).
  */
-function mergeSettingsJson(sourceDir, destDir) {
+/**
+ * Replace ~/.claude/ paths with ./.claude/ in all command fields (deep traverse).
+ */
+function replaceClaudePaths(obj) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (key === 'command' && typeof value === 'string') {
+            result[key] = value.replace(/~\/\.claude\//g, './.claude/');
+        }
+        else if (Array.isArray(value)) {
+            result[key] = value.map((item) => typeof item === 'object' && item !== null ? replaceClaudePaths(item) : item);
+        }
+        else if (typeof value === 'object' && value !== null) {
+            result[key] = replaceClaudePaths(value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Merge settings.json from source into destination.
+ * Hooks are merged per event key; duplicate hook entries (by deep equality) are skipped.
+ * Non-hook keys are shallow-merged (source wins for new keys, dest preserved for existing).
+ * statusLine is always excluded from merge (personal environment setting).
+ * When project=true, ~/.claude/ paths in command fields are converted to ./.claude/.
+ */
+function mergeSettingsJson(sourceDir, destDir, options) {
     const sourcePath = path.join(sourceDir, 'settings.json');
     const destPath = path.join(destDir, 'settings.json');
     if (!fs.existsSync(sourcePath)) {
@@ -149,8 +179,8 @@ function mergeSettingsJson(sourceDir, destDir) {
     }
     // Merge top-level keys (source fills in missing keys, dest's existing keys preserved)
     for (const key of Object.keys(sourceSettings)) {
-        if (key === 'hooks') {
-            continue; // hooks are merged separately below
+        if (key === 'hooks' || key === 'statusLine') {
+            continue; // hooks are merged separately below; statusLine is excluded
         }
         if (!(key in destSettings)) {
             destSettings[key] = sourceSettings[key];
@@ -168,28 +198,20 @@ function mergeSettingsJson(sourceDir, destDir) {
             destHooks[event] = [];
         }
         const destEntries = destHooks[event];
-        // Extract a command-based key from a hook entry for duplicate detection.
-        // Type 1: { type: "command", command: "..." } → returns "type:command"
-        // Type 2: { hooks: [{ type: "command", command: "..." }, ...] } → returns sorted "type:command" joined
-        const getHookKey = (entry) => {
-            if (entry.hooks && Array.isArray(entry.hooks)) {
-                return entry.hooks
-                    .map((h) => `${h.type || ''}:${h.command || ''}`)
-                    .sort()
-                    .join('\n');
-            }
-            return `${entry.type || ''}:${entry.command || ''}`;
-        };
         // Build a Set of command keys from existing entries for fast duplicate detection
-        const existingKeys = new Set(destEntries.map((entry) => getHookKey(entry)));
+        const existingKeys = new Set(destEntries.map((entry) => (0, utils_1.getHookKey)(entry)));
         for (const entry of sourceEntries) {
-            const key = getHookKey(entry);
+            const key = (0, utils_1.getHookKey)(entry);
             if (!existingKeys.has(key)) {
                 destEntries.push(entry);
                 existingKeys.add(key);
             }
         }
     }
+    // Convert ~/.claude/ → ./.claude/ paths for project mode
+    if (options?.project) {
+        destSettings = replaceClaudePaths(destSettings);
+    }
     ensureDir(destDir);
     fs.writeFileSync(destPath, JSON.stringify(destSettings, null, 2) + '\n', 'utf-8');
     console.log(`  ${chalk_1.default.blue('[merged]')} settings.json`);
@@ -198,11 +220,12 @@ function mergeSettingsJson(sourceDir, destDir) {
  * Copy .claude files to user's home directory
  */
 async function copyClaudeFiles(options = {}) {
-    const { dryRun = false, force = false } = options;
+    const { dryRun = false, force = false, project = false } = options;
     const sourceDir = getSourceGlobalDir();
-    const destDir = getDestClaudeDir();
+    const destDir = project ? path.join(process.cwd(), '.claude') : getDestClaudeDir();
+    const targetLabel = project ? 'project' : 'global';
     console.log(chalk_1.default.blue('Source:'), sourceDir);
-    console.log(chalk_1.default.blue('Destination:'), destDir);
+    console.log(chalk_1.default.blue('Destination:'), `${destDir} ${chalk_1.default.gray(`(${targetLabel})`)}`);
     console.log();
     // Check if source exists
     if (!fs.existsSync(sourceDir)) {
@@ -212,6 +235,7 @@ async function copyClaudeFiles(options = {}) {
     // Files to exclude from global copy (merge-handled separately)
     const EXCLUDE_FROM_GLOBAL = [
         'settings.json',
+        'statusline-command.sh',
     ];
     // Get all files to copy
     const allFiles = getAllFiles(sourceDir);
@@ -280,7 +304,7 @@ async function copyClaudeFiles(options = {}) {
         copiedCount++;
     }
     // Merge settings.json (hooks are merged, not overwritten)
-    mergeSettingsJson(sourceDir, destDir);
+    mergeSettingsJson(sourceDir, destDir, { project });
     console.log();
     console.log(chalk_1.default.green(`Done! Copied ${copiedCount} files, skipped ${skippedCount} files.`));
 }

package/dist/init-project.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Merge StartSession hook into settings.json.
+ * Appends the task-loader hook if not already present (duplicate detection via getHookKey).
+ */
+export declare function mergeProjectSettingsJson(destDir: string): void;
 /**
  * Initialize GitHub Project integration in current directory
  */

package/dist/init-project.js

@@ -36,11 +36,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeProjectSettingsJson = mergeProjectSettingsJson;
 exports.initProject = initProject;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const readline = __importStar(require("readline"));
 const chalk_1 = __importDefault(require("chalk"));
+const utils_1 = require("./utils");
 /**
  * Prompt user for input using readline
  */
@@ -112,9 +114,10 @@ function copyProjectFile(srcRelative, destDir) {
     console.log(chalk_1.default.green(`  ✓ ${path.relative(process.cwd(), destPath)}`));
 }
 /**
- * Merge StartSession hook into settings.json
+ * Merge StartSession hook into settings.json.
+ * Appends the task-loader hook if not already present (duplicate detection via getHookKey).
  */
-function mergeSettingsJson(destDir) {
+function mergeProjectSettingsJson(destDir) {
     const settingsPath = path.join(destDir, 'settings.json');
     let settings = {};
     if (fs.existsSync(settingsPath)) {
@@ -129,12 +132,21 @@ function mergeSettingsJson(destDir) {
     if (!settings.hooks) {
         settings.hooks = {};
     }
-    settings.hooks.StartSession = [
-        {
-            type: 'command',
-            command: 'bash .claude/hooks/task-loader.sh',
-        },
-    ];
+    if (!settings.hooks.StartSession) {
+        settings.hooks.StartSession = [];
+    }
+    const newEntry = {
+        hooks: [
+            {
+                type: 'command',
+                command: 'bash .claude/hooks/task-loader.sh',
+            },
+        ],
+    };
+    const existingKeys = new Set(settings.hooks.StartSession.map((e) => (0, utils_1.getHookKey)(e)));
+    if (!existingKeys.has((0, utils_1.getHookKey)(newEntry))) {
+        settings.hooks.StartSession.push(newEntry);
+    }
     fs.mkdirSync(destDir, { recursive: true });
     fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
     console.log(chalk_1.default.green(`  ✓ ${path.relative(process.cwd(), settingsPath)} (StartSession hook 추가)`));
@@ -152,7 +164,7 @@ async function initProject() {
     copyProjectFile('hooks/task-loader.sh', destDir);
     copyProjectFile('agents/project-task-manager.md', destDir);
     // 3. settings.json merge
-    mergeSettingsJson(destDir);
+    mergeProjectSettingsJson(destDir);
     console.log(chalk_1.default.cyan('\n✅ GitHub Project 설정 완료!'));
     console.log(chalk_1.default.gray(`   Owner: ${config.owner}`));
     console.log(chalk_1.default.gray(`   Project: #${config.projectNumber}`));

package/dist/utils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Extract a command-based key from a hook entry for duplicate detection.
+ * Includes the matcher field so that entries with the same command but different matchers
+ * are treated as distinct items.
+ *
+ * Type 1 (nested): { matcher?: "...", hooks: [{ type: "command", command: "..." }, ...] }
+ *   -> returns "[matcher]type:command\ntype:command" (sorted) or "type:command\ntype:command" if no matcher
+ *
+ * Type 2 (flat): { type: "command", command: "..." }
+ *   -> returns "type:command"
+ */
+export declare const getHookKey: (entry: any) => string;

package/dist/utils.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHookKey = void 0;
+/**
+ * Extract a command-based key from a hook entry for duplicate detection.
+ * Includes the matcher field so that entries with the same command but different matchers
+ * are treated as distinct items.
+ *
+ * Type 1 (nested): { matcher?: "...", hooks: [{ type: "command", command: "..." }, ...] }
+ *   -> returns "[matcher]type:command\ntype:command" (sorted) or "type:command\ntype:command" if no matcher
+ *
+ * Type 2 (flat): { type: "command", command: "..." }
+ *   -> returns "type:command"
+ */
+const getHookKey = (entry) => {
+    const matcher = entry.matcher || '';
+    if (entry.hooks && Array.isArray(entry.hooks)) {
+        const hooksKey = entry.hooks
+            .map((h) => `${h.type || ''}:${h.command || ''}`)
+            .sort()
+            .join('\n');
+        return matcher ? `[${matcher}]${hooksKey}` : hooksKey;
+    }
+    return `${entry.type || ''}:${entry.command || ''}`;
+};
+exports.getHookKey = getHookKey;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jun-claude-code",
-  "version": "0.0.17",
+  "version": "0.1.1",
   "description": "Claude Code configuration template - copy .claude settings to your project",
   "main": "dist/index.js",
   "bin": "dist/cli.js",
@@ -10,6 +10,7 @@
   ],
   "scripts": {
     "build": "tsc",
+    "test": "vitest run",
     "prepublishOnly": "yarn build"
   },
   "packageManager": "yarn@3.8.7",
@@ -19,7 +20,8 @@
   },
   "devDependencies": {
     "@types/node": "^20.10.0",
-    "typescript": "^5.5.3"
+    "typescript": "^5.5.3",
+    "vitest": "^4.0.18"
   },
   "keywords": [
     "claude",

package/templates/global/agents/git-manager.md

@@ -100,25 +100,63 @@ git log --oneline -10
 git diff main...HEAD
 ```
 
-### Step 2: 변경사항 분석
+### Step 2: PR 템플릿 확인
+
+```bash
+# 프로젝트에 PR 템플릿이 있는지 확인
+# 확인 경로 (우선순위 순):
+#   1. .github/pull_request_template.md
+#   2. .github/PULL_REQUEST_TEMPLATE.md
+#   3. docs/pull_request_template.md
+#   4. pull_request_template.md
+```
+
+- **템플릿이 있으면**: 해당 템플릿의 섹션 구조를 그대로 따라 PR 본문 작성
+- **템플릿이 없으면**: 아래 Step 4의 기본 포맷 사용
+
+### Step 3: 변경사항 분석
 
 모든 커밋을 분석하여 PR 내용 구성:
 - 변경된 파일 목록
 - 각 파일의 변경 내용
 - 전체 변경의 목적
 
-### Step 3: PR 생성
+### PR 본문 필수 포함 사항
+
+**템플릿 사용 여부와 관계없이**, PR 본문에는 반드시 다음 3가지를 포함:
+
+| 항목 | 설명 | 예시 |
+|------|------|------|
+| **의도 (Why)** | 이 변경을 하는 이유/배경 | "사용자 로그인 실패 시 에러 메시지가 표시되지 않는 문제" |
+| **문제 (What)** | 해결하려는 구체적 문제 | "catch 블록에서 에러를 무시하고 있었음" |
+| **해결 방법 (How)** | 어떻게 해결했는지 | "에러 핸들러를 추가하고 toast 알림으로 사용자에게 표시" |
+
+### Step 4: PR 생성
 
 ```bash
 # 원격에 push (필요시)
 git push -u origin <branch-name>
 
-# PR 생성
+# PR 템플릿이 있는 경우: 템플릿 구조를 따르되 Why/What/How 포함
+# PR 템플릿이 없는 경우: 아래 기본 포맷 사용
+
 gh pr create --title "<간결한 제목>" --body "$(cat <<'EOF'
 ## 📋 Summary
 
 > 이 PR이 해결하는 문제와 접근 방식을 1-2문장으로 설명
 
+## 🎯 Why (의도)
+
+> 왜 이 변경이 필요한가? 배경과 동기를 설명
+
+## 🐛 What (문제)
+
+> 어떤 문제가 있었는가? 구체적인 증상이나 요구사항
+
+## 🔧 How (해결 방법)
+
+> 어떻게 해결했는가? 접근 방식과 핵심 변경 내용
+
 ## 🔄 주요 변경사항
 
 ### 변경 1: [제목]

package/templates/global/settings.json

@@ -1,7 +1,7 @@
 {
   "statusLine": {
-    "format": "{{dir}} {{git}} | {{tokens}} | {{model}}",
-    "updateInterval": 1000
+    "type": "command",
+    "command": "~/.claude/statusline-command.sh"
   },
   "hooks": {
     "UserPromptSubmit": [

package/templates/global/skills/Backend/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: Backend
-description: NestJS/TypeORM 백엔드 개발 시 사용. Controller-Service-Repository 레이어 객체 변환, find vs queryBuilder 선택 기준 제공.
-keywords: [Backend, 백엔드, 레이어, DTO, Entity, Service, Controller, TypeORM, find, queryBuilder]
+description: NestJS/TypeORM 백엔드 개발 시 사용. 레이어 객체 변환, find vs queryBuilder 선택 기준, BDD 테스트 작성 규칙 제공.
+keywords: [Backend, 백엔드, 레이어, DTO, Entity, Service, Controller, TypeORM, find, queryBuilder, test, BDD, 테스트, Jest]
 estimated_tokens: ~400
 ---
 
@@ -174,3 +174,13 @@ const user = await this.userRepository.findOneBy({ id });
 - [ ] QueryBuilder는 groupBy, getRawMany 등 필요한 경우에만 사용하는가?
 
 </checklist>
+
+<reference>
+
+## 관련 문서
+
+| 주제 | 위치 | 설명 |
+|-----|------|------|
+| BDD 테스트 | `bdd-testing.md` | NestJS + Jest BDD 스타일 테스트 작성 규칙 |
+
+</reference>

package/templates/global/skills/Backend/bdd-testing.md

@@ -0,0 +1,211 @@
+---
+name: bdd-testing
+description: NestJS + Jest BDD 스타일 테스트 작성 시 사용. describe 네스팅 구조, Given/When/Then 패턴, Testing Module Mock 설정 규칙 제공.
+keywords: [BDD, test, 테스트, Jest, NestJS, describe, it, Given, When, Then, mock, TestingModule]
+estimated_tokens: ~500
+---
+
+# BDD 테스트 작성 규칙
+
+<rules>
+
+## describe 네스팅 구조
+
+> **Service 클래스명 > 메서드명 > 시나리오** 구조로 describe를 네스팅한다.
+
+| 레벨 | 대상 | 예시 |
+|------|------|------|
+| 1 | Service 클래스 | `describe('UserService', ...)` |
+| 2 | 메서드명 | `describe('create', ...)` |
+| 3 (선택) | 조건 그룹 | `describe('when role is admin', ...)` |
+
+- 3레벨은 동일 메서드에서 조건 분기가 많을 때만 사용한다
+- 3레벨까지만 사용한다
+
+```typescript
+describe('UserService', () => {
+  // 공통 setup (TestingModule, mock 등)
+
+  describe('create', () => {
+    it('should create user when valid dto given', () => {});
+    it('should throw ConflictException when email duplicated', () => {});
+  });
+
+  describe('findById', () => {
+    it('should return user when id exists', () => {});
+    it('should throw NotFoundException when id not found', () => {});
+  });
+});
+```
+
+## it 문구 및 Given/When/Then
+
+### it 문구 형식
+
+```
+"should [결과] when [조건]"
+```
+
+| 요소 | 설명 | 예시 |
+|------|------|------|
+| 결과 | 기대하는 동작 | `create user`, `throw NotFoundException` |
+| 조건 | 입력/상태 | `valid dto given`, `id not found` |
+
+### 블록 내부 구조
+
+각 `it` 블록 내부에 `// Given` / `// When` / `// Then` 주석으로 구분한다.
+
+```typescript
+it('should create user when valid dto given', async () => {
+  // Given
+  const dto: CreateUserDto = { name: 'John', email: 'john@test.com' };
+  jest.spyOn(userRepository, 'findOneBy').mockResolvedValue(null);
+  jest.spyOn(userRepository, 'save').mockResolvedValue({ id: 1, ...dto } as User);
+
+  // When
+  const result = await service.create(dto);
+
+  // Then
+  expect(result.name).toBe('John');
+  expect(userRepository.save).toHaveBeenCalledWith(expect.objectContaining({ name: 'John' }));
+});
+```
+
+## NestJS Testing Module 설정
+
+### 기본 패턴
+
+```typescript
+import { Test, TestingModule } from '@nestjs/testing';
+
+describe('UserService', () => {
+  let service: UserService;
+  let userRepository: Repository<User>;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        UserService,
+        {
+          provide: getRepositoryToken(User),
+          useValue: {
+            find: jest.fn(),
+            findOneBy: jest.fn(),
+            save: jest.fn(),
+            delete: jest.fn(),
+          },
+        },
+      ],
+    }).compile();
+
+    service = module.get<UserService>(UserService);
+    userRepository = module.get<Repository<User>>(getRepositoryToken(User));
+  });
+});
+```
+
+### Mock 규칙
+
+| 패턴 | 용도 | 예시 |
+|------|------|------|
+| `useValue` + `jest.fn()` | Repository mock | `{ save: jest.fn() }` |
+| `jest.spyOn` | 특정 호출에 반환값 지정 | `jest.spyOn(repo, 'findOneBy').mockResolvedValue(...)` |
+| `jest.mocked` | 이미 mock된 함수 타입 캐스팅 | `jest.mocked(repo.save).mockResolvedValue(...)` |
+
+- `useValue`로 mock 객체를 주입하고, 각 테스트에서 `jest.spyOn` 또는 `jest.mocked`로 반환값을 지정한다
+- `jest.mock()` 모듈 레벨 mock은 외부 라이브러리에만 사용한다
+
+### 외부 의존성 Mock
+
+```typescript
+// Service가 다른 Service에 의존할 때
+{
+  provide: EmailService,
+  useValue: {
+    sendWelcomeEmail: jest.fn().mockResolvedValue(undefined),
+  },
+},
+```
+
+</rules>
+
+<examples>
+
+### describe 구조
+
+<example type="good">
+```typescript
+// Service > Method > Scenario 명확
+describe('OrderService', () => {
+  describe('cancel', () => {
+    it('should cancel order when status is pending', async () => {});
+    it('should throw BadRequestException when status is shipped', async () => {});
+  });
+});
+```
+</example>
+<example type="bad">
+```typescript
+// 메서드별 그룹 없이 플랫하게 나열
+describe('OrderService', () => {
+  it('cancel pending order', async () => {});
+  it('cancel shipped order throws', async () => {});
+  it('create order', async () => {});
+});
+```
+</example>
+
+### Assertion
+
+<example type="good">
+```typescript
+// 구체적 assertion
+expect(result.status).toBe('cancelled');
+expect(orderRepository.save).toHaveBeenCalledWith(
+  expect.objectContaining({ status: 'cancelled' }),
+);
+```
+</example>
+<example type="bad">
+```typescript
+// 의미 없는 assertion
+expect(result).toBeDefined();
+expect(result).toBeTruthy();
+```
+</example>
+
+### Exception 테스트
+
+<example type="good">
+```typescript
+// 예외 타입 검증
+await expect(service.cancel(orderId)).rejects.toThrow(BadRequestException);
+```
+</example>
+<example type="bad">
+```typescript
+// try-catch로 예외 테스트
+try {
+  await service.cancel(orderId);
+  fail('should have thrown');
+} catch (e) {
+  expect(e).toBeDefined();
+}
+```
+</example>
+
+</examples>
+
+<checklist>
+
+## 체크리스트
+
+- [ ] describe 네스팅이 Service > Method > Scenario 구조인가?
+- [ ] it 문구가 `"should [결과] when [조건]"` 형식인가?
+- [ ] 각 it 블록에 `// Given` / `// When` / `// Then` 주석이 있는가?
+- [ ] `Test.createTestingModule`로 테스트 모듈을 구성했는가?
+- [ ] Repository mock은 `useValue` + `jest.fn()`으로 주입했는가?
+- [ ] assertion이 구체적인 값을 검증하는가?
+- [ ] 예외 테스트에 `rejects.toThrow`를 사용했는가?
+
+</checklist>

package/templates/global/statusline-command.sh

@@ -0,0 +1,84 @@
+#!/bin/bash
+
+# Read JSON input from stdin
+input=$(cat)
+
+# Extract data from JSON
+cwd=$(echo "$input" | jq -r '.workspace.current_dir')
+model=$(echo "$input" | jq -r '.model.display_name')
+session_name=$(echo "$input" | jq -r '.session_name // empty')
+remaining=$(echo "$input" | jq -r '.context_window.remaining_percentage // empty')
+used_tokens=$(echo "$input" | jq -r '.context_window.total_input_tokens // empty')
+total_tokens=$(echo "$input" | jq -r '.context_window.context_window_size // empty')
+
+# Get short directory name (basename)
+dir_name=$(basename "$cwd")
+
+# Git information
+git_info=""
+if git -C "$cwd" rev-parse --git-dir > /dev/null 2>&1; then
+  branch=$(git -C "$cwd" -c core.useBuiltinFSMonitor=false -c core.fsmonitor=false symbolic-ref --short HEAD 2>/dev/null || echo "detached")
+
+  # Check for uncommitted changes
+  if ! git -C "$cwd" -c core.useBuiltinFSMonitor=false -c core.fsmonitor=false diff --quiet 2>/dev/null || \
+     ! git -C "$cwd" -c core.useBuiltinFSMonitor=false -c core.fsmonitor=false diff --cached --quiet 2>/dev/null; then
+    status="✗"
+  else
+    status=""
+  fi
+
+  git_info=" git:($(printf '\033[31m')${branch}$(printf '\033[0m'))${status}"
+fi
+
+# Format token information
+format_token_count() {
+  local value=$1
+  if (( value >= 1000 )); then
+    printf "%.1fk" "$(bc <<< "scale=1; $value / 1000")"
+  else
+    echo "$value"
+  fi
+}
+
+# Get color based on usage percentage
+get_color_for_percentage() {
+  local percentage=$1
+  if (( percentage >= 90 )); then
+    printf '\033[31m'  # red
+  elif (( percentage >= 70 )); then
+    printf '\033[33m'  # yellow
+  else
+    printf '\033[0m'   # reset (no color)
+  fi
+}
+
+# Build status line in robbyrussell style
+status_line="$(printf '\033[36m')${dir_name}$(printf '\033[0m')${git_info}"
+
+# Add context percentage if available
+if [ -n "$remaining" ]; then
+  # Calculate usage percentage (100 - remaining)
+  usage=$((100 - remaining))
+  color=$(get_color_for_percentage "$usage")
+  status_line="${status_line} | ctx:${color}${usage}%$(printf '\033[0m')"
+fi
+
+# Add token information if available
+if [ -n "$used_tokens" ] && [ -n "$total_tokens" ]; then
+  used_formatted=$(format_token_count "$used_tokens")
+  total_formatted=$(format_token_count "$total_tokens")
+  # Calculate token usage percentage
+  token_usage=$(echo "scale=0; $used_tokens * 100 / $total_tokens" | bc)
+  color=$(get_color_for_percentage "$token_usage")
+  status_line="${status_line} | token:${color}${used_formatted}/${total_formatted}$(printf '\033[0m')"
+fi
+
+# Add model info
+status_line="${status_line} | ${model}"
+
+# Add session name if set
+if [ -n "$session_name" ]; then
+  status_line="${status_line} [${session_name}]"
+fi
+
+printf "%s" "$status_line"

package/templates/project/workflows/context-gen.yml

@@ -75,8 +75,12 @@ jobs:
             exit 0
           fi
 
+          SOURCE_PR_TITLE="${{ github.event.pull_request.title }}"
+          CONTEXT_PR_TITLE="${SOURCE_PR_TITLE} - Docs"
+          PR_NUMBER="${{ github.event.pull_request.number }}"
+
           CONTEXT_BRANCH="${{ github.head_ref }}-generated-context"
-          git commit -m "docs: context 문서 자동 업데이트"
+          git commit -m "${CONTEXT_PR_TITLE}"
           git push --force origin HEAD:refs/heads/${CONTEXT_BRANCH}
 
           # 기존 PR이 있으면 스킵, 없으면 생성
@@ -85,11 +89,11 @@ jobs:
             gh pr create \
               --head "${CONTEXT_BRANCH}" \
               --base "${{ github.head_ref }}" \
-              --title "docs: context 문서 자동 업데이트" \
-              --body "$(cat <<'PREOF'
+              --title "${CONTEXT_PR_TITLE}" \
+              --body "$(cat <<PREOF
           ## Auto-generated Context
 
-          PR의 코드 변경을 분석하여 자동 생성된 context 문서입니다.
+          #${PR_NUMBER} 의 코드 변경을 분석하여 자동 생성된 context 문서입니다.
           선택적으로 머지하여 반영할 수 있습니다.
 
           > 이 PR은 re-sync 시 force push로 업데이트됩니다.