@team-semicolon/semo-cli 4.3.0 → 4.4.0

package/dist/index.js

@@ -64,6 +64,7 @@ const get_1 = require("./commands/get");
 const sessions_1 = require("./commands/sessions");
 const db_1 = require("./commands/db");
 const memory_1 = require("./commands/memory");
+const test_1 = require("./commands/test");
 const global_cache_1 = require("./global-cache");
 const PACKAGE_NAME = "@team-semicolon/semo-cli";
 // package.json에서 버전 동적 로드
@@ -778,11 +779,7 @@ program
     if (!options.skipMcp) {
         await setupMCP(os.homedir(), [], options.force || false);
     }
-    // 6. semo-kb MCP 유저레벨 등록
-    if (!options.skipMcp) {
-        await setupSemoKbMcp();
-    }
-    // 7. 글로벌 CLAUDE.md에 KB-First 규칙 주입
+    // 6. 글로벌 CLAUDE.md에 KB-First 규칙 주입
     await injectKbFirstToGlobalClaudeMd();
     await (0, database_1.closeConnection)();
     // 결과 요약
@@ -793,7 +790,7 @@ program
     console.log(chalk_1.default.gray("  ~/.claude/commands/      팀 커맨드 (DB 기반)"));
     console.log(chalk_1.default.gray("  ~/.claude/agents/        팀 에이전트 (DB 기반, dedup)"));
     console.log(chalk_1.default.gray("  ~/.claude/settings.local.json  SessionStart/Stop 훅"));
-    console.log(chalk_1.default.gray("  ~/.claude/settings.json  semo-kb MCP (유저레벨, KB-First SoT)"));
+    console.log(chalk_1.default.gray("  ~/.claude/settings.json  Claude Code 설정 (유저레벨)"));
     console.log(chalk_1.default.cyan("\n다음 단계:"));
     console.log(chalk_1.default.gray("  프로젝트 디렉토리에서 'semo init'을 실행하세요."));
     console.log();
@@ -1360,29 +1357,87 @@ function registerMCPServer(server) {
 }
 // === 글로벌 CLAUDE.md에 KB-First 규칙 주입 ===
 const KB_FIRST_SECTION_MARKER = "## SEMO KB-First 행동 규칙";
