sonamu 0.8.5 → 0.8.6

package/dist/testing/dev-vitest-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dev-vitest-manager.d.ts","sourceRoot":"","sources":["../../src/testing/dev-vitest-manager.ts"],"names":[],"mappings":"AAUA,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,EAAE;QACP,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,MAAM,EAAE,UAAU,EAAE,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B,CAAC;AAQF,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,KAAK,CAAoB;IACjC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,MAAM,CAAS;IAEjB,KAAK,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA6B/C,GAAG,CAAC,IAAI,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,SAAS,CAAC;IAe3E,SAAS,IAAI,aAAa;IAQpB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;YAYjB,YAAY;YA2BZ,UAAU;IAkCxB,OAAO,CAAC,cAAc;IA4BtB,OAAO,CAAC,iBAAiB;IA4BzB,OAAO,CAAC,iBAAiB;CAe1B"}
+{"version":3,"file":"dev-vitest-manager.d.ts","sourceRoot":"","sources":["../../src/testing/dev-vitest-manager.ts"],"names":[],"mappings":"AAUA,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,EAAE;QACP,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,MAAM,EAAE,UAAU,EAAE,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B,CAAC;AAQF,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,KAAK,CAAoB;IACjC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,MAAM,CAAS;IAEjB,KAAK,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA6B/C,GAAG,CAAC,IAAI,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,SAAS,CAAC;IAe3E,SAAS,IAAI,aAAa;IAQpB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;YAoBjB,YAAY;YA2BZ,UAAU;IAkCxB,OAAO,CAAC,cAAc;IA4BtB,OAAO,CAAC,iBAAiB;IA4BzB,OAAO,CAAC,iBAAiB;CAe1B"}

package/dist/testing/dev-vitest-manager.js

@@ -59,6 +59,13 @@ export class DevVitestManager {
             return;
         }
         this.closed = true;
