sonamu 0.8.24 → 0.8.26

package/src/skills/sonamu/i18n.md

@@ -1,11 +1,11 @@
 ---
 name: sonamu-i18n
-description: Sonamu 다국어(i18n) 지원. 딕셔너리 설정, SD 함수 사용, 헬퍼 함수. Use when implementing internationalization.
+description: Sonamu internationalization (i18n) support. Dictionary configuration, SD function usage, helper functions. Use when implementing internationalization.
 ---
 
-# i18n (다국어 지원)
+# i18n (Internationalization)
 
-## 설정
+## Configuration
 
 `sonamu.config.ts`:
 
@@ -19,18 +19,18 @@ export default defineConfig({
 });
 ```
 
-## 파일 구조
+## File Structure
 
 ```
 packages/api/src/i18n/
-├── ko.ts           # 기본 locale (defaultLocale)
-├── en.ts           # 추가 locale
-└── sd.generated.ts # 자동 생성 (pnpm sync)
+├── ko.ts           # Default locale (defaultLocale)
+├── en.ts           # Additional locale
+└── sd.generated.ts # Auto-generated (pnpm sync)
 ```
 
-## 딕셔너리 파일
+## Dictionary Files
 
-### 기본 locale (ko.ts)
+### Default locale (ko.ts)
 
 ```typescript
 import { createFormat, josa } from "sonamu/dict";
@@ -46,7 +46,7 @@ export default {
 } as const;
 ```
 
-### 추가 locale (en.ts)
+### Additional locale (en.ts)
 
 ```typescript
 import { plural } from "sonamu/dict";
@@ -61,51 +61,51 @@ export default defineLocale({
 });
 ```
 
-## SD 함수 사용
+## Using the SD Function
 
-### 기본 사용
+### Basic Usage
 
 ```typescript
 import { SD } from "@/i18n/sd.generated";
 
-// 단순 문자열
+// Simple string
 SD("common.save");  // → "저장" (ko) / "Save" (en)
 
-// 함수형 (파라미터)
+// Function form (with parameters)
 SD("validation.required")("이메일");  // → "이메일은 필수입니다"
 SD("common.results")(5);  // → "5개 결과" (ko) / "5 results" (en)
 ```
 
-### 특정 locale 강제
+### Force a Specific Locale
 
 ```typescript
 const EN = SD.locale("en");
-EN("common.save");  // → "Save" (항상 영어)
+EN("common.save");  // → "Save" (always English)
 ```
 
-### Enum 라벨
+### Enum Labels
 
 ```typescript
-// entity.json에 정의된 enum 라벨
+// Enum labels defined in entity.json
 SD.enumLabels("ProjectStatus")["in_progress"];  // → "진행중"
 ```
 
-## 헬퍼 함수
+## Helper Functions
 
-### plural (복수형)
+### plural (pluralization)
 
 ```typescript
 import { plural } from "sonamu/dict";
 
-// 영어에서 단수/복수 처리
+// Handle singular/plural in English
 plural(count, {
   zero: "No items",     // count === 0
   one: "1 item",        // count === 1
-  other: `${count} items`,  // 그 외
+  other: `${count} items`,  // everything else
 });
 ```
 
-### josa (한국어 조사)
+### josa (Korean postposition helper)
 
 ```typescript
 import { josa } from "sonamu/dict";
@@ -117,7 +117,7 @@ josa("회사", "과와");    // → "회사와"
 josa("서울", "으로");    // → "서울로"
 ```
 
-### createFormat (숫자/날짜 포맷)
+### createFormat (number/date formatting)
 
 ```typescript
 import { createFormat } from "sonamu/dict";
@@ -127,17 +127,17 @@ format.number(1234567);  // → "1,234,567"
 format.date(new Date()); // → "2024. 1. 15."
 ```
 
-## Entity 연동
+## Entity Integration
 
-Entity의 title, prop desc, enum label이 자동으로 딕셔너리에 포함됨.
+Entity title, prop descriptions, and enum labels are automatically included in the dictionary.
 
 ```
