@team-semicolon/semo-cli 4.1.5 → 4.3.0

package/dist/index.js

@@ -56,11 +56,15 @@ const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
+const env_parser_1 = require("./env-parser");
 const database_1 = require("./database");
 const context_1 = require("./commands/context");
 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에서 버전 동적 로드
 function getCliVersion() {
@@ -133,7 +137,7 @@ async function getRemotePackageVersion(packagePath) {
     }
 }
 /**
- * semo-core/semo-skills 원격 버전 가져오기 (semo-system/ 하위 경로)
+ * semo-core 등 원격 버전 가져오기 (semo-system/ 하위 경로)
  */
 async function getRemoteCoreVersion(type) {
     try {
@@ -159,7 +163,7 @@ async function showVersionComparison(cwd) {
         // 1. CLI 버전 비교
         const currentCliVersion = VERSION;
         const latestCliVersion = await getLatestVersion();
-        // 2. semo-core, semo-skills 버전 비교
+        // 2. semo-core 버전 비교
         const semoSystemDir = path.join(cwd, "semo-system");
         const hasSemoSystem = fs.existsSync(semoSystemDir);
         const versionInfos = [];
@@ -171,15 +175,14 @@ async function showVersionComparison(cwd) {
             needsUpdate: latestCliVersion ? isVersionLower(currentCliVersion, latestCliVersion) : false,
             level: 0,
         });
-        // 레거시 환경 경고 (루트에 semo-core/semo-skills가 있는 경우)
+        // 레거시 환경 경고 (루트에 semo-core가 있는 경우)
         const hasLegacyCore = fs.existsSync(path.join(cwd, "semo-core"));
-        const hasLegacySkills = fs.existsSync(path.join(cwd, "semo-skills"));
-        if (hasLegacyCore || hasLegacySkills) {
+        if (hasLegacyCore) {
             spinner.warn("레거시 환경 감지됨");
             console.log(chalk_1.default.yellow("\n  ⚠️  구버전 SEMO 구조가 감지되었습니다."));
-            console.log(chalk_1.default.gray("     루트에 semo-core/ 또는 semo-skills/가 있습니다."));
+            console.log(chalk_1.default.gray("     루트에 semo-core/가 있습니다."));
             console.log(chalk_1.default.cyan("\n  💡 마이그레이션 방법:"));
-            console.log(chalk_1.default.gray("     1. 기존 semo-core/, semo-skills/ 폴더 삭제"));
+            console.log(chalk_1.default.gray("     1. 기존 semo-core/ 폴더 삭제"));
             console.log(chalk_1.default.gray("     2. .claude/ 폴더 삭제"));
             console.log(chalk_1.default.gray("     3. semo init 다시 실행\n"));
             console.log(chalk_1.default.gray("     또는: semo migrate --force\n"));
@@ -198,19 +201,7 @@ async function showVersionComparison(cwd) {
                 level: 0,
             });
         }
-        // semo-skills (semo-system/ 내부만 확인)
-        const skillsPathSystem = path.join(semoSystemDir, "semo-skills", "VERSION");
-        if (fs.existsSync(skillsPathSystem)) {
-            const localSkills = fs.readFileSync(skillsPathSystem, "utf-8").trim();
-            const remoteSkills = await getRemoteCoreVersion("semo-skills");
-            versionInfos.push({
-                name: "semo-skills",
-                local: localSkills,
-                remote: remoteSkills,
-                needsUpdate: remoteSkills ? isVersionLower(localSkills, remoteSkills) : false,
-                level: 0,
-            });
-        }
+        // semo-skills 제거됨 — 중앙 DB 단일 SoT
         // semo-agents (semo-system/ 내부)
         const agentsPathSystem = path.join(semoSystemDir, "semo-agents", "VERSION");
         if (fs.existsSync(agentsPathSystem)) {
@@ -384,13 +375,13 @@ function isSymlinkValid(linkPath) {
 }
 /**
  * 레거시 SEMO 환경을 감지합니다.
- * 레거시: 프로젝트 루트에 semo-core/, semo-skills/ 가 직접 있는 경우
+ * 레거시: 프로젝트 루트에 semo-core/ 가 직접 있는 경우
  * 신규: semo-system/ 하위에 있는 경우
  */
 function detectLegacyEnvironment(cwd) {
     const legacyPaths = [];
     // 루트에 직접 있는 레거시 디렉토리 확인
-    const legacyDirs = ["semo-core", "semo-skills", "sax-core", "sax-skills"];
+    const legacyDirs = ["semo-core", "sax-core", "sax-skills"];
     for (const dir of legacyDirs) {
         const dirPath = path.join(cwd, dir);
         if (fs.existsSync(dirPath) && !fs.lstatSync(dirPath).isSymbolicLink()) {
@@ -452,7 +443,7 @@ async function migrateLegacyEnvironment(cwd) {
     if (!shouldMigrate) {
         console.log(chalk_1.default.yellow("\n마이그레이션이 취소되었습니다."));
         console.log(chalk_1.default.gray("💡 수동 마이그레이션 방법:"));
-        console.log(chalk_1.default.gray("   1. 기존 semo-core/, semo-skills/ 폴더 삭제"));
+        console.log(chalk_1.default.gray("   1. 기존 레거시 폴더 삭제"));
         console.log(chalk_1.default.gray("   2. .claude/ 폴더 삭제"));
         console.log(chalk_1.default.gray("   3. semo init 다시 실행\n"));
         return false;
@@ -460,7 +451,7 @@ async function migrateLegacyEnvironment(cwd) {
     const spinner = (0, ora_1.default)("레거시 환경 마이그레이션 중...").start();
     try {
         // 1. 루트의 레거시 디렉토리 삭제
-        const legacyDirs = ["semo-core", "semo-skills", "sax-core", "sax-skills"];
+        const legacyDirs = ["semo-core", "sax-core", "sax-skills"];
         for (const dir of legacyDirs) {
             const dirPath = path.join(cwd, dir);
             if (fs.existsSync(dirPath) && !fs.lstatSync(dirPath).isSymbolicLink()) {
@@ -579,21 +570,6 @@ async function showVersionInfo() {
             level: 0,
         });
     }
-    // 3. semo-skills 버전 (루트 또는 semo-system 내부)
-    const skillsPathRoot = path.join(cwd, "semo-skills", "VERSION");
-    const skillsPathSystem = path.join(cwd, "semo-system", "semo-skills", "VERSION");
-    const skillsPath = fs.existsSync(skillsPathRoot) ? skillsPathRoot : skillsPathSystem;
-    if (fs.existsSync(skillsPath)) {
-        const localSkills = fs.readFileSync(skillsPath, "utf-8").trim();
-        const remoteSkills = await getRemoteCoreVersion("semo-skills");
-        versionInfos.push({
-            name: "semo-skills",
-            local: localSkills,
-            remote: remoteSkills,
-            needsUpdate: remoteSkills ? isVersionLower(localSkills, remoteSkills) : false,
-            level: 0,
-        });
-    }
     // 결과 출력
     const needsUpdateCount = versionInfos.filter(v => v.needsUpdate).length;
     if (versionInfos.length === 1) {
@@ -676,11 +652,6 @@ async function confirmOverwrite(itemName, itemPath) {
     if (!fs.existsSync(itemPath)) {
         return true;
     }
-    // 비인터랙티브 환경(CI, 파이프) — 덮어쓰지 않고 기존 파일 유지
-    if (!process.stdin.isTTY) {
-        console.log(chalk_1.default.gray(`  → ${itemName} 이미 존재 (비인터랙티브 모드: 건너뜀)`));
-        return false;
-    }
     const { shouldOverwrite } = await inquirer_1.default.prompt([
         {
             type: "confirm",
@@ -769,36 +740,82 @@ async function showToolsStatus() {
     }
     return true;
 }
-// === init 명령어 ===
+// === 글로벌 설정 체크 ===
+function isGlobalSetupDone() {
+    const home = os.homedir();
+    return (fs.existsSync(path.join(home, ".semo.env")) &&
+        fs.existsSync(path.join(home, ".claude", "skills")));
+}
+// === onboarding 명령어 (글로벌 1회 설정) ===
 program
-    .command("init")
-    .description("현재 프로젝트에 SEMO를 설치합니다")
+    .command("onboarding")
+    .description("글로벌 SEMO 설정 (머신당 1회) — ~/.claude/, ~/.semo.env")
+    .option("--credentials-gist <gistId>", "Private GitHub Gist에서 DB 접속정보 가져오기")
     .option("-f, --force", "기존 설정 덮어쓰기")
     .option("--skip-mcp", "MCP 설정 생략")
+    .action(async (options) => {
+    console.log(chalk_1.default.cyan.bold("\n🏠 SEMO 글로벌 온보딩\n"));
+    console.log(chalk_1.default.gray("  대상: ~/.claude/, ~/.semo.env (머신당 1회)\n"));
+    // 1. ~/.semo.env DB 접속 설정
+    await setupSemoEnv(options.credentialsGist, options.force);
+    // 2. DB health check
+    const spinner = (0, ora_1.default)("DB 연결 확인 중...").start();
+    const connected = await (0, database_1.isDbConnected)();
+    if (connected) {
+        spinner.succeed("DB 연결 확인됨");
+    }
+    else {
+        spinner.warn("DB 연결 실패 — 스킬/커맨드/에이전트 설치를 건너뜁니다");
+        console.log(chalk_1.default.gray("  ~/.semo.env를 확인하고 다시 시도하세요: semo onboarding\n"));
+        await (0, database_1.closeConnection)();
+        return;
+    }
+    // 3. Standard 설치 (DB → ~/.claude/skills, commands, agents)
+    await setupStandardGlobal();
+    // 4. Hooks 설치 (프로젝트 무관)
+    await setupHooks(false);
+    // 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"));
+    console.log(chalk_1.default.cyan("설치된 구성:"));
+    console.log(chalk_1.default.gray("  ~/.semo.env              DB 접속정보 (권한 600)"));
+    console.log(chalk_1.default.gray("  ~/.claude/skills/        팀 스킬 (DB 기반)"));
+    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();
+});
+// === init 명령어 (프로젝트별 설정) ===
+program
+    .command("init")
+    .description("현재 프로젝트에 SEMO 프로젝트 설정을 합니다 (글로벌: semo onboarding)")
+    .option("-f, --force", "기존 설정 덮어쓰기")
     .option("--no-gitignore", ".gitignore 수정 생략")
-    .option("--migrate", "레거시 환경 강제 마이그레이션")
-    .option("--seed-skills", "semo-system/semo-skills/ → semo.skills DB 초기 시딩")
-    .option("--credentials-gist <gistId>", "Private GitHub Gist에서 팀 DB 접속정보 자동 가져오기")
     .action(async (options) => {
-    console.log(chalk_1.default.cyan.bold("\n🚀 SEMO 설치 시작\n"));
+    console.log(chalk_1.default.cyan.bold("\n📁 SEMO 프로젝트 설정\n"));
     const cwd = process.cwd();
-    // 0.1. 버전 비교
-    await showVersionComparison(cwd);
-    // 0.5. 레거시 환경 감지 및 마이그레이션
-    const legacyCheck = detectLegacyEnvironment(cwd);
-    if (legacyCheck.hasLegacy || options.migrate) {
-        const migrationSuccess = await migrateLegacyEnvironment(cwd);
-        if (!migrationSuccess) {
-            process.exit(0);
-        }
-    }
-    // 1. 필수 도구 확인
-    const shouldContinue = await showToolsStatus();
-    if (!shouldContinue) {
-        console.log(chalk_1.default.yellow("\n설치가 취소되었습니다. 필수 도구 설치 후 다시 시도하세요.\n"));
-        process.exit(0);
+    // 0. 글로벌 설정 확인
+    if (!isGlobalSetupDone()) {
+        console.log(chalk_1.default.yellow("⚠ 글로벌 설정이 완료되지 않았습니다."));
+        console.log(chalk_1.default.gray("  먼저 'semo onboarding'을 실행하세요.\n"));
+        console.log(chalk_1.default.gray("  이 머신에서 처음 SEMO를 사용하시나요?"));
+        console.log(chalk_1.default.cyan("  → semo onboarding --credentials-gist <GIST_ID>\n"));
+        process.exit(1);
     }
-    // 1.5. Git 레포지토리 확인
+    // 1. Git 레포지토리 확인
     const spinner = (0, ora_1.default)("Git 레포지토리 확인 중...").start();
     try {
         (0, child_process_1.execSync)("git rev-parse --git-dir", { cwd, stdio: "pipe" });
@@ -814,64 +831,48 @@ program
         fs.mkdirSync(claudeDir, { recursive: true });
         console.log(chalk_1.default.green("\n✓ .claude/ 디렉토리 생성됨"));
     }
-    // 2.5. ~/.semo.env DB 접속 설정 (자동 감지 → Gist → 프롬프트) — DB 연결 전에 먼저
-    await setupSemoEnv(options.credentialsGist);
-    // 3. Standard 설치 (semo-core + semo-skills)
-    await setupStandard(cwd, options.force);
-    // 4. MCP 설정
-    if (!options.skipMcp) {
-        await setupMCP(cwd, [], options.force);
+    // 3. 로컬 스킬 경고 (기존 프로젝트 호환)
+    const localSkillsDir = path.join(claudeDir, "skills");
+    if (fs.existsSync(localSkillsDir)) {
+        try {
+            const localSkills = fs.readdirSync(localSkillsDir).filter(f => fs.statSync(path.join(localSkillsDir, f)).isDirectory());
+            if (localSkills.length > 0) {
+                console.log(chalk_1.default.yellow(`\nℹ 프로젝트 로컬 스킬이 감지되었습니다 (${localSkills.length}개).`));
+                console.log(chalk_1.default.gray("  글로벌 스킬(~/.claude/skills/)이 우선 적용됩니다."));
+                console.log(chalk_1.default.gray("  로컬 스킬을 제거하려면: rm -rf .claude/skills/ .claude/commands/ .claude/agents/\n"));
+            }
+        }
+        catch {
+            // ignore
+        }
     }
-    // 5. Context Mesh 초기화
+    // 4. Context Mesh 초기화
     await setupContextMesh(cwd);
+    // 5. CLAUDE.md 생성 (프로젝트 규칙만, 스킬 목록 없음)
+    await setupClaudeMd(cwd, [], options.force || false);
     // 6. .gitignore 업데이트
     if (options.gitignore !== false) {
         updateGitignore(cwd);
     }
-    // 7. Hooks 설치
-    await setupHooks(cwd, false);
-    // 8. CLAUDE.md 생성
-    await setupClaudeMd(cwd, [], options.force);
-    // 9. 설치 검증
-    const verificationResult = verifyInstallation(cwd, []);
-    printVerificationResult(verificationResult);
-    // 10. Skills DB 시딩 (--seed-skills 옵션)
-    if (options.seedSkills) {
-        console.log(chalk_1.default.cyan("\n🌱 스킬 DB 시딩 (--seed-skills)"));
-        const semoSystemDir = path.join(cwd, "semo-system");
-        await seedSkillsToDb(semoSystemDir);
-    }
     // 완료 메시지
-    if (verificationResult.success) {
-        console.log(chalk_1.default.green.bold("\n✅ SEMO 설치 완료!\n"));
-    }
-    else {
-        console.log(chalk_1.default.yellow.bold("\n⚠️ SEMO 설치 완료 (일부 문제 발견)\n"));
-    }
-    console.log(chalk_1.default.cyan("설치된 구성:"));
-    console.log(chalk_1.default.gray("  ✓ .claude/skills/    (DB 기반 스킬)"));
-    console.log(chalk_1.default.gray("  ✓ .claude/agents/    (DB 기반 에이전트)"));
-    console.log(chalk_1.default.gray("  ✓ .claude/commands/  (슬래시 커맨드)"));
-    console.log(chalk_1.default.gray("  ✓ .claude/memory/    (컨텍스트 동기화)"));
-    console.log(chalk_1.default.gray("  ✓ ~/.claude/settings.local.json  (훅 등록)"));
+    console.log(chalk_1.default.green.bold("\n✅ SEMO 프로젝트 설정 완료!\n"));
+    console.log(chalk_1.default.cyan("생성된 파일:"));
+    console.log(chalk_1.default.gray("  {cwd}/.claude/CLAUDE.md          프로젝트 규칙"));
+    console.log(chalk_1.default.gray("  {cwd}/.claude/memory/context.md   프로젝트 상태"));
+    console.log(chalk_1.default.gray("  {cwd}/.claude/memory/decisions.md ADR"));
+    console.log(chalk_1.default.gray("  {cwd}/.claude/memory/projects.md  프로젝트 맵"));
     console.log(chalk_1.default.cyan("\n다음 단계:"));
     console.log(chalk_1.default.gray("  1. Claude Code에서 프로젝트 열기 (SessionStart 훅이 자동 sync)"));
     console.log(chalk_1.default.gray("  2. 자연어로 요청하기 (예: \"댓글 기능 구현해줘\")"));
     console.log(chalk_1.default.gray("  3. /SEMO:help로 도움말 확인"));
     console.log();
-    console.log(chalk_1.default.gray("  DB 접속정보 변경: nano ~/.semo.env"));
-    console.log();
 });
-// === Standard 설치 (DB 기반) ===
-async function setupStandard(cwd, force) {
-    const claudeDir = path.join(cwd, ".claude");
-    console.log(chalk_1.default.cyan("\n📚 Standard 설치 (DB 기반)"));
-    console.log(chalk_1.default.gray("   스킬: DB에서 조회하여 파일 생성"));
-    console.log(chalk_1.default.gray("   커맨드: DB에서 조회하여 파일 생성"));
-    console.log(chalk_1.default.gray("   에이전트: DB에서 조회하여 파일 생성\n"));
+// === Standard 설치 (DB 기반, 글로벌 ~/.claude/) ===
+async function setupStandardGlobal() {
+    console.log(chalk_1.default.cyan("\n📚 Standard 설치 (DB → ~/.claude/)"));
+    console.log(chalk_1.default.gray("   스킬/커맨드/에이전트를 글로벌에 설치\n"));
     const spinner = (0, ora_1.default)("DB에서 스킬/커맨드/에이전트 조회 중...").start();
     try {
-        // DB 연결 확인
         const connected = await (0, database_1.isDbConnected)();
         if (connected) {
             spinner.text = "DB 연결 성공, 데이터 조회 중...";
@@ -879,174 +880,18 @@ async function setupStandard(cwd, force) {
         else {
             spinner.text = "DB 연결 실패, 폴백 데이터 사용 중...";
         }
-        // .claude 디렉토리 생성
-        fs.mkdirSync(claudeDir, { recursive: true });
-        // 1. 스킬 설치
-        const skillsDir = path.join(claudeDir, "skills");
-        if (force && fs.existsSync(skillsDir)) {
-            removeRecursive(skillsDir);
-        }
-        fs.mkdirSync(skillsDir, { recursive: true });
-        const skills = await (0, database_1.getActiveSkills)();
-        for (const skill of skills) {
-            const skillFolder = path.join(skillsDir, skill.name);
-            fs.mkdirSync(skillFolder, { recursive: true });
-            fs.writeFileSync(path.join(skillFolder, "SKILL.md"), skill.content);
-        }
-        console.log(chalk_1.default.green(`  ✓ skills 설치 완료 (${skills.length}개)`));
-        // 2. 커맨드 설치
-        const commandsDir = path.join(claudeDir, "commands");
-        if (force && fs.existsSync(commandsDir)) {
-            removeRecursive(commandsDir);
-        }
-        fs.mkdirSync(commandsDir, { recursive: true });
-        const commands = await (0, database_1.getCommands)();
-        // 폴더별로 그룹핑
-        const commandsByFolder = {};
-        for (const cmd of commands) {
-            if (!commandsByFolder[cmd.folder]) {
-                commandsByFolder[cmd.folder] = [];
-            }
-            commandsByFolder[cmd.folder].push(cmd);
-        }
-        let cmdCount = 0;
-        for (const [folder, cmds] of Object.entries(commandsByFolder)) {
-            const folderPath = path.join(commandsDir, folder);
-            fs.mkdirSync(folderPath, { recursive: true });
-            for (const cmd of cmds) {
-                fs.writeFileSync(path.join(folderPath, `${cmd.name}.md`), cmd.content);
-                cmdCount++;
-            }
-        }
-        console.log(chalk_1.default.green(`  ✓ commands 설치 완료 (${cmdCount}개)`));
-        // 3. 에이전트 설치
-        const agentsDir = path.join(claudeDir, "agents");
-        if (force && fs.existsSync(agentsDir)) {
-            removeRecursive(agentsDir);
-        }
-        fs.mkdirSync(agentsDir, { recursive: true });
-        const agents = await (0, database_1.getAgents)();
-        for (const agent of agents) {
-            const agentFolder = path.join(agentsDir, agent.name);
-            fs.mkdirSync(agentFolder, { recursive: true });
-            fs.writeFileSync(path.join(agentFolder, `${agent.name}.md`), agent.content);
-        }
-        console.log(chalk_1.default.green(`  ✓ agents 설치 완료 (${agents.length}개)`));
-        spinner.succeed("Standard 설치 완료 (DB 기반)");
+        const result = await (0, global_cache_1.syncGlobalCache)();
+        console.log(chalk_1.default.green(`  ✓ skills 설치 완료 (${result.skills}개)`));
+        console.log(chalk_1.default.green(`  ✓ commands 설치 완료 (${result.commands}개)`));
+        console.log(chalk_1.default.green(`  ✓ agents 설치 완료 (${result.agents}개)`));
+        spinner.succeed("Standard 설치 완료 (DB → ~/.claude/)");
     }
     catch (error) {
         spinner.fail("Standard 설치 실패");
         console.error(chalk_1.default.red(`   ${error}`));
     }
 }
-// === CLAUDE.md 생성 (DB 기반) ===
-async function generateClaudeMd(cwd) {
-    console.log(chalk_1.default.cyan("\n📄 CLAUDE.md 생성"));
-    const claudeMdPath = path.join(cwd, ".claude", "CLAUDE.md");
-    const skills = await (0, database_1.getActiveSkills)();
-    const skillCategories = await (0, database_1.getSkillCountByCategory)();
-    const skillList = Object.entries(skillCategories)
-        .map(([cat, count]) => `  - ${cat}: ${count}개`)
-        .join("\n");
-    const claudeMdContent = `# SEMO Project Configuration
-
-> SEMO (Semicolon Orchestrate) - AI Agent Orchestration Framework v3.14.0
-
----
-
-## 🔴 MANDATORY: Memory Context (항시 참조)
-
-> **⚠️ 세션 시작 시 반드시 \`.claude/memory/\` 폴더의 파일들을 먼저 읽으세요. 예외 없음.**
-
-### 필수 참조 파일
-
-\`\`\`
-.claude/memory/
-├── context.md     # 프로젝트 상태, 기술 스택, 진행 중 작업
-├── decisions.md   # 아키텍처 결정 기록 (ADR)
-├── projects.md    # GitHub Projects 설정
-└── rules/         # 프로젝트별 커스텀 규칙
-\`\`\`
-
-**이 파일들은 세션의 컨텍스트를 유지하는 장기 기억입니다. 매 세션마다 반드시 읽고 시작하세요.**
-
----
-
-## 🔴 MANDATORY: Orchestrator-First Execution
-
-> **⚠️ 이 규칙은 모든 사용자 요청에 적용됩니다. 예외 없음.**
-
-### 실행 흐름 (필수)
-
-\`\`\`
-1. 사용자 요청 수신
-2. Orchestrator가 의도 분석 후 적절한 Agent/Skill 라우팅
-3. Agent/Skill이 작업 수행
-4. 실행 결과 반환
-\`\`\`
-
-### Orchestrator 참조
-
-**Primary Orchestrator**: \`.claude/agents/orchestrator/orchestrator.md\`
-
-이 파일에서 라우팅 테이블, 의도 분류, 메시지 포맷을 확인하세요.
-
----
-
-## 🔴 NON-NEGOTIABLE RULES
-
-### 1. Orchestrator-First Policy
-
-> **모든 요청은 반드시 Orchestrator를 통해 라우팅됩니다. 직접 처리 금지.**
-
-**직접 처리 금지 항목**:
-- 코드 작성/수정 → \`write-code\` 스킬
-- Git 커밋/푸시 → \`git-workflow\` 스킬
-- 품질 검증 → \`quality-gate\` 스킬
-
-### 2. Pre-Commit Quality Gate
-
-> **코드 변경이 포함된 커밋 전 반드시 Quality Gate를 통과해야 합니다.**
-
-\`\`\`bash
-# 필수 검증 순서
-npm run lint           # 1. ESLint 검사
-npx tsc --noEmit       # 2. TypeScript 타입 체크
-npm run build          # 3. 빌드 검증
-\`\`\`
-
----
-
-## 설치된 구성
-
-### 스킬 (${skills.length}개)
-${skillList}
-
-## 구조
-
-\`\`\`
-.claude/
-├── settings.json      # MCP 서버 설정
-├── agents/            # 에이전트 (DB 기반 설치)
-├── skills/            # 스킬 (DB 기반 설치)
-└── commands/          # 커맨드 (DB 기반 설치)
-\`\`\`
-
-## 사용 가능한 커맨드
-
-| 커맨드 | 설명 |
-|--------|------|
-| \`/SEMO:help\` | 도움말 |
-| \`/SEMO:dry-run {프롬프트}\` | 명령 검증 (라우팅 시뮬레이션) |
-| \`/SEMO-workflow:greenfield\` | Greenfield 워크플로우 시작 |
-
----
-
-> Generated by SEMO CLI v3.14.0 (DB-based installation)
-`;
-    fs.writeFileSync(claudeMdPath, claudeMdContent);
-    console.log(chalk_1.default.green("✓ .claude/CLAUDE.md 생성됨"));
-}
+// (generateClaudeMd removed — setupClaudeMd handles project CLAUDE.md generation)
 // === Standard 심볼릭 링크 (레거시 호환) ===
 async function createStandardSymlinks(cwd) {
     const claudeDir = path.join(cwd, ".claude");
@@ -1070,29 +915,9 @@ async function createStandardSymlinks(cwd) {
         }
         console.log(chalk_1.default.green(`  ✓ .claude/agents/ (${agents.length}개 agent 링크됨)`));
     }
-    // skills 디렉토리 생성 및 개별 링크 (DB 기반 - 활성 스킬만)
+    // skills — 중앙 DB 단일 SoT (semo-skills 파일시스템 제거됨)
     const claudeSkillsDir = path.join(claudeDir, "skills");
-    const coreSkillsDir = path.join(semoSystemDir, "semo-skills");
-    if (fs.existsSync(coreSkillsDir)) {
-        // 기존 심볼릭 링크면 삭제 (디렉토리로 변경)
-        if (fs.existsSync(claudeSkillsDir) && fs.lstatSync(claudeSkillsDir).isSymbolicLink()) {
-            removeRecursive(claudeSkillsDir);
-        }
-        fs.mkdirSync(claudeSkillsDir, { recursive: true });
-        // DB에서 활성 스킬 목록 조회 (19개 핵심 스킬만)
-        const activeSkillNames = await (0, database_1.getActiveSkillNames)();
-        let linkedCount = 0;
-        for (const skillName of activeSkillNames) {
-            const skillLink = path.join(claudeSkillsDir, skillName);
-            const skillTarget = path.join(coreSkillsDir, skillName);
-            // 스킬 폴더가 존재하는 경우에만 링크
-            if (fs.existsSync(skillTarget) && !fs.existsSync(skillLink)) {
-                createSymlinkOrJunction(skillTarget, skillLink);
-                linkedCount++;
-            }
-        }
-        console.log(chalk_1.default.green(`  ✓ .claude/skills/ (${linkedCount}개 skill 링크됨 - DB 기반)`));
-    }
+    fs.mkdirSync(claudeSkillsDir, { recursive: true });
     // commands 링크
     const commandsDir = path.join(claudeDir, "commands");
     fs.mkdirSync(commandsDir, { recursive: true });
@@ -1183,15 +1008,10 @@ function verifyInstallation(cwd, installedExtensions = []) {
     }
     // === 레거시: semo-system 기반 설치 검증 ===
     const coreDir = path.join(semoSystemDir, "semo-core");
-    const skillsDir = path.join(semoSystemDir, "semo-skills");
     if (!fs.existsSync(coreDir)) {
         result.errors.push("semo-core가 설치되지 않았습니다");
         result.success = false;
     }
-    if (!fs.existsSync(skillsDir)) {
-        result.errors.push("semo-skills가 설치되지 않았습니다");
-        result.success = false;
-    }
     // 2. agents 링크 검증 (isSymlinkValid 사용)
     const claudeAgentsDir = path.join(claudeDir, "agents");
     const coreAgentsDir = path.join(coreDir, "agents");
@@ -1218,31 +1038,7 @@ function verifyInstallation(cwd, installedExtensions = []) {
             }
         }
     }
-    // 3. skills 링크 검증 (isSymlinkValid 사용)
-    if (fs.existsSync(skillsDir)) {
-        const expectedSkills = fs.readdirSync(skillsDir).filter(f => fs.statSync(path.join(skillsDir, f)).isDirectory());
-        result.stats.skills.expected = expectedSkills.length;
-        const claudeSkillsDir = path.join(claudeDir, "skills");
-        if (fs.existsSync(claudeSkillsDir)) {
-            for (const skill of expectedSkills) {
-                const linkPath = path.join(claudeSkillsDir, skill);
-                try {
-                    if (fs.existsSync(linkPath) || fs.lstatSync(linkPath).isSymbolicLink()) {
-                        if (isSymlinkValid(linkPath)) {
-                            result.stats.skills.linked++;
-                        }
-                        else {
-                            result.stats.skills.broken++;
-                            result.warnings.push(`깨진 링크: .claude/skills/${skill}`);
-                        }
-                    }
-                }
-                catch {
-                    // 링크가 존재하지 않음
-                }
-            }
-        }
-    }
+    // 3. skills — 중앙 DB 단일 SoT (파일시스템 검증 불필요)
     // 4. commands 검증 (isSymlinkValid 사용)
     const semoCommandsLink = path.join(claudeDir, "commands", "SEMO");
     try {
@@ -1372,110 +1168,156 @@ const BASE_MCP_SERVERS = [
         name: "context7",
         command: "npx",
         args: ["-y", "@upstash/context7-mcp"],
+        scope: "user",
     },
     {
         name: "sequential-thinking",
         command: "npx",
         args: ["-y", "@modelcontextprotocol/server-sequential-thinking"],
+        scope: "user",
     },
     {
         name: "playwright",
         command: "npx",
         args: ["-y", "@anthropic-ai/mcp-server-playwright"],
+        scope: "user",
     },
     {
         name: "github",
         command: "npx",
         args: ["-y", "@modelcontextprotocol/server-github"],
+        scope: "user",
+    },
+];
+const SEMO_CREDENTIALS = [
+    {
+        key: "DATABASE_URL",
+        required: true,
+        sensitive: true,
+        description: "팀 코어 PostgreSQL 연결 URL",
+        promptMessage: "DATABASE_URL:",
+    },
+    {
+        key: "OPENAI_API_KEY",
+        required: false,
+        sensitive: true,
+        description: "OpenAI API 키 (KB 임베딩용)",
+        promptMessage: "OPENAI_API_KEY (없으면 Enter):",
+    },
+    {
+        key: "SLACK_WEBHOOK",
+        required: false,
+        sensitive: false,
+        description: "Slack 알림 Webhook (선택)",
+        promptMessage: "SLACK_WEBHOOK (없으면 Enter):",
     },
 ];
-// === ~/.semo.env 설정 (자동 감지 → Gist → 프롬프트) ===
-function writeSemoEnvFile(dbUrl, slackWebhook = "") {
+function writeSemoEnvFile(creds) {
     const envFile = path.join(os.homedir(), ".semo.env");
-    const content = `# SEMO 환경변수 — 모든 컨텍스트에서 자동 로드됨
-# (Claude Code 앱, OpenClaw LaunchAgent, cron 등 비인터랙티브 환경 포함)
-
-DATABASE_URL='${dbUrl}'
-
-# Slack 알림 Webhook (선택 — bot-ops 채널 dead-letter 감지용)
-SLACK_WEBHOOK='${slackWebhook}'
-`;
-    fs.writeFileSync(envFile, content, { mode: 0o600 });
+    const lines = [
+        "# SEMO 환경변수 — 모든 컨텍스트에서 자동 로드됨",
+        "# (Claude Code 앱, OpenClaw LaunchAgent, cron 등)",
+        "",
+    ];
+    // 레지스트리 키 먼저 (순서 보장)
+    for (const def of SEMO_CREDENTIALS) {
+        const val = creds[def.key] || "";
+        lines.push(`# ${def.description}`);
+        lines.push(`${def.key}='${val}'`);
+        lines.push("");
+    }
+    // 레지스트리 외 추가 키
+    for (const [k, v] of Object.entries(creds)) {
+        if (!SEMO_CREDENTIALS.some((d) => d.key === k)) {
+            lines.push(`${k}='${v}'`);
+        }
+    }
+    lines.push("");
+    fs.writeFileSync(envFile, lines.join("\n"), { mode: 0o600 });
 }
-function readSemoEnvDbUrl() {
+function readSemoEnvCreds() {
     const envFile = path.join(os.homedir(), ".semo.env");
     if (!fs.existsSync(envFile))
-        return null;
-    const content = fs.readFileSync(envFile, "utf-8");
-    const match = content.match(/^DATABASE_URL='([^']+)'/m) || content.match(/^DATABASE_URL="([^"]+)"/m);
-    return match ? match[1] : null;
+        return {};
+    try {
+        return (0, env_parser_1.parseEnvContent)(fs.readFileSync(envFile, "utf-8"));
+    }
+    catch {
+        return {};
+    }
 }
-function fetchDbUrlFromGist(gistId) {
+function fetchCredsFromGist(gistId) {
     try {
         const raw = (0, child_process_1.execSync)(`gh gist view ${gistId} --raw`, {
             encoding: "utf-8",
             stdio: ["pipe", "pipe", "pipe"],
             timeout: 8000,
         });
-        // Gist 파일 형식: DATABASE_URL=<url> 또는 단순 URL
-        const match = raw.match(/DATABASE_URL=['"]?([^'"\s]+)['"]?/) || raw.match(/^(postgres(?:ql)?:\/\/[^\s]+)/m);
-        return match ? match[1].trim() : null;
+        const creds = (0, env_parser_1.parseEnvContent)(raw);
+        return Object.keys(creds).length > 0 ? creds : null;
     }
     catch {
         return null;
     }
 }
-async function setupSemoEnv(credentialsGist) {
-    const envFile = path.join(os.homedir(), ".semo.env");
-    console.log(chalk_1.default.cyan("\n🔑 DB 접속 설정"));
-    // 1. 이미 env var로 설정됨
-    if (process.env.DATABASE_URL) {
-        console.log(chalk_1.default.green("  ✅ DATABASE_URL (환경변수)"));
-        if (!readSemoEnvDbUrl()) {
-            writeSemoEnvFile(process.env.DATABASE_URL);
-            console.log(chalk_1.default.gray(`  → ~/.semo.env 에 저장됨 (비인터랙티브 환경용)`));
-        }
-        return;
-    }
-    // 2. ~/.semo.env 에 이미 있음
-    const existing = readSemoEnvDbUrl();
-    if (existing) {
-        console.log(chalk_1.default.green("  ✅ DATABASE_URL (~/.semo.env)"));
-        return;
-    }
-    // 3. Private GitHub Gist 자동 fetch
+async function setupSemoEnv(credentialsGist, force) {
+    console.log(chalk_1.default.cyan("\n🔑 환경변수 설정"));
+    // 1. 기존 파일
+    const existing = force ? {} : readSemoEnvCreds();
+    // 2. Gist
     const gistId = credentialsGist || process.env.SEMO_CREDENTIALS_GIST;
+    let gistCreds = {};
     if (gistId) {
         console.log(chalk_1.default.gray("  GitHub Gist에서 팀 접속정보 가져오는 중..."));
-        const url = fetchDbUrlFromGist(gistId);
-        if (url) {
-            writeSemoEnvFile(url);
-            console.log(chalk_1.default.green(`  ✅ Gist (${gistId.slice(0, 8)}...)에서 DATABASE_URL 설정됨`));
-            return;
+        gistCreds = fetchCredsFromGist(gistId) || {};
+    }
+    // 3. 머지: gist(base) ← file(override) ← env(override)
+    const merged = { ...gistCreds };
+    for (const [k, v] of Object.entries(existing)) {
+        if (v)
+            merged[k] = v;
+    }
+    for (const def of SEMO_CREDENTIALS) {
+        if (process.env[def.key])
+            merged[def.key] = process.env[def.key];
+    }
+    // 4. required인데 없는 키만 프롬프트
+    let hasNewKeys = false;
+    for (const def of SEMO_CREDENTIALS) {
+        if (merged[def.key]) {
+            const label = def.sensitive ? "(설정됨)" : merged[def.key];
+            console.log(chalk_1.default.green(`  ✅ ${def.key} ${label}`));
+        }
+        else if (def.required) {
+            const { value } = await inquirer_1.default.prompt([
+                {
+                    type: "password",
+                    name: "value",
+                    message: def.promptMessage,
+                    mask: "*",
+                },
+            ]);
+            if (value?.trim()) {
+                merged[def.key] = value.trim();
+                hasNewKeys = true;
+            }
+        }
+        else {
+            console.log(chalk_1.default.gray(`  ⏭  ${def.key} (없음 — 선택사항)`));
         }
-        console.log(chalk_1.default.yellow("  ⚠️  Gist fetch 실패 — 수동 입력으로 전환"));
     }
-    // 4. 인터랙티브 프롬프트
-    console.log(chalk_1.default.gray("  팀 Core DB URL을 붙여넣으세요 (나중에 ~/.semo.env에서 수정 가능)"));
-    const { dbUrl } = await inquirer_1.default.prompt([
-        {
-            type: "password",
-            name: "dbUrl",
-            message: "DATABASE_URL:",
-            mask: "*",
-        },
-    ]);
-    if (dbUrl && dbUrl.trim()) {
-        writeSemoEnvFile(dbUrl.trim());
+    // 5. 변경사항이 있거나 파일이 없으면 쓰기
+    const envFile = path.join(os.homedir(), ".semo.env");
+    const needsWrite = force ||
+        hasNewKeys ||
+        !fs.existsSync(envFile) ||
+        Object.keys(gistCreds).some((k) => !existing[k]);
+    if (needsWrite) {
+        writeSemoEnvFile(merged);
         console.log(chalk_1.default.green("  ✅ ~/.semo.env 저장됨 (권한: 600)"));
-        console.log(chalk_1.default.gray(`  파일: ${envFile}`));
     }
     else {
-        // 빈 템플릿 생성
-        if (!fs.existsSync(envFile)) {
-            writeSemoEnvFile("");
-        }
-        console.log(chalk_1.default.yellow("  ⚠️  건너뜀 — ~/.semo.env에서 DATABASE_URL을 직접 입력하세요"));
+        console.log(chalk_1.default.gray("  ~/.semo.env 변경 없음"));
     }
 }
 // === Claude MCP 서버 존재 여부 확인 ===
@@ -1504,6 +1346,9 @@ function registerMCPServer(server) {
                 args.push("-e", `${key}=${value}`);
             }
         }
+        // scope 지정 (기본: project)
+        const scope = server.scope || "project";
+        args.push("-s", scope);
         // -- 구분자 후 명령어와 인자 추가
         args.push("--", server.command, ...server.args);
         (0, child_process_1.execSync)(`claude ${args.join(" ")}`, { stdio: "pipe" });
@@ -1513,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)"));
@@ -1529,23 +1464,13 @@ async function setupMCP(cwd, _extensions, force) {
     const settings = {
         mcpServers: {},
     };
-    // MCP 서버 목록 수집
-    const allServers = [...BASE_MCP_SERVERS];
-    // settings.json에 mcpServers 저장 (백업용)
-    for (const server of allServers) {
-        const serverConfig = {
-            command: server.command,
-            args: server.args,
-        };
-        if (server.env) {
-            serverConfig.env = server.env;
-        }
-        settings.mcpServers[server.name] = serverConfig;
-    }
+    // semo-kb는 유저레벨에서 등록 (semo onboarding)하므로 프로젝트 settings에 쓰지 않음
+    // 공통 서버(context7 등)도 유저레벨에 등록하므로 프로젝트 settings에 쓰지 않음
     fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-    console.log(chalk_1.default.green("✓ .claude/settings.json 생성됨 (MCP 설정 백업)"));
-    // Claude Code에 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];
     const successServers = [];
     const skippedServers = [];
     const failedServers = [];
@@ -1628,12 +1553,13 @@ semo-system/
     }
 }
 // === Hooks 설치/업데이트 ===
-async function setupHooks(cwd, isUpdate = false) {
+async function setupHooks(isUpdate = false) {
     const action = isUpdate ? "업데이트" : "설치";
     console.log(chalk_1.default.cyan(`\n🪝 Claude Code Hooks ${action}`));
-    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    console.log(chalk_1.default.gray("   semo CLI 기반 컨텍스트 동기화\n"));
+    const homeDir = os.homedir();
     const settingsPath = path.join(homeDir, ".claude", "settings.local.json");
-    // Core 훅: semo context sync/push — semo-hooks 유무와 무관하게 항상 등록
+    // hooks 설정 객체 — semo CLI만 사용 (프로젝트 경로 무관)
     const hooksConfig = {
         SessionStart: [
             {
@@ -1660,36 +1586,6 @@ async function setupHooks(cwd, isUpdate = false) {
             },
         ],
     };
-    // semo-hooks 빌드 (선택적 — semo-system 레포에서만 동작)
-    const hooksDir = path.join(cwd, "semo-system", "semo-hooks");
-    if (fs.existsSync(hooksDir)) {
-        let hooksBuilt = false;
-        try {
-            (0, child_process_1.execSync)("npm install", { cwd: hooksDir, stdio: ["pipe", "pipe", "pipe"] });
-            (0, child_process_1.execSync)("npm run build", { cwd: hooksDir, stdio: ["pipe", "pipe", "pipe"] });
-            hooksBuilt = true;
-        }
-        catch {
-            console.log(chalk_1.default.yellow("  ⚠ semo-hooks 빌드 실패 (core 훅만 등록)"));
-        }
-        if (hooksBuilt) {
-            const hooksCmd = `node ${path.join(hooksDir, "dist", "index.js")}`;
-            hooksConfig.SessionStart.unshift({
-                matcher: "",
-                hooks: [{ type: "command", command: `${hooksCmd} session-start`, timeout: 10 }],
-            });
-            hooksConfig.UserPromptSubmit = [
-                { matcher: "", hooks: [{ type: "command", command: `${hooksCmd} user-prompt`, timeout: 5 }] },
-            ];
-            hooksConfig.Stop.unshift({
-                matcher: "",
-                hooks: [{ type: "command", command: `${hooksCmd} stop`, timeout: 10 }],
-            });
-            hooksConfig.SessionEnd = [
-                { matcher: "", hooks: [{ type: "command", command: `${hooksCmd} session-end`, timeout: 10 }] },
-            ];
-        }
-    }
     // 기존 설정 로드 또는 새로 생성
     let existingSettings = {};
     const claudeConfigDir = path.join(homeDir, ".claude");
@@ -1890,132 +1786,86 @@ async function setupClaudeMd(cwd, _extensions, force) {
             return;
         }
     }
-    const projectName = path.basename(cwd);
-    const installDate = new Date().toISOString().split("T")[0];
-    const claudeMdContent = `# ${projectName} — Claude Configuration
-
-> SEMO v${VERSION} 설치됨 (${installDate})
-
----
-
-## SEMO란?
-
-**SEMO (Semicolon Orchestrate)** 는 OpenClaw 봇팀과 로컬 Claude Code 세션이
-**팀 Core DB를 단일 진실 공급원(Single Source of Truth)으로 공유**하는 컨텍스트 동기화 시스템이다.
-
-\`\`\`
-로컬 Claude Code 세션
-    ↕ semo context sync / push
-팀 Core DB (PostgreSQL, semo 스키마)
-    ↕ 봇 세션 시작/종료 훅
-OpenClaw 봇팀 (7개 봇)
-  workclaw · reviewclaw · planclaw · designclaw
-  infraclaw · growthclaw · semiclaw
-\`\`\`
-
-**이 CLAUDE.md가 설치된 프로젝트는 OpenClaw 봇팀의 컨텍스트를 실시간으로 공유받는다.**
-
----
-
-## 자동 동기화
-
-세션 시작/종료 시 팀 Core DB와 자동 동기화됩니다.
+    // 프로젝트 규칙만 (스킬/에이전트 목록은 글로벌 ~/.claude/에 있음)
+    const claudeMdContent = `# SEMO Project Configuration
 
-| 시점 | 동작 |
-|------|------|
-| 세션 시작 | \`semo context sync\` → \`.claude/memory/\` 최신화 |
-| 세션 종료 | \`semo context push\` → \`decisions.md\` 변경분 DB 저장 |
+> SEMO (Semicolon Orchestrate) - AI Agent Orchestration Framework v${VERSION}
+> 스킬/에이전트/커맨드는 글로벌(~/.claude/)에서 로드됩니다.
 
 ---
 
-## Memory Context
-
-\`.claude/memory/\` 파일들은 **팀 Core DB (\`semo\` 스키마)에서 자동으로 채워집니다**.
-직접 편집하지 마세요 — 세션 시작 시 덮어씌워집니다.
+## KB 접근 (semo-kb MCP 서버)
 
-| 파일 | DB 소스 | 방향 |
-|------|---------|------|
-| \`team.md\` | \`kb WHERE domain='team'\` | DB → 로컬 (읽기 전용) |
-| \`projects.md\` | \`kb WHERE domain='project'\` | DB → 로컬 (읽기 전용) |
-| \`decisions.md\` | \`kb WHERE domain='decision'\` | **양방향** (편집 가능, Stop 시 DB 저장) |
-| \`infra.md\` | \`kb WHERE domain='infra'\` | DB → 로컬 (읽기 전용) |
-| \`process.md\` | \`kb WHERE domain='process'\` | DB → 로컬 (읽기 전용) |
-| \`bots.md\` | \`semo.bot_status\` | DB → 로컬 (봇 상태) |
-| \`ontology.md\` | \`semo.ontology\` | DB → 로컬 (읽기 전용) |
+KB 데이터는 **semo-kb MCP 서버**를 통해 Core DB에서 실시간 조회합니다.
 
-**decisions.md 만 편집 가능합니다.** 아키텍처 결정(ADR)을 여기에 기록하세요.
+| MCP 도구 | 설명 |
+|----------|------|
+| \`kb_search\` | 벡터+텍스트 하이브리드 검색 (query, domain?, limit?, mode?) |
+| \`kb_get\` | domain+key 정확 조회 |
+| \`kb_list\` | 도메인별 엔트리 목록 |
+| \`kb_upsert\` | KB 항목 쓰기 (OpenAI 임베딩 자동 생성) |
+| \`kb_bot_status\` | 봇 상태 테이블 조회 |
+| \`kb_ontology\` | 온톨로지 스키마 조회 |
+| \`kb_digest\` | 봇 구독 도메인 변경 다이제스트 |
 
 ---
 
-## 설치된 구성
-
-\`\`\`
-.claude/
-├── CLAUDE.md       # 이 파일
-├── settings.json   # MCP 서버 설정 + SessionStart/Stop 훅
-├── memory/         # Core DB → 로컬 자동 동기화 컨텍스트
-├── skills/         # SEMO 스킬 (semo-system/semo-skills/ 링크)
-├── agents/         # SEMO 에이전트 (semo-system/meta/agents/ 링크)
-└── commands/SEMO   # 슬래시 커맨드 (semo-system/semo-core/commands/)
-\`\`\`
-
----
-
-## 프로젝트 규칙 (팀이 채워야 함)
-
-> 아래 섹션은 이 프로젝트 고유의 규칙을 기록하세요.
-> 팀 공통 규칙은 \`memory/process.md\`에 있습니다.
-
-### 기술 스택
-
-<!-- 예: Next.js 14, PostgreSQL, TypeScript strict mode -->
+## KB-First 행동 규칙 (NON-NEGOTIABLE)
 
-### 브랜치 전략
+> KB는 팀의 Single Source of Truth이다. 아래 규칙은 예외 없이 적용된다.
 
-<!-- 예: main(prod) / dev(staging) / feat/* -->
+### 읽기 (Query-First)
+다음 주제 질문 → **반드시 kb_search/kb_get으로 KB 먼저 조회** 후 답변:
+- 팀원 정보 → \`domain: team\`
+- 프로젝트 현황 → \`domain: project\`
+- 의사결정 기록 → \`domain: decision\`
+- 업무 프로세스 → \`domain: process\`
+- 인프라 구성 → \`domain: infra\`
+- KPI → \`domain: kpi\`
 
-### 코딩 컨벤션
+**금지:** 위 주제를 자체 지식/세션 기억만으로 답변하는 것.
+KB에 없으면: "KB에 해당 정보가 없습니다. 알려주시면 등록하겠습니다."
 
-<!-- 예: ESLint airbnb, 함수형 컴포넌트 필수, any 금지 -->
+### 쓰기 (Write-Back)
+다음 상황 → **반드시 kb_upsert로 KB에 즉시 기록:**
+- 사용자가 팀 정보를 정정하거나 새 사실을 알려줄 때
+- 의사결정이 내려졌을 때
+- 프로세스/규칙이 변경되었을 때
 
-### 아키텍처 특이사항
-
-<!-- 예: DB 직접 접근 금지 — 반드시 API route 통해야 함 -->
+**금지:** "알겠습니다/기억하겠습니다"만 하고 KB에 쓰지 않는 것.
 
 ---
 
-## Quality Gate
+## Pre-Commit Quality Gate
 
-코드 변경 커밋 전 필수:
+> **코드 변경이 포함된 커밋 전 반드시 Quality Gate를 통과해야 합니다.**
 
 \`\`\`bash
-npm run lint       # ESLint
-npx tsc --noEmit   # TypeScript
-npm run build      # 빌드 검증
+npm run lint           # ESLint 검사
+npx tsc --noEmit       # TypeScript 타입 체크
+npm run build          # 빌드 검증
 \`\`\`
 
-\`--no-verify\` 사용 금지.
+\`--no-verify\` 플래그 사용 금지.
 
 ---
 
-## 슬래시 커맨드
+## 환경변수 (\`~/.semo.env\`)
 
-| 커맨드 | 설명 |
-|--------|------|
-| \`/SEMO:help\` | 도움말 |
-| \`/SEMO:feedback\` | 피드백 제출 |
-| \`/SEMO:health\` | 환경 헬스체크 |
+SEMO는 \`~/.semo.env\` 파일에서 팀 공통 환경변수를 로드합니다.
+SessionStart 훅과 OpenClaw 게이트웨이 래퍼에서 자동 source됩니다.
 
----
+| 변수 | 용도 | 필수 |
+|------|------|------|
+| \`DATABASE_URL\` | 팀 Core DB (PostgreSQL) 연결 | ✅ |
+| \`OPENAI_API_KEY\` | KB 임베딩용 (text-embedding-3-small) | 선택 |
+| \`SLACK_WEBHOOK\` | Slack 알림 | 선택 |
 
-## 복구 명령어
+키 갱신이 필요하면 \`~/.semo.env\`를 직접 편집하거나 \`semo onboarding -f\`를 실행하세요.
 
-\`\`\`bash
-semo doctor              # 환경 진단 (DB 연결, 설치 상태)
-semo config db           # DB URL 재설정
-semo context sync        # memory/ 수동 최신화
-semo bots status         # 봇 상태 조회
-\`\`\`
+---
+
+> Generated by SEMO CLI v${VERSION}
 `;
     fs.writeFileSync(claudeMdPath, claudeMdContent);
     console.log(chalk_1.default.green("✓ .claude/CLAUDE.md 생성됨"));
@@ -2030,7 +1880,7 @@ program
     console.log(chalk_1.default.cyan.bold("\n📦 SEMO 패키지 목록\n"));
     // Standard 패키지 표시
     console.log(chalk_1.default.white.bold("Standard (필수)"));
-    const standardPkgs = ["semo-core", "semo-skills", "semo-agents", "semo-scripts"];
+    const standardPkgs = ["semo-core", "semo-agents", "semo-scripts"];
     for (const pkg of standardPkgs) {
         const isInstalled = fs.existsSync(path.join(semoSystemDir, pkg));
         console.log(`  ${isInstalled ? chalk_1.default.green("✓") : chalk_1.default.gray("○")} ${pkg}`);
@@ -2063,7 +1913,6 @@ program
     console.log(chalk_1.default.white.bold("Standard:"));
     const standardChecks = [
         { name: "semo-core", path: path.join(semoSystemDir, "semo-core") },
-        { name: "semo-skills", path: path.join(semoSystemDir, "semo-skills") },
     ];
     let standardOk = true;
     for (const check of standardChecks) {
@@ -2101,11 +1950,27 @@ program
     .command("update")
     .description("SEMO를 최신 버전으로 업데이트합니다")
     .option("--self", "CLI만 업데이트")
+    .option("--global", "글로벌 스킬/커맨드/에이전트를 DB 최신으로 갱신 (~/.claude/)")
     .option("--system", "semo-system만 업데이트")
     .option("--skip-cli", "CLI 업데이트 건너뛰기")
-    .option("--only <packages>", "특정 패키지만 업데이트 (쉼표 구분: semo-core,semo-skills,biz/management)")
+    .option("--only <packages>", "특정 패키지만 업데이트 (쉼표 구분: semo-core,biz/management)")
     .option("--migrate", "레거시 환경 강제 마이그레이션")
     .action(async (options) => {
+    // === --global: 글로벌 스킬 갱신 ===
+    if (options.global) {
+        console.log(chalk_1.default.cyan.bold("\n🔄 SEMO 글로벌 업데이트\n"));
+        console.log(chalk_1.default.gray("  대상: ~/.claude/skills, commands, agents (DB 최신)\n"));
+        const connected = await (0, database_1.isDbConnected)();
+        if (!connected) {
+            console.log(chalk_1.default.red("  DB 연결 실패 — ~/.semo.env를 확인하세요."));
+            await (0, database_1.closeConnection)();
+            process.exit(1);
+        }
+        await setupStandardGlobal();
+        await (0, database_1.closeConnection)();
+        console.log(chalk_1.default.green.bold("\n✅ 글로벌 스킬 업데이트 완료!\n"));
+        return;
+    }
     console.log(chalk_1.default.cyan.bold("\n🔄 SEMO 업데이트\n"));
     const cwd = process.cwd();
     const semoSystemDir = path.join(cwd, "semo-system");
@@ -2159,22 +2024,19 @@ program
     }
     // 업데이트 대상 결정
     const updateSemoCore = !isSelectiveUpdate || onlyPackages.includes("semo-core");
-    const updateSemoSkills = !isSelectiveUpdate || onlyPackages.includes("semo-skills");
     const updateSemoAgents = !isSelectiveUpdate || onlyPackages.includes("semo-agents");
     const updateSemoScripts = !isSelectiveUpdate || onlyPackages.includes("semo-scripts");
     console.log(chalk_1.default.cyan("\n📚 semo-system 업데이트"));
     console.log(chalk_1.default.gray("  대상:"));
     if (updateSemoCore)
         console.log(chalk_1.default.gray("    - semo-core"));
-    if (updateSemoSkills)
-        console.log(chalk_1.default.gray("    - semo-skills"));
     if (updateSemoAgents)
         console.log(chalk_1.default.gray("    - semo-agents"));
     if (updateSemoScripts)
         console.log(chalk_1.default.gray("    - semo-scripts"));
-    if (!updateSemoCore && !updateSemoSkills && !updateSemoAgents && !updateSemoScripts) {
+    if (!updateSemoCore && !updateSemoAgents && !updateSemoScripts) {
         console.log(chalk_1.default.yellow("\n  ⚠️ 업데이트할 패키지가 없습니다."));
-        console.log(chalk_1.default.gray("     설치된 패키지: semo-core, semo-skills, semo-agents, semo-scripts"));
+        console.log(chalk_1.default.gray("     설치된 패키지: semo-core, semo-agents, semo-scripts"));
         return;
     }
     const spinner = (0, ora_1.default)("\n  최신 버전 다운로드 중...").start();
@@ -2185,7 +2047,6 @@ program
         // Standard 업데이트 (선택적) - semo-system/ 하위에서 복사
         const standardUpdates = [
             { flag: updateSemoCore, name: "semo-core" },
-            { flag: updateSemoSkills, name: "semo-skills" },
             { flag: updateSemoAgents, name: "semo-agents" },
             { flag: updateSemoScripts, name: "semo-scripts" },
         ];
@@ -2272,7 +2133,7 @@ program
         }
     }
     // === 6. Hooks 업데이트 ===
-    await setupHooks(cwd, true);
+    await setupHooks(true);
     // === 7. 설치 검증 ===
     const verificationResult = verifyInstallation(cwd, []);
     printVerificationResult(verificationResult);
@@ -2331,20 +2192,22 @@ program
 // === config 명령어 (설치 후 설정 변경) ===
 const configCmd = program.command("config").description("SEMO 설정 관리");
 configCmd
-    .command("db")
-    .description("팀 Core DB 접속정보 설정 (DATABASE_URL → ~/.semo.env)")
+    .command("env")
+    .description("SEMO 환경변수 설정 (DATABASE_URL, OPENAI_API_KEY 등)")
     .option("--credentials-gist <gistId>", "Private GitHub Gist에서 자동 가져오기")
+    .option("--force", "기존 값도 Gist에서 덮어쓰기")
     .action(async (options) => {
-    console.log(chalk_1.default.cyan.bold("\n🔑 DB 접속정보 설정\n"));
-    // 기존 값 확인
-    const existing = readSemoEnvDbUrl();
-    if (existing) {
+    console.log(chalk_1.default.cyan.bold("\n🔑 SEMO 환경변수 설정\n"));
+    const existing = readSemoEnvCreds();
+    const hasExisting = Object.keys(existing).length > 0;
+    if (hasExisting && !options.force) {
+        const keys = Object.keys(existing).join(", ");
         const { overwrite } = await inquirer_1.default.prompt([
             {
                 type: "confirm",
                 name: "overwrite",
-                message: `기존 DATABASE_URL이 있습니다. 덮어쓰시겠습니까?`,
-                default: false,
+                message: `기존 설정이 있습니다 (${keys}). Gist에서 없는 키를 보충하시겠습니까?`,
+                default: true,
             },
         ]);
         if (!overwrite) {
@@ -2352,34 +2215,8 @@ configCmd
             return;
         }
     }
-    // Gist 또는 프롬프트로 가져오기
-    const gistId = options.credentialsGist || process.env.SEMO_CREDENTIALS_GIST;
-    if (gistId) {
-        console.log(chalk_1.default.gray("GitHub Gist에서 접속정보 가져오는 중..."));
-        const url = fetchDbUrlFromGist(gistId);
-        if (url) {
-            writeSemoEnvFile(url);
-            console.log(chalk_1.default.green("✅ ~/.semo.env 업데이트 완료"));
-            return;
-        }
-        console.log(chalk_1.default.yellow("⚠️  Gist fetch 실패 — 수동 입력"));
-    }
-    const { dbUrl } = await inquirer_1.default.prompt([
-        {
-            type: "password",
-            name: "dbUrl",
-            message: "DATABASE_URL:",
-            mask: "*",
-        },
-    ]);
-    if (dbUrl && dbUrl.trim()) {
-        writeSemoEnvFile(dbUrl.trim());
-        console.log(chalk_1.default.green("✅ ~/.semo.env 저장됨 (권한: 600)"));
-        console.log(chalk_1.default.gray("  다음 Claude Code 세션부터 자동으로 적용됩니다."));
-    }
-    else {
-        console.log(chalk_1.default.yellow("취소됨"));
-    }
+    await setupSemoEnv(options.credentialsGist, options.force);
+    console.log(chalk_1.default.gray("  다음 Claude Code 세션부터 자동으로 적용됩니다."));
 });
 // === doctor 명령어 (설치 상태 진단) ===
 program
@@ -2410,7 +2247,7 @@ program
         console.log(chalk_1.default.gray("   💡 해결: semo init 실행"));
     }
     else {
-        const packages = ["semo-core", "semo-skills", "semo-agents", "semo-scripts"];
+        const packages = ["semo-core", "semo-agents", "semo-scripts"];
         for (const pkg of packages) {
             const pkgPath = path.join(semoSystemDir, pkg);
             if (fs.existsSync(pkgPath)) {
@@ -2484,19 +2321,7 @@ function readSyncState(cwd) {
         }
         catch { /* */ }
     }
-    return { botId: "", lastPull: null, lastPush: null, sharedCount: 0, botCount: 0 };
-}
-function detectBotId() {
-    // 1. Env var
-    if (process.env.SEMO_BOT_ID)
-        return process.env.SEMO_BOT_ID;
-    // 2. Detect from cwd (e.g. ~/.openclaw-workclaw → workclaw)
-    const cwd = process.cwd();
-    const match = cwd.match(/\.openclaw-(\w+)/);
-    if (match)
-        return match[1];
-    // 3. Default
-    return "unknown";
+    return { lastPull: null, lastPush: null, sharedCount: 0 };
 }
 const kbCmd = program
     .command("kb")
@@ -2504,16 +2329,14 @@ const kbCmd = program
 kbCmd
     .command("pull")
     .description("DB에서 KB를 로컬 .kb/로 내려받기")
-    .option("--bot <name>", "봇 ID", detectBotId())
     .option("--domain <name>", "특정 도메인만")
     .action(async (options) => {
     const spinner = (0, ora_1.default)("KB 데이터 가져오는 중...").start();
     try {
         const pool = (0, database_1.getPool)();
-        const result = await (0, kb_1.kbPull)(pool, options.bot, options.domain, process.cwd());
+        const result = await (0, kb_1.kbPull)(pool, options.domain, process.cwd());
         spinner.succeed(`KB pull 완료`);
-        console.log(chalk_1.default.green(`  📦 공통 KB: ${result.shared.length}건`));
-        console.log(chalk_1.default.green(`  🤖 봇 KB (${options.bot}): ${result.bot.length}건`));
+        console.log(chalk_1.default.green(`  📦 KB: ${result.length}건`));
         // Also pull ontology
         const ontoCount = await (0, kb_1.ontoPullToLocal)(pool, process.cwd());
         console.log(chalk_1.default.green(`  📐 온톨로지: ${ontoCount}개 도메인`));
@@ -2529,9 +2352,8 @@ kbCmd
 kbCmd
     .command("push")
     .description("로컬 .kb/ 데이터를 DB에 업로드")
-    .option("--bot <name>", "봇 ID", detectBotId())
-    .option("--target <type>", "대상 (shared|bot)", "bot")
-    .option("--file <path>", ".kb/ 내 특정 파일")
+    .option("--file <path>", ".kb/ 내 특정 파일", "team.json")
+    .option("--created-by <name>", "작성자 식별자")
     .action(async (options) => {
     const cwd = process.cwd();
     const kbDir = path.join(cwd, ".kb");
@@ -2542,14 +2364,13 @@ kbCmd
     const spinner = (0, ora_1.default)("KB 데이터 업로드 중...").start();
     try {
         const pool = (0, database_1.getPool)();
-        const filename = options.file || (options.target === "shared" ? "team.json" : "bot.json");
-        const filePath = path.join(kbDir, filename);
+        const filePath = path.join(kbDir, options.file);
         if (!fs.existsSync(filePath)) {
-            spinner.fail(`파일을 찾을 수 없습니다: .kb/${filename}`);
+            spinner.fail(`파일을 찾을 수 없습니다: .kb/${options.file}`);
             process.exit(1);
         }
         const entries = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-        const result = await (0, kb_1.kbPush)(pool, options.bot, entries, options.target, cwd);
+        const result = await (0, kb_1.kbPush)(pool, entries, options.createdBy, cwd);
         spinner.succeed(`KB push 완료`);
         console.log(chalk_1.default.green(`  ✅ ${result.upserted}건 업서트됨`));
         if (result.errors.length > 0) {
@@ -2567,15 +2388,14 @@ kbCmd
 kbCmd
     .command("status")
     .description("KB 동기화 상태 확인")
-    .option("--bot <name>", "봇 ID", detectBotId())
-    .action(async (options) => {
+    .action(async () => {
     const spinner = (0, ora_1.default)("KB 상태 조회 중...").start();
     try {
         const pool = (0, database_1.getPool)();
-        const status = await (0, kb_1.kbStatus)(pool, options.bot);
+        const status = await (0, kb_1.kbStatus)(pool);
         spinner.stop();
         console.log(chalk_1.default.cyan.bold("\n📊 KB 상태\n"));
-        console.log(chalk_1.default.white("  📦 공통 KB (shared)"));
+        console.log(chalk_1.default.white("  📦 KB (knowledge_base)"));
         console.log(chalk_1.default.gray(`     총 ${status.shared.total}건`));
         for (const [domain, count] of Object.entries(status.shared.domains)) {
             console.log(chalk_1.default.gray(`     - ${domain}: ${count}건`));
@@ -2583,17 +2403,6 @@ kbCmd
         if (status.shared.lastUpdated) {
             console.log(chalk_1.default.gray(`     최종 업데이트: ${status.shared.lastUpdated}`));
         }
-        console.log(chalk_1.default.white(`\n  🤖 봇 KB (${options.bot})`));
-        console.log(chalk_1.default.gray(`     총 ${status.bot.total}건`));
-        for (const [domain, count] of Object.entries(status.bot.domains)) {
-            console.log(chalk_1.default.gray(`     - ${domain}: ${count}건`));
-        }
-        if (status.bot.lastUpdated) {
-            console.log(chalk_1.default.gray(`     최종 업데이트: ${status.bot.lastUpdated}`));
-        }
-        if (status.bot.lastSynced) {
-            console.log(chalk_1.default.gray(`     최종 동기화: ${status.bot.lastSynced}`));
-        }
         // Local sync state
         const syncState = readSyncState(process.cwd());
         if (syncState.lastPull || syncState.lastPush) {
@@ -2615,42 +2424,32 @@ kbCmd
 kbCmd
     .command("list")
     .description("KB 항목 목록 조회")
-    .option("--bot <name>", "봇 ID", detectBotId())
     .option("--domain <name>", "도메인 필터")
+    .option("--service <name>", "서비스(프로젝트) 필터 — 해당 서비스의 모든 도메인 항목 반환")
     .option("--limit <n>", "최대 항목 수", "50")
     .option("--format <type>", "출력 형식 (table|json)", "table")
     .action(async (options) => {
     try {
         const pool = (0, database_1.getPool)();
-        const result = await (0, kb_1.kbList)(pool, {
+        const entries = await (0, kb_1.kbList)(pool, {
             domain: options.domain,
-            botId: options.bot,
+            service: options.service,
             limit: parseInt(options.limit),
         });
         if (options.format === "json") {
-            console.log(JSON.stringify(result, null, 2));
+            console.log(JSON.stringify(entries, null, 2));
         }
         else {
             console.log(chalk_1.default.cyan.bold("\n📋 KB 목록\n"));
-            if (result.shared.length > 0) {
-                console.log(chalk_1.default.white("  📦 공통 KB"));
+            if (entries.length > 0) {
                 console.log(chalk_1.default.gray("  ─────────────────────────────────────────"));
-                for (const entry of result.shared) {
+                for (const entry of entries) {
                     const preview = entry.content.substring(0, 60).replace(/\n/g, " ");
                     console.log(chalk_1.default.cyan(`  [${entry.domain}] `) + chalk_1.default.white(entry.key));
                     console.log(chalk_1.default.gray(`    ${preview}${entry.content.length > 60 ? "..." : ""}`));
                 }
             }
-            if (result.bot.length > 0) {
-                console.log(chalk_1.default.white(`\n  🤖 봇 KB (${options.bot})`));
-                console.log(chalk_1.default.gray("  ─────────────────────────────────────────"));
-                for (const entry of result.bot) {
-                    const preview = entry.content.substring(0, 60).replace(/\n/g, " ");
-                    console.log(chalk_1.default.cyan(`  [${entry.domain}] `) + chalk_1.default.white(entry.key));
-                    console.log(chalk_1.default.gray(`    ${preview}${entry.content.length > 60 ? "..." : ""}`));
-                }
-            }
-            if (result.shared.length === 0 && result.bot.length === 0) {
+            else {
                 console.log(chalk_1.default.yellow("  KB가 비어있습니다."));
             }
             console.log();
@@ -2666,8 +2465,8 @@ kbCmd
 kbCmd
     .command("search <query>")
     .description("KB 검색 (시맨틱 + 텍스트 하이브리드)")
-    .option("--bot <name>", "봇 KB도 검색", detectBotId())
     .option("--domain <name>", "도메인 필터")
+    .option("--service <name>", "서비스(프로젝트) 필터")
     .option("--limit <n>", "최대 결과 수", "10")
     .option("--mode <type>", "검색 모드 (hybrid|semantic|text)", "hybrid")
     .action(async (query, options) => {
@@ -2676,7 +2475,7 @@ kbCmd
         const pool = (0, database_1.getPool)();
         const results = await (0, kb_1.kbSearch)(pool, query, {
             domain: options.domain,
-            botId: options.bot,
+            service: options.service,
             limit: parseInt(options.limit),
             mode: options.mode,
         });
@@ -2703,46 +2502,9 @@ kbCmd
         process.exit(1);
     }
 });
-kbCmd
-    .command("diff")
-    .description("로컬 .kb/ vs DB 차이 비교")
-    .option("--bot <name>", "봇 ID", detectBotId())
-    .action(async (options) => {
-    const spinner = (0, ora_1.default)("차이 비교 중...").start();
-    try {
-        const pool = (0, database_1.getPool)();
-        const diff = await (0, kb_1.kbDiff)(pool, options.bot, process.cwd());
-        spinner.stop();
-        console.log(chalk_1.default.cyan.bold("\n📊 KB Diff\n"));
-        console.log(chalk_1.default.green(`  ✚ 추가됨 (DB에만 있음): ${diff.added.length}건`));
-        console.log(chalk_1.default.red(`  ✖ 삭제됨 (로컬에만 있음): ${diff.removed.length}건`));
-        console.log(chalk_1.default.yellow(`  ✎ 변경됨: ${diff.modified.length}건`));
-        console.log(chalk_1.default.gray(`  ═ 동일: ${diff.unchanged}건`));
-        if (diff.added.length > 0) {
-            console.log(chalk_1.default.green("\n  ✚ 추가된 항목:"));
-            diff.added.forEach(e => console.log(chalk_1.default.gray(`    [${e.domain}] ${e.key}`)));
-        }
-        if (diff.removed.length > 0) {
-            console.log(chalk_1.default.red("\n  ✖ 삭제된 항목:"));
-            diff.removed.forEach(e => console.log(chalk_1.default.gray(`    [${e.domain}] ${e.key}`)));
-        }
-        if (diff.modified.length > 0) {
-            console.log(chalk_1.default.yellow("\n  ✎ 변경된 항목:"));
-            diff.modified.forEach(m => console.log(chalk_1.default.gray(`    [${m.local.domain}] ${m.local.key}`)));
-        }
-        console.log();
-        await (0, database_1.closeConnection)();
-    }
-    catch (err) {
-        spinner.fail(`Diff 실패: ${err}`);
-        await (0, database_1.closeConnection)();
-        process.exit(1);
-    }
-});
 kbCmd
     .command("embed")
     .description("기존 KB 항목에 임베딩 벡터 생성 (OPENAI_API_KEY 필요)")
-    .option("--bot <name>", "봇 KB도 임베딩", detectBotId())
     .option("--domain <name>", "도메인 필터")
     .option("--force", "이미 임베딩된 항목도 재생성")
     .action(async (options) => {
@@ -2755,29 +2517,17 @@ kbCmd
     try {
         const pool = (0, database_1.getPool)();
         const client = await pool.connect();
-        // Shared KB
-        let sharedSql = "SELECT kb_id, domain, key, content FROM semo.knowledge_base WHERE 1=1";
-        const sharedParams = [];
+        let sql = "SELECT kb_id, domain, key, content FROM semo.knowledge_base WHERE 1=1";
+        const params = [];
         let pIdx = 1;
         if (!options.force)
-            sharedSql += " AND embedding IS NULL";
+            sql += " AND embedding IS NULL";
         if (options.domain) {
-            sharedSql += ` AND domain = $${pIdx++}`;
-            sharedParams.push(options.domain);
-        }
-        const sharedRows = await client.query(sharedSql, sharedParams);
-        // Bot KB
-        let botSql = "SELECT id, domain, key, content FROM semo.bot_knowledge WHERE bot_id = $1";
-        const botParams = [options.bot];
-        let bIdx = 2;
-        if (!options.force)
-            botSql += " AND embedding IS NULL";
-        if (options.domain) {
-            botSql += ` AND domain = $${bIdx++}`;
-            botParams.push(options.domain);
+            sql += ` AND domain = $${pIdx++}`;
+            params.push(options.domain);
         }
-        const botRows = await client.query(botSql, botParams);
-        const total = sharedRows.rows.length + botRows.rows.length;
+        const rows = await client.query(sql, params);
+        const total = rows.rows.length;
         spinner.succeed(`${total}건 임베딩 대상`);
         if (total === 0) {
             console.log(chalk_1.default.green("  모든 항목이 이미 임베딩되어 있습니다."));
@@ -2787,8 +2537,7 @@ kbCmd
         }
         let done = 0;
         const embedSpinner = (0, ora_1.default)(`임베딩 생성 중... 0/${total}`).start();
-        // Process shared KB
-        for (const row of sharedRows.rows) {
+        for (const row of rows.rows) {
             const embedding = await (0, kb_1.generateEmbedding)(`${row.key}: ${row.content}`);
             if (embedding) {
                 await client.query("UPDATE semo.knowledge_base SET embedding = $1::vector WHERE kb_id = $2", [`[${embedding.join(",")}]`, row.kb_id]);
@@ -2796,15 +2545,6 @@ kbCmd
             done++;
             embedSpinner.text = `임베딩 생성 중... ${done}/${total}`;
         }
-        // Process bot KB
-        for (const row of botRows.rows) {
-            const embedding = await (0, kb_1.generateEmbedding)(`${row.key}: ${row.content}`);
-            if (embedding) {
-                await client.query("UPDATE semo.bot_knowledge SET embedding = $1::vector WHERE id = $2", [`[${embedding.join(",")}]`, row.id]);
-            }
-            done++;
-            embedSpinner.text = `임베딩 생성 중... ${done}/${total}`;
-        }
         embedSpinner.succeed(`${done}건 임베딩 완료`);
         client.release();
         await (0, database_1.closeConnection)();
@@ -2818,7 +2558,6 @@ kbCmd
 kbCmd
     .command("sync")
     .description("양방향 동기화 (pull → merge → push)")
-    .option("--bot <name>", "봇 ID", detectBotId())
     .option("--domain <name>", "도메인 필터")
     .action(async (options) => {
     console.log(chalk_1.default.cyan.bold("\n🔄 KB 동기화\n"));
@@ -2826,8 +2565,8 @@ kbCmd
     try {
         const pool = (0, database_1.getPool)();
         // Step 1: Pull
-        const pulled = await (0, kb_1.kbPull)(pool, options.bot, options.domain, process.cwd());
-        spinner.succeed(`Pull 완료: 공통 ${pulled.shared.length}건, 봇 ${pulled.bot.length}건`);
+        const pulled = await (0, kb_1.kbPull)(pool, options.domain, process.cwd());
+        spinner.succeed(`Pull 완료: ${pulled.length}건`);
         // Step 2: Pull ontology
         const spinner2 = (0, ora_1.default)("Step 2/2: 온톨로지 동기화...").start();
         const ontoCount = await (0, kb_1.ontoPullToLocal)(pool, process.cwd());
@@ -2850,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));
         }
@@ -2864,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();
@@ -2957,6 +2756,8 @@ ontoCmd
 (0, bots_1.registerBotsCommands)(program);
 (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 기반)
@@ -2984,119 +2785,12 @@ function parseSkillFrontmatter(content) {
     // tools 배열
     const toolsMatch = fm.match(/^tools:\s*\[(.+)\]$/m);
     const tools = toolsMatch ? toolsMatch[1].split(",").map((t) => t.trim()) : [];
-    // category: 상위 디렉토리명 또는 name 자체 (semo-skills의 경우 dir = skill name)
+    // category
     const category = "core";
     return { name, description, category, tools };
 }
-/**
- * semo-system/semo-skills/ 스캔 → semo.skills 테이블 upsert
- */
-async function seedSkillsToDb(semoSystemDir) {
-    const skillsDir = path.join(semoSystemDir, "semo-skills");
-    if (!fs.existsSync(skillsDir)) {
-        console.log(chalk_1.default.red(`\n❌ semo-skills 디렉토리를 찾을 수 없습니다: ${skillsDir}`));
-        return;
-    }
-    const connected = await (0, database_1.isDbConnected)();
-    if (!connected) {
-        console.log(chalk_1.default.red("❌ DB 연결 실패 — seed-skills 건너뜀"));
-        return;
-    }
-    const spinner = (0, ora_1.default)("semo-skills 스캔 중...").start();
-    // 활성 스킬 디렉토리 수집 (_archived, CHANGELOG, VERSION 제외)
-    const excludeDirs = new Set(["_archived", "CHANGELOG"]);
-    const excludeFiles = new Set(["VERSION"]);
-    const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
-    const skillDirs = entries.filter(e => e.isDirectory() && !excludeDirs.has(e.name));
-    const skills = [];
-    for (const dir of skillDirs) {
-        const skillMdPath = path.join(skillsDir, dir.name, "SKILL.md");
-        if (!fs.existsSync(skillMdPath))
-            continue;
-        const content = fs.readFileSync(skillMdPath, "utf-8");
-        const parsed = parseSkillFrontmatter(content);
-        if (!parsed)
-            continue;
-        skills.push({ ...parsed, content });
-    }
-    spinner.text = `${skills.length}개 스킬 발견 — DB에 upsert 중...`;
-    const pool = (0, database_1.getPool)();
-    const client = await pool.connect();
-    let upserted = 0;
-    const errors = [];
-    try {
-        await client.query("BEGIN");
-        for (let i = 0; i < skills.length; i++) {
-            const skill = skills[i];
-            try {
-                await client.query(`INSERT INTO semo.skills
-             (name, display_name, description, content, category, package,
-              is_active, is_required, install_order, version)
-           VALUES ($1, $2, $3, $4, $5, $6, true, false, $7, '1.0.0')
-           ON CONFLICT (name) DO UPDATE SET
-             display_name = EXCLUDED.display_name,
-             description  = EXCLUDED.description,
-             content      = EXCLUDED.content,
-             category     = EXCLUDED.category`, [skill.name, skill.name, skill.description, skill.content, skill.category, "semo-skills", i + 1]);
-                upserted++;
-            }
-            catch (err) {
-                errors.push(`${skill.name}: ${err}`);
-            }
-        }
-        await client.query("COMMIT");
-        spinner.succeed(`seed-skills 완료: ${upserted}개 스킬 upsert`);
-        if (errors.length > 0) {
-            errors.forEach(e => console.log(chalk_1.default.red(`  ❌ ${e}`)));
-        }
-    }
-    catch (err) {
-        await client.query("ROLLBACK");
-        spinner.fail(`seed-skills 실패: ${err}`);
-    }
-    finally {
-        client.release();
-    }
-}
-// `semo skills` 커맨드 그룹
-const skillsCmd = program
-    .command("skills")
-    .description("스킬 관리 (DB 시딩 등)");
-skillsCmd
-    .command("seed")
-    .description("semo-system/semo-skills/ → semo.skills DB upsert")
-    .option("--semo-system <path>", "semo-system 경로 (기본: ./semo-system)")
-    .option("--dry-run", "실제 upsert 없이 스캔 결과만 출력")
-    .action(async (options) => {
-    const cwd = process.cwd();
-    const semoSystemDir = options.semoSystem
-        ? path.resolve(options.semoSystem)
-        : path.join(cwd, "semo-system");
-    if (options.dryRun) {
-        const skillsDir = path.join(semoSystemDir, "semo-skills");
-        if (!fs.existsSync(skillsDir)) {
-            console.log(chalk_1.default.red(`❌ ${skillsDir} 없음`));
-            process.exit(1);
-        }
-        const excludeDirs = new Set(["_archived", "CHANGELOG"]);
-        const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
-        const skillDirs = entries.filter(e => e.isDirectory() && !excludeDirs.has(e.name));
-        console.log(chalk_1.default.cyan.bold("\n[dry-run] 발견된 스킬:\n"));
-        for (const dir of skillDirs) {
-            const mdPath = path.join(skillsDir, dir.name, "SKILL.md");
-            if (!fs.existsSync(mdPath))
-                continue;
-            const parsed = parseSkillFrontmatter(fs.readFileSync(mdPath, "utf-8"));
-            if (parsed) {
-                console.log(chalk_1.default.gray(`  ${parsed.name.padEnd(20)} ${parsed.description.split("\n")[0].substring(0, 60)}`));
-            }
-        }
-        console.log();
-        return;
-    }
-    await seedSkillsToDb(semoSystemDir);
-    await (0, database_1.closeConnection)();
-});
+// semo skills seed — 제거됨 (중앙 DB 단일 SoT)
+// 봇 전용 스킬은 semo bots seed로 동기화
 // === -v 옵션 처리 (program.parse 전에 직접 처리) ===
 async function main() {
     const args = process.argv.slice(2);