sonamu 0.8.24 → 0.8.26

package/src/skills/sonamu/upsert.md

@@ -1,94 +1,94 @@
 ---
 name: sonamu-upsert
-description: Sonamu UpsertBuilder로 복잡한 관계 데이터 저장. ubRegister, ubUpsert, insertOnly, updateBatch 패턴, FK 순서, cleanOrphans. Use when saving related data with foreign key dependencies.
+description: Saving complex relational data with Sonamu UpsertBuilder. ubRegister, ubUpsert, insertOnly, updateBatch patterns, FK ordering, cleanOrphans. Use when saving related data with foreign key dependencies.
 ---
 
 # UpsertBuilder
 
-## UBRef 타입
+## UBRef Type
 
-`ubRegister()`가 반환하는 참조 객체:
+The reference object returned by `ubRegister()`:
 
 ```typescript
 type UBRef = {
-  uuid: string;   // 고유 식별자
-  of: string;     // 테이블명
-  use?: string;   // 참조할 필드 (기본값: "id")
+  uuid: string;   // unique identifier
+  of: string;     // table name
+  use?: string;   // field to reference (default: "id")
 };
 ```
 
-## 기본 패턴
+## Basic Pattern
 
 ```typescript
 const wdb = this.getPuri("w");
 
-// 데이터 등록 (UBRef 반환)
+// Register data (returns UBRef)
 const userRef = wdb.ubRegister("users", { email: "john@test.com", username: "john" });
 
-// 관계 데이터에 UBRef 사용
+// Use UBRef in related data
 wdb.ubRegister("employees", { user_id: userRef, department_id: deptId });
 
-// 트랜잭션 내에서 순서대로 저장
+// Save in order inside a transaction
 return wdb.transaction(async (trx) => {
-  await trx.ubUpsert("users");       // 먼저 저장 (FK 참조됨)
-  return trx.ubUpsert("employees");  // 나중에 저장 (FK 사용)
+  await trx.ubUpsert("users");       // Save first (referenced by FK)
+  return trx.ubUpsert("employees");  // Save after (uses FK)
 });
 ```
 
-## CRITICAL: 필수 필드 포함 필수
+## CRITICAL: All Required Fields Must Be Included
 
-**ubUpsert는 PostgreSQL의 `ON CONFLICT ... DO UPDATE` 쿼리를 사용합니다.**
+**ubUpsert uses PostgreSQL's `ON CONFLICT ... DO UPDATE` query.**
 
-업데이트 시에도 **모든 필수 필드(NOT NULL 제약이 있는 필드)**를 포함해야 합니다.
+Even when updating, **all required fields (fields with NOT NULL constraints)** must be included.
 
 ```typescript
-// BAD - 필수 필드 누락
+// BAD - missing required field
 wdb.ubRegister("posts", {
   id: 1,
   title: "Updated Title",
-  // content 필수 필드 누락! → ON CONFLICT UPDATE 시 NULL 설정 시도 → DB 에러
+  // content required field missing! → ON CONFLICT UPDATE tries to set NULL → DB error
 });
 // Error: null value in column "content" violates not-null constraint
 
-// GOOD - 모든 필수 필드 포함
+// GOOD - all required fields included
 wdb.ubRegister("posts", {
   id: 1,
   title: "Updated Title",
-  content: "Updated Content",  // 필수 필드 포함!
-  author_id: 1,                // FK도 필수 필드면 포함!
+  content: "Updated Content",  // required field included!
+  author_id: 1,                // FK also included if required!
 });
 ```
 
-**필수 필드 확인 방법**:
-1. entity.json의 props 확인
-2. `nullable: true`가 **없는** 필드 = 필수 필드
-3. `id`, `created_at`, `dbDefault` 있는 필드는 제외 가능
+**How to identify required fields**:
+1. Check props in entity.json
+2. Fields without `nullable: true` = required fields
+3. `id`, `created_at`, fields with `dbDefault` can be omitted
 
 ```json
-// entity.json 예시
+// entity.json example
 {
   "props": [
-    { "name": "id", "type": "integer" },  // 제외 가능
-    { "name": "title", "type": "string" },  // 필수! (nullable 없음)
-    { "name": "content", "type": "string" },  // 필수! (nullable 없음)
-    { "name": "category", "type": "string", "nullable": true },  // 선택
-    { "name": "created_at", "type": "date", "dbDefault": "CURRENT_TIMESTAMP" }  // 제외 가능
+    { "name": "id", "type": "integer" },  // can be omitted
+    { "name": "title", "type": "string" },  // required! (no nullable)
+    { "name": "content", "type": "string" },  // required! (no nullable)
+    { "name": "category", "type": "string", "nullable": true },  // optional
+    { "name": "created_at", "type": "date", "dbDefault": "CURRENT_TIMESTAMP" }  // can be omitted
   ]
 }
 ```
 
