@team-semicolon/semo-cli 4.12.0 → 4.15.0

package/dist/kb.js

@@ -81,7 +81,7 @@ function combineKey(key, subKey) {
 // ============================================================
 // Embedding
 // ============================================================
-const EMBEDDING_MODEL = "text-embedding-3-small";
+const EMBEDDING_MODEL = 'text-embedding-3-small';
 const EMBEDDING_DIMENSIONS = 1024; // DB vector(1024) 유지 — OpenAI dimensions 파라미터로 축소
 /**
  * Generate embedding vector for text using OpenAI Embeddings API
@@ -92,11 +92,11 @@ async function generateEmbedding(text) {
     if (!apiKey)
         return null;
     try {
-        const response = await fetch("https://api.openai.com/v1/embeddings", {
-            method: "POST",
+        const response = await fetch('https://api.openai.com/v1/embeddings', {
+            method: 'POST',
             headers: {
-                "Authorization": `Bearer ${apiKey}`,
-                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
             },
             body: JSON.stringify({
                 model: EMBEDDING_MODEL,
@@ -109,7 +109,7 @@ async function generateEmbedding(text) {
             console.error(`Embedding API error: ${response.status} ${err}`);
             return null;
         }
-        const data = await response.json();
+        const data = (await response.json());
         return data.data?.[0]?.embedding || null;
     }
     catch (err) {
@@ -125,21 +125,21 @@ async function generateEmbeddings(texts) {
     if (!apiKey)
         return texts.map(() => null);
     try {
-        const response = await fetch("https://api.openai.com/v1/embeddings", {
-            method: "POST",
+        const response = await fetch('https://api.openai.com/v1/embeddings', {
+            method: 'POST',
             headers: {
-                "Authorization": `Bearer ${apiKey}`,
-                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
             },
             body: JSON.stringify({
                 model: EMBEDDING_MODEL,
-                input: texts.map(t => t.substring(0, 8000)),
+                input: texts.map((t) => t.substring(0, 8000)),
                 dimensions: EMBEDDING_DIMENSIONS,
             }),
         });
         if (!response.ok)
             return texts.map(() => null);
-        const data = await response.json();
+        const data = (await response.json());
         return data.data?.map((d) => d.embedding) || texts.map(() => null);
     }
     catch {
@@ -149,8 +149,8 @@ async function generateEmbeddings(texts) {
 // ============================================================
 // KB Directory Management
 // ============================================================
-const KB_DIR = ".kb";
-const SYNC_STATE_FILE = ".sync-state.json";
+const KB_DIR = '.kb';
+const SYNC_STATE_FILE = '.sync-state.json';
 function getKBDir(cwd) {
     return path.join(cwd, KB_DIR);
 }
@@ -159,7 +159,7 @@ function ensureKBDir(cwd) {
     if (!fs.existsSync(kbDir)) {
         fs.mkdirSync(kbDir, { recursive: true });
     }
-    const ontoDir = path.join(kbDir, "ontology");
+    const ontoDir = path.join(kbDir, 'ontology');
     if (!fs.existsSync(ontoDir)) {
         fs.mkdirSync(ontoDir, { recursive: true });
     }
@@ -169,7 +169,7 @@ function readSyncState(cwd) {
     const statePath = path.join(getKBDir(cwd), SYNC_STATE_FILE);
     if (fs.existsSync(statePath)) {
         try {
-            return JSON.parse(fs.readFileSync(statePath, "utf-8"));
+            return JSON.parse(fs.readFileSync(statePath, 'utf-8'));
         }
         catch {
             // corrupted file
@@ -190,7 +190,7 @@ function readKBFile(cwd, filename) {
     if (!fs.existsSync(filePath))
         return [];
     try {
-        return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
     }
     catch {
         return [];
@@ -212,14 +212,14 @@ async function kbPull(pool, domain, cwd) {
     `;
         const params = [];
         if (domain) {
-            query += " WHERE domain = $1";
+            query += ' WHERE domain = $1';
             params.push(domain);
         }
-        query += " ORDER BY domain, key";
+        query += ' ORDER BY domain, key';
         const result = await client.query(query, params);
         const entries = result.rows;
         if (cwd) {
-            writeKBFile(cwd, "team.json", entries);
+            writeKBFile(cwd, 'team.json', entries);
             const state = readSyncState(cwd);
             state.lastPull = new Date().toISOString();
             state.sharedCount = entries.length;
@@ -240,7 +240,7 @@ async function kbPush(pool, entries, createdBy, cwd) {
     const errors = [];
     try {
         // Domain validation: check all domains against ontology before transaction
-        const ontologyResult = await client.query("SELECT domain FROM semo.ontology");
+        const ontologyResult = await client.query('SELECT domain FROM semo.ontology');
         const knownDomains = new Set(ontologyResult.rows.map((r) => r.domain));
         const invalidEntries = [];
         const validEntries = [];
@@ -255,28 +255,36 @@ async function kbPush(pool, entries, createdBy, cwd) {
         if (invalidEntries.length > 0) {
             errors.push(...invalidEntries);
         }
-        await client.query("BEGIN");
-        const texts = validEntries.map(e => `${e.key}: ${e.content}`);
+        await client.query('BEGIN');
+        const texts = validEntries.map((e) => `${e.key}: ${e.content}`);
         const embeddings = await generateEmbeddings(texts);
         for (let i = 0; i < validEntries.length; i++) {
             const entry = validEntries[i];
             try {
                 const embedding = embeddings[i];
-                const embeddingStr = embedding ? `[${embedding.join(",")}]` : null;
+                const embeddingStr = embedding ? `[${embedding.join(',')}]` : null;
                 const { key: flatKey, subKey } = splitKey(entry.key);
                 await client.query(`INSERT INTO semo.knowledge_base (domain, key, sub_key, content, metadata, created_by, embedding)
            VALUES ($1, $2, $3, $4, $5, $6, $7::vector)
            ON CONFLICT (domain, key, sub_key) DO UPDATE SET
              content = EXCLUDED.content,
              metadata = EXCLUDED.metadata,
-             embedding = EXCLUDED.embedding`, [entry.domain, flatKey, subKey, entry.content, JSON.stringify(entry.metadata || {}), entry.created_by || createdBy || "unknown", embeddingStr]);
+             embedding = EXCLUDED.embedding`, [
+                    entry.domain,
+                    flatKey,
+                    subKey,
+                    entry.content,
+                    JSON.stringify(entry.metadata || {}),
+                    entry.created_by || createdBy || 'unknown',
+                    embeddingStr,
+                ]);
                 upserted++;
             }
             catch (err) {
                 errors.push(`${entry.domain}/${entry.key}: ${err}`);
             }
         }
-        await client.query("COMMIT");
+        await client.query('COMMIT');
         if (cwd) {
             const state = readSyncState(cwd);
             state.lastPush = new Date().toISOString();
@@ -284,7 +292,7 @@ async function kbPush(pool, entries, createdBy, cwd) {
         }
     }
     catch (err) {
-        await client.query("ROLLBACK");
+        await client.query('ROLLBACK');
         errors.push(`Transaction failed: ${err}`);
     }
     finally {
@@ -329,7 +337,7 @@ async function kbList(pool, options) {
     const limit = options.limit || 50;
     const offset = options.offset || 0;
     try {
-        let query = "SELECT domain, key, sub_key, content, metadata, created_by, version, updated_at::text FROM semo.knowledge_base";
+        let query = 'SELECT domain, key, sub_key, content, metadata, created_by, version, updated_at::text FROM semo.knowledge_base';
         const params = [];
         let paramIdx = 1;
         if (options.domain) {
@@ -359,7 +367,7 @@ async function kbList(pool, options) {
 async function kbSearch(pool, query, options) {
     const client = await pool.connect();
     const limit = options.limit || 10;
-    const mode = options.mode || "hybrid";
+    const mode = options.mode || 'hybrid';
     // Resolve service → domain list for filtering
     let serviceDomains = null;
     if (options.service && !options.domain) {
@@ -368,10 +376,10 @@ async function kbSearch(pool, query, options) {
     try {
         let results = [];
         // Try semantic search first (if mode allows and embedding API available)
-        if (mode !== "text") {
+        if (mode !== 'text') {
             const queryEmbedding = await generateEmbedding(query);
             if (queryEmbedding) {
-                const embeddingStr = `[${queryEmbedding.join(",")}]`;
+                const embeddingStr = `[${queryEmbedding.join(',')}]`;
                 // Vector search on shared KB
                 let sql = `
           SELECT domain, key, sub_key, content, metadata, created_by, version, updated_at::text,
@@ -394,7 +402,7 @@ async function kbSearch(pool, query, options) {
                 const sharedResult = await client.query(sql, params);
                 results = sharedResult.rows;
                 // If we got results from semantic search and mode is not hybrid, return
-                if (results.length > 0 && mode === "semantic") {
+                if (results.length > 0 && mode === 'semantic') {
                     return results;
                 }
             }
@@ -403,8 +411,8 @@ async function kbSearch(pool, query, options) {
         // Split query into tokens and match ANY token via ILIKE (Korean-friendly)
         // For Korean tokens of 4+ chars with no spaces, add 2-char sub-tokens
         // e.g. "노조관리" → ["노조관리", "노조", "관리"]
-        if (mode !== "semantic" || results.length === 0) {
-            const rawTokens = query.split(/\s+/).filter(t => t.length >= 2);
+        if (mode !== 'semantic' || results.length === 0) {
+            const rawTokens = query.split(/\s+/).filter((t) => t.length >= 2);
             const tokens = [];
             const KOREAN_RE = /[\uAC00-\uD7AF]/;
             for (const t of rawTokens) {
@@ -420,20 +428,16 @@ async function kbSearch(pool, query, options) {
             const textParams = [];
             let tIdx = 1;
             // Build per-token ILIKE conditions + count matching tokens for scoring
-            const tokenConditions = tokens.map(token => {
+            const tokenConditions = tokens.map((token) => {
                 textParams.push(`%${token}%`);
                 return `(CASE WHEN content ILIKE $${tIdx} OR key ILIKE $${tIdx} OR sub_key ILIKE $${tIdx++} THEN 1 ELSE 0 END)`;
             });
             // Score = 0.7 base + 0.15 * (matched_tokens / total_tokens), capped at 0.95
-            const matchCountExpr = tokenConditions.length > 0
-                ? tokenConditions.join(" + ")
-                : "0";
+            const matchCountExpr = tokenConditions.length > 0 ? tokenConditions.join(' + ') : '0';
             const scoreExpr = `LEAST(0.95, 0.7 + 0.15 * (${matchCountExpr})::float / ${Math.max(tokens.length, 1)})`;
             // WHERE: any token matches
             const whereTokens = tokens.map((_, i) => `(content ILIKE $${i + 1} OR key ILIKE $${i + 1} OR sub_key ILIKE $${i + 1})`);
-            const whereClause = whereTokens.length > 0
-                ? whereTokens.join(" OR ")
-                : "FALSE";
+            const whereClause = whereTokens.length > 0 ? whereTokens.join(' OR ') : 'FALSE';
             let textSql = `
         SELECT domain, key, sub_key, content, metadata, created_by, version, updated_at::text,
                ${scoreExpr} as score
@@ -574,7 +578,7 @@ async function resolveServiceDomainsLocal(client, service) {
 async function ontoValidate(pool, domain, entries) {
     const onto = await ontoShow(pool, domain);
     if (!onto) {
-        return { valid: 0, invalid: [{ key: "*", errors: [`Ontology domain '${domain}' not found`] }] };
+        return { valid: 0, invalid: [{ key: '*', errors: [`Ontology domain '${domain}' not found`] }] };
     }
     // If no entries provided, fetch from DB
     if (!entries) {
@@ -595,7 +599,7 @@ async function ontoValidate(pool, domain, entries) {
         const errors = [];
         // Check required fields
         for (const field of required) {
-            if (!entry[field] && entry[field] !== "") {
+            if (!entry[field] && entry[field] !== '') {
                 errors.push(`Missing required field: ${field}`);
             }
         }
@@ -607,12 +611,12 @@ async function ontoValidate(pool, domain, entries) {
                 const val = entry.metadata[propKey];
                 if (val !== undefined) {
                     if (def.enum && !def.enum.includes(val)) {
-                        errors.push(`metadata.${propKey}: '${val}' not in allowed values [${def.enum.join(", ")}]`);
+                        errors.push(`metadata.${propKey}: '${val}' not in allowed values [${def.enum.join(', ')}]`);
                     }
-                    if (def.type === "string" && typeof val !== "string") {
+                    if (def.type === 'string' && typeof val !== 'string') {
                         errors.push(`metadata.${propKey}: expected string, got ${typeof val}`);
                     }
-                    if (def.type === "array" && !Array.isArray(val)) {
+                    if (def.type === 'array' && !Array.isArray(val)) {
                         errors.push(`metadata.${propKey}: expected array, got ${typeof val}`);
                     }
                 }
@@ -737,13 +741,15 @@ async function kbUpsert(pool, entry) {
     // Domain validation
     const client = await pool.connect();
     try {
-        const ontoCheck = await client.query("SELECT domain FROM semo.ontology WHERE domain = $1", [entry.domain]);
+        const ontoCheck = await client.query('SELECT domain FROM semo.ontology WHERE domain = $1', [
+            entry.domain,
+        ]);
         if (ontoCheck.rows.length === 0) {
-            const known = await client.query("SELECT domain FROM semo.ontology ORDER BY domain");
+            const known = await client.query('SELECT domain FROM semo.ontology ORDER BY domain');
             const knownDomains = known.rows.map((r) => r.domain);
             return {
                 success: false,
-                error: `도메인 '${entry.domain}'은(는) 온톨로지에 등록되지 않았습니다. 등록된 도메인: [${knownDomains.join(", ")}]`,
+                error: `도메인 '${entry.domain}'은(는) 온톨로지에 등록되지 않았습니다. 등록된 도메인: [${knownDomains.join(', ')}]`,
             };
         }
     }
@@ -753,14 +759,14 @@ async function kbUpsert(pool, entry) {
     // Naming convention check: kebab-case only
     const warnings = [];
     if (/_/.test(key)) {
-        const suggested = key.replace(/_/g, "-");
+        const suggested = key.replace(/_/g, '-');
         return {
             success: false,
             error: `키 '${key}'에 snake_case가 포함되어 있습니다. kebab-case를 사용하세요: '${suggested}'`,
         };
     }
     if (/_/.test(subKey)) {
-        const suggested = subKey.replace(/_/g, "-");
+        const suggested = subKey.replace(/_/g, '-');
         return {
             success: false,
             error: `sub_key '${subKey}'에 snake_case가 포함되어 있습니다. kebab-case를 사용하세요: '${suggested}'`,
@@ -770,25 +776,41 @@ async function kbUpsert(pool, entry) {
     {
         const schemaClient = await pool.connect();
         try {
-            const typeResult = await schemaClient.query("SELECT entity_type FROM semo.ontology WHERE domain = $1 AND entity_type IS NOT NULL", [entry.domain]);
+            const typeResult = await schemaClient.query('SELECT entity_type FROM semo.ontology WHERE domain = $1 AND entity_type IS NOT NULL', [entry.domain]);
             if (typeResult.rows.length > 0) {
                 const entityType = typeResult.rows[0].entity_type;
-                const schemaResult = await schemaClient.query("SELECT scheme_key, COALESCE(key_type, 'singleton') as key_type FROM semo.kb_type_schema WHERE type_key = $1", [entityType]);
+                const schemaResult = await schemaClient.query("SELECT scheme_key, COALESCE(key_type, 'singleton') as key_type, COALESCE(source, 'manual') as source FROM semo.kb_type_schema WHERE type_key = $1", [entityType]);
                 const schemas = schemaResult.rows;
                 if (schemas.length > 0) {
-                    const match = schemas.find(s => s.scheme_key === key);
+                    const match = schemas.find((s) => s.scheme_key === key);
                     if (!match) {
-                        const allowedKeys = schemas.map(s => s.key_type === "singleton" ? s.scheme_key : `${s.scheme_key}/{sub_key}`);
+                        const allowedKeys = schemas.map((s) => s.key_type === 'singleton' ? s.scheme_key : `${s.scheme_key}/{sub_key}`);
                         return {
                             success: false,
-                            error: `키 '${key}'은(는) '${entityType}' 타입의 스키마에 허용되지 않습니다. 허용 키: [${allowedKeys.join(", ")}]`,
+                            error: `키 '${key}'은(는) '${entityType}' 타입의 스키마에 허용되지 않습니다. 허용 키: [${allowedKeys.join(', ')}]`,
                         };
                     }
-                    if (match.key_type === "singleton" && subKey !== "") {
-                        return { success: false, error: `키 '${key}'은(는) singleton이므로 sub_key가 비어야 합니다.` };
+                    // Projection key 차단: pm-pipeline만 쓰기 허용
+                    if (match.source === 'projection') {
+                        const createdBy = entry.created_by ?? '';
+                        if (!createdBy.startsWith('pm-') && !createdBy.startsWith('gfp-')) {
+                            return {
+                                success: false,
+                                error: `키 '${key}'은(는) projection 키입니다 (PM 파이프라인에서 자동 동기화). 직접 쓰기가 차단됩니다.`,
+                            };
+                        }
                     }
-                    if (match.key_type === "collection" && subKey === "") {
-                        return { success: false, error: `키 '${key}'은(는) collection이므로 sub_key가 필요합니다.` };
+                    if (match.key_type === 'singleton' && subKey !== '') {
+                        return {
+                            success: false,
+                            error: `키 '${key}'은(는) singleton이므로 sub_key가 비어야 합니다.`,
+                        };
+                    }
+                    if (match.key_type === 'collection' && subKey === '') {
+                        return {
+                            success: false,
+                            error: `키 '${key}'은(는) collection이므로 sub_key가 필요합니다.`,
+                        };
                     }
                 }
             }
@@ -801,20 +823,67 @@ async function kbUpsert(pool, entry) {
             schemaClient.release();
         }
     }
+    // Slug hygiene validation for decision/incident
+    if (key === 'decision' || key === 'incident') {
+        const slug = subKey.replace(/^\d{4}-\d{2}-\d{2}\//, ''); // strip date prefix
+        if (/^test/i.test(slug) || /test$/i.test(slug) || slug === 'test') {
+            return {
+                success: false,
+                error: `${key}의 sub_key에 'test'가 포함되어 있습니다. 테스트 데이터는 KB에 저장할 수 없습니다.`,
+            };
+        }
+        if (slug.length < 3) {
+            return {
+                success: false,
+                error: `${key}의 sub_key '${slug}'가 너무 짧습니다 (최소 3자). 구체적인 slug를 사용하세요 (예: 'github-seat-reduction').`,
+            };
+        }
+        const genericSlugs = ['결정사항', '검토된-대안', '변경사항', '결정', '메모', '임시'];
+        if (genericSlugs.includes(slug)) {
+            return {
+                success: false,
+                error: `${key}의 sub_key '${slug}'가 너무 일반적입니다. 구체적인 slug를 사용하세요 (예: 'github-seat-reduction').`,
+            };
+        }
+    }
+    // Metadata required fields validation by key type
+    {
+        const meta = (entry.metadata || {});
+        const requiredMetaByKey = {
+            decision: {
+                fields: ['decided_at', 'decided_by'],
+                label: '의사결정',
+            },
+            incident: {
+                fields: ['occurred_at', 'severity', 'status'],
+                label: '인시던트',
+            },
+        };
+        const rule = requiredMetaByKey[key];
+        if (rule) {
+            const missing = rule.fields.filter((f) => !meta[f]);
+            if (missing.length > 0) {
+                return {
+                    success: false,
+                    error: `${rule.label} 엔트리(key='${key}')는 metadata에 [${missing.join(', ')}] 필드가 필수입니다. --metadata '{"${missing[0]}":"..."}' 형태로 전달하세요.`,
+                };
+            }
+        }
+    }
     // Generate embedding (mandatory)
     const fullKey = combineKey(key, subKey);
     const text = `${fullKey}: ${entry.content}`;
     const embedding = await generateEmbedding(text);
     if (!embedding) {
         const reason = process.env.OPENAI_API_KEY
-            ? "임베딩 생성 API 호출 실패"
-            : "OPENAI_API_KEY가 설정되지 않음";
+            ? '임베딩 생성 API 호출 실패'
+            : 'OPENAI_API_KEY가 설정되지 않음';
         return {
             success: false,
             error: `임베딩 생성 실패 — ${reason}. 임베딩 없이 저장하면 벡터 검색에서 누락되므로 저장이 거부됩니다.`,
         };
     }
-    const embeddingStr = `[${embedding.join(",")}]`;
+    const embeddingStr = `[${embedding.join(',')}]`;
     const writeClient = await pool.connect();
     try {
         await writeClient.query(`INSERT INTO semo.knowledge_base (domain, key, sub_key, content, metadata, created_by, embedding)
@@ -828,10 +897,41 @@ async function kbUpsert(pool, entry) {
             subKey,
             entry.content,
             JSON.stringify(entry.metadata || {}),
-            entry.created_by || "semo-cli",
+            entry.created_by || 'semo-cli',
             embeddingStr,
         ]);
-        return { success: true };
+        // KB→DB 동기화: Dashboard API에 위임 (파서 단일화)
+        if ((key === 'kpi' || key === 'action-item') && subKey) {
+            try {
+                const baseUrl = process.env.DASHBOARD_URL ||
+                    process.env.NEXT_PUBLIC_BASE_URL ||
+                    'https://semo.semi-colon.space';
+                const syncRes = await fetch(`${baseUrl}/api/kb-sync`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        domain: entry.domain,
+                        key,
+                        sub_key: subKey,
+                        content: entry.content,
+                    }),
+                });
+                if (syncRes.ok) {
+                    const syncData = await syncRes.json();
+                    if (syncData.synced > 0) {
+                        console.error(`  ↳ DB sync: ${syncData.synced} records`);
+                    }
+                }
+                else {
+                    console.error(`[kb] ⚠️  DB sync failed: ${syncRes.status}`);
+                }
+            }
+            catch (wtErr) {
+                // sync 실패는 KB 성공에 영향 없음 — 로깅만
+                console.error(`[kb] ⚠️  DB sync 실패 (KB 저장은 정상): ${wtErr}`);
+            }
+        }
+        return { success: true, warnings: warnings.length > 0 ? warnings : undefined };
     }
     catch (err) {
         return { success: false, error: String(err) };
@@ -951,17 +1051,19 @@ async function ontoRegister(pool, opts) {
     const client = await pool.connect();
     try {
         // 1. Validate entity_type
-        const typeCheck = await client.query("SELECT type_key FROM semo.ontology_types WHERE type_key = $1", [opts.entity_type]);
+        const typeCheck = await client.query('SELECT type_key FROM semo.ontology_types WHERE type_key = $1', [opts.entity_type]);
         if (typeCheck.rows.length === 0) {
-            const known = await client.query("SELECT type_key FROM semo.ontology_types ORDER BY type_key");
+            const known = await client.query('SELECT type_key FROM semo.ontology_types ORDER BY type_key');
             const knownTypes = known.rows.map((r) => r.type_key);
             return {
                 success: false,
-                error: `타입 '${opts.entity_type}'은(는) 존재하지 않습니다. 사용 가능한 타입: [${knownTypes.join(", ")}]`,
+                error: `타입 '${opts.entity_type}'은(는) 존재하지 않습니다. 사용 가능한 타입: [${knownTypes.join(', ')}]`,
             };
         }
         // 2. Check domain doesn't already exist
-        const existCheck = await client.query("SELECT domain FROM semo.ontology WHERE domain = $1", [opts.domain]);
+        const existCheck = await client.query('SELECT domain FROM semo.ontology WHERE domain = $1', [
+            opts.domain,
+        ]);
         if (existCheck.rows.length > 0) {
             return { success: false, error: `도메인 '${opts.domain}'은(는) 이미 등록되어 있습니다.` };
         }
@@ -971,7 +1073,7 @@ async function ontoRegister(pool, opts) {
             opts.domain,
             opts.entity_type,
             opts.description || null,
-            opts.service || "_global",
+            opts.service || '_global',
             opts.tags || [opts.entity_type],
             JSON.stringify({}),
         ]);
@@ -984,19 +1086,17 @@ async function ontoRegister(pool, opts) {
          WHERE type_key = $1 AND required = true
          ORDER BY sort_order`, [opts.entity_type]);
             for (const s of schemaResult.rows) {
-                if (s.key_type === "collection")
+                if (s.key_type === 'collection')
                     continue; // collection은 sub_key가 필요하므로 스킵
-                const placeholder = s.value_hint
-                    ? `(미입력 — hint: ${s.value_hint})`
-                    : `(미입력)`;
+                const placeholder = s.value_hint ? `(미입력 — hint: ${s.value_hint})` : `(미입력)`;
                 const text = `${s.scheme_key}: ${placeholder}`;
                 const embedding = await generateEmbedding(text);
-                const embeddingStr = embedding ? `[${embedding.join(",")}]` : null;
+                const embeddingStr = embedding ? `[${embedding.join(',')}]` : null;
                 try {
                     await client.query(`INSERT INTO semo.knowledge_base (domain, key, sub_key, content, metadata, created_by, embedding)
              VALUES ($1, $2, '', $3, '{}', 'semo-cli:onto-register', $4::vector)
              ON CONFLICT (domain, key, sub_key) DO NOTHING`, [opts.domain, s.scheme_key, placeholder, embeddingStr]);
-                    createdEntries.push({ key: s.scheme_key, sub_key: "" });
+                    createdEntries.push({ key: s.scheme_key, sub_key: '' });
                 }
                 catch {
                     // 개별 entry 실패는 무시 — 도메인 등록 자체는 성공
@@ -1021,12 +1121,12 @@ async function ontoUnregister(pool, domain, force) {
     const client = await pool.connect();
     try {
         // 1. Check domain exists
-        const domainCheck = await client.query("SELECT domain, entity_type, service FROM semo.ontology WHERE domain = $1", [domain]);
+        const domainCheck = await client.query('SELECT domain, entity_type, service FROM semo.ontology WHERE domain = $1', [domain]);
         if (domainCheck.rows.length === 0) {
             return { success: false, error: `도메인 '${domain}'은(는) 존재하지 않습니다.` };
         }
         // 2. Count KB entries
-        const countResult = await client.query("SELECT COUNT(*)::int AS cnt FROM semo.knowledge_base WHERE domain = $1", [domain]);
+        const countResult = await client.query('SELECT COUNT(*)::int AS cnt FROM semo.knowledge_base WHERE domain = $1', [domain]);
         const entryCount = countResult.rows[0].cnt;
         // 3. If entries exist and no force → error
         if (entryCount > 0 && !force) {
@@ -1036,19 +1136,21 @@ async function ontoUnregister(pool, domain, force) {
             };
         }
         // 4. Transaction: delete KB entries (if any) → delete ontology
-        await client.query("BEGIN");
+        await client.query('BEGIN');
         try {
             let deletedEntries = 0;
             if (entryCount > 0) {
-                const delResult = await client.query("DELETE FROM semo.knowledge_base WHERE domain = $1", [domain]);
+                const delResult = await client.query('DELETE FROM semo.knowledge_base WHERE domain = $1', [
+                    domain,
+                ]);
                 deletedEntries = delResult.rowCount ?? 0;
             }
-            await client.query("DELETE FROM semo.ontology WHERE domain = $1", [domain]);
-            await client.query("COMMIT");
+            await client.query('DELETE FROM semo.ontology WHERE domain = $1', [domain]);
+            await client.query('COMMIT');
             return { success: true, deleted_entries: deletedEntries };
         }
         catch (err) {
-            await client.query("ROLLBACK");
+            await client.query('ROLLBACK');
             return { success: false, error: String(err) };
         }
     }
@@ -1064,32 +1166,38 @@ async function ontoAddKey(pool, opts) {
     try {
         // Naming convention: kebab-case only
         if (/_/.test(opts.scheme_key)) {
-            const suggested = opts.scheme_key.replace(/_/g, "-");
-            return { success: false, error: `키 '${opts.scheme_key}'에 snake_case가 포함되어 있습니다. kebab-case를 사용하세요: '${suggested}'` };
+            const suggested = opts.scheme_key.replace(/_/g, '-');
+            return {
+                success: false,
+                error: `키 '${opts.scheme_key}'에 snake_case가 포함되어 있습니다. kebab-case를 사용하세요: '${suggested}'`,
+            };
         }
         // Check type exists
-        const typeCheck = await client.query("SELECT DISTINCT type_key FROM semo.kb_type_schema WHERE type_key = $1", [opts.type_key]);
+        const typeCheck = await client.query('SELECT DISTINCT type_key FROM semo.kb_type_schema WHERE type_key = $1', [opts.type_key]);
         if (typeCheck.rows.length === 0) {
             // Check if this type exists in ontology at all
-            const ontoCheck = await client.query("SELECT DISTINCT entity_type FROM semo.ontology WHERE entity_type = $1", [opts.type_key]);
+            const ontoCheck = await client.query('SELECT DISTINCT entity_type FROM semo.ontology WHERE entity_type = $1', [opts.type_key]);
             if (ontoCheck.rows.length === 0) {
                 return { success: false, error: `타입 '${opts.type_key}'이(가) 존재하지 않습니다.` };
             }
         }
         // Check duplicate
-        const dupCheck = await client.query("SELECT id FROM semo.kb_type_schema WHERE type_key = $1 AND scheme_key = $2", [opts.type_key, opts.scheme_key]);
+        const dupCheck = await client.query('SELECT id FROM semo.kb_type_schema WHERE type_key = $1 AND scheme_key = $2', [opts.type_key, opts.scheme_key]);
         if (dupCheck.rows.length > 0) {
-            return { success: false, error: `키 '${opts.scheme_key}'은(는) '${opts.type_key}' 타입에 이미 존재합니다.` };
+            return {
+                success: false,
+                error: `키 '${opts.scheme_key}'은(는) '${opts.type_key}' 타입에 이미 존재합니다.`,
+            };
         }
         // Get max sort_order
-        const maxOrder = await client.query("SELECT COALESCE(MAX(sort_order), 0) + 10 as next_order FROM semo.kb_type_schema WHERE type_key = $1", [opts.type_key]);
+        const maxOrder = await client.query('SELECT COALESCE(MAX(sort_order), 0) + 10 as next_order FROM semo.kb_type_schema WHERE type_key = $1', [opts.type_key]);
         const sortOrder = maxOrder.rows[0].next_order;
         await client.query(`INSERT INTO semo.kb_type_schema (type_key, scheme_key, scheme_description, key_type, required, value_hint, sort_order)
        VALUES ($1, $2, $3, $4, $5, $6, $7)`, [
             opts.type_key,
             opts.scheme_key,
             opts.description || opts.scheme_key,
-            opts.key_type || "singleton",
+            opts.key_type || 'singleton',
             opts.required || false,
             opts.value_hint || null,
             sortOrder,
@@ -1109,21 +1217,20 @@ async function ontoAddKey(pool, opts) {
 async function ontoCreateType(pool, opts) {
     // kebab-case 검증
     if (!/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/.test(opts.type_key)) {
-        return { success: false, error: `타입 키 '${opts.type_key}'이(가) 유효하지 않습니다. kebab-case 소문자만 사용 가능 (예: my-type)` };
+        return {
+            success: false,
+            error: `타입 키 '${opts.type_key}'이(가) 유효하지 않습니다. kebab-case 소문자만 사용 가능 (예: my-type)`,
+        };
     }
     const client = await pool.connect();
     try {
         // 중복 확인
-        const dupCheck = await client.query("SELECT type_key FROM semo.ontology_types WHERE type_key = $1", [opts.type_key]);
+        const dupCheck = await client.query('SELECT type_key FROM semo.ontology_types WHERE type_key = $1', [opts.type_key]);
         if (dupCheck.rows.length > 0) {
             return { success: false, error: `타입 '${opts.type_key}'은(는) 이미 존재합니다.` };
         }
         await client.query(`INSERT INTO semo.ontology_types (type_key, schema, description)
-       VALUES ($1, $2, $3)`, [
-            opts.type_key,
-            JSON.stringify(opts.schema || {}),
-            opts.description || opts.type_key,
-        ]);
+       VALUES ($1, $2, $3)`, [opts.type_key, JSON.stringify(opts.schema || {}), opts.description || opts.type_key]);
         return { success: true };
     }
     catch (err) {
@@ -1139,9 +1246,12 @@ async function ontoCreateType(pool, opts) {
 async function ontoRemoveKey(pool, typeKey, schemeKey) {
     const client = await pool.connect();
     try {
-        const result = await client.query("DELETE FROM semo.kb_type_schema WHERE type_key = $1 AND scheme_key = $2 RETURNING id", [typeKey, schemeKey]);
+        const result = await client.query('DELETE FROM semo.kb_type_schema WHERE type_key = $1 AND scheme_key = $2 RETURNING id', [typeKey, schemeKey]);
         if (result.rows.length === 0) {
-            return { success: false, error: `키 '${schemeKey}'은(는) '${typeKey}' 타입에 존재하지 않습니다.` };
+            return {
+                success: false,
+                error: `키 '${schemeKey}'은(는) '${typeKey}' 타입에 존재하지 않습니다.`,
+            };
         }
         return { success: true };
     }
@@ -1155,7 +1265,7 @@ async function ontoRemoveKey(pool, typeKey, schemeKey) {
 async function ontoPullToLocal(pool, cwd) {
     const domains = await ontoList(pool);
     const kbDir = ensureKBDir(cwd);
-    const ontoDir = path.join(kbDir, "ontology");
+    const ontoDir = path.join(kbDir, 'ontology');
     for (const d of domains) {
         fs.writeFileSync(path.join(ontoDir, `${d.domain}.json`), JSON.stringify(d, null, 2));
     }