@team-semicolon/semo-cli 4.7.4 → 4.9.0

package/dist/commands/audit.d.ts

@@ -23,13 +23,62 @@ export interface BotAuditResult {
     score: number;
     checks: AuditCheck[];
 }
+interface CheckDef {
+    name: string;
+    check: (botDir: string, botId: string) => AuditCheck;
+}
+export interface WorkspaceStandardRow {
+    path_pattern: string;
+    entry_type: string;
+    level: string;
+    severity: string;
+    category: string;
+    bot_scope: string;
+    bot_ids: string[];
+    symlink_target: string | null;
+    content_rules: Record<string, unknown> | null;
+    description: string | null;
+    fix_action: string | null;
+    fix_template: string | null;
+}
+export declare function loadCheckDefs(pool: Pool): Promise<{
+    defs: CheckDef[];
+    rows: WorkspaceStandardRow[];
+}>;
 /** Sync version using fallback CHECK_DEFS (no DB) */
 export declare function auditBot(botDir: string, botId: string): BotAuditResult;
 /** Async version using DB-loaded rules */
 export declare function auditBotFromDb(botDir: string, botId: string, pool: Pool): Promise<BotAuditResult>;
+/** Legacy hardcoded fix — used when DB is unavailable */
 export declare function fixBot(botDir: string, botId: string, checks: AuditCheck[]): number;
+/**
+ * DB `fix_action`/`fix_template` 기반 auto-fix.
+ * 지원 액션: create_file, create_dir, create_symlink, delete (--force 필요)
+ */
+export declare function fixBotFromDb(botDir: string, botId: string, checks: AuditCheck[], dbRules: WorkspaceStandardRow[], options?: {
+    force?: boolean;
+}): {
+    fixed: number;
+    skipped: string[];
+};
+/**
+ * DB의 required 규칙에 대해 파일이 없으면 생성.
+ * content_rules 위반은 보고만 한다.
+ */
+export declare function syncBotFromDb(botDir: string, botId: string, dbRules: WorkspaceStandardRow[]): {
+    created: number;
+    violations: string[];
+};
+export interface SkillAuditCheck extends AuditCheck {
+    skillName?: string;
+}
+/**
+ * 봇의 skills/ 하위 스킬 디렉토리 구조 검증
+ */
+export declare function auditSkillStructure(botDir: string, botId: string): SkillAuditCheck[];
 export declare function auditBotKb(pool: Pool): Promise<AuditCheck[]>;
 export declare function auditBotDb(botId: string, pool: Pool): Promise<AuditCheck[]>;
 export declare function mergeDbChecks(result: BotAuditResult, dbChecks: AuditCheck[]): BotAuditResult;
 export declare function formatAuditSlack(results: BotAuditResult[]): string;
 export declare function storeAuditResults(results: BotAuditResult[], client: PoolClient): Promise<void>;
+export {};

package/dist/commands/audit.js

@@ -46,9 +46,13 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCheckDefs = loadCheckDefs;
 exports.auditBot = auditBot;
 exports.auditBotFromDb = auditBotFromDb;
 exports.fixBot = fixBot;
+exports.fixBotFromDb = fixBotFromDb;
+exports.syncBotFromDb = syncBotFromDb;
+exports.auditSkillStructure = auditSkillStructure;
 exports.auditBotKb = auditBotKb;
 exports.auditBotDb = auditBotDb;
 exports.mergeDbChecks = mergeDbChecks;
