@team-semicolon/semo-cli 4.2.0 → 4.3.0

package/dist/commands/memory.d.ts

@@ -0,0 +1,8 @@
+/**
+ * semo memory sync — L1 (bot workspace) → L2 (KB) 메모리 동기화
+ *
+ * Bot workspace의 일일 메모리 파일(YYYY-MM-DD.md)을 KB memory 도메인으로 싱크.
+ * V1: LLM 요약 없이 raw 저장 (Garden 정책 확정 후 추가 예정)
+ */
+import { Command } from "commander";
+export declare function registerMemoryCommands(program: Command): void;

package/dist/commands/memory.js

@@ -0,0 +1,297 @@
+"use strict";
+/**
+ * semo memory sync — L1 (bot workspace) → L2 (KB) 메모리 동기화
+ *
+ * Bot workspace의 일일 메모리 파일(YYYY-MM-DD.md)을 KB memory 도메인으로 싱크.
+ * V1: LLM 요약 없이 raw 저장 (Garden 정책 확정 후 추가 예정)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerMemoryCommands = registerMemoryCommands;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const crypto = __importStar(require("crypto"));
+const database_1 = require("../database");
+const kb_1 = require("../kb");
+// ============================================================
+// Constants
+// ============================================================
+const BOT_IDS = [
+    "semiclaw",
+    "workclaw",
+    "reviewclaw",
+    "planclaw",
+    "designclaw",
+    "infraclaw",
+    "growthclaw",
+];
+const MEMORY_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}\.md$/;
+const STATE_DIR = path.join(os.homedir(), ".semo");
+const STATE_FILE = path.join(STATE_DIR, "memory-sync-state.json");
+// ============================================================
+// State Management
+// ============================================================
+function readSyncState() {
+    try {
+        if (fs.existsSync(STATE_FILE)) {
+            return JSON.parse(fs.readFileSync(STATE_FILE, "utf-8"));
+        }
+    }
+    catch {
+        // corrupted state file
+    }
+    return { synced: {} };
+}
+function writeSyncState(state) {
+    fs.mkdirSync(STATE_DIR, { recursive: true });
+    fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+}
+function contentHash(content) {
+    return crypto.createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+// ============================================================
+// File Discovery
+// ============================================================
+function discoverBotMemoryFiles(botId, minAgeDays) {
+    const memoryDir = path.join(os.homedir(), `.openclaw-${botId}`, "workspace", "memory");
+    if (!fs.existsSync(memoryDir))
+        return [];
+    const candidates = [];
+    const cutoffDate = new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - minAgeDays);
+    const files = fs.readdirSync(memoryDir);
+    for (const file of files) {
+        if (!MEMORY_DATE_PATTERN.test(file))
+            continue;
+        const dateStr = file.replace(".md", "");
+        const fileDate = new Date(dateStr + "T23:59:59Z");
+        if (fileDate > cutoffDate)
+            continue; // Too recent
+        const filePath = path.join(memoryDir, file);
+        const content = fs.readFileSync(filePath, "utf-8").trim();
+        if (!content)
+            continue; // Skip empty files
+        candidates.push({
+            sourceType: "bot",
+            sourceId: botId,
+            date: dateStr,
+            filePath,
+            content,
+            hash: contentHash(content),
+        });
+    }
+    return candidates;
+}
+// ============================================================
+// Sync Logic
+// ============================================================
+async function syncMemories(candidates, state, force, dryRun) {
+    let synced = 0;
+    let skipped = 0;
+    const errors = [];
+    if (candidates.length === 0) {
+        return { synced, skipped, errors };
+    }
+    const pool = (0, database_1.getPool)();
+    for (const candidate of candidates) {
+        const stateKey = `${candidate.sourceId}/${candidate.date}`;
+        // Check watermark
+        if (!force) {
+            const existing = state.synced[stateKey];
+            if (existing && existing.hash === candidate.hash) {
+                skipped++;
+                continue;
+            }
+        }
+        if (dryRun) {
+            console.log(chalk_1.default.gray(`  [dry-run] ${stateKey} (${candidate.content.length} chars, hash: ${candidate.hash})`));
+            synced++;
+            continue;
+        }
+        try {
+            const domain = "memory";
+            const key = stateKey;
+            const metadata = {
+                source_type: candidate.sourceType,
+                source_id: candidate.sourceId,
+                date: candidate.date,
+                content_hash: candidate.hash,
+                original_size: candidate.content.length,
+                synced_at: new Date().toISOString(),
+            };
+            // Generate embedding
+            const text = `${key}: ${candidate.content}`;
+            const embedding = await (0, kb_1.generateEmbedding)(text);
+            const embeddingStr = embedding ? `[${embedding.join(",")}]` : null;
+            const client = await pool.connect();
+            try {
+                await client.query(`INSERT INTO semo.knowledge_base (domain, key, content, metadata, created_by, embedding)
+           VALUES ($1, $2, $3, $4, $5, $6::vector)
+           ON CONFLICT (domain, key) DO UPDATE SET
+             content = EXCLUDED.content,
+             metadata = EXCLUDED.metadata,
+             embedding = EXCLUDED.embedding`, [
+                    domain,
+                    key,
+                    candidate.content,
+                    JSON.stringify(metadata),
+                    "semo-memory-sync",
+                    embeddingStr,
+                ]);
+            }
+            finally {
+                client.release();
+            }
+            // Update watermark
+            state.synced[stateKey] = {
+                hash: candidate.hash,
+                syncedAt: new Date().toISOString(),
+            };
+            synced++;
+        }
+        catch (err) {
+            errors.push(`${stateKey}: ${err}`);
+        }
+    }
+    return { synced, skipped, errors };
+}
+// ============================================================
+// Command Registration
+// ============================================================
+function registerMemoryCommands(program) {
+    const memoryCmd = program
+        .command("memory")
+        .description("메모리 관리 — L1(bot workspace) → L2(KB) 동기화");
+    memoryCmd
+        .command("sync")
+        .description("봇 워크스페이스 메모리를 KB memory 도메인으로 동기화")
+        .option("--source <type>", "소스 타입 (bot | local | all)", "all")
+        .option("--bot <id>", "특정 봇만 동기화")
+        .option("--days <n>", "N일 이상 경과한 메모리만 동기화", "2")
+        .option("--dry-run", "프리뷰만 (실제 동기화 안 함)")
+        .option("--force", "워터마크 무시, 전체 재동기화")
+        .action(async (options) => {
+        const dryRun = !!options.dryRun;
+        const force = !!options.force;
+        const minAgeDays = parseInt(options.days) || 2;
+        const sourceType = options.source;
+        const specificBot = options.bot;
+        const spinner = (0, ora_1.default)(dryRun ? "동기화 대상 탐색 중..." : "메모리 동기화 중...").start();
+        try {
+            const state = readSyncState();
+            let allCandidates = [];
+            // Discover bot memory files
+            if (sourceType === "bot" || sourceType === "all") {
+                const bots = specificBot ? [specificBot] : BOT_IDS;
+                for (const botId of bots) {
+                    const candidates = discoverBotMemoryFiles(botId, minAgeDays);
+                    allCandidates.push(...candidates);
+                }
+            }
+            spinner.text = `${allCandidates.length}개 메모리 파일 발견`;
+            if (allCandidates.length === 0) {
+                spinner.succeed("동기화 대상 메모리 파일 없음");
+                await (0, database_1.closeConnection)();
+                return;
+            }
+            const result = await syncMemories(allCandidates, state, force, dryRun);
+            if (!dryRun) {
+                writeSyncState(state);
+            }
+            if (dryRun) {
+                spinner.succeed(`[dry-run] ${result.synced}건 동기화 예정, ${result.skipped}건 스킵`);
+            }
+            else {
+                spinner.succeed(`${result.synced}건 동기화 완료, ${result.skipped}건 스킵 (변경 없음)`);
+            }
+            if (result.errors.length > 0) {
+                console.log(chalk_1.default.yellow(`  ⚠️ ${result.errors.length}건 오류:`));
+                for (const err of result.errors) {
+                    console.log(chalk_1.default.red(`     ${err}`));
+                }
+            }
+            console.log();
+            await (0, database_1.closeConnection)();
+        }
+        catch (err) {
+            spinner.fail(`메모리 동기화 실패: ${err}`);
+            await (0, database_1.closeConnection)();
+            process.exit(1);
+        }
+    });
+    memoryCmd
+        .command("status")
+        .description("메모리 동기화 상태 확인")
+        .option("--bot <id>", "특정 봇만")
+        .action(async (options) => {
+        const state = readSyncState();
+        const specificBot = options.bot;
+        console.log(chalk_1.default.cyan.bold("\n📝 메모리 동기화 상태\n"));
+        const entries = Object.entries(state.synced);
+        if (entries.length === 0) {
+            console.log(chalk_1.default.yellow("  동기화된 메모리 없음"));
+            console.log();
+            return;
+        }
+        // Group by source
+        const grouped = {};
+        for (const [key, val] of entries) {
+            const [sourceId, date] = key.split("/");
+            if (specificBot && sourceId !== specificBot)
+                continue;
+            if (!grouped[sourceId])
+                grouped[sourceId] = [];
+            grouped[sourceId].push({ date, ...val });
+        }
+        for (const [sourceId, items] of Object.entries(grouped)) {
+            console.log(chalk_1.default.white(`  ${sourceId}:`));
+            const sorted = items.sort((a, b) => b.date.localeCompare(a.date));
+            const shown = sorted.slice(0, 10);
+            for (const item of shown) {
+                console.log(chalk_1.default.gray(`    ${item.date}  (synced: ${item.syncedAt.split("T")[0]})`));
+            }
+            if (sorted.length > 10) {
+                console.log(chalk_1.default.gray(`    ... +${sorted.length - 10} more`));
+            }
+        }
+        console.log();
+    });
+}

package/dist/database.d.ts

@@ -43,6 +43,7 @@ export interface Agent {
     package: string;
     is_active: boolean;
     install_order: number;
+    metadata?: Record<string, unknown>;
 }
 export interface Package {
     id: string;

package/dist/database.js

@@ -262,7 +262,8 @@ async function getAgents() {
         const result = await getPool().query(`
       SELECT id, name, name AS display_name,
              persona_prompt AS content,
-             package, is_active, install_order
+             package, is_active, install_order,
+             metadata
       FROM agent_definitions
       WHERE is_active = true AND office_id IS NULL
       ORDER BY install_order

package/dist/global-cache.js

@@ -174,6 +174,19 @@ async function syncGlobalCache(claudeDir) {
                 .join("\n");
             content += `\n\n## 위임 매트릭스\n${delegationLines}\n`;
         }
+        // metadata에 model/description이 있으면 YAML frontmatter 주입
+        if (agent.metadata && (agent.metadata.model || agent.metadata.description)) {
+            const hasFrontmatter = content.trimStart().startsWith('---');
+            if (!hasFrontmatter) {
+                const fm = ['---'];
+                if (agent.metadata.description)
+                    fm.push(`description: "${agent.metadata.description}"`);
+                if (agent.metadata.model)
+                    fm.push(`model: "${agent.metadata.model}"`);
+                fm.push('---', '');
+                content = fm.join('\n') + content;
+            }
+        }
         fs.writeFileSync(path.join(agentFolder, `${agent.name}.md`), content);
     }
     return {

package/dist/index.js

@@ -63,6 +63,7 @@ const bots_1 = require("./commands/bots");
 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 global_cache_1 = require("./global-cache");
 const PACKAGE_NAME = "@team-semicolon/semo-cli";
 // package.json에서 버전 동적 로드
@@ -773,10 +774,16 @@ program
     await setupStandardGlobal();
     // 4. Hooks 설치 (프로젝트 무관)
     await setupHooks(false);
-    // 5. MCP 설정 (글로벌)
+    // 5. MCP 설정 (글로벌 공통 서버)
     if (!options.skipMcp) {
         await setupMCP(os.homedir(), [], options.force || false);
     }
+    // 6. semo-kb MCP 유저레벨 등록
+    if (!options.skipMcp) {
+        await setupSemoKbMcp();
+    }
+    // 7. 글로벌 CLAUDE.md에 KB-First 규칙 주입
+    await injectKbFirstToGlobalClaudeMd();
     await (0, database_1.closeConnection)();
     // 결과 요약
     console.log(chalk_1.default.green.bold("\n✅ SEMO 글로벌 온보딩 완료!\n"));
@@ -786,6 +793,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.cyan("\n다음 단계:"));
     console.log(chalk_1.default.gray("  프로젝트 디렉토리에서 'semo init'을 실행하세요."));
     console.log();
@@ -1350,6 +1358,96 @@ function registerMCPServer(server) {
         return { success: false, error: String(error) };
     }
 }
+// === 글로벌 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 = `
+${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\`
+
+**금지:** 위 주제를 자체 지식/세션 기억만으로 답변하는 것.
+KB에 없으면: "KB에 해당 정보가 없습니다. 알려주시면 등록하겠습니다."
+
+### 쓰기 (Write-Back)
+사용자가 팀 정보를 정정/추가/변경하면, 의사결정이 내려지면 → **반드시 kb_upsert로 KB에 즉시 기록.**
+**금지:** "알겠습니다/기억하겠습니다"만 하고 KB에 쓰지 않는 것.
+`;
+    if (fs.existsSync(globalClaudeMd)) {
+        const content = fs.readFileSync(globalClaudeMd, "utf-8");
+        if (content.includes(KB_FIRST_SECTION_MARKER)) {
+            // 기존 섹션 교체
+            const regex = new RegExp(`\\n${KB_FIRST_SECTION_MARKER.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?(?=\\n## |$)`, "m");
+            const updated = content.replace(regex, kbFirstBlock);
+            fs.writeFileSync(globalClaudeMd, updated);
+            console.log(chalk_1.default.gray("  ~/.claude/CLAUDE.md KB-First 규칙 업데이트됨"));
+        }
+        else {
+            // 끝에 추가
+            fs.writeFileSync(globalClaudeMd, content.trimEnd() + "\n" + kbFirstBlock);
+            console.log(chalk_1.default.green("  ✓ ~/.claude/CLAUDE.md에 KB-First 규칙 추가됨"));
+        }
+    }
+    else {
+        // 파일 없으면 생성
+        fs.writeFileSync(globalClaudeMd, kbFirstBlock.trim() + "\n");
+        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)"));
@@ -1366,14 +1464,10 @@ async function setupMCP(cwd, _extensions, force) {
     const settings = {
         mcpServers: {},
     };
-    // settings.json에는 프로젝트 전용 semo-kb만 기록
-    // 공통 서버(context7 등)는 유저레벨에 등록하므로 프로젝트 settings에 쓰지 않음
-    settings.mcpServers["semo-kb"] = {
-        command: "node",
-        args: ["packages/mcp-kb/dist/index.js"],
-    };
+    // semo-kb는 유저레벨에서 등록 (semo onboarding)하므로 프로젝트 settings에 쓰지 않음
+    // 공통 서버(context7 등)도 유저레벨에 등록하므로 프로젝트 settings에 쓰지 않음
     fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-    console.log(chalk_1.default.green("✓ .claude/settings.json 생성됨 (semo-kb MCP 설정)"));
+    console.log(chalk_1.default.green("✓ .claude/settings.json 생성됨"));
     // Claude Code에 MCP 서버 등록 시도 (공통 서버는 유저레벨로)
     console.log(chalk_1.default.cyan("\n🔌 Claude Code에 MCP 서버 등록 중..."));
     const allServers = [...BASE_MCP_SERVERS];
@@ -2331,6 +2425,7 @@ kbCmd
     .command("list")
     .description("KB 항목 목록 조회")
     .option("--domain <name>", "도메인 필터")
+    .option("--service <name>", "서비스(프로젝트) 필터 — 해당 서비스의 모든 도메인 항목 반환")
     .option("--limit <n>", "최대 항목 수", "50")
     .option("--format <type>", "출력 형식 (table|json)", "table")
     .action(async (options) => {
@@ -2338,6 +2433,7 @@ kbCmd
         const pool = (0, database_1.getPool)();
         const entries = await (0, kb_1.kbList)(pool, {
             domain: options.domain,
+            service: options.service,
             limit: parseInt(options.limit),
         });
         if (options.format === "json") {
@@ -2370,6 +2466,7 @@ kbCmd
     .command("search <query>")
     .description("KB 검색 (시맨틱 + 텍스트 하이브리드)")
     .option("--domain <name>", "도메인 필터")
+    .option("--service <name>", "서비스(프로젝트) 필터")
     .option("--limit <n>", "최대 결과 수", "10")
     .option("--mode <type>", "검색 모드 (hybrid|semantic|text)", "hybrid")
     .action(async (query, options) => {
@@ -2378,6 +2475,7 @@ kbCmd
         const pool = (0, database_1.getPool)();
         const results = await (0, kb_1.kbSearch)(pool, query, {
             domain: options.domain,
+            service: options.service,
             limit: parseInt(options.limit),
             mode: options.mode,
         });
@@ -2491,11 +2589,15 @@ const ontoCmd = program
 ontoCmd
     .command("list")
     .description("정의된 온톨로지 도메인 목록")
+    .option("--service <name>", "서비스별 필터")
     .option("--format <type>", "출력 형식 (table|json)", "table")
     .action(async (options) => {
     try {
         const pool = (0, database_1.getPool)();
-        const domains = await (0, kb_1.ontoList)(pool);
+        let domains = await (0, kb_1.ontoList)(pool);
+        if (options.service) {
+            domains = domains.filter(d => d.service === options.service || d.domain === options.service || d.domain.startsWith(`${options.service}.`));
+        }
         if (options.format === "json") {
             console.log(JSON.stringify(domains, null, 2));
         }
@@ -2505,10 +2607,66 @@ ontoCmd
                 console.log(chalk_1.default.yellow("  온톨로지가 정의되지 않았습니다."));
             }
             else {
+                // Group by service
+                const global = domains.filter(d => !d.service);
+                const byService = {};
                 for (const d of domains) {
-                    console.log(chalk_1.default.cyan(`  ${d.domain}`) + chalk_1.default.gray(` (v${d.version})`));
-                    if (d.description)
-                        console.log(chalk_1.default.gray(`    ${d.description}`));
+                    if (d.service) {
+                        if (!byService[d.service])
+                            byService[d.service] = [];
+                        byService[d.service].push(d);
+                    }
+                }
+                if (global.length > 0) {
+                    console.log(chalk_1.default.white.bold("  Global"));
+                    for (const d of global) {
+                        const typeStr = d.entity_type ? chalk_1.default.gray(` [${d.entity_type}]`) : "";
+                        console.log(chalk_1.default.cyan(`    ${d.domain}`) + typeStr + chalk_1.default.gray(` (v${d.version})`));
+                        if (d.description)
+                            console.log(chalk_1.default.gray(`      ${d.description}`));
+                    }
+                }
+                for (const [svc, svcDomains] of Object.entries(byService)) {
+                    console.log(chalk_1.default.white.bold(`\n  Service: ${svc}`));
+                    for (const d of svcDomains) {
+                        const typeStr = d.entity_type ? chalk_1.default.gray(` [${d.entity_type}]`) : "";
+                        console.log(chalk_1.default.cyan(`    ${d.domain}`) + typeStr + chalk_1.default.gray(` (v${d.version})`));
+                        if (d.description)
+                            console.log(chalk_1.default.gray(`      ${d.description}`));
+                    }
+                }
+            }
+            console.log();
+        }
+        await (0, database_1.closeConnection)();
+    }
+    catch (err) {
+        console.error(chalk_1.default.red(`조회 실패: ${err}`));
+        await (0, database_1.closeConnection)();
+        process.exit(1);
+    }
+});
+ontoCmd
+    .command("types")
+    .description("온톨로지 타입 목록 (구조적 템플릿)")
+    .option("--format <type>", "출력 형식 (table|json)", "table")
+    .action(async (options) => {
+    try {
+        const pool = (0, database_1.getPool)();
+        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"));
+            if (types.length === 0) {
+                console.log(chalk_1.default.yellow("  타입이 정의되지 않았습니다. (016 마이그레이션 실행 필요)"));
+            }
+            else {
+                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();
@@ -2599,6 +2757,7 @@ ontoCmd
 (0, get_1.registerGetCommands)(program);
 (0, sessions_1.registerSessionsCommands)(program);
 (0, db_1.registerDbCommands)(program);
+(0, memory_1.registerMemoryCommands)(program);
 // === semo skills — DB 시딩 ===
 /**
  * SKILL.md frontmatter 파싱 (YAML 파서 없이 regex 기반)

package/dist/kb.d.ts

@@ -32,8 +32,18 @@ export interface OntologyDomain {
     schema: Record<string, unknown>;
     description: string | null;
     version: number;
+    service?: string | null;
+    entity_type?: string | null;
+    parent?: string | null;
+    tags?: string[];
     updated_at?: string;
 }
+export interface OntologyType {
+    type_key: string;
+    schema: Record<string, unknown>;
+    description: string | null;
+    version: number;
+}
 export interface KBStatusInfo {
     shared: {
         total: number;
@@ -79,6 +89,7 @@ export declare function kbStatus(pool: Pool): Promise<KBStatusInfo>;
  */
 export declare function kbList(pool: Pool, options: {
     domain?: string;
+    service?: string;
     limit?: number;
     offset?: number;
 }): Promise<KBEntry[]>;