-entity.{EntityId}              → Entity 타이틀
-entity.{EntityId}.{propName}   → 속성 설명
-enum.{EnumId}.{value}          → Enum 값 라벨
+entity.{EntityId}              → Entity title
+entity.{EntityId}.{propName}   → Property description
+enum.{EnumId}.{value}          → Enum value label
 ```
 
-예시:
+Example:
 ```typescript
 SD("entity.User");           // → "사용자"
 SD("entity.User.email");     // → "이메일"
@@ -146,7 +146,7 @@ SD("enum.UserRole.admin");   // → "관리자"
 
 ## localizedColumn
 
-DB에 locale별 컬럼이 있을 때 현재 locale에 맞는 값 반환:
+Returns the value for the current locale when locale-specific columns exist in the DB:
 
 ```typescript
 import { localizedColumn } from "@/i18n/sd.generated";
@@ -155,98 +155,98 @@ import { localizedColumn } from "@/i18n/sd.generated";
 localizedColumn(tag, "name");  // → "태그" (ko) / "Tag" (en)
 ```
 
-## Sonamu UI 관리
+## Sonamu UI Management
 
-`http://localhost:34900/sonamu-ui` → i18n 탭에서:
-- 딕셔너리 조회/수정
-- 키 추가/삭제
+`http://localhost:34900/sonamu-ui` → i18n tab:
+- Browse/edit dictionary
+- Add/delete keys
 - Excel import/export
-- 미사용 키 검사
+- Detect unused keys
 
-## 키 네이밍 규칙
+## Key Naming Conventions
 
-| 패턴 | 용도 | 예시 |
-|------|------|------|
-| `common.*` | 공통 UI 텍스트 | `common.save`, `common.cancel` |
-| `error.*` | 에러 메시지 | `error.notFound`, `error.forbidden` |
-| `validation.*` | 유효성 검사 | `validation.required`, `validation.email` |
-| `entity.*` | Entity 관련 | `entity.User`, `entity.User.email` |
-| `enum.*` | Enum 라벨 | `enum.UserRole.admin` |
-| `menu.*` | 메뉴/네비게이션 | `menu.home`, `menu.settings` |
-| `rc.*` | react-components 내장 | `rc.pagination.next` |
+| Pattern | Purpose | Example |
+|---------|---------|---------|
+| `common.*` | Common UI text | `common.save`, `common.cancel` |
+| `error.*` | Error messages | `error.notFound`, `error.forbidden` |
+| `validation.*` | Validation messages | `validation.required`, `validation.email` |
+| `entity.*` | Entity-related | `entity.User`, `entity.User.email` |
+| `enum.*` | Enum labels | `enum.UserRole.admin` |
+| `menu.*` | Menu/navigation | `menu.home`, `menu.settings` |
+| `rc.*` | react-components built-in | `rc.pagination.next` |
 
-## 트러블슈팅
+## Troubleshooting
 
-### LocalizedString 타입 오류
+### LocalizedString Type Error
 
-`Type 'string' is not assignable to type '{ __brand: "LocalizedString"; }'` 오류가 발생하는 경우:
+When you see `Type 'string' is not assignable to type '{ __brand: "LocalizedString"; }'`:
 
-**원인 1: ko.ts에 i18n 키 누락**
+**Cause 1: Missing i18n key in ko.ts**
 ```typescript
-// 잘못된 예: ko.ts에 키가 없으면 타입 오류
-SD("validation.password");  // 키가 ko.ts에 없음
+// Wrong: type error when key is missing from ko.ts
+SD("validation.password");  // key not in ko.ts
 ```
 
-해결: ko.ts에 키 추가 후 `pnpm sync`
+Fix: Add the key to ko.ts and run `pnpm sync`
 
-**원인 2: 모델에서 SD() 미사용**
+**Cause 2: Not using SD() in the model**
 ```typescript
-// 잘못된 예: 문자열 직접 사용
+// Wrong: using a raw string directly
 throw new BadRequestException("이메일이 잘못되었습니다");
 
-// 올바른 예: SD() 함수 사용
+// Correct: use the SD() function
 throw new BadRequestException(SD("error.invalidEmail"));
 ```
 