@@ -324,6 +328,7 @@ const FIXABLE_DIRS = {
 const FILE_TEMPLATES = {
     "SOUL.md": (botId) => `# ${botId} — SOUL\n\n## Identity\n\n> TODO\n\n## R&R\n\n> TODO\n\n## KB Lookup Protocol\n\n> semo kb get/search로 팀 정보 조회\n\n## Operating Procedures\n\n> TODO\n\n## NON-NEGOTIABLE\n\n1. TODO\n`,
 };
+/** Legacy hardcoded fix — used when DB is unavailable */
 function fixBot(botDir, botId, checks) {
     let fixed = 0;
     for (const check of checks) {
@@ -384,6 +389,295 @@ function fixBot(botDir, botId, checks) {
     return fixed;
 }
 // ============================================================
+// DB-based auto-fix — fix_action/fix_template 활용
+// ============================================================
+/**
+ * DB `fix_action`/`fix_template` 기반 auto-fix.
+ * 지원 액션: create_file, create_dir, create_symlink, delete (--force 필요)
+ */
+function fixBotFromDb(botDir, botId, checks, dbRules, options = {}) {
+    let fixed = 0;
+    const skipped = [];
+    const home = process.env.HOME || "/Users/reus";
+    // Build a map of check name → row for quick lookup
+    const failedCheckNames = new Set(checks.filter((c) => !c.passed).map((c) => c.name));
+    for (const row of dbRules) {
+        if (!row.fix_action || !row.fix_template)
+            continue;
+        const checkName = `${row.category}/${row.path_pattern}`;
+        // Check if any of the failed checks relate to this row
+        const isRelevant = failedCheckNames.has(checkName) ||
+            failedCheckNames.has(`${checkName}-symlink`);
+        if (!isRelevant)
+            continue;
+        // Variable substitution in fix_template
+        const resolvedTemplate = row.fix_template
+            .replace(/\$BOT_ID/g, botId)
+            .replace(/\$HOME/g, home);
+        const targetPath = path.join(botDir, row.path_pattern);
+        switch (row.fix_action) {
+            case "create_file": {
+                if (fs.existsSync(targetPath))
+                    break;
+                const dir = path.dirname(targetPath);
+                if (!fs.existsSync(dir)) {
+                    fs.mkdirSync(dir, { recursive: true });
+                }
+                fs.writeFileSync(targetPath, resolvedTemplate, "utf-8");
+                fixed++;
+                break;
+            }
+            case "create_dir": {
+                const dirPath = row.path_pattern.endsWith("/")
+                    ? path.join(botDir, row.path_pattern.slice(0, -1))
+                    : targetPath;
+                if (!fs.existsSync(dirPath)) {
+                    fs.mkdirSync(dirPath, { recursive: true });
+                    fixed++;
+                }
+                break;
+            }
+            case "create_symlink": {
+                const symlinkTarget = resolvedTemplate;
+                if (!fs.existsSync(symlinkTarget))
+                    break;
+                if (fs.existsSync(targetPath)) {
+                    const stats = fs.lstatSync(targetPath);
+                    if (stats.isSymbolicLink()) {
+                        const existing = fs.readlinkSync(targetPath);
+                        if (existing === symlinkTarget)
+                            break; // already correct
+                        fs.unlinkSync(targetPath);
+                    }
+                    else {
+                        fs.unlinkSync(targetPath);
+                    }
+                }
+                fs.symlinkSync(symlinkTarget, targetPath);
+                fixed++;
+                break;
+            }
+            case "delete": {
+                if (!fs.existsSync(targetPath))
+                    break;
+                if (!options.force) {
+                    skipped.push(`${row.path_pattern} (delete requires --force)`);
+                    break;
+                }
+                const stats = fs.lstatSync(targetPath);
+                if (stats.isDirectory()) {
+                    fs.rmSync(targetPath, { recursive: true, force: true });
+                }
+                else {
+                    fs.unlinkSync(targetPath);
+                }
+                fixed++;
+                break;
+            }
+        }
+    }
+    return { fixed, skipped };
+}
+// ============================================================
+// --sync: DB required 항목 proactive 보장
+// ============================================================
+/**
+ * DB의 required 규칙에 대해 파일이 없으면 생성.
+ * content_rules 위반은 보고만 한다.
+ */
+function syncBotFromDb(botDir, botId, dbRules) {
+    let created = 0;
+    const violations = [];
+    const home = process.env.HOME || "/Users/reus";
+    for (const row of dbRules) {
+        if (row.level !== "required")
+            continue;
+        if (row.path_pattern.includes("*"))
+            continue; // glob patterns handled separately
+        const targetPath = path.join(botDir, row.path_pattern);
+        if (row.entry_type === "dir") {
+            const dirPath = row.path_pattern.endsWith("/")
+                ? path.join(botDir, row.path_pattern.slice(0, -1))
+                : targetPath;
+            if (!fs.existsSync(dirPath)) {
+                if (row.fix_action === "create_dir") {
+                    fs.mkdirSync(dirPath, { recursive: true });
+                    created++;
+                }
+            }
+        }
+        else if (row.entry_type === "symlink") {
+            if (!fs.existsSync(targetPath) && row.fix_action === "create_symlink" && row.fix_template) {
+                const symlinkTarget = row.fix_template
+                    .replace(/\$BOT_ID/g, botId)
+                    .replace(/\$HOME/g, home);
+                if (fs.existsSync(symlinkTarget)) {
+                    const dir = path.dirname(targetPath);
+                    if (!fs.existsSync(dir))
+                        fs.mkdirSync(dir, { recursive: true });
+                    fs.symlinkSync(symlinkTarget, targetPath);
+                    created++;
+                }
+            }
+        }
+        else {
+            // file
+            if (!fs.existsSync(targetPath)) {
+                if (row.fix_action === "create_file" && row.fix_template) {
+                    const content = row.fix_template
+                        .replace(/\$BOT_ID/g, botId)
+                        .replace(/\$HOME/g, home);
+                    const dir = path.dirname(targetPath);
+                    if (!fs.existsSync(dir))
+                        fs.mkdirSync(dir, { recursive: true });
+                    fs.writeFileSync(targetPath, content, "utf-8");
+                    created++;
+                }
+            }
+            else if (row.content_rules) {
+                // File exists — check content_rules violations (report only)
+                const rules = row.content_rules;
+                const maxLines = rules.max_lines;
+                if (maxLines) {
+                    try {
+                        const lines = fs.readFileSync(targetPath, "utf-8").split("\n").length;
+                        if (lines > maxLines) {
+                            violations.push(`${row.path_pattern}: ${lines} lines (max ${maxLines})`);
+                        }
+                    }
+                    catch { /* skip unreadable */ }
+                }
+            }
+        }
+    }
+    return { created, violations };
+}
+/**
+ * 봇의 skills/ 하위 스킬 디렉토리 구조 검증
+ */
+function auditSkillStructure(botDir, botId) {
+    const checks = [];
+    const skillsDir = path.join(botDir, "skills");
+    if (!fs.existsSync(skillsDir) || !fs.statSync(skillsDir).isDirectory()) {
+        return checks;
+    }
+    let entries;
+    try {
+        entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+    }
+    catch {
+        return checks;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (entry.name.startsWith("_") || entry.name.startsWith("."))
+            continue;
+        if (entry.name.endsWith(".skill"))
+            continue;
+        const skillName = entry.name;
+        const skillDir = path.join(skillsDir, skillName);
+        const skillMdPath = path.join(skillDir, "SKILL.md");
+        // SKILL.md 존재 여부
+        if (!fs.existsSync(skillMdPath)) {
+            checks.push({
+                name: `skill/${skillName}/SKILL.md`,
+                passed: false,
+                detail: `skills/${skillName}/SKILL.md missing`,
+                skillName,
+            });
+            continue;
+        }
+        // SKILL.md 내용 검증
+        let content;
+        try {
+            content = fs.readFileSync(skillMdPath, "utf-8");
+        }
+        catch {
+            checks.push({
+                name: `skill/${skillName}/SKILL.md`,
+                passed: false,
+                detail: `skills/${skillName}/SKILL.md unreadable`,
+                skillName,
+            });
+            continue;
+        }
+        // SKILL.md exists
+        checks.push({
+            name: `skill/${skillName}/SKILL.md`,
+            passed: true,
+            detail: `skills/${skillName}/SKILL.md exists`,
+            skillName,
+        });
+        // Line count check (max 500)
+        const lines = content.split("\n").length;
+        checks.push({
+            name: `skill/${skillName}/lines`,
+            passed: lines <= 500,
+            detail: lines <= 500
+                ? `skills/${skillName}/SKILL.md: ${lines} lines (≤ 500)`
+                : `skills/${skillName}/SKILL.md: ${lines} lines (> 500, too long)`,
+            skillName,
+        });
+        // Frontmatter check (---\nname: ...\ndescription: ...\n---)
+        const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+        if (fmMatch) {
+            const fm = fmMatch[1];
+            const nameMatch = fm.match(/^name:\s*(.+)$/m);
+            const descMatch = fm.match(/^description:/m);
+            if (nameMatch) {
+                const fmName = nameMatch[1].trim();
+                const isKebab = /^[a-z0-9]+(-[a-z0-9]+)*$/.test(fmName);
+                checks.push({
+                    name: `skill/${skillName}/name-kebab`,
+                    passed: isKebab,
+                    detail: isKebab
+                        ? `skills/${skillName} name "${fmName}" is kebab-case`
+                        : `skills/${skillName} name "${fmName}" is not kebab-case`,
+                    skillName,
+                });
+            }
+            else {
+                checks.push({
+                    name: `skill/${skillName}/name-kebab`,
+                    passed: false,
+                    detail: `skills/${skillName}/SKILL.md frontmatter missing 'name'`,
+                    skillName,
+                });
+            }
+            checks.push({
+                name: `skill/${skillName}/description`,
+                passed: !!descMatch,
+                detail: descMatch
+                    ? `skills/${skillName}/SKILL.md has description`
+                    : `skills/${skillName}/SKILL.md frontmatter missing 'description'`,
+                skillName,
+            });
+        }
+        else {
+            checks.push({
+                name: `skill/${skillName}/frontmatter`,
+                passed: false,
+                detail: `skills/${skillName}/SKILL.md missing frontmatter (--- block)`,
+                skillName,
+            });
+        }
+        // Forbidden files check
+        const forbiddenFiles = ["README.md", "CHANGELOG.md", "INSTALL.md", "LICENSE", "LICENSE.md"];
+        for (const forbidden of forbiddenFiles) {
+            if (fs.existsSync(path.join(skillDir, forbidden))) {
+                checks.push({
+                    name: `skill/${skillName}/forbidden-${forbidden}`,
+                    passed: false,
+                    detail: `skills/${skillName}/${forbidden} exists (forbidden)`,
+                    skillName,
+                });
+            }
+        }
+    }
+    return checks;
+}
+// ============================================================
 // KB domain checks (async, requires pool)
 // ============================================================
 const KB_REQUIRED_DOMAINS = ["semicolon"];

package/dist/commands/bots.js

@@ -561,7 +561,9 @@ function registerBotsCommands(program) {
         .command("audit")
         .description("봇 워크스페이스 표준 구조 audit")
         .option("--format <type>", "출력 형식 (table|json|slack)", "table")
-        .option("--fix", "누락 파일/디렉토리 자동 생성")
+        .option("--fix", "누락 파일/디렉토리 자동 생성 (DB fix_action 활용)")
+        .option("--sync", "DB required 항목 proactive 보장 (누락 파일 생성)")
+        .option("--force", "delete fix_action 실행 허용 (--fix와 함께 사용)")
         .option("--no-db", "DB 저장 건너뛰기")
         .option("--local", "~/.claude/semo/bots/ 로컬 미러 audit")
         .action(async (options) => {
@@ -596,14 +598,74 @@ function registerBotsCommands(program) {
         // Run audit — try DB-based rules first, fallback to hardcoded
         let results;
         const dbConnected = await (0, database_1.isDbConnected)();
+        let dbRules = [];
         if (dbConnected) {
             const pool = (0, database_1.getPool)();
+            try {
+                const { rows } = await (0, audit_1.loadCheckDefs)(pool);
+                dbRules = rows;
+            }
+            catch { /* DB rules load failed, will use fallback */ }
             results = await Promise.all(botEntries.map(({ botId, botDir }) => (0, audit_1.auditBotFromDb)(botDir, botId, pool)));
         }
         else {
             results = botEntries.map(({ botId, botDir }) => (0, audit_1.auditBot)(botDir, botId));
         }
+        // Merge skill structure checks into results
+        for (let i = 0; i < results.length; i++) {
+            const skillChecks = (0, audit_1.auditSkillStructure)(botEntries[i].botDir, botEntries[i].botId);
+            if (skillChecks.length > 0) {
+                results[i] = (0, audit_1.mergeDbChecks)(results[i], skillChecks);
+            }
+        }
         spinner.stop();
+        // --sync: DB required 항목 proactive 보장
+        if (options.sync && dbRules.length > 0) {
+            let totalCreated = 0;
+            const allViolations = [];
+            for (const { botId, botDir } of botEntries) {
+                const botSpecificRules = dbRules.filter((row) => {
+                    if (row.bot_scope === "all")
+                        return true;
+                    if (row.bot_scope === "include")
+                        return row.bot_ids.includes(botId);
+                    if (row.bot_scope === "exclude")
+                        return !row.bot_ids.includes(botId);
+                    return true;
+                });
+                const { created, violations } = (0, audit_1.syncBotFromDb)(botDir, botId, botSpecificRules);
+                if (created > 0) {
+                    console.log(chalk_1.default.green(`  ✔ ${botId}: ${created}개 항목 동기화 생성`));
+                    totalCreated += created;
+                }
+                allViolations.push(...violations.map((v) => `${botId}: ${v}`));
+            }
+            if (totalCreated > 0) {
+                console.log(chalk_1.default.green(`\n총 ${totalCreated}개 동기화`));
+            }
+            if (allViolations.length > 0) {
+                console.log(chalk_1.default.yellow(`\n⚠ content_rules 위반 (보고만):`));
+                for (const v of allViolations) {
+                    console.log(chalk_1.default.yellow(`  - ${v}`));
+                }
+            }
+            // Re-audit after sync
+            if (totalCreated > 0) {
+                if (dbConnected) {
+                    const pool = (0, database_1.getPool)();
+                    results = await Promise.all(botEntries.map(({ botId, botDir }) => (0, audit_1.auditBotFromDb)(botDir, botId, pool)));
+                }
+                else {
+                    results = botEntries.map(({ botId, botDir }) => (0, audit_1.auditBot)(botDir, botId));
+                }
+                for (let i = 0; i < results.length; i++) {
+                    const skillChecks = (0, audit_1.auditSkillStructure)(botEntries[i].botDir, botEntries[i].botId);
+                    if (skillChecks.length > 0) {
+                        results[i] = (0, audit_1.mergeDbChecks)(results[i], skillChecks);
+                    }
+                }
+            }
+        }
         // --fix
         if (options.fix) {
             let totalFixed = 0;
@@ -611,20 +673,50 @@ function registerBotsCommands(program) {
                 const botDir = isLocal
                     ? path.join(home, ".claude", "semo", "bots", r.botId)
                     : path.join(home, `.openclaw-${r.botId}`, "workspace");
-                const fixed = (0, audit_1.fixBot)(botDir, r.botId, r.checks);
+                let fixed;
+                if (dbRules.length > 0) {
+                    // DB-based fix
+                    const botSpecificRules = dbRules.filter((row) => {
+                        if (row.bot_scope === "all")
+                            return true;
+                        if (row.bot_scope === "include")
+                            return row.bot_ids.includes(r.botId);
+                        if (row.bot_scope === "exclude")
+                            return !row.bot_ids.includes(r.botId);
+                        return true;
+                    });
+                    const result = (0, audit_1.fixBotFromDb)(botDir, r.botId, r.checks, botSpecificRules, { force: options.force });
+                    fixed = result.fixed;
+                    if (result.skipped.length > 0) {
+                        for (const s of result.skipped) {
+                            console.log(chalk_1.default.yellow(`  ⚠ ${r.botId}: ${s}`));
+                        }
+                    }
+                }
+                else {
+                    // Fallback to hardcoded fix
+                    fixed = (0, audit_1.fixBot)(botDir, r.botId, r.checks);
+                }
                 if (fixed > 0) {
-                    console.log(chalk_1.default.green(`  ✔ ${r.botId}: ${fixed}개 파일/디렉토리 생성`));
+                    console.log(chalk_1.default.green(`  ✔ ${r.botId}: ${fixed}개 파일/디렉토리 수정`));
                     totalFixed += fixed;
                 }
             }
             if (totalFixed > 0) {
                 console.log(chalk_1.default.green(`\n총 ${totalFixed}개 수정`));
                 // Re-audit after fix
+                if (dbConnected) {
+                    const pool = (0, database_1.getPool)();
+                    results = await Promise.all(botEntries.map(({ botId, botDir }) => (0, audit_1.auditBotFromDb)(botDir, botId, pool)));
+                }
+                else {
+                    results = botEntries.map(({ botId, botDir }) => (0, audit_1.auditBot)(botDir, botId));
+                }
                 for (let i = 0; i < results.length; i++) {
-                    const botDir = isLocal
-                        ? path.join(home, ".claude", "semo", "bots", results[i].botId)
-                        : path.join(home, `.openclaw-${results[i].botId}`, "workspace");
-                    results[i] = (0, audit_1.auditBot)(botDir, results[i].botId);
+                    const skillChecks = (0, audit_1.auditSkillStructure)(botEntries[i].botDir, botEntries[i].botId);
+                    if (skillChecks.length > 0) {
+                        results[i] = (0, audit_1.mergeDbChecks)(results[i], skillChecks);
+                    }
                 }
             }
         }

package/dist/commands/skill-sync.d.ts

@@ -1,12 +1,15 @@
 /**
- * skill-sync — 봇 전용 스킬 파일 스캔 + DB 동기화
+ * skill-sync — 봇 워크스페이스 스킬 스캔 + DB 동기화
+ *
+ * v2.0: ~/.openclaw-{bot}/workspace/skills/ 경로 스캔 (semo-system/ 폐기)
+ * 봇 목록은 bot_status DB에서 동적 로드, fallback으로 로컬 디렉토리 스캔.
  *
  * semo bots sync (piggyback) 및 semo context sync (세션 훅) 양쪽에서 호출.
  * 스킬 이름은 flat (예: 'kb-manager'), metadata.bot_ids 배열로 봇 매핑.
  * 동일 스킬명이 여러 봇에 존재하면 bot_ids를 머지.
  */
-import { PoolClient } from "pg";
-interface ScannedSkill {
+import { Pool, PoolClient } from "pg";
+export interface ScannedSkill {
     name: string;
     prompt: string;
     package: string;
@@ -17,12 +20,21 @@ export interface SkillSyncResult {
     total: number;
 }
 /**
- * semo-system/bot-workspaces 에서 봇 전용 스킬 파일 스캔
+ * ~/.openclaw-{bot}/workspace/skills/ 에서 봇 전용 스킬 파일 스캔
+ *
+ * @param botIds - 스캔 대상 봇 ID 목록
+ */
+export declare function scanSkills(botIds: string[]): ScannedSkill[];
+/**
+ * @deprecated semo-system/ 기반 스캔 (하위호환 유지)
  */
 export declare function scanSkills(semoSystemDir: string): ScannedSkill[];
+/**
+ * DB에서 봇 목록을 로드, fallback으로 로컬 디렉토리 스캔
+ */
+export declare function getBotIds(pool: Pool): Promise<string[]>;
 /**
  * 스캔된 스킬을 skill_definitions에 upsert
  * flat name + metadata.bot_ids 배열 사용, 동일 스킬명은 bot_ids 머지
  */
-export declare function syncSkillsToDB(client: PoolClient, semoSystemDir: string): Promise<SkillSyncResult>;
-export {};
+export declare function syncSkillsToDB(client: PoolClient, pool: Pool): Promise<SkillSyncResult>;

package/dist/commands/skill-sync.js

@@ -1,6 +1,9 @@
 "use strict";
 /**
- * skill-sync — 봇 전용 스킬 파일 스캔 + DB 동기화
+ * skill-sync — 봇 워크스페이스 스킬 스캔 + DB 동기화
+ *
+ * v2.0: ~/.openclaw-{bot}/workspace/skills/ 경로 스캔 (semo-system/ 폐기)
+ * 봇 목록은 bot_status DB에서 동적 로드, fallback으로 로컬 디렉토리 스캔.
  *
  * semo bots sync (piggyback) 및 semo context sync (세션 훅) 양쪽에서 호출.
  * 스킬 이름은 flat (예: 'kb-manager'), metadata.bot_ids 배열로 봇 매핑.
@@ -41,13 +44,55 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scanSkills = scanSkills;
+exports.getBotIds = getBotIds;
 exports.syncSkillsToDB = syncSkillsToDB;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-/**
- * semo-system/bot-workspaces 에서 봇 전용 스킬 파일 스캔
- */
-function scanSkills(semoSystemDir) {
+function scanSkills(arg) {
+    if (typeof arg === "string") {
+        return scanSkillsLegacy(arg);
+    }
+    return scanSkillsV2(arg);
+}
+function scanSkillsV2(botIds) {
+    const skills = [];
+    const home = process.env.HOME || "/Users/reus";
+    for (const botId of botIds) {
+        const skillsDir = path.join(home, `.openclaw-${botId}`, "workspace", "skills");
+        if (!fs.existsSync(skillsDir))
+            continue;
+        let skillEntries;
+        try {
+            skillEntries = fs.readdirSync(skillsDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const skillEntry of skillEntries) {
+            if (!skillEntry.isDirectory())
+                continue;
+            if (skillEntry.name.endsWith(".skill"))
+                continue;
+            if (skillEntry.name.startsWith("_") || skillEntry.name.startsWith("."))
+                continue;
+            const skillMdPath = path.join(skillsDir, skillEntry.name, "SKILL.md");
+            if (!fs.existsSync(skillMdPath))
+                continue;
+            try {
+                skills.push({
+                    name: skillEntry.name,
+                    prompt: fs.readFileSync(skillMdPath, "utf-8"),
+                    package: "openclaw",
+                    botId,
+                });
+            }
+            catch { /* skip unreadable */ }
+        }
+    }
+    return skills;
+}
+/** Legacy: semo-system/bot-workspaces 에서 스캔 (하위호환) */
+function scanSkillsLegacy(semoSystemDir) {
     const skills = [];
     const workspacesDir = path.join(semoSystemDir, "bot-workspaces");
     if (!fs.existsSync(workspacesDir))
@@ -81,12 +126,42 @@ function scanSkills(semoSystemDir) {
     }
     return skills;
 }
+/**
+ * DB에서 봇 목록을 로드, fallback으로 로컬 디렉토리 스캔
+ */
+async function getBotIds(pool) {
+    try {
+        const result = await pool.query("SELECT bot_id FROM semo.bot_status ORDER BY bot_id");
+        if (result.rows.length > 0) {
+            return result.rows.map((r) => r.bot_id);
+        }
+    }
+    catch { /* fallback to local scan */ }
+    // Fallback: scan ~/.openclaw-*/workspace/ directories
+    const home = process.env.HOME || "/Users/reus";
+    const botIds = [];
+    try {
+        const entries = fs.readdirSync(home);
+        for (const entry of entries) {
+            const match = entry.match(/^\.openclaw-(.+)$/);
+            if (match) {
+                const wsDir = path.join(home, entry, "workspace");
+                if (fs.existsSync(wsDir)) {
+                    botIds.push(match[1]);
+                }
+            }
+        }
+    }
+    catch { /* skip */ }
+    return botIds.sort();
+}
 /**
  * 스캔된 스킬을 skill_definitions에 upsert
  * flat name + metadata.bot_ids 배열 사용, 동일 스킬명은 bot_ids 머지
  */
-async function syncSkillsToDB(client, semoSystemDir) {
-    const skills = scanSkills(semoSystemDir);
+async function syncSkillsToDB(client, pool) {
+    const botIds = await getBotIds(pool);
+    const skills = scanSkills(botIds);
     for (const skill of skills) {
         await client.query(`INSERT INTO semo.skill_definitions (name, prompt, package, metadata, is_active, office_id)
        VALUES ($1, $2, $3, $4, true, NULL)

package/dist/index.js

@@ -1665,7 +1665,7 @@ kbCmd
 });
 kbCmd
     .command("upsert <domain> <key> [sub_key]")
-    .description("KB 항목 쓰기 (upsert) — 임베딩 자동 생성 + 스키마 검증")
+    .description("KB 항목 쓰기 (upsert) — 임베딩 자동 생성 + 스키마 검증 (key는 kebab-case만 허용)")
     .requiredOption("--content <text>", "항목 본문")
     .option("--metadata <json>", "추가 메타데이터 (JSON 문자열)")
     .option("--created-by <name>", "작성자 식별자", "semo-cli")
@@ -1702,13 +1702,66 @@ kbCmd
         process.exit(1);
     }
 });
+kbCmd
+    .command("delete <domain> <key> [sub_key]")
+    .description("KB 항목 삭제 (domain + key + sub_key)")
+    .option("--yes", "확인 프롬프트 건너뛰기 (크론/스크립트용)")
+    .action(async (domain, key, subKey, options) => {
+    try {
+        const pool = (0, database_1.getPool)();
+        // 삭제 전 항목 확인
+        const entry = await (0, kb_1.kbGet)(pool, domain, key, subKey);
+        if (!entry) {
+            console.log(chalk_1.default.yellow(`\n  항목 없음: ${domain}/${key}${subKey ? '/' + subKey : ''}\n`));
+            await (0, database_1.closeConnection)();
+            process.exit(1);
+        }
+        // 확인 프롬프트 (--yes가 없으면)
+        if (!options.yes) {
+            const fullPath = `${domain}/${entry.key}${entry.sub_key ? '/' + entry.sub_key : ''}`;
+            console.log(chalk_1.default.cyan(`\n📄 삭제 대상: ${fullPath}`));
+            console.log(chalk_1.default.gray(`  version: ${entry.version} | created_by: ${entry.created_by} | updated: ${entry.updated_at}`));
+            console.log(chalk_1.default.gray(`  content: ${entry.content.substring(0, 120)}${entry.content.length > 120 ? '...' : ''}\n`));
+            const { createInterface } = await import("readline");
+            const rl = createInterface({ input: process.stdin, output: process.stdout });
+            const answer = await new Promise((resolve) => {
+                rl.question(chalk_1.default.yellow("  정말 삭제하시겠습니까? (y/N): "), resolve);
+            });
+            rl.close();
+            if (answer.toLowerCase() !== "y") {
+                console.log(chalk_1.default.gray("  취소됨.\n"));
+                await (0, database_1.closeConnection)();
+                return;
+            }
+        }
+        const result = await (0, kb_1.kbDelete)(pool, domain, key, subKey);
+        if (result.deleted) {
+            const fullPath = `${domain}/${result.entry.key}${result.entry.sub_key ? '/' + result.entry.sub_key : ''}`;
+            console.log(chalk_1.default.green(`✔ KB 삭제 완료: ${fullPath}`));
+        }
+        else {
+            console.log(chalk_1.default.red(`✖ KB 삭제 실패: ${result.error}`));
+            process.exit(1);
+        }
+        await (0, database_1.closeConnection)();
+    }
+    catch (err) {
+        console.error(chalk_1.default.red(`삭제 실패: ${err}`));
+        await (0, database_1.closeConnection)();
+        process.exit(1);
+    }
+});
 kbCmd
     .command("ontology")
     .description("온톨로지 조회 — 도메인/타입/스키마/라우팅 테이블")
-    .option("--action <type>", "동작 (list|show|services|types|instances|schema|routing-table|register)", "list")
+    .option("--action <type>", "동작 (list|show|services|types|instances|schema|routing-table|register|add-key|remove-key)", "list")
     .option("--domain <name>", "action=show|register 시 도메인")
-    .option("--type <name>", "action=schema|register 시 타입 키")
-    .option("--description <text>", "action=register 시 설명")
+    .option("--type <name>", "action=schema|register|add-key|remove-key 시 타입 키")
+    .option("--key <name>", "action=add-key|remove-key 시 스키마 키")
+    .option("--key-type <type>", "action=add-key 시 키 유형 (singleton|collection)", "singleton")
+    .option("--required", "action=add-key 시 필수 여부")
+    .option("--hint <text>", "action=add-key 시 값 힌트")
+    .option("--description <text>", "action=register|add-key 시 설명")
     .option("--service <name>", "action=register 시 서비스 그룹")
     .option("--tags <tags>", "action=register 시 태그 (쉼표 구분)")
     .option("--no-init", "action=register 시 필수 KB entry 자동 생성 건너뛰기")
@@ -1896,8 +1949,51 @@ kbCmd
                 }
             }
         }
+        else if (action === "add-key") {
+            if (!options.type) {
+                console.log(chalk_1.default.red("--type 옵션이 필요합니다. (예: --type service)"));
+                process.exit(1);
+            }
+            if (!options.key) {
+                console.log(chalk_1.default.red("--key 옵션이 필요합니다. (예: --key slack_channel)"));
+                process.exit(1);
+            }
+            const result = await (0, kb_1.ontoAddKey)(pool, {
+                type_key: options.type,
+                scheme_key: options.key,
+                description: options.description,
+                key_type: options.keyType,
+                required: options.required || false,
+                value_hint: options.hint,
+            });
+            if (result.success) {
+                console.log(chalk_1.default.green(`\n✅ 스키마 키 추가 완료: ${options.type}.${options.key} (${options.keyType})\n`));
+            }
+            else {
+                console.log(chalk_1.default.red(`\n❌ 스키마 키 추가 실패: ${result.error}\n`));
+                process.exit(1);
+            }
+        }
+        else if (action === "remove-key") {
+            if (!options.type) {
+                console.log(chalk_1.default.red("--type 옵션이 필요합니다."));
+                process.exit(1);
+            }
+            if (!options.key) {
+                console.log(chalk_1.default.red("--key 옵션이 필요합니다."));
+                process.exit(1);
+            }
+            const result = await (0, kb_1.ontoRemoveKey)(pool, options.type, options.key);
+            if (result.success) {
+                console.log(chalk_1.default.green(`\n✅ 스키마 키 삭제 완료: ${options.type}.${options.key}\n`));
+            }
+            else {
+                console.log(chalk_1.default.red(`\n❌ 스키마 키 삭제 실패: ${result.error}\n`));
+                process.exit(1);
+            }
+        }
         else {
-            console.log(chalk_1.default.red(`알 수 없는 action: '${action}'. 사용 가능: list, show, services, types, instances, schema, routing-table, register`));
+            console.log(chalk_1.default.red(`알 수 없는 action: '${action}'. 사용 가능: list, show, services, types, instances, schema, routing-table, register, add-key, remove-key`));
             process.exit(1);
         }
         await (0, database_1.closeConnection)();

package/dist/kb.d.ts

@@ -135,6 +135,15 @@ export declare function kbDigest(pool: Pool, since: string, domain?: string): Pr
  * Get a single KB entry by domain + key + sub_key
  */
 export declare function kbGet(pool: Pool, domain: string, rawKey: string, rawSubKey?: string): Promise<KBEntry | null>;
+/**
+ * Delete a single KB entry by domain/key/sub_key.
+ * Returns the deleted entry content for confirmation, or null if not found.
+ */
+export declare function kbDelete(pool: Pool, domain: string, rawKey: string, rawSubKey?: string): Promise<{
+    deleted: boolean;
+    entry?: KBEntry;
+    error?: string;
+}>;
 /**
  * Upsert a single KB entry with domain/key validation and embedding generation
  */
@@ -223,6 +232,27 @@ export interface OntoRegisterResult {
  * 4. If init_required (default true), create KB entries for required keys in kb_type_schema
  */
 export declare function ontoRegister(pool: Pool, opts: OntoRegisterOptions): Promise<OntoRegisterResult>;
+/**
+ * Add a key to a type schema
+ */
+export declare function ontoAddKey(pool: Pool, opts: {
+    type_key: string;
+    scheme_key: string;
+    description?: string;
+    key_type?: "singleton" | "collection";
+    required?: boolean;
+    value_hint?: string;
+}): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+/**
+ * Remove a key from a type schema
+ */
+export declare function ontoRemoveKey(pool: Pool, typeKey: string, schemeKey: string): Promise<{
+    success: boolean;
+    error?: string;
+}>;
 /**
  * Write ontology schemas to local cache
  */

package/dist/kb.js

@@ -55,12 +55,15 @@ exports.ontoListTypes = ontoListTypes;
 exports.ontoValidate = ontoValidate;
 exports.kbDigest = kbDigest;
 exports.kbGet = kbGet;
+exports.kbDelete = kbDelete;
 exports.kbUpsert = kbUpsert;
 exports.ontoListSchema = ontoListSchema;
 exports.ontoRoutingTable = ontoRoutingTable;
 exports.ontoListServices = ontoListServices;
 exports.ontoListInstances = ontoListInstances;
 exports.ontoRegister = ontoRegister;
+exports.ontoAddKey = ontoAddKey;
+exports.ontoRemoveKey = ontoRemoveKey;
 exports.ontoPullToLocal = ontoPullToLocal;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -683,6 +686,37 @@ async function kbGet(pool, domain, rawKey, rawSubKey) {
         client.release();
     }
 }
+/**
+ * Delete a single KB entry by domain/key/sub_key.
+ * Returns the deleted entry content for confirmation, or null if not found.
+ */
+async function kbDelete(pool, domain, rawKey, rawSubKey) {
+    let key;
+    let subKey;
+    if (rawSubKey !== undefined) {
+        key = rawKey;
+        subKey = rawSubKey;
+    }
+    else {
+        const split = splitKey(rawKey);
+        key = split.key;
+        subKey = split.subKey;
+    }
+    const client = await pool.connect();
+    try {
+        const result = await client.query(`DELETE FROM semo.knowledge_base
+       WHERE domain = $1 AND key = $2 AND sub_key = $3
+       RETURNING domain, key, sub_key, content, metadata, created_by, version,
+                 created_at::text, updated_at::text`, [domain, key, subKey]);
+        if (result.rows.length === 0) {
+            return { deleted: false, error: `항목 없음: ${domain}/${combineKey(key, subKey)}` };
+        }
+        return { deleted: true, entry: result.rows[0] };
+    }
+    finally {
+        client.release();
+    }
+}
 /**
  * Upsert a single KB entry with domain/key validation and embedding generation
  */
@@ -714,6 +748,22 @@ async function kbUpsert(pool, entry) {
     finally {
         client.release();
     }
+    // Naming convention check: kebab-case only
+    const warnings = [];
+    if (/_/.test(key)) {
+        const suggested = key.replace(/_/g, "-");
+        return {
+            success: false,
+            error: `키 '${key}'에 snake_case가 포함되어 있습니다. kebab-case를 사용하세요: '${suggested}'`,
+        };
+    }
+    if (/_/.test(subKey)) {
+        const suggested = subKey.replace(/_/g, "-");
+        return {
+            success: false,
+            error: `sub_key '${subKey}'에 snake_case가 포함되어 있습니다. kebab-case를 사용하세요: '${suggested}'`,
+        };
+    }
     // Key validation against type schema
     {
         const schemaClient = await pool.connect();
@@ -960,6 +1010,69 @@ async function ontoRegister(pool, opts) {
         client.release();
     }
 }
+/**
+ * Add a key to a type schema
+ */
+async function ontoAddKey(pool, opts) {
+    const client = await pool.connect();
+    try {
+        // Naming convention: kebab-case only
+        if (/_/.test(opts.scheme_key)) {
+            const suggested = opts.scheme_key.replace(/_/g, "-");
+            return { success: false, error: `키 '${opts.scheme_key}'에 snake_case가 포함되어 있습니다. kebab-case를 사용하세요: '${suggested}'` };
+        }
+        // Check type exists
+        const typeCheck = await client.query("SELECT DISTINCT type_key FROM semo.kb_type_schema WHERE type_key = $1", [opts.type_key]);
+        if (typeCheck.rows.length === 0) {
+            // Check if this type exists in ontology at all
+            const ontoCheck = await client.query("SELECT DISTINCT entity_type FROM semo.ontology WHERE entity_type = $1", [opts.type_key]);
+            if (ontoCheck.rows.length === 0) {
+                return { success: false, error: `타입 '${opts.type_key}'이(가) 존재하지 않습니다.` };
+            }
+        }
+        // Check duplicate
+        const dupCheck = await client.query("SELECT id FROM semo.kb_type_schema WHERE type_key = $1 AND scheme_key = $2", [opts.type_key, opts.scheme_key]);
+        if (dupCheck.rows.length > 0) {
+            return { success: false, error: `키 '${opts.scheme_key}'은(는) '${opts.type_key}' 타입에 이미 존재합니다.` };
+        }
+        // Get max sort_order
+        const maxOrder = await client.query("SELECT COALESCE(MAX(sort_order), 0) + 10 as next_order FROM semo.kb_type_schema WHERE type_key = $1", [opts.type_key]);
+        const sortOrder = maxOrder.rows[0].next_order;
+        await client.query(`INSERT INTO semo.kb_type_schema (type_key, scheme_key, scheme_description, key_type, required, value_hint, sort_order)
+       VALUES ($1, $2, $3, $4, $5, $6, $7)`, [
+            opts.type_key,
+            opts.scheme_key,
+            opts.description || opts.scheme_key,
+            opts.key_type || "singleton",
+            opts.required || false,
+            opts.value_hint || null,
+            sortOrder,
+        ]);
+        return { success: true };
+    }
+    catch (err) {
+        return { success: false, error: String(err) };
+    }
+    finally {
+        client.release();
+    }
+}
+/**
+ * Remove a key from a type schema
+ */
+async function ontoRemoveKey(pool, typeKey, schemeKey) {
+    const client = await pool.connect();
+    try {
+        const result = await client.query("DELETE FROM semo.kb_type_schema WHERE type_key = $1 AND scheme_key = $2 RETURNING id", [typeKey, schemeKey]);
+        if (result.rows.length === 0) {
+            return { success: false, error: `키 '${schemeKey}'은(는) '${typeKey}' 타입에 존재하지 않습니다.` };
+        }
+        return { success: true };
+    }
+    finally {
+        client.release();
+    }
+}
 /**
  * Write ontology schemas to local cache
  */

package/package.json

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