-async function injectKbFirstToGlobalClaudeMd() {
-    const globalClaudeMd = path.join(os.homedir(), ".claude", "CLAUDE.md");
-    const kbFirstBlock = `
+async function buildKbFirstBlock() {
+    // DB에서 온톨로지 + 타입스키마를 조회해서 동적 생성
+    let domainGuide = "";
+    try {
+        const pool = (0, database_1.getPool)();
+        // 1. 타입스키마: 타입별 scheme_key 목록
+        const schemaRows = await pool.query(`SELECT type_key, scheme_key, required, scheme_description
+       FROM semo.kb_type_schema ORDER BY type_key, sort_order, scheme_key`);
+        const typeSchemas = new Map();
+        for (const r of schemaRows.rows) {
+            const entries = typeSchemas.get(r.type_key) || [];
+            entries.push({ scheme_key: r.scheme_key, required: r.required, desc: r.scheme_description || "" });
+            typeSchemas.set(r.type_key, entries);
+        }
+        // 2. 온톨로지: 엔티티 타입별 도메인 목록
+        const ontoRows = await pool.query(`SELECT entity_type, domain, description FROM semo.ontology ORDER BY entity_type, domain`);
+        const entities = new Map();
+        for (const r of ontoRows.rows) {
+            const list = entities.get(r.entity_type) || [];
+            list.push({ domain: r.domain, desc: r.description || "" });
+            entities.set(r.entity_type, list);
+        }
+        // 3. 도메인 가이드 생성
+        const orgDomains = entities.get("organization") || [];
+        const svcDomains = entities.get("service") || [];
+        const orgSchema = typeSchemas.get("organization") || [];
+        const svcSchema = typeSchemas.get("service") || [];
+        domainGuide += "#### 도메인 구조\n";
+        domainGuide += "| 패턴 | 예시 | 용도 |\n|------|------|------|\n";
+        if (orgDomains.length > 0) {
+            const orgEx = orgDomains.map(o => o.domain).join(", ");
+            const orgKeys = orgSchema.filter(s => !s.scheme_key.includes("{")).map(s => s.scheme_key).join(", ");
+            domainGuide += `| 조직 도메인 | \`${orgEx}\` | ${orgKeys} 등 조직 정보 |\n`;
+        }
+        if (svcDomains.length > 0) {
+            const svcEx = svcDomains.slice(0, 5).map(s => s.domain).join(", ");
+            const svcKeys = svcSchema.filter(s => !s.scheme_key.includes("{")).map(s => s.scheme_key).join(", ");
+            domainGuide += `| 서비스 도메인 | \`${svcEx}\` 등 ${svcDomains.length}개 | ${svcKeys} 등 서비스 정보 |\n`;
+        }
+        domainGuide += "\n#### 읽기 예시 (Query-First)\n";
+        domainGuide += "다음 주제 질문 → **반드시 `semo kb search`/`semo kb get`으로 KB 먼저 조회** 후 답변:\n";
+        // 조직 도메인 키 가이드
+        for (const s of orgSchema) {
+            if (s.scheme_key.includes("{")) {
+                const label = s.desc || s.scheme_key;
+                domainGuide += `- ${label} → \`domain: ${orgDomains[0]?.domain || "semicolon"}\`, key: \`${s.scheme_key}\`\n`;
+            }
+        }
+        // 서비스 도메인 키 가이드
+        for (const s of svcSchema.filter(s => s.required && !s.scheme_key.includes("{"))) {
+            const label = s.desc || s.scheme_key;
+            domainGuide += `- 서비스 ${label} → \`domain: {서비스명}\`, key: \`${s.scheme_key}\`\n`;
+        }
+        domainGuide += `- 서비스 KPI → \`domain: {서비스명}\`, key: \`kpi/current\`\n`;
+        domainGuide += `- 서비스 마일스톤 → \`domain: {서비스명}\`, key: \`milestone/{slug}\`\n`;
+    }
+    catch {
+        // DB 연결 실패 시 최소한의 가이드
+        domainGuide = `### 읽기 (Query-First)
+다음 주제 질문 → **반드시 \`semo kb search\`/\`semo kb get\`으로 KB 먼저 조회** 후 답변.
+도메인/키 구조는 \`semo kb ontology --action list\`로 확인 가능.
+`;
+    }
+    return `
 ${KB_FIRST_SECTION_MARKER}
 
-> semo-kb MCP 서버가 유저레벨에 등록되어 있습니다. KB는 팀의 Single Source of Truth입니다.
-
-### 읽기 (Query-First)
-다음 주제 질문 → **반드시 kb_search/kb_get으로 KB 먼저 조회** 후 답변:
-- 팀원 정보 → \`domain: team\`
-- 프로젝트 현황 → \`domain: project\`
-- 의사결정 기록 → \`domain: decision\`
-- 업무 프로세스 → \`domain: process\`
-- 인프라 구성 → \`domain: infra\`
-- KPI → \`domain: kpi\`
+> semo CLI의 kb-manager 스킬을 통해 KB에 접근합니다. KB는 팀의 Single Source of Truth입니다.
+> 도메인/키 구조가 변경될 수 있으므로 \`semo kb ontology --action list\`로 최신 구조를 확인하세요.
 
+${domainGuide}
 **금지:** 위 주제를 자체 지식/세션 기억만으로 답변하는 것.
 KB에 없으면: "KB에 해당 정보가 없습니다. 알려주시면 등록하겠습니다."
 
 ### 쓰기 (Write-Back)
-사용자가 팀 정보를 정정/추가/변경하면, 의사결정이 내려지면 → **반드시 kb_upsert로 KB에 즉시 기록.**
+사용자가 팀 정보를 정정/추가/변경하면, 의사결정이 내려지면 → **반드시 \`semo kb upsert\`로 KB에 즉시 기록.**
 **금지:** "알겠습니다/기억하겠습니다"만 하고 KB에 쓰지 않는 것.
 `;