-## 저장 순서 (중요!)
+## Save Order (Important!)
 
-FK가 참조하는 테이블을 먼저 저장:
+Save the table referenced by FK first:
 
 ```typescript
-await trx.ubUpsert("companies");   // 1. 의존성 없음
-await trx.ubUpsert("departments"); // 2. company_id 필요
-await trx.ubUpsert("users");       // 3. 의존성 없음
-await trx.ubUpsert("employees");   // 4. user_id, department_id 필요
+await trx.ubUpsert("companies");   // 1. No dependencies
+await trx.ubUpsert("departments"); // 2. Needs company_id
+await trx.ubUpsert("users");       // 3. No dependencies
+await trx.ubUpsert("employees");   // 4. Needs user_id, department_id
 ```
 
-## Model save 패턴
+## Model save Pattern
 
 ```typescript
 @api({ httpMethod: "POST" })
@@ -102,25 +102,25 @@ async save(spa: UserSaveParams[]): Promise<number[]> {
 }
 ```
 
-## 관계 데이터 저장
+## Saving Related Data
 
 ```typescript
 await this.getPuri("w").transaction(async (trx) => {
-  // User 등록
+  // Register User
   const userRef = trx.ubRegister("users", {
     email: data.email,
     username: data.username,
     password: bcrypt.hashSync(data.password, 10),
   });
 
-  // Employee 등록 (userRef 사용)
+  // Register Employee (using userRef)
   trx.ubRegister("employees", {
     user_id: userRef,
     department_id: data.departmentId,
     salary: data.salary,
   });
 
-  // 순서대로 저장
+  // Save in order
   await trx.ubUpsert("users");
   const [employeeId] = await trx.ubUpsert("employees");
   return employeeId;
@@ -130,16 +130,16 @@ await this.getPuri("w").transaction(async (trx) => {
 ## Upsert (Insert or Update)
 
 ```typescript
-// id 없으면 INSERT
+// INSERT when no id
 wdb.ubRegister("users", { email: "new@test.com", username: "new" });
 