-모든 사용자 노출 문자열은 반드시 SD() 함수로 감싸야 합니다.
+All user-facing strings must be wrapped with the SD() function.
 
 ---
 
-## 타입 안정성
+## Type Safety
 
-### String PK 지원
+### String PK Support
 
-Entity가 String PK를 사용하는 경우 i18n 함수 타입도 이를 반영해야 합니다.
+When an Entity uses a String PK, the i18n function types must reflect this.
 
-**BAD: Number만 지원**
+**BAD: Number only**
 ```typescript
 // ko.ts
 notFound: (name: string, id: number) => `존재하지 않는 ${name} ID ${id}`,
 
-// String PK 엔티티에서 타입 오류 발생
-// Account, Session, User, Verification 등
+// Type error when used with String PK entities
+// Account, Session, User, Verification, etc.
 throw new NotFoundException(SD("notFound")(this.modelName, id));
 // Error: Argument of type 'string' is not assignable to parameter of type 'number'
 ```
 
-**GOOD: Union 타입으로 둘 다 지원**
+**GOOD: Support both with a union type**
 ```typescript
 // ko.ts
 notFound: (name: string, id: number | string) => `존재하지 않는 ${name} ID ${id}`,
 
-// Number PK, String PK 모두 사용 가능
+// Works for both Number PK and String PK
 throw new NotFoundException(SD("notFound")(this.modelName, id));
 ```
 
-**적용 대상 i18n 키:**
-- `notFound`: Entity 조회 실패
-- `error.entityNotFound`: 구체적인 엔티티 조회 실패 (deprecated, notFound 사용 권장)
+**Applicable i18n keys:**
+- `notFound`: Entity lookup failure
+- `error.entityNotFound`: Specific entity lookup failure (deprecated, prefer `notFound`)
 
-### 네임스페이스별 타입 패턴
+### Type Patterns by Namespace
 
-| i18n 키 | 파라미터 타입 | 용도 |
-|---------|--------------|------|
-| `notFound` | `(name: string, id: number \| string)` | Entity 조회 실패 |
-| `search.invalidField` | `(field: string)` | 잘못된 검색 필드 |
-| `validation.required` | `(field: string)` | 필수 필드 검증 |
-| `validation.maxLength` | `(field: string, max: number)` | 최대 길이 검증 |
-| `validation.minLength` | `(field: string, min: number)` | 최소 길이 검증 |
-| `entity.create` | `(name: string)` | Entity 생성 화면 |
-| `entity.edit` | `(name: string, id: number \| string)` | Entity 수정 화면 |
+| i18n key | Parameter type | Purpose |
+|---------|----------------|---------|
+| `notFound` | `(name: string, id: number \| string)` | Entity lookup failure |
+| `search.invalidField` | `(field: string)` | Invalid search field |
+| `validation.required` | `(field: string)` | Required field validation |
+| `validation.maxLength` | `(field: string, max: number)` | Max length validation |
+| `validation.minLength` | `(field: string, min: number)` | Min length validation |
+| `entity.create` | `(name: string)` | Entity creation screen |
+| `entity.edit` | `(name: string, id: number \| string)` | Entity edit screen |
 
-### PK 타입 확인 방법
+### How to Check PK Type
 
-Entity 파일에서 id 필드 타입을 확인:
+Check the id field type in the Entity file:
 
 ```json
 // String PK
@@ -256,7 +256,7 @@ Entity 파일에서 id 필드 타입을 확인:
   }
 }
 
-// Number PK (기본값)
+// Number PK (default)
 {
   "props": {
     "id": { "type": "int", "autoIncrement": true }
@@ -264,7 +264,7 @@ Entity 파일에서 id 필드 타입을 확인:
 }
 ```
 
-**KOPRI 프로젝트의 String PK 엔티티:**
+**String PK entities in the KOPRI project:**
 - Account
 - Session
 - User

package/src/skills/sonamu/migration.md

@@ -1,51 +1,51 @@
 ---
 name: sonamu-migration