+}
+async function injectKbFirstToGlobalClaudeMd() {
+    const globalClaudeMd = path.join(os.homedir(), ".claude", "CLAUDE.md");
+    const kbFirstBlock = await buildKbFirstBlock();
     if (fs.existsSync(globalClaudeMd)) {
         const content = fs.readFileSync(globalClaudeMd, "utf-8");
         if (content.includes(KB_FIRST_SECTION_MARKER)) {
@@ -1404,50 +1459,6 @@ KB에 없으면: "KB에 해당 정보가 없습니다. 알려주시면 등록하
         console.log(chalk_1.default.green("  ✓ ~/.claude/CLAUDE.md 생성됨 (KB-First 규칙)"));
     }
 }
-// === semo-kb MCP 유저레벨 등록 ===
-async function setupSemoKbMcp() {
-    console.log(chalk_1.default.cyan("\n📡 semo-kb MCP 유저레벨 등록"));
-    console.log(chalk_1.default.gray("   KB-First SoT — 어디서든 KB 조회/갱신 가능\n"));
-    // semo-kb MCP 서버 경로 탐색
-    // 1. cwd에서 packages/mcp-kb/dist/index.js 찾기
-    // 2. CLI 패키지 기준으로 monorepo 루트 탐색
-    // 3. 환경변수 SEMO_PROJECT_ROOT
-    const candidates = [
-        path.join(process.cwd(), "packages", "mcp-kb", "dist", "index.js"),
-        process.env.SEMO_PROJECT_ROOT
-            ? path.join(process.env.SEMO_PROJECT_ROOT, "packages", "mcp-kb", "dist", "index.js")
-            : "",
-        path.resolve(__dirname, "..", "..", "..", "mcp-kb", "dist", "index.js"),
-    ].filter(Boolean);
-    const mcpEntryPath = candidates.find((p) => fs.existsSync(p));
-    if (!mcpEntryPath) {
-        console.log(chalk_1.default.yellow("  ⚠ semo-kb MCP 서버를 찾을 수 없습니다."));
-        console.log(chalk_1.default.gray("    semo 프로젝트 루트에서 실행하거나 SEMO_PROJECT_ROOT 환경변수를 설정하세요."));
-        console.log(chalk_1.default.gray("    예: cd /path/to/semo && semo onboarding"));
-        return;
-    }
-    const absolutePath = path.resolve(mcpEntryPath);
-    console.log(chalk_1.default.gray(`  경로: ${absolutePath}`));
-    // claude mcp add로 유저레벨 등록
-    const result = registerMCPServer({
-        name: "semo-kb",
-        command: "node",
-        args: [absolutePath],
-        scope: "user",
-    });
-    if (result.success) {
-        if (result.skipped) {
-            console.log(chalk_1.default.gray("  semo-kb 이미 등록됨 (건너뜀)"));
-        }
-        else {
-            console.log(chalk_1.default.green("  ✓ semo-kb MCP 유저레벨 등록 완료"));
-        }
-    }
-    else {
-        console.log(chalk_1.default.yellow(`  ⚠ semo-kb 등록 실패: ${result.error}`));
-        console.log(chalk_1.default.gray("    수동 등록: claude mcp add semo-kb -s user -- node " + absolutePath));
-    }
-}
 // === MCP 설정 ===
 async function setupMCP(cwd, _extensions, force) {
     console.log(chalk_1.default.cyan("\n🔧 Black Box 설정 (MCP Server)"));
@@ -1464,8 +1475,7 @@ async function setupMCP(cwd, _extensions, force) {
     const settings = {
         mcpServers: {},
     };
-    // semo-kb는 유저레벨에서 등록 (semo onboarding)하므로 프로젝트 settings에 쓰지 않음
-    // 공통 서버(context7 등)도 유저레벨에 등록하므로 프로젝트 settings에 쓰지 않음
+    // 공통 서버(context7 등)는 유저레벨에 등록하므로 프로젝트 settings에 쓰지 않음
     fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
     console.log(chalk_1.default.green("✓ .claude/settings.json 생성됨"));
     // Claude Code에 MCP 서버 등록 시도 (공통 서버는 유저레벨로)
@@ -1786,6 +1796,13 @@ async function setupClaudeMd(cwd, _extensions, force) {
             return;
         }
     }
+    // KB-First 섹션을 DB에서 동적 생성
+    const kbFirstFull = await buildKbFirstBlock();
+    // 프로젝트용: "## SEMO KB-First 행동 규칙" → "## KB-First 행동 규칙 (NON-NEGOTIABLE)"
+    const kbFirstSection = kbFirstFull
+        .replace(KB_FIRST_SECTION_MARKER, "## KB-First 행동 규칙 (NON-NEGOTIABLE)")
+        .replace(/> semo CLI의 kb-manager 스킬을 통해.*\n/, "> KB는 팀의 Single Source of Truth이다. 아래 규칙은 예외 없이 적용된다.\n")
+        .trim();
     // 프로젝트 규칙만 (스킬/에이전트 목록은 글로벌 ~/.claude/에 있음)
     const claudeMdContent = `# SEMO Project Configuration
 
@@ -1794,45 +1811,21 @@ async function setupClaudeMd(cwd, _extensions, force) {
 
 ---
 
-## KB 접근 (semo-kb MCP 서버)
+## KB 접근 (semo CLI)
 
-KB 데이터는 **semo-kb MCP 서버**를 통해 Core DB에서 실시간 조회합니다.
+KB 데이터는 **semo CLI** (\`kb-manager\` 스킬)를 통해 Core DB에서 조회합니다.
 
-| MCP 도구 | 설명 |
-|----------|------|
-| \`kb_search\` | 벡터+텍스트 하이브리드 검색 (query, domain?, limit?, mode?) |
-| \`kb_get\` | domain+key 정확 조회 |
-| \`kb_list\` | 도메인별 엔트리 목록 |
-| \`kb_upsert\` | KB 항목 쓰기 (OpenAI 임베딩 자동 생성) |
-| \`kb_bot_status\` | 봇 상태 테이블 조회 |
-| \`kb_ontology\` | 온톨로지 스키마 조회 |
-| \`kb_digest\` | 봇 구독 도메인 변경 다이제스트 |
+| 명령어 | 설명 |
+|--------|------|
+| \`semo kb search "쿼리"\` | 벡터+텍스트 하이브리드 검색 |
+| \`semo kb get <domain> <key> [sub_key]\` | domain+key 정확 조회 |
+| \`semo kb list --domain <domain>\` | 도메인별 엔트리 목록 |
+| \`semo kb upsert <domain> <key> [sub_key] --content "내용"\` | KB 항목 쓰기 |
+| \`semo kb ontology --action <action>\` | 온톨로지 조회 |
 
 ---
 
-## KB-First 행동 규칙 (NON-NEGOTIABLE)
-
-> KB는 팀의 Single Source of Truth이다. 아래 규칙은 예외 없이 적용된다.
-
-### 읽기 (Query-First)
-다음 주제 질문 → **반드시 kb_search/kb_get으로 KB 먼저 조회** 후 답변:
-- 팀원 정보 → \`domain: team\`
-- 프로젝트 현황 → \`domain: project\`
-- 의사결정 기록 → \`domain: decision\`
-- 업무 프로세스 → \`domain: process\`
-- 인프라 구성 → \`domain: infra\`
-- KPI → \`domain: kpi\`
-
-**금지:** 위 주제를 자체 지식/세션 기억만으로 답변하는 것.
-KB에 없으면: "KB에 해당 정보가 없습니다. 알려주시면 등록하겠습니다."
-
-### 쓰기 (Write-Back)
-다음 상황 → **반드시 kb_upsert로 KB에 즉시 기록:**
-- 사용자가 팀 정보를 정정하거나 새 사실을 알려줄 때
-- 의사결정이 내려졌을 때
-- 프로세스/규칙이 변경되었을 때
-
-**금지:** "알겠습니다/기억하겠습니다"만 하고 KB에 쓰지 않는 것.
+${kbFirstSection}
 
 ---
 
@@ -2582,6 +2575,242 @@ kbCmd
         process.exit(1);
     }
 });
+kbCmd
+    .command("get <domain> <key> [sub_key]")
+    .description("KB 단일 항목 정확 조회 (domain + key + sub_key)")
+    .option("--format <type>", "출력 형식 (json|table)", "json")
+    .action(async (domain, key, subKey, options) => {
+    try {
+        const pool = (0, database_1.getPool)();
+        const entry = await (0, kb_1.kbGet)(pool, domain, key, subKey);
+        if (!entry) {
+            console.log(chalk_1.default.yellow(`\n  항목 없음: ${domain}/${key}${subKey ? '/' + subKey : ''}\n`));
+            await (0, database_1.closeConnection)();
+            process.exit(1);
+        }
+        if (options.format === "json") {
+            console.log(JSON.stringify(entry, null, 2));
+        }
+        else {
+            console.log(chalk_1.default.cyan.bold(`\n📄 [${entry.domain}] ${entry.key}${entry.sub_key ? '/' + entry.sub_key : ''}\n`));
+            console.log(entry.content);
+            if (entry.metadata && Object.keys(entry.metadata).length > 0) {
+                console.log(chalk_1.default.gray(`\n  metadata: ${JSON.stringify(entry.metadata)}`));
+            }
+            if (entry.updated_at) {
+                console.log(chalk_1.default.gray(`  updated: ${entry.updated_at}`));
+            }
+            console.log();
+        }
+        await (0, database_1.closeConnection)();
+    }
+    catch (err) {
+        console.error(chalk_1.default.red(`조회 실패: ${err}`));
+        await (0, database_1.closeConnection)();
+        process.exit(1);
+    }
+});
+kbCmd
+    .command("upsert <domain> <key> [sub_key]")
+    .description("KB 항목 쓰기 (upsert) — 임베딩 자동 생성 + 스키마 검증")
+    .requiredOption("--content <text>", "항목 본문")
+    .option("--metadata <json>", "추가 메타데이터 (JSON 문자열)")
+    .option("--created-by <name>", "작성자 식별자", "semo-cli")
+    .action(async (domain, key, subKey, options) => {
+    const spinner = (0, ora_1.default)("KB upsert 중...").start();
+    try {
+        const pool = (0, database_1.getPool)();
+        const metadata = options.metadata ? JSON.parse(options.metadata) : undefined;
+        const result = await (0, kb_1.kbUpsert)(pool, {
+            domain,
+            key,
+            sub_key: subKey,
+            content: options.content,
+            metadata,
+            created_by: options.createdBy,
+        });
+        if (result.success) {
+            spinner.succeed(`KB upsert 완료: ${domain}/${key}${subKey ? '/' + subKey : ''}`);
+            if (result.warnings && result.warnings.length > 0) {
+                for (const w of result.warnings) {
+                    console.log(chalk_1.default.yellow(`  ⚠️ ${w}`));
+                }
+            }
+        }
+        else {
+            spinner.fail(`KB upsert 실패: ${result.error}`);
+            process.exit(1);
+        }
+        await (0, database_1.closeConnection)();
+    }
+    catch (err) {
+        spinner.fail(`KB upsert 실패: ${err}`);
+        await (0, database_1.closeConnection)();
+        process.exit(1);
+    }
+});
+kbCmd
+    .command("ontology")
+    .description("온톨로지 조회 — 도메인/타입/스키마/라우팅 테이블")
+    .option("--action <type>", "조회 동작 (list|show|services|types|instances|schema|routing-table)", "list")
+    .option("--domain <name>", "action=show 시 도메인")
+    .option("--type <name>", "action=schema 시 타입 키")
+    .option("--format <type>", "출력 형식 (json|table)", "table")
+    .action(async (options) => {
+    try {
+        const pool = (0, database_1.getPool)();
+        const action = options.action;
+        if (action === "list") {
+            const domains = await (0, kb_1.ontoList)(pool);
+            if (options.format === "json") {
+                console.log(JSON.stringify(domains, null, 2));
+            }
+            else {
+                console.log(chalk_1.default.cyan.bold("\n📐 온톨로지 도메인\n"));
+                for (const d of domains) {
+                    const typeStr = d.entity_type ? chalk_1.default.gray(` [${d.entity_type}]`) : "";
+                    const svcStr = d.service ? chalk_1.default.gray(` (${d.service})`) : "";
+                    console.log(chalk_1.default.cyan(`  ${d.domain}`) + typeStr + svcStr);
+                    if (d.description)
+                        console.log(chalk_1.default.gray(`    ${d.description}`));
+                }
+                console.log();
+            }
+        }
+        else if (action === "show") {
+            if (!options.domain) {
+                console.log(chalk_1.default.red("--domain 옵션이 필요합니다."));
+                process.exit(1);
+            }
+            const onto = await (0, kb_1.ontoShow)(pool, options.domain);
+            if (!onto) {
+                console.log(chalk_1.default.red(`온톨로지 '${options.domain}'을 찾을 수 없습니다.`));
+                process.exit(1);
+            }
+            if (options.format === "json") {
+                console.log(JSON.stringify(onto, null, 2));
+            }
+            else {
+                console.log(chalk_1.default.cyan.bold(`\n📐 온톨로지: ${onto.domain}\n`));
+                if (onto.description)
+                    console.log(chalk_1.default.white(`  ${onto.description}`));
+                console.log(chalk_1.default.gray(`  버전: ${onto.version}`));
+                console.log(chalk_1.default.gray(`  스키마:\n`));
+                console.log(chalk_1.default.white(JSON.stringify(onto.schema, null, 2).split("\n").map(l => "    " + l).join("\n")));
+                console.log();
+            }
+        }
+        else if (action === "services") {
+            const services = await (0, kb_1.ontoListServices)(pool);
+            if (options.format === "json") {
+                console.log(JSON.stringify(services, null, 2));
+            }
+            else {
+                console.log(chalk_1.default.cyan.bold("\n📐 서비스 목록\n"));
+                for (const s of services) {
+                    console.log(chalk_1.default.cyan(`  ${s.service}`) + chalk_1.default.gray(` (${s.domain_count} domains)`));
+                    console.log(chalk_1.default.gray(`    ${s.domains.join(", ")}`));
+                }
+                console.log();
+            }
+        }
+        else if (action === "types") {
+            const types = await (0, kb_1.ontoListTypes)(pool);
+            if (options.format === "json") {
+                console.log(JSON.stringify(types, null, 2));
+            }
+            else {
+                console.log(chalk_1.default.cyan.bold("\n📐 온톨로지 타입\n"));
+                for (const t of types) {
+                    console.log(chalk_1.default.cyan(`  ${t.type_key}`) + chalk_1.default.gray(` (v${t.version})`));
+                    if (t.description)
+                        console.log(chalk_1.default.gray(`    ${t.description}`));
+                }
+                console.log();
+            }
+        }
+        else if (action === "instances") {
+            const instances = await (0, kb_1.ontoListInstances)(pool);
+            if (options.format === "json") {
+                console.log(JSON.stringify(instances, null, 2));
+            }
+            else {
+                console.log(chalk_1.default.cyan.bold("\n📐 서비스 인스턴스\n"));
+                for (const inst of instances) {
+                    console.log(chalk_1.default.cyan(`  ${inst.domain}`) + chalk_1.default.gray(` (${inst.entry_count} entries)`));
+                    if (inst.description)
+                        console.log(chalk_1.default.gray(`    ${inst.description}`));
+                    if (inst.scoped_domains.length > 0) {
+                        console.log(chalk_1.default.gray(`    scoped: ${inst.scoped_domains.join(", ")}`));
+                    }
+                }
+                console.log();
+            }
+        }
+        else if (action === "schema") {
+            if (!options.type) {
+                console.log(chalk_1.default.red("--type 옵션이 필요합니다. (예: --type service)"));
+                process.exit(1);
+            }
+            const schema = await (0, kb_1.ontoListSchema)(pool, options.type);
+            if (options.format === "json") {
+                console.log(JSON.stringify(schema, null, 2));
+            }
+            else {
+                console.log(chalk_1.default.cyan.bold(`\n📐 타입 스키마: ${options.type}\n`));
+                if (schema.length === 0) {
+                    console.log(chalk_1.default.yellow(`  스키마 없음: '${options.type}'`));
+                }
+                else {
+                    for (const s of schema) {
+                        const reqStr = s.required ? chalk_1.default.red(" *") : "";
+                        const typeStr = chalk_1.default.gray(` [${s.key_type}]`);
+                        console.log(chalk_1.default.cyan(`  ${s.scheme_key}`) + typeStr + reqStr);
+                        if (s.scheme_description)
+                            console.log(chalk_1.default.gray(`    ${s.scheme_description}`));
+                        if (s.value_hint)
+                            console.log(chalk_1.default.gray(`    hint: ${s.value_hint}`));
+                    }
+                }
+                console.log();
+            }
+        }
+        else if (action === "routing-table") {
+            const table = await (0, kb_1.ontoRoutingTable)(pool);
+            if (options.format === "json") {
+                console.log(JSON.stringify(table, null, 2));
+            }
+            else {
+                console.log(chalk_1.default.cyan.bold("\n📐 라우팅 테이블\n"));
+                let lastDomain = "";
+                for (const r of table) {
+                    if (r.domain !== lastDomain) {
+                        lastDomain = r.domain;
+                        const svcStr = r.service ? chalk_1.default.gray(` (${r.service})`) : "";
+                        console.log(chalk_1.default.white.bold(`\n  ${r.domain}`) + chalk_1.default.gray(` [${r.entity_type}]`) + svcStr);
+                        if (r.domain_description)
+                            console.log(chalk_1.default.gray(`    ${r.domain_description}`));
+                    }
+                    const typeStr = chalk_1.default.gray(` [${r.key_type}]`);
+                    console.log(chalk_1.default.cyan(`    → ${r.scheme_key}`) + typeStr);
+                    if (r.scheme_description)
+                        console.log(chalk_1.default.gray(`      ${r.scheme_description}`));
+                }
+                console.log();
+            }
+        }
+        else {
+            console.log(chalk_1.default.red(`알 수 없는 action: '${action}'. 사용 가능: list, show, services, types, instances, schema, routing-table`));
+            process.exit(1);
+        }
+        await (0, database_1.closeConnection)();
+    }
+    catch (err) {
+        console.error(chalk_1.default.red(`온톨로지 조회 실패: ${err}`));
+        await (0, database_1.closeConnection)();
+        process.exit(1);
+    }
+});
 // === Ontology 관리 ===
 const ontoCmd = program
     .command("onto")
@@ -2607,11 +2836,11 @@ ontoCmd
                 console.log(chalk_1.default.yellow("  온톨로지가 정의되지 않았습니다."));
             }
             else {
-                // Group by service
-                const global = domains.filter(d => !d.service);
+                // Group by service (_global treated as Global)
+                const global = domains.filter(d => !d.service || d.service === '_global');
                 const byService = {};
                 for (const d of domains) {
-                    if (d.service) {
+                    if (d.service && d.service !== '_global') {
                         if (!byService[d.service])
                             byService[d.service] = [];
                         byService[d.service].push(d);
@@ -2758,6 +2987,7 @@ ontoCmd
 (0, sessions_1.registerSessionsCommands)(program);
 (0, db_1.registerDbCommands)(program);
 (0, memory_1.registerMemoryCommands)(program);
+(0, test_1.registerTestCommands)(program);
 // === semo skills — DB 시딩 ===
 /**
  * SKILL.md frontmatter 파싱 (YAML 파서 없이 regex 기반)

package/dist/kb.d.ts

@@ -20,6 +20,7 @@ export declare function generateEmbeddings(texts: string[]): Promise<(number[] |
 export interface KBEntry {
     domain: string;
     key: string;
+    sub_key?: string;
     content: string;
     metadata?: Record<string, unknown>;
     created_by?: string;
@@ -54,6 +55,7 @@ export interface KBStatusInfo {
 export interface KBDigestEntry {
     domain: string;
     key: string;
+    sub_key?: string;
     content: string;
     version: number;
     change_type: 'new' | 'updated';
@@ -129,6 +131,73 @@ export declare function ontoValidate(pool: Pool, domain: string, entries?: KBEnt
  * Returns all KB changes since the given ISO timestamp.
  */
 export declare function kbDigest(pool: Pool, since: string, domain?: string): Promise<KBDigestResult>;
+/**
+ * Get a single KB entry by domain + key + sub_key
+ */
+export declare function kbGet(pool: Pool, domain: string, rawKey: string, rawSubKey?: string): Promise<KBEntry | null>;
+/**
+ * Upsert a single KB entry with domain/key validation and embedding generation
+ */
+export declare function kbUpsert(pool: Pool, entry: {
+    domain: string;
+    key: string;
+    sub_key?: string;
+    content: string;
+    metadata?: Record<string, unknown>;
+    created_by?: string;
+}): Promise<{
+    success: boolean;
+    error?: string;
+    warnings?: string[];
+}>;
+export interface TypeSchemaEntry {
+    type_key: string;
+    scheme_key: string;
+    scheme_description: string;
+    required: boolean;
+    value_hint: string | null;
+    sort_order: number;
+    key_type: "singleton" | "collection";
+}
+export interface RoutingEntry {
+    domain: string;
+    entity_type: string;
+    service: string | null;
+    domain_description: string | null;
+    scheme_key: string;
+    key_type: string;
+    scheme_description: string;
+    value_hint: string | null;
+}
+export interface ServiceInfo {
+    service: string;
+    domain_count: number;
+    domains: string[];
+}
+export interface ServiceInstance {
+    domain: string;
+    description: string | null;
+    service: string;
+    tags: string[];
+    scoped_domains: string[];
+    entry_count: number;
+}
+/**
+ * List type schema entries for a given entity type
+ */
+export declare function ontoListSchema(pool: Pool, typeKey: string): Promise<TypeSchemaEntry[]>;
+/**
+ * Full domain→key routing table for bot auto-classification
+ */
+export declare function ontoRoutingTable(pool: Pool): Promise<RoutingEntry[]>;
+/**
+ * List services grouped with domain counts
+ */
+export declare function ontoListServices(pool: Pool): Promise<ServiceInfo[]>;
+/**
+ * List service instances (entity_type = 'service')
+ */
+export declare function ontoListInstances(pool: Pool): Promise<ServiceInstance[]>;
 /**
  * Write ontology schemas to local cache
  */