+        // 큐에 남은 작업들을 reject하여 호출자가 영구 대기하지 않도록 정리
+        while(this.queue.length > 0){
+            const entry = this.queue.shift();
+            if (entry) {
+                entry.reject(new Error("DevVitestManager is being shut down"));
+            }
+        }
         if (this.vitest) {
             await this.vitest.close();
             this.vitest = null;
@@ -180,4 +187,4 @@ export class DevVitestManager {
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/testing/dev-vitest-manager.ts"],"sourcesContent":["import type { UserConfig as ViteUserConfig } from \"vite\";\nimport type {\n  CliOptions,\n  TestCase,\n  TestModule,\n  TestRunResult,\n  TestSpecification,\n  Vitest,\n} from \"vitest/node\";\n\nexport type RunResult = {\n  ok: boolean;\n  summary: {\n    total: number;\n    passed: number;\n    failed: number;\n    skipped: number;\n    durationMs: number;\n  };\n  failed: FailedTest[];\n};\n\nexport type FailedTest = {\n  name: string;\n  file: string;\n  error: string;\n};\n\nexport type ManagerStatus = {\n  ready: boolean;\n  running: boolean;\n  lastRunAt: string | null;\n};\n\ntype QueueEntry = {\n  task: () => Promise<RunResult>;\n  resolve: (result: RunResult) => void;\n  reject: (error: unknown) => void;\n};\n\nexport class DevVitestManager {\n  private vitest: Vitest | null = null;\n  private running = false;\n  private lastRunAt: string | null = null;\n  private queue: QueueEntry[] = [];\n  private processing = false;\n  private closed = false;\n\n  async start(vitestConfigPath?: string): Promise<void> {\n    // 이미 시작된 경우 중복 초기화를 방지\n    if (this.vitest) {\n      return;\n    }\n\n    const { createVitest } = await import(\"vitest/node\");\n\n    const viteOverrides: ViteUserConfig = {\n      server: { watch: null },\n    };\n\n    const cliOptions: CliOptions = {\n      watch: true,\n      standalone: true,\n      forceRerunTriggers: [],\n      config: vitestConfigPath,\n      env: {\n        NODE_ENV: \"test\",\n      },\n    };\n\n    this.vitest = await createVitest(\"test\", cliOptions, viteOverrides);\n    await this.vitest.init();\n\n    this.vitest.onFilterWatchedSpecification((_spec) => false);\n    this.closed = false;\n  }\n\n  async run(opts: { files?: string[]; pattern?: string }): Promise<RunResult> {\n    if (this.closed) {\n      throw new Error(\"DevVitestManager is already shut down\");\n    }\n    if (!this.vitest) {\n      throw new Error(\"DevVitestManager is not started\");\n    }\n\n    return new Promise<RunResult>((resolve, reject) => {\n      const task = () => this.executeRun(opts);\n      this.queue.push({ task, resolve, reject });\n      this.processQueue();\n    });\n  }\n\n  getStatus(): ManagerStatus {\n    return {\n      ready: this.vitest !== null && !this.closed,\n      running: this.running,\n      lastRunAt: this.lastRunAt,\n    };\n  }\n\n  async shutdown(): Promise<void> {\n    if (this.closed) {\n      return;\n    }\n    this.closed = true;\n\n    if (this.vitest) {\n      await this.vitest.close();\n      this.vitest = null;\n    }\n  }\n\n  private async processQueue(): Promise<void> {\n    if (this.processing) {\n      return;\n    }\n    this.processing = true;\n\n    try {\n      while (this.queue.length > 0) {\n        const entry = this.queue.shift();\n        if (!entry) break;\n        if (this.closed) {\n          entry.reject(new Error(\"DevVitestManager is already shut down\"));\n          continue;\n        }\n\n        try {\n          const result = await entry.task();\n          entry.resolve(result);\n        } catch (err) {\n          entry.reject(err);\n        }\n      }\n    } finally {\n      this.processing = false;\n    }\n  }\n\n  private async executeRun(opts: { files?: string[]; pattern?: string }): Promise<RunResult> {\n    const vitest = this.vitest;\n    if (!vitest) {\n      throw new Error(\"DevVitestManager is not started\");\n    }\n\n    this.running = true;\n    const startTime = Date.now();\n\n    if (opts.pattern) {\n      vitest.setGlobalTestNamePattern(opts.pattern);\n    }\n\n    try {\n      const specs: TestSpecification[] = opts.files\n        ? await vitest.globTestSpecifications(opts.files)\n        : await vitest.globTestSpecifications();\n\n      const allTestsRun = !opts.files || opts.files.length === 0;\n      const runResult: TestRunResult = await vitest.runTestSpecifications(specs, allTestsRun);\n\n      const durationMs = Date.now() - startTime;\n      this.lastRunAt = new Date().toISOString();\n\n      const specModuleIds = new Set(specs.map((s) => s.moduleId));\n      return this.collectResults(runResult, durationMs, specModuleIds);\n    } finally {\n      if (opts.pattern) {\n        vitest.resetGlobalTestNamePattern();\n      }\n      this.running = false;\n    }\n  }\n\n  private collectResults(\n    runResult: TestRunResult,\n    durationMs: number,\n    specModuleIds: Set<string>,\n  ): RunResult {\n    let total = 0;\n    let passed = 0;\n    let failed = 0;\n    let skipped = 0;\n    const failedTests: FailedTest[] = [];\n\n    for (const testModule of runResult.testModules) {\n      if (!specModuleIds.has(testModule.moduleId)) continue;\n      this.collectFromModule(testModule, failedTests, (counts) => {\n        total += counts.total;\n        passed += counts.passed;\n        failed += counts.failed;\n        skipped += counts.skipped;\n      });\n    }\n\n    return {\n      ok: failed === 0,\n      summary: { total, passed, failed, skipped, durationMs },\n      failed: failedTests,\n    };\n  }\n\n  private collectFromModule(\n    testModule: TestModule,\n    failedTests: FailedTest[],\n    addCounts: (counts: { total: number; passed: number; failed: number; skipped: number }) => void,\n  ): void {\n    let total = 0;\n    let passed = 0;\n    let failed = 0;\n    let skipped = 0;\n\n    for (const testCase of testModule.children.allTests()) {\n      total++;\n      const result = testCase.result();\n\n      if (result.state === \"passed\") {\n        passed++;\n      } else if (result.state === \"failed\") {\n        failed++;\n        failedTests.push(this.extractFailedTest(testCase, testModule));\n      } else {\n        // pending/skipped 상태는 skipped로 집계\n        skipped++;\n      }\n    }\n\n    addCounts({ total, passed, failed, skipped });\n  }\n\n  private extractFailedTest(testCase: TestCase, testModule: TestModule): FailedTest {\n    const result = testCase.result();\n    let errorMessage = \"Unknown error\";\n\n    if (result.state === \"failed\" && result.errors.length > 0) {\n      const firstError = result.errors[0];\n      errorMessage = firstError.message ?? String(firstError);\n    }\n\n    return {\n      name: testCase.fullName,\n      file: testModule.moduleId,\n      error: errorMessage,\n    };\n  }\n}\n"],"names":["DevVitestManager","vitest","running","lastRunAt","queue","processing","closed","start","vitestConfigPath","createVitest","viteOverrides","server","watch","cliOptions","standalone","forceRerunTriggers","config","env","NODE_ENV","init","onFilterWatchedSpecification","_spec","run","opts","Error","Promise","resolve","reject","task","executeRun","push","processQueue","getStatus","ready","shutdown","close","length","entry","shift","result","err","startTime","Date","now","pattern","setGlobalTestNamePattern","specs","files","globTestSpecifications","allTestsRun","runResult","runTestSpecifications","durationMs","toISOString","specModuleIds","Set","map","s","moduleId","collectResults","resetGlobalTestNamePattern","total","passed","failed","skipped","failedTests","testModule","testModules","has","collectFromModule","counts","ok","summary","addCounts","testCase","children","allTests","state","extractFailedTest","errorMessage","errors","firstError","message","String","name","fullName","file","error"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/testing/dev-vitest-manager.ts"],"sourcesContent":["import type { UserConfig as ViteUserConfig } from \"vite\";\nimport type {\n  CliOptions,\n  TestCase,\n  TestModule,\n  TestRunResult,\n  TestSpecification,\n  Vitest,\n} from \"vitest/node\";\n\nexport type RunResult = {\n  ok: boolean;\n  summary: {\n    total: number;\n    passed: number;\n    failed: number;\n    skipped: number;\n    durationMs: number;\n  };\n  failed: FailedTest[];\n};\n\nexport type FailedTest = {\n  name: string;\n  file: string;\n  error: string;\n};\n\nexport type ManagerStatus = {\n  ready: boolean;\n  running: boolean;\n  lastRunAt: string | null;\n};\n\ntype QueueEntry = {\n  task: () => Promise<RunResult>;\n  resolve: (result: RunResult) => void;\n  reject: (error: unknown) => void;\n};\n\nexport class DevVitestManager {\n  private vitest: Vitest | null = null;\n  private running = false;\n  private lastRunAt: string | null = null;\n  private queue: QueueEntry[] = [];\n  private processing = false;\n  private closed = false;\n\n  async start(vitestConfigPath?: string): Promise<void> {\n    // 이미 시작된 경우 중복 초기화를 방지\n    if (this.vitest) {\n      return;\n    }\n\n    const { createVitest } = await import(\"vitest/node\");\n\n    const viteOverrides: ViteUserConfig = {\n      server: { watch: null },\n    };\n\n    const cliOptions: CliOptions = {\n      watch: true,\n      standalone: true,\n      forceRerunTriggers: [],\n      config: vitestConfigPath,\n      env: {\n        NODE_ENV: \"test\",\n      },\n    };\n\n    this.vitest = await createVitest(\"test\", cliOptions, viteOverrides);\n    await this.vitest.init();\n\n    this.vitest.onFilterWatchedSpecification((_spec) => false);\n    this.closed = false;\n  }\n\n  async run(opts: { files?: string[]; pattern?: string }): Promise<RunResult> {\n    if (this.closed) {\n      throw new Error(\"DevVitestManager is already shut down\");\n    }\n    if (!this.vitest) {\n      throw new Error(\"DevVitestManager is not started\");\n    }\n\n    return new Promise<RunResult>((resolve, reject) => {\n      const task = () => this.executeRun(opts);\n      this.queue.push({ task, resolve, reject });\n      this.processQueue();\n    });\n  }\n\n  getStatus(): ManagerStatus {\n    return {\n      ready: this.vitest !== null && !this.closed,\n      running: this.running,\n      lastRunAt: this.lastRunAt,\n    };\n  }\n\n  async shutdown(): Promise<void> {\n    if (this.closed) {\n      return;\n    }\n    this.closed = true;\n\n    // 큐에 남은 작업들을 reject하여 호출자가 영구 대기하지 않도록 정리\n    while (this.queue.length > 0) {\n      const entry = this.queue.shift();\n      if (entry) {\n        entry.reject(new Error(\"DevVitestManager is being shut down\"));\n      }\n    }\n\n    if (this.vitest) {\n      await this.vitest.close();\n      this.vitest = null;\n    }\n  }\n\n  private async processQueue(): Promise<void> {\n    if (this.processing) {\n      return;\n    }\n    this.processing = true;\n\n    try {\n      while (this.queue.length > 0) {\n        const entry = this.queue.shift();\n        if (!entry) break;\n        if (this.closed) {\n          entry.reject(new Error(\"DevVitestManager is already shut down\"));\n          continue;\n        }\n\n        try {\n          const result = await entry.task();\n          entry.resolve(result);\n        } catch (err) {\n          entry.reject(err);\n        }\n      }\n    } finally {\n      this.processing = false;\n    }\n  }\n\n  private async executeRun(opts: { files?: string[]; pattern?: string }): Promise<RunResult> {\n    const vitest = this.vitest;\n    if (!vitest) {\n      throw new Error(\"DevVitestManager is not started\");\n    }\n\n    this.running = true;\n    const startTime = Date.now();\n\n    if (opts.pattern) {\n      vitest.setGlobalTestNamePattern(opts.pattern);\n    }\n\n    try {\n      const specs: TestSpecification[] = opts.files\n        ? await vitest.globTestSpecifications(opts.files)\n        : await vitest.globTestSpecifications();\n\n      const allTestsRun = !opts.files || opts.files.length === 0;\n      const runResult: TestRunResult = await vitest.runTestSpecifications(specs, allTestsRun);\n\n      const durationMs = Date.now() - startTime;\n      this.lastRunAt = new Date().toISOString();\n\n      const specModuleIds = new Set(specs.map((s) => s.moduleId));\n      return this.collectResults(runResult, durationMs, specModuleIds);\n    } finally {\n      if (opts.pattern) {\n        vitest.resetGlobalTestNamePattern();\n      }\n      this.running = false;\n    }\n  }\n\n  private collectResults(\n    runResult: TestRunResult,\n    durationMs: number,\n    specModuleIds: Set<string>,\n  ): RunResult {\n    let total = 0;\n    let passed = 0;\n    let failed = 0;\n    let skipped = 0;\n    const failedTests: FailedTest[] = [];\n\n    for (const testModule of runResult.testModules) {\n      if (!specModuleIds.has(testModule.moduleId)) continue;\n      this.collectFromModule(testModule, failedTests, (counts) => {\n        total += counts.total;\n        passed += counts.passed;\n        failed += counts.failed;\n        skipped += counts.skipped;\n      });\n    }\n\n    return {\n      ok: failed === 0,\n      summary: { total, passed, failed, skipped, durationMs },\n      failed: failedTests,\n    };\n  }\n\n  private collectFromModule(\n    testModule: TestModule,\n    failedTests: FailedTest[],\n    addCounts: (counts: { total: number; passed: number; failed: number; skipped: number }) => void,\n  ): void {\n    let total = 0;\n    let passed = 0;\n    let failed = 0;\n    let skipped = 0;\n\n    for (const testCase of testModule.children.allTests()) {\n      total++;\n      const result = testCase.result();\n\n      if (result.state === \"passed\") {\n        passed++;\n      } else if (result.state === \"failed\") {\n        failed++;\n        failedTests.push(this.extractFailedTest(testCase, testModule));\n      } else {\n        // pending/skipped 상태는 skipped로 집계\n        skipped++;\n      }\n    }\n\n    addCounts({ total, passed, failed, skipped });\n  }\n\n  private extractFailedTest(testCase: TestCase, testModule: TestModule): FailedTest {\n    const result = testCase.result();\n    let errorMessage = \"Unknown error\";\n\n    if (result.state === \"failed\" && result.errors.length > 0) {\n      const firstError = result.errors[0];\n      errorMessage = firstError.message ?? String(firstError);\n    }\n\n    return {\n      name: testCase.fullName,\n      file: testModule.moduleId,\n      error: errorMessage,\n    };\n  }\n}\n"],"names":["DevVitestManager","vitest","running","lastRunAt","queue","processing","closed","start","vitestConfigPath","createVitest","viteOverrides","server","watch","cliOptions","standalone","forceRerunTriggers","config","env","NODE_ENV","init","onFilterWatchedSpecification","_spec","run","opts","Error","Promise","resolve","reject","task","executeRun","push","processQueue","getStatus","ready","shutdown","length","entry","shift","close","result","err","startTime","Date","now","pattern","setGlobalTestNamePattern","specs","files","globTestSpecifications","allTestsRun","runResult","runTestSpecifications","durationMs","toISOString","specModuleIds","Set","map","s","moduleId","collectResults","resetGlobalTestNamePattern","total","passed","failed","skipped","failedTests","testModule","testModules","has","collectFromModule","counts","ok","summary","addCounts","testCase","children","allTests","state","extractFailedTest","errorMessage","errors","firstError","message","String","name","fullName","file","error"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonamu",
-  "version": "0.8.5",
+  "version": "0.8.6",
   "description": "Sonamu — TypeScript Fullstack API Framework",
   "keywords": [
     "typescript",
@@ -119,10 +119,10 @@
     "tsicli": "^1.0.5",
     "vite": "7.3.0",
     "vitest": "^4.0.10",
-    "@sonamu-kit/hmr-hook": "^0.4.1",
     "@sonamu-kit/hmr-runner": "^0.1.1",
     "@sonamu-kit/tasks": "^0.2.0",
-    "@sonamu-kit/ts-loader": "^2.1.3"
+    "@sonamu-kit/ts-loader": "^2.1.3",
+    "@sonamu-kit/hmr-hook": "^0.4.1"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.13",

package/src/skills/sonamu/SKILL.md

@@ -25,65 +25,21 @@ Sonamu 프레임워크로 프로젝트를 개발하기 위한 Claude Code skill
 
 ## 개발 흐름
 
-### 1. 프로젝트 생성
-```bash
-pnpm create sonamu [프로젝트명] --yes
-```
+**CRITICAL: 모든 개발은 반드시 `workflow.md`의 PHASE 0 → 7 순서를 따른다. 단계를 건너뛰거나 순서를 바꾸지 않는다.**
 
-### 2. Sonamu 링크 설정 (선택)
-**Skills 원본 동기화가 필요한 경우만** `pnpm-workspace.yaml`에 추가:
-```yaml
-overrides:
-  sonamu: link:../../sonamu/modules/sonamu
 ```
-> 이유: Skills sync, 로컬 Sonamu 변경사항 즉시 반영
-
-### 3. 의존성 설치 및 빌드
-프로젝트 루트에서:
-```bash
-pnpm install
-pnpm -r build
+PHASE 0: 프로젝트 초기화  (프로젝트 생성 + auth generate)
+PHASE 1: 엔티티 설계      (Auth 엔티티 확인 후 나머지 설계)
+PHASE 2: 엔티티 생성
+PHASE 3: 마이그레이션
+PHASE 4: Cone 생성     (LLM 사용 여부 사용자에게 확인 후 진행)
+PHASE 5: 스캐폴딩
+PHASE 6: 테스트 작성  (완료 후 Fixture 생성 여부 확인, LLM 사용 여부도 확인)
+PHASE 7: API 개발
+PHASE 8: Frontend 개발
 ```
-> 빌드 실패 시 → 4번 도커 먼저 실행 후 5번 dev 서버 올리고 재시도
-
-### 4. Docker 실행
-```bash
-cd packages/api
-pnpm docker:up
-```
-
-### 5. 개발 서버 실행
-```bash
-pnpm dev
-```
-> 3번 빌드가 실패했다면, dev 서버가 올라온 후 프로젝트 루트에서 `pnpm -r build` 재시도
-
-### 6. Auth 엔티티 생성 (별도 터미널)
-**dev 실행 중**에:
-```bash
-pnpm sonamu auth generate
-```
-> dev 모드에서 실행해야 types도 자동 생성됨
-
-### 7. Subset 확인
-Sonamu UI Entity 메뉴에서 subset 체크
-
-### 8. Migration
-```bash
-pnpm sonamu migrate run
-```
-
-### 9. Scaffolding
-Sonamu UI에서 Model/View Scaffolding 실행
-
-### 10. API 단위테스트
-```bash
-pnpm test:watch
-```
-
-### 11. 프론트엔드 개발
 
-**상세 내용:** `project-init.md` 참조
+**상세 내용:** `workflow.md` 참조
 
 ---
 

package/src/skills/sonamu/workflow.md

@@ -5,12 +5,79 @@ description: Sonamu 전체 개발 워크플로우. 엔티티 설계부터 Fronte
 
 # Sonamu 전체 개발 워크플로우
 
-사용자가 시스템 구축을 요청하면 다음 7단계로 진행한다.
+사용자가 시스템 구축을 요청하면 다음 9단계로 진행한다.
+
+**CRITICAL: 이 워크플로우는 반드시 순서대로 진행한다. 단계를 건너뛰거나 순서를 바꾸지 않는다.**
 
 **CRITICAL: 요구사항이 이미 제공된 경우에도 설계 및 비즈니스 로직은 반드시 사용자와 함께 확인한다.**
 요구사항 명세는 출발점일 뿐이다. Entity 구조, 관계, 필드, 상태 전이, 권한 규칙 등은 항상 사용자에게 질문하고 승인을 받아야 한다. 과거에 비슷한 요구사항을 받은 적이 있더라도 이번 프로젝트의 설계는 새로 확인한다.
 
-## 사용자 요청 → 완성까지 7단계
+## 사용자 요청 → 완성까지 9단계
+
+### PHASE 0: 프로젝트 초기화
+
+**목표:** 프로젝트 생성 및 better-auth 기반 엔티티 준비
+
+**참조 스킬:** project-init.md, create-sonamu.md, auth.md
+
+**절차:**
+
+1. **작업 경로 확인**
+   - 현재 디렉토리 또는 지정 디렉토리 확인
+   - `project-init.md` "0. 작업 경로 확인" 참조
+
+2. **프로젝트 생성**
+   ```bash
+   pnpm create sonamu [프로젝트명] --yes
+   ```
+   기존 프로젝트면 경로 확인 후 진행.
+
+3. **요구사항 문서화** (요구사항 제공 시)
+   - `.claude/skills/project/requirements.md` 작성
+   - `project-init.md` "요구사항 문서화" 참조
+
+4. **의존성 설치 및 빌드**
+   ```bash
+   pnpm install
+   pnpm -r build
+   ```
+   > 빌드 실패 시 → 5번 Docker 먼저 실행 후 6번 dev 서버 올리고 재시도
+
+5. **Docker 실행**
+   ```bash
+   cd packages/api
+   pnpm docker:up
+   ```
+
+6. **개발 서버 실행**
+   ```bash
+   pnpm dev
+   ```
+
+7. **Auth 엔티티 생성** (별도 터미널, dev 실행 중)
+   ```bash
+   cd packages/api
+   pnpm sonamu auth generate
+   ```
+   생성되는 엔티티: `User`, `Session`, `Account`, `Verification`
+   > dev 모드에서 실행해야 types 파일도 자동 생성됨
+
+8. **생성된 Auth 엔티티 확인**
+   - Sonamu UI (`http://localhost:34900/sonamu-ui`) → Entity 메뉴에서 4개 엔티티 확인
+   - **User 엔티티 필드 파악** (id 타입, 기본 제공 필드 목록)
+   - 이후 PHASE 1 엔티티 설계 시 User와의 관계를 고려해야 하므로 반드시 확인
+
+**완료 기준:**
+
+- [ ] 프로젝트 생성 완료
+- [ ] Docker 실행 중
+- [ ] dev 서버 실행 중
+- [ ] `pnpm sonamu auth generate` 완료
+- [ ] User, Session, Account, Verification 엔티티 확인 완료
+
+**다음 단계:** PHASE 1 엔티티 설계
+
+---
 
 ### PHASE 1: 엔티티 설계
 
@@ -18,6 +85,9 @@ description: Sonamu 전체 개발 워크플로우. 엔티티 설계부터 Fronte
 
 **참조 스킬:** entity-basic.md, entity-relations.md
 
+**CRITICAL: PHASE 0에서 생성된 Auth 엔티티(User, Session, Account, Verification)를 확인한 후 설계를 시작한다.**
+User 엔티티는 이미 생성되어 있으므로 중복 생성하지 않는다. 다른 엔티티에서 User를 참조하는 관계는 이미 존재하는 User 엔티티 구조에 맞춰 설계한다.
+
 **절차:**
 
 1. **비즈니스 플로우 작성**
@@ -218,11 +288,71 @@ pnpm dev  # 이 상태로 유지하면서 작업
 - [ ] Migration 오류 없이 완료
 - [ ] DB에 테이블 생성 확인 (psql 또는 DB UI)
 
-**다음 단계:** PHASE 4 스캐폴딩
+**다음 단계:** PHASE 4 Cone 생성
+
+---
+
+### PHASE 4: Cone 생성
+
+**목표:** Entity에 fixture 생성 가이드 메타데이터(cone) 부착
+
+**참조 스킬:** fixture-cli.md (고급: cone 메타데이터 섹션)
+
+**Cone이란?**
+각 Entity/Prop/Subset/Enum에 `cone` 메타데이터를 추가하여 fixture 생성 시 더 현실적인 테스트 데이터를 만들 수 있게 하는 기능이다. `note`, `fixtureGenerator`, `fixtureDefault`, `dataSource` 등의 속성으로 구성된다.
+
+**절차:**
+
+1. **LLM 사용 여부 확인**
+
+   사용자에게 묻는다:
+   > "Cone 메타데이터를 생성할게요. 요구사항 명세(`requirements.md`)를 참고하여 LLM이 각 필드에 맞는 설명과 faker 생성 로직을 자동으로 작성할 수 있습니다.
+   > LLM(Claude API)을 호출하여 생성하갬습니까?
+   > 1. 예 — AI가 요구사항 기반 상세 cone 생성 (ANTHROPIC_API_KEY 필요, 소량 과금)
+   > 2. 아니오 — faker 타입 매핑 기반 템플릿 cone 자동 생성 (API 키 불필요)"
+
+   **선택 1 — LLM 사용:**
+   ```bash
+   # 단일 Entity
+   pnpm sonamu cone gen [EntityId]
+
+   # 전체 Entity
+   pnpm sonamu cone gen --all
+
+   # 전체 재생성 (기존 덮어쓰기)
+   pnpm sonamu cone gen --all --regenerate
+
+   # 언어 지정 (기본: sonamu.config.ts의 i18n.defaultLocale)
+   pnpm sonamu cone gen --all --locale ko
+   ```
+   > ANTHROPIC_API_KEY가 없으면 에러 발생 → `sonamu.secret.ts` 또는 환경변수 설정 필요
+
+   **선택 2 — 템플릿 cone 사용:**
+   ```bash
+   # stub entity 시 이미 템플릿 cone이 생성되어 있음 (별도 작업 불필요)
+   # 필요 시 개별 Entity의 entity.json을 직접 편집
+   ```
+   > stub entity 실행 시 faker 타입 매핑 기반 기본 cone이 자동 생성된다.
+   > 나중에 `pnpm sonamu cone gen [EntityId]`로 AI 업그레이드 가능.
+
+2. **생성 결과 확인**
+   - 각 Entity의 `entity.json` → `cone` 필드 확인
+   - `note`: 필드 설명 및 fixture 생성 가이드
+   - `fixtureGenerator`: faker.js 표현식
+   - `dataSource`: BelongsToOne 관계 참조 전략
+   - 필요 시 직접 편집하여 커스터마이징
+
+**완료 기준:**
+
+- [ ] 모든 Entity의 `entity.json`에 cone 메타데이터 존재
+- [ ] BelongsToOne 관계 필드에 `dataSource` 설정 확인
+- [ ] LLM 사용 시 비용 확인 (콘솔 출력 참고)
+
+**다음 단계:** PHASE 5 스캐폴딩
 
 ---
 
-### PHASE 4: 스캐폴딩
+### PHASE 5: 스캐폴딩
 
 **목표:** Model, API, Frontend 코드 자동 생성
 
@@ -299,11 +429,11 @@ pnpm dev  # 이 상태로 유지하면서 작업
 - [ ] Relation이 있는 경우 ko.ts 키 추가 완료
 - [ ] types.ts nullable 필드 처리 완료
 
-**다음 단계:** PHASE 5 테스트 작성
+**다음 단계:** PHASE 6 테스트 작성
 
 ---
 
-### PHASE 5: 테스트 작성
+### PHASE 6: 테스트 작성
 
 **목표:** 업무 프로세스 기반 모듈 테스트 작성
 
@@ -406,11 +536,47 @@ pnpm dev  # 이 상태로 유지하면서 작업
 - [ ] 업무 시나리오 검증 완료
 - [ ] 모든 그룹 커밋 완료
 
-**다음 단계:** PHASE 6 API 개발
+**[사용자 확인] Fixture 생성**
+
+테스트 작성 완료 후 사용자에게 묻는다:
+
+> "Fixture 데이터를 생성할게요.
+> 테스트 DB에 현실적인 샘플 데이터를 체우면 확장성 테스트나 프론트엔드 개발에 도움이 됩니다.
+> Fixture를 생성하시갌습니까?
+> 1. 예 — Fixture 생성 진행
+> 2. 아니오 — PHASE 7 API 개발로 바로 진행"
+
+**예 선택 시 — Fixture 생성 방식 확인:**
+
+> "Fixture 데이터를 어떻게 생성할까요?
+> 1. LLM 사용 — `cone.note` 기반으로 Claude API가 현실적인 데이터 생성 (ANTHROPIC_API_KEY 필요)
+> 2. 템플릿 사용 — faker.js 기반 자동 생성 (API 키 불필요)"
+
+**LLM 사용 시:**
+```bash
+# 대화형 모드
+pnpm sonamu fixture gen
+
+# 또는 직접 지정
+pnpm sonamu fixture gen --include User,Post,Comment --count 10 --use-llm
+
+# 후 테스트 DB 동기화
+pnpm sonamu fixture sync
+```
+
+**템플릿 사용 시:**
+```bash
+pnpm sonamu fixture gen --include User,Post,Comment --count 10
+pnpm sonamu fixture sync
+```
+
+> fixture gen 세부 옵션 및 생성 전략은 `fixture-cli.md` 참조
+
+**다음 단계:** PHASE 7 API 개발
 
 ---
 
-### PHASE 6: API 개발
+### PHASE 7: API 개발
 
 **목표:** 요구사항에 따른 비즈니스 로직 API 구현
 
@@ -464,11 +630,11 @@ pnpm dev  # 이 상태로 유지하면서 작업
 - [ ] API 테스트 통과
 - [ ] Build 성공
 
-**다음 단계:** PHASE 7 Frontend 개발
+**다음 단계:** PHASE 8 Frontend 개발
 
 ---
 
-### PHASE 7: Frontend 개발
+### PHASE 8: Frontend 개발
 
 **목표:** 화면에서 실제 동작 확인
 
@@ -547,20 +713,29 @@ pnpm dev  # 이 상태로 유지하면서 작업
 
 ## 빠른 참조 테이블
 
-| 단계            | 예상 시간   | 핵심 명령어              | 핵심 스킬            |
-| --------------- | ----------- | ------------------------ | -------------------- |
-| 1. 설계         | 5-10분      | (대화)                   | entity-basic.md      |
-| 2. 생성         | 10-15분     | `stub entity`, `sync`    | entity-basic.md      |
-| 3. 마이그레이션 | 5분         | `migration:latest`       | migration.md         |
-| 4. 스캐폴딩     | 5-10분      | `scaffold`, `build`      | scaffolding.md       |
-| 5. 테스트       | 30-60분     | `test`, `test:watch`     | testing.md           |
-| **6. API 개발** | **1-3시간** | **@api 데코레이터**      | **api.md, model.md** |
-| **7. Frontend** | **2-5시간** | **Service, useTypeForm** | **frontend.md**      |
+| 단계                 | 예상 시간   | 핵심 명령어                   | 핵심 스킬                     |
+| -------------------- | ----------- | ----------------------------- | ----------------------------- |
+| **0. 프로젝트 초기화** | **5-10분** | **`create sonamu`, `auth generate`** | **project-init.md, auth.md** |
+| 1. 엔티티 설계       | 5-10분      | (대화)                        | entity-basic.md               |
+| 2. 엔티티 생성       | 10-15분     | `stub entity`, `sync`         | entity-basic.md               |
+| 3. 마이그레이션      | 5분         | `migration:latest`            | migration.md                  |
+| **4. Cone 생성**    | **5-10분** | **`cone gen`**                | **fixture-cli.md**            |
+| 5. 스캐폴딩          | 5-10분      | `scaffold`, `build`           | scaffolding.md                |
+| 6. 테스트            | 30-60분     | `test`, `test:watch`          | testing.md                    |
+| **7. API 개발**      | **1-3시간** | **@api 데코레이터**           | **api.md, model.md**          |
+| **8. Frontend**      | **2-5시간** | **Service, useTypeForm**      | **frontend.md**               |
 
 ---
 
 ## 각 단계의 완료 확인
 
+### PHASE 0 완료 시
+
+```
+프로젝트 초기화 완료 (Auth 엔티티 생성 포함)
+→ 다음: PHASE 1 엔티티 설계 (entity-basic.md)
+```
+
 ### PHASE 1 완료 시
 
 ```
@@ -579,32 +754,40 @@ pnpm dev  # 이 상태로 유지하면서 작업
 
 ```
 마이그레이션 완료
-→ 다음: PHASE 4 스캐폴딩 (scaffolding.md)
+→ 다음: PHASE 4 Cone 생성 (fixture-cli.md)
 ```
 
 ### PHASE 4 완료 시
 
 ```
-스캐폴딩 완료
-→ 다음: PHASE 5 테스트 작성 (testing.md)
+Cone 생성 완료
+→ 다음: PHASE 5 스캐폴딩 (scaffolding.md)
 ```
 
 ### PHASE 5 완료 시
 
 ```
-테스트 작성 완료
-→ 다음: PHASE 6 API 개발 (api.md)
+스ce90폴딩 완료
+→ 다음: PHASE 6 테스트 작성 (testing.md)
 ```
 
 ### PHASE 6 완료 시
 
 ```
-API 개발 완료
-→ 다음: PHASE 7 Frontend 개발 (frontend.md)
+테스트 작성 완료
+[사용자 확인] Fixture 생성 여부 확인 원스톱
+→ 다음: PHASE 7 API 개발 (api.md)
 ```
 
 ### PHASE 7 완료 시
 
+```
+API 개발 완료
+→ 다음: PHASE 8 Frontend 개발 (frontend.md)
+```
+
+### PHASE 8 완료 시
+
 ```
 Frontend 개발 완료
 전체 워크플로우 완료

package/src/testing/dev-vitest-manager.ts

@@ -104,6 +104,14 @@ export class DevVitestManager {
     }
     this.closed = true;
 
+    // 큐에 남은 작업들을 reject하여 호출자가 영구 대기하지 않도록 정리
+    while (this.queue.length > 0) {
+      const entry = this.queue.shift();
+      if (entry) {
+        entry.reject(new Error("DevVitestManager is being shut down"));
+      }
+    }
+
     if (this.vitest) {
       await this.vitest.close();
       this.vitest = null;