-description: Sonamu 데이터베이스 마이그레이션. CREATE/ALTER TABLE, FK 순서, up/down 함수. Use when modifying database schema.
+description: Sonamu database migration. CREATE/ALTER TABLE, FK ordering, up/down functions. Use when modifying database schema.
 ---
 
 # Migration
 
-## CRITICAL: Migration은 Sonamu UI 또는 CLI로 생성한다
+## CRITICAL: Migrations are generated via Sonamu UI or CLI
 
-**Migration 파일을 직접 작성하거나 SQL을 직접 실행하지 않는다.** Sonamu가 entity.json 변경사항을 감지하여 정확한 migration 파일을 생성해준다.
+**Do not write migration files manually or execute SQL directly.** Sonamu detects entity.json changes and generates accurate migration files.
 
-**사전 준비:**
-- `/packages/api`에서 `pnpm dev` 실행 중이어야 함
+**Prerequisites:**
+- `pnpm dev` must be running in `/packages/api`
 
-**방법 1: Sonamu UI (사용자에게 확인 후 선택)**
-1. 브라우저에서 Sonamu UI 접속: `http://localhost:34900/sonamu-ui`
-2. Migration 메뉴에서 prepared 리스트 확인
-3. "Generate" 버튼으로 migration 파일 생성
-4. "Apply" 버튼으로 실제 DB에 적용
+**Method 1: Sonamu UI (confirm with user before choosing)**
+1. Open Sonamu UI in browser: `http://localhost:34900/sonamu-ui`
+2. Check the prepared list in the Migration menu
+3. Generate a migration file with the "Generate" button
+4. Apply to the actual DB with the "Apply" button
 
-**방법 2: CLI**
+**Method 2: CLI**
 ```bash
 cd packages/api
-pnpm sonamu migrate generate   # migration 파일 생성
-pnpm sonamu migrate run         # 실제 DB에 적용
+pnpm sonamu migrate generate   # Generate migration file
+pnpm sonamu migrate run         # Apply to actual DB
 ```
 
-**CRITICAL: 사용자에게 UI와 CLI 중 어떤 방식으로 진행할지 물어본 후 진행한다.**
+**CRITICAL: Ask the user whether to proceed with UI or CLI before starting.**
 
 **DO NOT:**
-- Migration 파일을 수동으로 작성
-- `CREATE TABLE`, `ALTER TABLE` 등 SQL을 직접 실행
+- Write migration files manually
+- Execute SQL directly (`CREATE TABLE`, `ALTER TABLE`, etc.)
 
-**예외:** PK 타입 변경 등 Sonamu가 자동 처리할 수 없는 특수 케이스만 raw SQL 허용 (아래 "PK 타입 변경" 섹션 참조)
+**Exception:** Only raw SQL is allowed for special cases that Sonamu cannot handle automatically, such as PK type changes (see "PK Type Change" section below)
 
-**CRITICAL: Cross-table 연쇄 변경은 단일 파일로 처리한다.** FK drop → 타입 변경 → FK restore처럼 여러 테이블에 걸친 연쇄 변경은 반드시 하나의 migration 파일 안에서 순서대로 실행해야 한다. 파일을 나누면 중간 상태에서 constraint 위반이 발생한다. (상세: 아래 "PK 타입 변경" 섹션 참조)
+**CRITICAL: Handle cross-table cascading changes in a single file.** Cascading changes across multiple tables — such as FK drop → type change → FK restore — must be executed in order within a single migration file. Splitting into separate files causes constraint violations in intermediate states. (Details: see "PK Type Change" section below)
 
-## 기본 구조
+## Basic Structure
 
 ```typescript
 import type { Knex } from "knex";
 
 export async function up(knex: Knex): Promise<void> {
-  // 변경 적용
+  // Apply changes
 }
 
 export async function down(knex: Knex): Promise<void> {
-  // 변경 롤백
+  // Rollback changes
 }
 ```
 