@@ -87,6 +98,7 @@ export declare function kbList(pool: Pool, options: {
  */
 export declare function kbSearch(pool: Pool, query: string, options: {
     domain?: string;
+    service?: string;
     limit?: number;
     mode?: "semantic" | "text" | "hybrid";
 }): Promise<KBEntry[]>;
@@ -98,6 +110,10 @@ export declare function ontoList(pool: Pool): Promise<OntologyDomain[]>;
  * Show ontology detail for a domain
  */
 export declare function ontoShow(pool: Pool, domain: string): Promise<OntologyDomain | null>;
+/**
+ * List all ontology types (structural templates)
+ */
+export declare function ontoListTypes(pool: Pool): Promise<OntologyType[]>;
 /**
  * Validate KB entries against ontology schema (basic JSON Schema validation)
  */

package/dist/kb.js

@@ -51,6 +51,7 @@ exports.kbList = kbList;
 exports.kbSearch = kbSearch;
 exports.ontoList = ontoList;
 exports.ontoShow = ontoShow;
+exports.ontoListTypes = ontoListTypes;
 exports.ontoValidate = ontoValidate;
 exports.kbDigest = kbDigest;
 exports.ontoPullToLocal = ontoPullToLocal;
@@ -313,6 +314,14 @@ async function kbList(pool, options) {
             query += ` WHERE domain = $${paramIdx++}`;
             params.push(options.domain);
         }
+        else if (options.service) {
+            // Resolve service to domain list: service name itself + dot-notation domains
+            const serviceDomains = await resolveServiceDomainsLocal(client, options.service);
+            if (serviceDomains.length > 0) {
+                query += ` WHERE domain = ANY($${paramIdx++})`;
+                params.push(serviceDomains);
+            }
+        }
         query += ` ORDER BY domain, key LIMIT $${paramIdx++} OFFSET $${paramIdx++}`;
         params.push(limit, offset);
         const result = await client.query(query, params);
@@ -329,6 +338,11 @@ async function kbSearch(pool, query, options) {
     const client = await pool.connect();
     const limit = options.limit || 10;
     const mode = options.mode || "hybrid";
+    // Resolve service → domain list for filtering
+    let serviceDomains = null;
+    if (options.service && !options.domain) {
+        serviceDomains = await resolveServiceDomainsLocal(client, options.service);
+    }
     try {
         let results = [];
         // Try semantic search first (if mode allows and embedding API available)
@@ -349,6 +363,10 @@ async function kbSearch(pool, query, options) {
                     sql += ` AND domain = $${paramIdx++}`;
                     params.push(options.domain);
                 }
+                else if (serviceDomains && serviceDomains.length > 0) {
+                    sql += ` AND domain = ANY($${paramIdx++})`;
+                    params.push(serviceDomains);
+                }
                 sql += ` ORDER BY embedding <=> $1::vector LIMIT $${paramIdx++}`;
                 params.push(limit);
                 const sharedResult = await client.query(sql, params);
@@ -390,6 +408,10 @@ async function kbSearch(pool, query, options) {
                 textSql += ` AND domain = $${tIdx++}`;
                 textParams.push(options.domain);
             }
+            else if (serviceDomains && serviceDomains.length > 0) {
+                textSql += ` AND domain = ANY($${tIdx++})`;
+                textParams.push(serviceDomains);
+            }
             textSql += ` ORDER BY score DESC, updated_at DESC LIMIT $${tIdx++}`;
             textParams.push(limit);
             const textResult = await client.query(textSql, textParams);
@@ -447,8 +469,10 @@ async function ontoList(pool) {
     const client = await pool.connect();
     try {
         const result = await client.query(`
-      SELECT domain, schema, description, version, updated_at::text
-      FROM semo.ontology ORDER BY domain
+      SELECT domain, schema, description, version,
+             service, entity_type, parent, tags,
+             updated_at::text
+      FROM semo.ontology ORDER BY service NULLS FIRST, domain
     `);
         return result.rows;
     }
@@ -462,13 +486,52 @@ async function ontoList(pool) {
 async function ontoShow(pool, domain) {
     const client = await pool.connect();
     try {
-        const result = await client.query(`SELECT domain, schema, description, version, updated_at::text FROM semo.ontology WHERE domain = $1`, [domain]);
+        const result = await client.query(`SELECT domain, schema, description, version,
+              service, entity_type, parent, tags,
+              updated_at::text
+       FROM semo.ontology WHERE domain = $1`, [domain]);
         return result.rows[0] || null;
     }
     finally {
         client.release();
     }
 }
+/**
+ * List all ontology types (structural templates)
+ */
+async function ontoListTypes(pool) {
+    const client = await pool.connect();
+    try {
+        const result = await client.query(`
+      SELECT type_key, schema, description, version
+      FROM semo.ontology_types ORDER BY type_key
+    `);
+        return result.rows;
+    }
+    catch {
+        return []; // Table may not exist yet (pre-016 migration)
+    }
+    finally {
+        client.release();
+    }
+}
+/**
+ * Resolve a service name to its associated domain list.
+ * Uses ontology.service column + dot-notation domain detection.
+ */
+async function resolveServiceDomainsLocal(client, service) {
+    try {
+        const result = await client.query(`SELECT domain FROM semo.ontology WHERE service = $1
+       UNION
+       SELECT domain FROM semo.ontology WHERE domain LIKE $2
+       UNION
+       SELECT domain FROM semo.ontology WHERE domain = $1`, [service, `${service}.%`]);
+        return result.rows.map((r) => r.domain);
+    }
+    catch {
+        return [];
+    }
+}
 /**
  * Validate KB entries against ontology schema (basic JSON Schema validation)
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-semicolon/semo-cli",
-  "version": "4.2.0",
+  "version": "4.3.0",
   "description": "SEMO CLI - AI Agent Orchestration Framework Installer",
   "main": "dist/index.js",
   "bin": {