-// id 있으면 UPDATE
+// UPDATE when id is present
 wdb.ubRegister("users", { id: 1, email: "updated@test.com" });
 ```
 
-**충돌 처리**: Entity의 unique index가 있으면 자동으로 사전 조회하여 기존 레코드의 id를 채운 후 UPDATE 수행
+**Conflict handling**: If the Entity has a unique index, automatically pre-fetches to populate the existing record's id, then performs UPDATE
 
-## ManyToMany 관계
+## ManyToMany Relationships
 
 ```typescript
 await wdb.transaction(async (trx) => {
@@ -157,52 +157,52 @@ await wdb.transaction(async (trx) => {
 });
 ```
 
-## 자기 참조 (Self-Reference)
+## Self-Reference
 
-계층 구조(예: 카테고리, 조직도)에서 자기 참조 관계는 자동으로 레벨별 순차 처리:
+In hierarchical structures (e.g. categories, org charts), self-referential relationships are automatically processed level by level:
 
 ```typescript
 await wdb.transaction(async (trx) => {
-  // 루트 카테고리
+  // Root category
   const rootRef = trx.ubRegister("categories", { name: "Root", parent_id: null });
   
-  // 자식 카테고리 (rootRef 참조)
+  // Child category (references rootRef)
   const childRef = trx.ubRegister("categories", { name: "Child", parent_id: rootRef });
   
-  // 손자 카테고리 (childRef 참조)
+  // Grandchild category (references childRef)
   trx.ubRegister("categories", { name: "Grandchild", parent_id: childRef });
 
-  // 내부적으로 레벨별 순차 처리 (Root → Child → Grandchild)
+  // Internally processed level by level (Root → Child → Grandchild)
   await trx.ubUpsert("categories");
 });
 ```
 
-## insertOnly (INSERT 전용)
+## insertOnly (INSERT Only)
 
-UPDATE 없이 INSERT만 수행:
+Perform INSERT without UPDATE:
 
 ```typescript
 await trx.insertOnly("logs", { chunkSize: 1000 });
 ```
 
-## updateBatch (배치 업데이트)
+## updateBatch (Batch Update)
 
-대량 UPDATE 작업:
+Bulk UPDATE operations:
 
 ```typescript
-// 여러 레코드 등록
+// Register multiple records
 wdb.ubRegister("users", { id: 1, status: "active" });
 wdb.ubRegister("users", { id: 2, status: "active" });
 wdb.ubRegister("users", { id: 3, status: "inactive" });
 
 await wdb.transaction(async (trx) => {
   await trx.updateBatch("users", {
-    chunkSize: 500,      // 배치 크기 (기본값: 500)
-    where: "id",         // WHERE 조건 컬럼 (기본값: "id")
+    chunkSize: 500,      // batch size (default: 500)
+    where: "id",         // WHERE condition column (default: "id")
   });
 });
 
-// 복합 키로 WHERE 조건
+// Composite key for WHERE condition
 await trx.updateBatch("user_settings", {
   where: ["user_id", "setting_key"],
 });
@@ -210,19 +210,19 @@ await trx.updateBatch("user_settings", {
 
 ## UpsertOptions
 
-`ubUpsert()`의 옵션:
+Options for `ubUpsert()`:
 
 ```typescript
 type UpsertOptions = {
-  chunkSize?: number;      // 배치 크기
-  cleanOrphans?: string | string[];  // 고아 레코드 삭제 기준 FK 컬럼
-  inherit?: string[];      // UPDATE 시 기존 값 유지할 컬럼
+  chunkSize?: number;      // batch size
+  cleanOrphans?: string | string[];  // FK column(s) to use as basis for deleting orphan records
+  inherit?: string[];      // columns to preserve existing values on UPDATE
 };
 ```
 
 ### chunkSize
 
-대량 데이터 처리 시 배치 크기 지정:
+Specify batch size for large data processing:
 
 ```typescript
 await trx.ubUpsert("logs", { chunkSize: 1000 });
@@ -230,15 +230,15 @@ await trx.ubUpsert("logs", { chunkSize: 1000 });
 
 ### cleanOrphans
 
-FK 기준으로 고아 레코드 자동 삭제:
+Automatically delete orphan records based on FK:
 
 ```typescript
-// 단일 FK
+// Single FK
 await trx.ubUpsert("order_items", {
-  cleanOrphans: "order_id",  // order_id가 같고 이번에 upsert 안 된 레코드 삭제
+  cleanOrphans: "order_id",  // delete records with the same order_id that were not upserted this time
 });
 
-// 복합 FK
+// Composite FK
 await trx.ubUpsert("project_members", {
   cleanOrphans: ["project_id", "team_id"],
 });
@@ -246,31 +246,31 @@ await trx.ubUpsert("project_members", {
 
 ### inherit
 
-UPDATE 시 특정 컬럼은 기존 값 유지:
+Preserve existing values for specific columns on UPDATE:
 
 ```typescript
 await trx.ubUpsert("users", {
-  inherit: ["created_at", "password"],  // 이 컬럼들은 UPDATE에서 제외
+  inherit: ["created_at", "password"],  // these columns are excluded from UPDATE
 });
 ```
 
-## ubUpsertOrInsert (조건부 모드)
+## ubUpsertOrInsert (Conditional Mode)
 
-upsert 또는 insert 모드를 런타임에 선택합니다.
+Select upsert or insert mode at runtime.
 
 ```typescript
-await trx.ubUpsertOrInsert("logs", "insert");   // INSERT 전용
-await trx.ubUpsertOrInsert("users", "upsert");  // UPSERT (기본)
+await trx.ubUpsertOrInsert("logs", "insert");   // INSERT only
+await trx.ubUpsertOrInsert("users", "upsert");  // UPSERT (default)
 await trx.ubUpsertOrInsert("users", "upsert", { cleanOrphans: "team_id" });
 ```
 
-| 파라미터 | 타입 | 설명 |
+| Parameter | Type | Description |
 |----------|------|------|
-| `tableName` | string | 테이블명 |
-| `mode` | `"upsert"` \| `"insert"` | 동작 모드 |
-| `options` | `UpsertOptions` | chunkSize, cleanOrphans, inherit (ubUpsert와 동일) |
+| `tableName` | string | table name |
+| `mode` | `"upsert"` \| `"insert"` | operation mode |
+| `options` | `UpsertOptions` | chunkSize, cleanOrphans, inherit (same as ubUpsert) |
 
-`mode: "insert"`일 때 `insertOnly`와 달리 `UpsertOptions` (cleanOrphans, inherit)를 사용할 수 있습니다.
+When `mode: "insert"`, unlike `insertOnly`, `UpsertOptions` (cleanOrphans, inherit) can be used.
 
 ## Rules
 

package/src/skills/sonamu/vector.md

@@ -1,43 +1,43 @@
 ---
 name: sonamu-vector
-description: pgvector 기반 벡터 검색. Embedding(Voyage AI/OpenAI), Chunking, 하이브리드 검색(Vector+FTS) 지원. Use when implementing vector search, semantic search, or text embedding features.
+description: pgvector-based vector search. Embedding (Voyage AI/OpenAI), Chunking, hybrid search (Vector+FTS) support. Use when implementing vector search, semantic search, or text embedding features.
 ---
 
-# 벡터 검색 가이드
+# Vector Search Guide
 
-Sonamu는 pgvector 기반 벡터 검색을 지원합니다. Voyage AI와 OpenAI 임베딩 프로바이더를 통합 지원하며, 하이브리드 검색(Vector + Full-Text Search)도 가능합니다.
+Sonamu supports pgvector-based vector search. It integrates both Voyage AI and OpenAI embedding providers, and also supports hybrid search (Vector + Full-Text Search).
 
-**소스코드:** `modules/sonamu/src/vector/`
+**Source code:** `modules/sonamu/src/vector/`
 
 ---
 
-## 구조
+## Structure
 
-| 파일 | 역할 |
+| File | Role |
 |------|------|
-| `types.ts` | 전체 타입 정의 (EmbeddingProvider, VectorSearchResult, VectorConfig 등) |
-| `config.ts` | 기본 설정값 + `createVectorConfig()` 헬퍼 |
-| `embedding.ts` | Embedding 클라이언트 (Voyage AI, OpenAI 통합) |
-| `chunking.ts` | 텍스트 청킹 (긴 문서 분할) |
+| `types.ts` | Full type definitions (EmbeddingProvider, VectorSearchResult, VectorConfig, etc.) |
+| `config.ts` | Default configuration values + `createVectorConfig()` helper |
+| `embedding.ts` | Embedding client (Voyage AI and OpenAI integration) |
+| `chunking.ts` | Text chunking (splitting long documents) |
 
 ---
 
-## 임베딩 프로바이더
+## Embedding Providers
 
-| 프로바이더 | 모델 | 차원 | maxTokens | batchSize | 패키지 |
+| Provider | Model | Dimensions | maxTokens | batchSize | Package |
 |-----------|------|------|-----------|-----------|--------|
 | `voyage` | `voyage-3` | 1024 | 32000 | 128 | `voyageai` |
 | `openai` | `text-embedding-3-small` | 1536 | 8191 | 100 | `@ai-sdk/openai` |
 
-### API 키 설정
+### API Key Configuration
 
 ```bash
-# 환경변수
+# Environment variables
 export VOYAGE_API_KEY=pa-...
 export OPENAI_API_KEY=sk-...
 ```
 
-또는 `sonamu.config.ts`:
+Or in `sonamu.config.ts`:
 ```typescript
 export default defineConfig({
   secret: {
@@ -47,80 +47,80 @@ export default defineConfig({
 });
 ```
 
-키 우선순위: `Sonamu.secrets.voyage_api_key` → `process.env.VOYAGE_API_KEY`
+Key priority: `Sonamu.secrets.voyage_api_key` → `process.env.VOYAGE_API_KEY`
 
 ---
 
-## Embedding 사용법
+## Embedding Usage
 
 ```typescript
 import { Embedding } from "sonamu/vector";
 
-// 단일 텍스트
-const result = await Embedding.embedOne("검색할 텍스트", "voyage", "query");
+// Single text
+const result = await Embedding.embedOne("text to search", "voyage", "query");
 // result: { embedding: number[], model: "voyage-3", tokenCount: 15 }
 
-// 다수 텍스트 (batchSize 초과 시 자동 분할)
+// Multiple texts (auto-splits when exceeding batchSize)
 const results = await Embedding.embed(
-  ["텍스트1", "텍스트2", ...],
+  ["text1", "text2", ...],
   "voyage",
   "document",         // inputType: "document" | "query"
-  (processed, total) => console.log(`${processed}/${total}`),  // 진행률 콜백
+  (processed, total) => console.log(`${processed}/${total}`),  // progress callback
 );
 
-// 차원 수 확인
+// Check number of dimensions
 Embedding.getDimensions("voyage");  // 1024
 Embedding.getDimensions("openai");  // 1536
 ```
 
-### Voyage AI inputType (비대칭 임베딩)
+### Voyage AI inputType (Asymmetric Embedding)
 
-| inputType | 용도 |
+| inputType | Use case |
 |-----------|------|
-| `"document"` | DB에 저장할 문서 임베딩 시 |
-| `"query"` | 검색 쿼리 임베딩 시 |
+| `"document"` | When embedding documents to store in DB |
+| `"query"` | When embedding search queries |
 
-**CRITICAL: 저장 시 `"document"`, 검색 시 `"query"`를 사용해야 비대칭 임베딩이 올바르게 작동합니다.**
+**CRITICAL: Use `"document"` when storing and `"query"` when searching for asymmetric embedding to work correctly.**
 
 ---
 
-## Chunking 사용법
+## Chunking Usage
 
-긴 문서를 적절한 크기로 분할합니다.
+Splits long documents into appropriately-sized pieces.
 
 ```typescript
 import { Chunking } from "sonamu/vector";
 
 const chunker = new Chunking({
-  chunkSize: 500,     // 청크 최대 크기 (문자 수)
-  chunkOverlap: 50,   // 청크 간 겹침
-  minChunkSize: 50,   // 최소 청크 크기
+  chunkSize: 500,     // Maximum chunk size (character count)
+  chunkOverlap: 50,   // Overlap between chunks
+  minChunkSize: 50,   // Minimum chunk size
 });
 
-// 청킹 필요 여부
-chunker.needsChunking("짧은 텍스트");  // false
+// Check if chunking is needed
+chunker.needsChunking("short text");  // false
 
-// 청크 분할
+// Split into chunks
 const chunks = chunker.chunk(longText);
 // chunks: [{ index: 0, text: "...", startOffset: 0, endOffset: 500 }, ...]
 
-// 예상 청크 수
+// Estimate number of chunks
 chunker.estimateChunkCount(longText);  // 5
 ```
 
-### 청킹 기본 설정
+### Chunking Default Settings
 
-| 옵션 | 기본값 | 설명 |
+| Option | Default | Description |
 |------|--------|------|
-| `chunkSize` | 500 | 청크 최대 크기 (문자 수) |
-| `chunkOverlap` | 50 | 청크 간 겹침 |
-| `minChunkSize` | 50 | 최소 청크 크기 |
-| `skipThreshold` | 200 | 이 크기 이하면 청킹 없이 통과 |
-| `separators` | `["\n\n", "\n", "。", ". ", ...]` | 분할 기준 (우선순위 순) |
+| `chunkSize` | 500 | Maximum chunk size (character count) |
+| `chunkOverlap` | 50 | Overlap between chunks |
+| `minChunkSize` | 50 | Minimum chunk size |
+| `skipThreshold` | 200 | Passes through without chunking if at or below this size |
+| `separators` | `["\n\n", "\n", "。", ". ", ...]` | Split delimiters (in priority order) |
 
 ---
 
-## 검색 설정
+## Search Configuration
 
 ```typescript
 import { createVectorConfig } from "sonamu/vector";
@@ -128,20 +128,20 @@ import { createVectorConfig } from "sonamu/vector";
 const config = createVectorConfig({
   search: {
     defaultLimit: 10,
-    similarityThreshold: 0.5,  // 이 값 이하는 결과에서 제외
-    vectorWeight: 0.7,         // 하이브리드 검색 시 벡터 가중치
-    ftsWeight: 0.3,            // 하이브리드 검색 시 FTS 가중치
+    similarityThreshold: 0.5,  // Results below this value are excluded
+    vectorWeight: 0.7,         // Vector weight in hybrid search
+    ftsWeight: 0.3,            // FTS weight in hybrid search
   },
   pgvector: {
-    iterativeScan: true,       // pgvector iterative scan 사용
-    efSearch: 100,             // HNSW 인덱스 검색 정확도
+    iterativeScan: true,       // Use pgvector iterative scan
+    efSearch: 100,             // HNSW index search accuracy
   },
 });
 ```
 
 ---
 
-## 타입 정의
+## Type Definitions
 
 ### VectorSearchResult
 
@@ -166,10 +166,10 @@ interface HybridSearchResult<T> extends VectorSearchResult<T> {
 
 ```typescript
 interface VectorSearchOptions {
-  embeddingColumn?: string;  // 임베딩 컬럼명 (기본: "embedding")
+  embeddingColumn?: string;  // Embedding column name (default: "embedding")
   limit?: number;
-  threshold?: number;        // 유사도 임계값
-  where?: string;            // SQL WHERE 조건
+  threshold?: number;        // Similarity threshold
+  where?: string;            // SQL WHERE condition
 }
 ```
 
@@ -177,36 +177,36 @@ interface VectorSearchOptions {
 
 ```typescript
 interface HybridSearchOptions extends VectorSearchOptions {
-  vectorWeight?: number;     // 벡터 검색 가중치
-  ftsWeight?: number;        // FTS 가중치
-  ftsColumn?: string;        // FTS 대상 컬럼명
+  vectorWeight?: number;     // Vector search weight
+  ftsWeight?: number;        // FTS weight
+  ftsColumn?: string;        // Target column name for FTS
 }
 ```
 
 ---
 
-## pgvector DB 설정
+## pgvector DB Setup
 
-### 확장 설치
+### Install Extension
 
 ```sql
 CREATE EXTENSION IF NOT EXISTS vector;
 ```
 
-### 임베딩 컬럼 추가
+### Add Embedding Column
 
 ```sql
--- Voyage AI (1024차원)
+-- Voyage AI (1024 dimensions)
 ALTER TABLE documents ADD COLUMN embedding vector(1024);
 
--- OpenAI (1536차원)
+-- OpenAI (1536 dimensions)
 ALTER TABLE documents ADD COLUMN embedding vector(1536);
 ```
 
-### HNSW 인덱스
+### HNSW Index
 
 ```sql
--- 코사인 유사도 기반 인덱스
+-- Cosine similarity-based index
 CREATE INDEX ON documents
 USING hnsw (embedding vector_cosine_ops)
 WITH (m = 16, ef_construction = 64);
@@ -214,8 +214,8 @@ WITH (m = 16, ef_construction = 64);
 
 ---
 
-## 참고
+## References
 
-- **소스코드**: `modules/sonamu/src/vector/`
-- **pgvector 공식**: https://github.com/pgvector/pgvector
+- **Source code**: `modules/sonamu/src/vector/`
+- **pgvector official**: https://github.com/pgvector/pgvector
 - **Voyage AI**: https://docs.voyageai.com/

package/src/testing/fixture-generator.ts

@@ -57,7 +57,7 @@ export class FixtureGenerator {
       locale: options?.locale || "ko",
       useLLM: options?.useLLM || false,
       enableLLMCache: options?.enableLLMCache !== false,
-      llmModel: options?.llmModel || "claude-sonnet-4-5",
+      llmModel: options?.llmModel || "claude-sonnet-4-6",
     };
   }
 
@@ -825,7 +825,7 @@ export class FixtureGenerator {
       const { generateText } = await import("ai");
 
       const rowResponse = await generateText({
-        model: createAnthropic({ apiKey })(this.options.llmModel || "claude-sonnet-4-5"),
+        model: createAnthropic({ apiKey })(this.options.llmModel || "claude-sonnet-4-6"),
         prompt: this.buildRowLLMPrompt(llmProps, entity),
       });
       if (!rowResponse || typeof rowResponse.text !== "string") {
@@ -869,7 +869,7 @@ export class FixtureGenerator {
     const { generateText } = await import("ai");
 
     const singleResponse = await generateText({
-      model: createAnthropic({ apiKey })(this.options.llmModel || "claude-sonnet-4-5"),
+      model: createAnthropic({ apiKey })(this.options.llmModel || "claude-sonnet-4-6"),
       prompt: this.buildLLMPrompt(fixtureHint, prop, entity),
     });
     if (!singleResponse || typeof singleResponse.text !== "string") {
@@ -1208,7 +1208,7 @@ Rules:
 
     try {
       const { Sonamu } = require("../api");
-      apiKey = Sonamu.secret?.anthropic_api_key;
+      apiKey = Sonamu.secrets?.anthropic_api_key;
     } catch {
       // Sonamu가 초기화되지 않은 경우 (테스트 환경 등)
     }

package/src/ui/ai-client.ts

@@ -34,7 +34,7 @@ class AIClient {
       const { anthropic } = await import("@ai-sdk/anthropic");
       const aiModule = await import("ai");
       this.aiSdk = { ...aiModule, anthropic };
-      this.model = anthropic("claude-sonnet-4-5");
+      this.model = anthropic("claude-sonnet-4-6");
     } catch (error) {
       console.warn(
         "AI SDK packages not installed. Install @ai-sdk/anthropic and ai to use AI features.",