@@ -71,14 +71,14 @@ export async function down(knex: Knex): Promise<void> {
 ## ALTER TABLE
 
 ```typescript
-// 컬럼 추가
+// Add column
 export async function up(knex: Knex): Promise<void> {
   await knex.schema.alterTable("users", (table) => {
     table.string("phone", 20).nullable();
   });
 }
 
-// 컬럼 삭제
+// Drop column
 export async function down(knex: Knex): Promise<void> {
   await knex.schema.alterTable("users", (table) => {
     table.dropColumns("phone");
@@ -104,100 +104,100 @@ export async function down(knex: Knex): Promise<void> {
 }
 ```
 
-## PK 타입 변경
+## PK Type Change
 
-### 상황
-기존 테이블의 PK 타입을 변경해야 하는 경우 (예: integer -> text, bigint -> uuid 등). 해당 PK를 참조하는 FK들이 여러 테이블에 존재하는 상황.
+### Situation
+When the PK type of an existing table must be changed (e.g. integer -> text, bigint -> uuid), with FKs referencing that PK in multiple tables.
 
-### 필수 순서
+### Required Order
 
-참조 무결성이 있는 컬럼(FK가 참조하는 PK)의 타입을 변경할 때는 반드시 다음 순서를 따라야 함:
+When changing the type of a column that has referential integrity (a PK referenced by FKs), the following order must be followed:
 
 ```typescript
 export async function up(knex: Knex): Promise<void> {
-  // 1단계: 해당 PK를 참조하는 모든 FK constraint DROP
+  // Step 1: DROP all FK constraints referencing this PK
   await knex.raw('ALTER TABLE "child_table_1" DROP CONSTRAINT "child_table_1_parent_id_foreign"');
   await knex.raw('ALTER TABLE "child_table_2" DROP CONSTRAINT "child_table_2_parent_id_foreign"');
 
-  // 2단계: PK constraint DROP
+  // Step 2: DROP the PK constraint
   await knex.raw('ALTER TABLE "parent_table" DROP CONSTRAINT "parent_table_pkey"');
 
-  // 3단계: PK 컬럼과 모든 FK 컬럼의 타입을 동시에 변경
+  // Step 3: Change types of the PK column and all FK columns simultaneously
   await knex.raw('ALTER TABLE "parent_table" ALTER COLUMN "id" TYPE new_type USING "id"::new_type');
   await knex.raw('ALTER TABLE "child_table_1" ALTER COLUMN "parent_id" TYPE new_type USING "parent_id"::new_type');
   await knex.raw('ALTER TABLE "child_table_2" ALTER COLUMN "parent_id" TYPE new_type USING "parent_id"::new_type');
 
-  // 4단계: PK constraint ADD
+  // Step 4: ADD the PK constraint
   await knex.raw('ALTER TABLE "parent_table" ADD CONSTRAINT "parent_table_pkey" PRIMARY KEY ("id")');
 
-  // 5단계: 모든 FK constraint ADD
+  // Step 5: ADD all FK constraints
   await knex.raw('ALTER TABLE "child_table_1" ADD CONSTRAINT "child_table_1_parent_id_foreign" FOREIGN KEY ("parent_id") REFERENCES "parent_table"("id") ON UPDATE RESTRICT ON DELETE CASCADE');
   await knex.raw('ALTER TABLE "child_table_2" ADD CONSTRAINT "child_table_2_parent_id_foreign" FOREIGN KEY ("parent_id") REFERENCES "parent_table"("id") ON UPDATE RESTRICT ON DELETE RESTRICT');
 }
 ```
 
-### 핵심 원칙
+### Core Principles
 
-1. **FK constraint가 존재하는 상태에서는 참조 컬럼 타입 변경 불가**: PostgreSQL은 FK와 참조되는 PK의 타입이 일치하지 않으면 에러 발생. 반드시 constraint를 먼저 제거해야 함.
+1. **Cannot change the type of a referenced column while FK constraints exist**: PostgreSQL throws an error if the types of the FK and referenced PK do not match. Constraints must be removed first.
 
-2. **하나의 migration에서 모든 변경 처리**: 여러 migration으로 나누면 중간 상태에서 constraint 위반. PK와 모든 FK의 타입 변경을 한 번에 수행.
+2. **Handle all changes in a single migration**: Splitting into multiple migrations causes constraint violations in intermediate states. Change the types of the PK and all FKs in one go.
 
-3. **knex schema builder 대신 raw SQL 사용 권장**: 명확한 실행 순서 보장, constraint 이름 명시 가능, 복잡한 타입 변환(USING) 지원.
+3. **Prefer raw SQL over the knex schema builder**: Guarantees clear execution order, allows explicit constraint naming, and supports complex type conversions (USING).
 
-### 실제 예시: users.id integer -> text
+### Real Example: users.id integer -> text
 
 ```typescript
 export async function up(knex: Knex): Promise<void> {
-  // 1. FK 제약조건 제거
+  // 1. Remove FK constraints
   await knex.raw('ALTER TABLE "accounts" DROP CONSTRAINT "accounts_user_id_foreign"');
   await knex.raw('ALTER TABLE "sessions" DROP CONSTRAINT "sessions_user_id_foreign"');
 
-  // 2. PK 제약조건 제거
+  // 2. Remove PK constraint
   await knex.raw('ALTER TABLE "users" DROP CONSTRAINT "users_pkey"');
 
-  // 3. 타입 변경 (USING 절로 변환 명시)
+  // 3. Change types (explicit conversion with USING clause)
   await knex.raw('ALTER TABLE "users" ALTER COLUMN "id" TYPE text USING "id"::text');
   await knex.raw('ALTER TABLE "accounts" ALTER COLUMN "user_id" TYPE text USING "user_id"::text');
   await knex.raw('ALTER TABLE "sessions" ALTER COLUMN "user_id" TYPE text USING "user_id"::text');
 
-  // 4. PK 제약조건 복구
+  // 4. Restore PK constraint
   await knex.raw('ALTER TABLE "users" ADD CONSTRAINT "users_pkey" PRIMARY KEY ("id")');
 
-  // 5. FK 제약조건 복구
+  // 5. Restore FK constraints
   await knex.raw('ALTER TABLE "accounts" ADD CONSTRAINT "accounts_user_id_foreign" FOREIGN KEY ("user_id") REFERENCES "users"("id") ON UPDATE RESTRICT ON DELETE CASCADE');
   await knex.raw('ALTER TABLE "sessions" ADD CONSTRAINT "sessions_user_id_foreign" FOREIGN KEY ("user_id") REFERENCES "users"("id") ON UPDATE RESTRICT ON DELETE CASCADE');
 }
 ```
 
-### FK 참조 테이블 찾기
+### Finding FK Reference Tables
 
 ```bash
-# Entity에서 특정 엔티티를 참조하는 relation 찾기
+# Find relations referencing a specific entity in entity files
 grep -r "with.*User" --include="*.entity.json"
 ```
 
-### 흔한 실수
+### Common Mistakes
 
-1. **여러 migration으로 분리**: FK drop, 타입 변경, FK restore를 별도 파일로 나누면 첫 번째 파일 apply 직후 constraint 위반. 관련 변경은 항상 단일 파일로 통합할 것.
+1. **Splitting into multiple migrations**: Separating FK drop, type change, and FK restore into separate files causes a constraint violation immediately after the first file is applied. Always consolidate related changes into a single file.
 
-2. **constraint 제거 없이 타입 변경**: `cannot alter type of a column used by a foreign key` 에러 발생
+2. **Changing type without removing constraint**: Causes `cannot alter type of a column used by a foreign key` error
 
-3. **USING 절 누락**: `column "id" cannot be cast automatically to type text` 에러 발생. integer -> text는 `USING "id"::text` 필수.
+3. **Missing USING clause**: Causes `column "id" cannot be cast automatically to type text` error. `USING "id"::text` is required for integer -> text.
 
-4. **constraint 이름 불일치**: `SELECT constraint_name FROM information_schema.table_constraints WHERE table_name = 'accounts'`로 정확한 constraint 이름 확인 필요.
+4. **Constraint name mismatch**: Verify the exact constraint name with `SELECT constraint_name FROM information_schema.table_constraints WHERE table_name = 'accounts'`.
 
-## 명령어
+## Commands
 
-**`packages/api`** 디렉토리에서 실행:
+Run from the **`packages/api`** directory:
 
 ```bash
 cd packages/api
-pnpm sonamu migrate run      # 로컬 DB에 모든 Migration 실행
-pnpm sonamu migrate status   # 상태 확인
-pnpm sonamu migrate apply    # 특정 DB 설정 대상으로 적용
+pnpm sonamu migrate run      # Run all pending migrations on local DB
+pnpm sonamu migrate status   # Check migration status
+pnpm sonamu migrate apply    # Apply to a specific DB configuration target
 ```
 
-**주의**: `migrate up`, `migrate rollback`은 CLI에서 제공하지 않음. Sonamu UI에서 롤백 가능.
+**Note**: `migrate up` and `migrate rollback` are not provided in the CLI. Rollback is available from Sonamu UI.
 
 ## Entity Type → DB Type
 
@@ -223,13 +223,13 @@ pnpm sonamu migrate apply    # 특정 DB 설정 대상으로 적용
 | `vector[]` | `vector(n)[]` | `table.specificType(name, 'vector(n)[]')` |
 | `tsvector` | `tsvector` | `table.specificType(name, 'tsvector')` |
 
-## 실행 순서 (중요!)
+## Execution Order (Important!)
 
 ```
-1. CREATE TABLE companies       (의존성 없음)
-2. CREATE TABLE departments     (company_id 컬럼만)
-3. CREATE TABLE users           (의존성 없음)
-4. CREATE TABLE employees       (user_id, department_id 컬럼만)
+1. CREATE TABLE companies       (no dependencies)
+2. CREATE TABLE departments     (company_id column only)
+3. CREATE TABLE users           (no dependencies)
+4. CREATE TABLE employees       (user_id, department_id columns only)
 5. FOREIGN KEY departments      (company_id → companies.id)
 6. FOREIGN KEY employees        (user_id → users.id, etc.)
 ```
@@ -244,50 +244,50 @@ pnpm sonamu migrate apply    # 특정 DB 설정 대상으로 적용
 
 ### 1. MUST Build dist First
 
-sync 명령은 `dist/sonamu.config.js`를 참조합니다. 없으면 오류 발생.
+The sync command references `dist/sonamu.config.js`. An error will occur if it does not exist.
 
 ```bash
 cd packages/api
 npx swc src/sonamu.config.ts -o dist/sonamu.config.js --config-file .swcrc
 ```
 
-### 2. DB 연결 확인
+### 2. Verify DB Connection
 
 ```bash
-# Docker 컨테이너 확인
+# Check Docker containers
 docker ps | grep container
 
-# sonamu.config.ts에서 DB 설정 확인
+# Check DB configuration in sonamu.config.ts
 # - host, port, database, user, password
-# - PostgreSQL vs MySQL 구분
+# - Distinguish PostgreSQL vs MySQL
 ```
 
-### 3. 순환 참조 시
+### 3. Circular References
 
-마이그레이션을 분리하거나, FK를 nullable로 설정 후 나중에 추가.
+Split the migration, or set the FK to nullable and add it later.
 
-## 전체 워크플로우
+## Full Workflow
 
 ```bash
 cd packages/api
 
-# 1. config 빌드
+# 1. Build config
 npx swc src/sonamu.config.ts -o dist/sonamu.config.js --config-file .swcrc
 
-# 2. sync 실행
+# 2. Run sync
 pnpm sonamu sync
 
-# 3. Sonamu UI에서 마이그레이션 생성/실행
+# 3. Generate/run migration from Sonamu UI
 
-# 4. 스캐폴딩 실행
+# 4. Run scaffolding
 
-# 5. model orderBy 케이스 확인/추가 (model.md 참조)
+# 5. Check/add orderBy cases in model (see model.md)
 
-# 6. API 빌드
+# 6. Build API
 npm run build
 
-# 7. Web form 확인/수정 (frontend.md 참조)
+# 7. Check/fix web form (see frontend.md)
 
-# 8. Web 빌드
+# 8. Build web
 cd ../web && npm run build
 ```