@team-semicolon/semo-cli 4.13.0 → 4.15.1

package/dist/commands/sessions.js

@@ -492,4 +492,160 @@ function registerSessionsCommands(program) {
             await (0, database_1.closeConnection)();
         }
     });
+    // ── semo sessions digest ──────────────────────────────────────────────────
+    sessionsCmd
+        .command("digest")
+        .description("세션 transcript에서 미기록 의사결정 추출")
+        .option("--transcript <path>", "transcript JSONL 파일 경로")
+        .option("--session-dir <dir>", "세션 디렉토리 (최신 transcript 자동 선택)")
+        .option("--hours <n>", "최근 N시간 내 transcript만 (session-dir 사용 시)", "24")
+        .option("--format <type>", "출력 형식 (table|json)", "table")
+        .option("--output <path>", "결과를 파일로 출력")
+        .action(async (options) => {
+        // transcript 파일 찾기
+        let transcripts = [];
+        if (options.transcript) {
+            if (!fs.existsSync(options.transcript)) {
+                console.error(chalk_1.default.red(`❌ 파일 없음: ${options.transcript}`));
+                process.exit(1);
+            }
+            transcripts = [options.transcript];
+        }
+        else if (options.sessionDir) {
+            const dir = options.sessionDir;
+            if (!fs.existsSync(dir)) {
+                console.error(chalk_1.default.red(`❌ 디렉토리 없음: ${dir}`));
+                process.exit(1);
+            }
+            const hours = parseInt(options.hours) || 24;
+            const cutoff = Date.now() - hours * 60 * 60 * 1000;
+            const files = fs.readdirSync(dir)
+                .filter(f => f.endsWith(".jsonl"))
+                .map(f => ({ name: f, path: path.join(dir, f), mtime: fs.statSync(path.join(dir, f)).mtimeMs }))
+                .filter(f => f.mtime > cutoff)
+                .sort((a, b) => b.mtime - a.mtime);
+            transcripts = files.map(f => f.path);
+        }
+        else {
+            // 기본: 현재 semo 프로젝트의 세션 디렉토리
+            const semoSessionDir = path.join(os.homedir(), ".claude", "projects", "-Users-reus-Desktop-Sources-semicolon-projects-semo");
+            if (fs.existsSync(semoSessionDir)) {
+                const hours = parseInt(options.hours) || 24;
+                const cutoff = Date.now() - hours * 60 * 60 * 1000;
+                const files = fs.readdirSync(semoSessionDir)
+                    .filter(f => f.endsWith(".jsonl"))
+                    .map(f => ({ name: f, path: path.join(semoSessionDir, f), mtime: fs.statSync(path.join(semoSessionDir, f)).mtimeMs }))
+                    .filter(f => f.mtime > cutoff)
+                    .sort((a, b) => b.mtime - a.mtime);
+                transcripts = files.map(f => f.path);
+            }
+        }
+        if (transcripts.length === 0) {
+            console.log(chalk_1.default.yellow("⚠ 분석할 transcript가 없습니다."));
+            process.exit(0);
+        }
+        // 의사결정 키워드 패턴
+        const decisionRe = /(?:도입했|폐기했|전환했|적용했|배포했|마이그레이션|변경했|합의했|결정했|도입합니다|폐기합니다|전환합니다|적용합니다|배포합니다|도입 완료|폐기 완료|전환 완료|적용 완료|배포 완료|표준화했|통합했|분리했|추가했|제거했|Phase \d+ 완료|설정을? 변경|규칙을? 변경|프로세스를? 변경|NON-NEGOTIABLE|신규 생성|전체 배포)/g;
+        const kbRecordRe = /KB 기록:|semo kb upsert|KB upsert 완료|답변근거: KB/;
+        const candidates = [];
+        for (const tPath of transcripts) {
+            const lines = fs.readFileSync(tPath, "utf-8").split("\n").filter(l => l.trim());
+            let lastKbUpsertLine = -1;
+            for (let i = 0; i < lines.length; i++) {
+                try {
+                    const entry = JSON.parse(lines[i]);
+                    const msg = entry.message ?? entry;
+                    // KB upsert tool call 추적
+                    if (msg.role === "assistant") {
+                        const content = msg.content ?? [];
+                        for (const block of content) {
+                            if (block?.type === "tool_use") {
+                                const inp = JSON.stringify(block.input ?? {});
+                                if (inp.includes("kb upsert") || inp.includes("kb_upsert")) {
+                                    lastKbUpsertLine = i;
+                                }
+                            }
+                        }
+                    }
+                    // tool result에서 upsert 완료 추적
+                    if (msg.role === "tool") {
+                        const content = Array.isArray(msg.content)
+                            ? msg.content.map((c) => typeof c === "string" ? c : c?.text ?? "").join(" ")
+                            : String(msg.content ?? "");
+                        if (content.includes("upsert 완료")) {
+                            lastKbUpsertLine = i;
+                        }
+                    }
+                    // assistant 텍스트에서 의사결정 키워드 탐지
+                    if (msg.role === "assistant") {
+                        const content = msg.content ?? [];
+                        for (const block of content) {
+                            if (block?.type !== "text")
+                                continue;
+                            let text = block.text ?? "";
+                            // 코드 블록 제거
+                            text = text.replace(/```[\s\S]*?```/g, "").replace(/`[^`\n]+`/g, "");
+                            const matches = text.match(decisionRe);
+                            if (matches && matches.length > 0) {
+                                const hasKbInText = kbRecordRe.test(text);
+                                // 같은 턴(±5줄 이내)에 KB upsert가 있었는지
+                                const hasKbNearby = Math.abs(i - lastKbUpsertLine) <= 10;
+                                candidates.push({
+                                    file: path.basename(tPath),
+                                    lineNum: i,
+                                    text: text.slice(0, 200).replace(/\n/g, " "),
+                                    keywords: [...new Set(matches)].slice(0, 3),
+                                    hasKbRecord: hasKbInText || hasKbNearby,
+                                    timestamp: entry.timestamp ? new Date(entry.timestamp).toLocaleString("ko-KR") : undefined,
+                                });
+                            }
+                        }
+                    }
+                }
+                catch { /* skip */ }
+            }
+        }
+        // 미기록 건만 필터
+        const unrecorded = candidates.filter(c => !c.hasKbRecord);
+        const recorded = candidates.filter(c => c.hasKbRecord);
+        if (options.format === "json") {
+            const result = { total: candidates.length, recorded: recorded.length, unrecorded: unrecorded.length, items: unrecorded };
+            const out = JSON.stringify(result, null, 2);
+            if (options.output) {
+                fs.writeFileSync(options.output, out);
+                console.log(chalk_1.default.green(`✔ 결과 저장: ${options.output}`));
+            }
+            else {
+                console.log(out);
+            }
+        }
+        else {
+            console.log(chalk_1.default.cyan.bold(`\n📋 세션 의사결정 다이제스트\n`));
+            console.log(chalk_1.default.gray(`  transcript: ${transcripts.length}개 | 총 감지: ${candidates.length}건 | 기록됨: ${recorded.length}건 | 미기록: ${unrecorded.length}건\n`));
+            if (unrecorded.length === 0) {
+                console.log(chalk_1.default.green("  ✅ 미기록 의사결정 없음\n"));
+            }
+            else {
+                console.log(chalk_1.default.yellow.bold("  ⚠ 미기록 의사결정:\n"));
+                for (const c of unrecorded) {
+                    console.log(chalk_1.default.yellow(`  [${c.file}:${c.lineNum}]`) + chalk_1.default.gray(c.timestamp ? ` ${c.timestamp}` : ""));
+                    console.log(chalk_1.default.white(`    키워드: ${c.keywords.join(", ")}`));
+                    console.log(chalk_1.default.gray(`    "${c.text.slice(0, 120)}..."\n`));
+                }
+            }
+            if (options.output) {
+                const lines = [`# 세션 의사결정 다이제스트`, ``, `총 감지: ${candidates.length}건 | 기록됨: ${recorded.length}건 | 미기록: ${unrecorded.length}건`, ``];
+                if (unrecorded.length > 0) {
+                    lines.push(`## 미기록 의사결정`, ``);
+                    for (const c of unrecorded) {
+                        lines.push(`- **[${c.file}:${c.lineNum}]** ${c.keywords.join(", ")}`);
+                        lines.push(`  > ${c.text.slice(0, 150)}...`);
+                        lines.push(``);
+                    }
+                }
+                fs.writeFileSync(options.output, lines.join("\n"));
+                console.log(chalk_1.default.green(`✔ 결과 저장: ${options.output}`));
+            }
+        }
+    });
 }

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

@@ -8,12 +8,13 @@
  * 스킬 이름은 flat (예: 'kb-manager'), metadata.bot_ids 배열로 봇 매핑.
  * 동일 스킬명이 여러 봇에 존재하면 bot_ids를 머지.
  */
-import { Pool, PoolClient } from "pg";
+import { Pool, PoolClient } from 'pg';
 export interface ScannedSkill {
     name: string;
     prompt: string;
     package: string;
     botId: string;
+    referenceFiles?: Record<string, string>;
 }
 export interface SkillSyncResult {
     botSpecific: number;

package/dist/commands/skill-sync.js

@@ -49,16 +49,16 @@ exports.syncSkillsToDB = syncSkillsToDB;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 function scanSkills(arg) {
-    if (typeof arg === "string") {
+    if (typeof arg === 'string') {
         return scanSkillsLegacy(arg);
     }
     return scanSkillsV2(arg);
 }
 function scanSkillsV2(botIds) {
     const skills = [];
-    const home = process.env.HOME || "/Users/reus";
+    const home = process.env.HOME || '/Users/reus';
     for (const botId of botIds) {
-        const skillsDir = path.join(home, `.openclaw-${botId}`, "workspace", "skills");
+        const skillsDir = path.join(home, `.openclaw-${botId}`, 'workspace', 'skills');
         if (!fs.existsSync(skillsDir))
             continue;
         let skillEntries;
@@ -71,22 +71,49 @@ function scanSkillsV2(botIds) {
         for (const skillEntry of skillEntries) {
             if (!skillEntry.isDirectory())
                 continue;
-            if (skillEntry.name.endsWith(".skill"))
+            if (skillEntry.name.endsWith('.skill'))
                 continue;
-            if (skillEntry.name.startsWith("_") || skillEntry.name.startsWith("."))
+            if (skillEntry.name.startsWith('_') || skillEntry.name.startsWith('.'))
                 continue;
-            const skillMdPath = path.join(skillsDir, skillEntry.name, "SKILL.md");
+            const skillMdPath = path.join(skillsDir, skillEntry.name, 'SKILL.md');
             if (!fs.existsSync(skillMdPath))
                 continue;
             try {
+                // Scan references/ subdirectory
+                let referenceFiles;
+                const refsDir = path.join(skillsDir, skillEntry.name, 'references');
+                if (fs.existsSync(refsDir)) {
+                    try {
+                        const refs = {};
+                        for (const refFile of fs.readdirSync(refsDir)) {
+                            const refPath = path.join(refsDir, refFile);
+                            try {
+                                if (!fs.statSync(refPath).isFile())
+                                    continue;
+                                refs[refFile] = fs.readFileSync(refPath, 'utf-8');
+                            }
+                            catch {
+                                /* skip unreadable */
+                            }
+                        }
+                        if (Object.keys(refs).length > 0)
+                            referenceFiles = refs;
+                    }
+                    catch {
+                        /* skip unreadable refs dir */
+                    }
+                }
                 skills.push({
                     name: skillEntry.name,
-                    prompt: fs.readFileSync(skillMdPath, "utf-8"),
-                    package: "openclaw",
+                    prompt: fs.readFileSync(skillMdPath, 'utf-8'),
+                    package: 'openclaw',
                     botId,
+                    referenceFiles,
                 });
             }
-            catch { /* skip unreadable */ }
+            catch {
+                /* skip unreadable */
+            }
         }
     }
     return skills;
@@ -94,34 +121,61 @@ function scanSkillsV2(botIds) {
 /** Legacy: semo-system/bot-workspaces 에서 스캔 (하위호환) */
 function scanSkillsLegacy(semoSystemDir) {
     const skills = [];
-    const workspacesDir = path.join(semoSystemDir, "bot-workspaces");
+    const workspacesDir = path.join(semoSystemDir, 'bot-workspaces');
     if (!fs.existsSync(workspacesDir))
         return skills;
     const botEntries = fs.readdirSync(workspacesDir, { withFileTypes: true });
     for (const botEntry of botEntries) {
         if (!botEntry.isDirectory())
             continue;
-        const skillsDir = path.join(workspacesDir, botEntry.name, "skills");
+        const skillsDir = path.join(workspacesDir, botEntry.name, 'skills');
         if (!fs.existsSync(skillsDir))
             continue;
         const skillEntries = fs.readdirSync(skillsDir, { withFileTypes: true });
         for (const skillEntry of skillEntries) {
             if (!skillEntry.isDirectory())
                 continue;
-            if (skillEntry.name.endsWith(".skill"))
+            if (skillEntry.name.endsWith('.skill'))
                 continue;
-            const skillMdPath = path.join(skillsDir, skillEntry.name, "SKILL.md");
+            const skillMdPath = path.join(skillsDir, skillEntry.name, 'SKILL.md');
             if (!fs.existsSync(skillMdPath))
                 continue;
             try {
+                // Scan references/ subdirectory
+                let referenceFiles;
+                const refsDir = path.join(skillsDir, skillEntry.name, 'references');
+                if (fs.existsSync(refsDir)) {
+                    try {
+                        const refs = {};
+                        for (const refFile of fs.readdirSync(refsDir)) {
+                            const refPath = path.join(refsDir, refFile);
+                            try {
+                                if (!fs.statSync(refPath).isFile())
+                                    continue;
+                                refs[refFile] = fs.readFileSync(refPath, 'utf-8');
+                            }
+                            catch {
+                                /* skip unreadable */
+                            }
+                        }
+                        if (Object.keys(refs).length > 0)
+                            referenceFiles = refs;
+                    }
+                    catch {
+                        /* skip unreadable refs dir */
+                    }
+                }
                 skills.push({
                     name: skillEntry.name,
-                    prompt: fs.readFileSync(skillMdPath, "utf-8"),
-                    package: "openclaw",
+                    prompt: fs.readFileSync(skillMdPath, 'utf-8'),
+                    package: 'openclaw',
                     botId: botEntry.name,
+                    referenceFiles,
                 });
             }
-            catch { /* skip unreadable */ }
+            catch {
+                /* skip unreadable */
+            }
         }
     }
     return skills;
@@ -131,28 +185,32 @@ function scanSkillsLegacy(semoSystemDir) {
  */
 async function getBotIds(pool) {
     try {
-        const result = await pool.query("SELECT bot_id FROM semo.bot_status ORDER BY bot_id");
+        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 */ }
+    catch {
+        /* fallback to local scan */
+    }
     // Fallback: scan ~/.openclaw-*/workspace/ directories
-    const home = process.env.HOME || "/Users/reus";
+    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");
+                const wsDir = path.join(home, entry, 'workspace');
                 if (fs.existsSync(wsDir)) {
                     botIds.push(match[1]);
                 }
             }
         }
     }
-    catch { /* skip */ }
+    catch {
+        /* skip */
+    }
     return botIds.sort();
 }
 /**
@@ -163,13 +221,20 @@ async function syncSkillsToDB(client, pool) {
     const botIds = await getBotIds(pool);
     const skills = scanSkills(botIds);
     for (const skill of skills) {
+        const metadata = { bot_ids: [skill.botId] };
+        if (skill.referenceFiles)
+            metadata.reference_files = skill.referenceFiles;
         await client.query(`INSERT INTO semo.skill_definitions (name, prompt, package, metadata, is_active, office_id)
        VALUES ($1, $2, $3, $4, true, NULL)
        ON CONFLICT (name, office_id) DO UPDATE SET
          prompt = EXCLUDED.prompt,
          package = EXCLUDED.package,
          metadata = jsonb_set(
-           skill_definitions.metadata,
+           CASE
+             WHEN EXCLUDED.metadata ? 'reference_files'
+             THEN jsonb_set(skill_definitions.metadata, '{reference_files}', EXCLUDED.metadata->'reference_files')
+             ELSE skill_definitions.metadata
+           END,
            '{bot_ids}',
            (SELECT jsonb_agg(DISTINCT v)
             FROM jsonb_array_elements(
@@ -177,7 +242,7 @@ async function syncSkillsToDB(client, pool) {
               COALESCE(EXCLUDED.metadata->'bot_ids', '[]'::jsonb)
             ) AS v)
          ),
-         updated_at = NOW()`, [skill.name, skill.prompt, skill.package, JSON.stringify({ bot_ids: [skill.botId] })]);
+         updated_at = NOW()`, [skill.name, skill.prompt, skill.package, JSON.stringify(metadata)]);
     }
     return {
         botSpecific: skills.length,

package/dist/commands/skill-sync.test.js

@@ -56,8 +56,8 @@ let tmpDir;
 let passed = 0;
 let failed = 0;
 function setup() {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "skill-sync-test-"));
-    fs.mkdirSync(path.join(dir, "bot-workspaces"), { recursive: true });
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'skill-sync-test-'));
+    fs.mkdirSync(path.join(dir, 'bot-workspaces'), { recursive: true });
     return dir;
 }
 function cleanup(dir) {
@@ -73,114 +73,147 @@ function assert(condition, message) {
         console.log(`  ❌ ${message}`);
     }
 }
-function makeBotSkill(dir, botId, skillName, content) {
-    const skillDir = path.join(dir, "bot-workspaces", botId, "skills", skillName);
+function makeBotSkill(dir, botId, skillName, content, refs) {
+    const skillDir = path.join(dir, 'bot-workspaces', botId, 'skills', skillName);
     fs.mkdirSync(skillDir, { recursive: true });
-    fs.writeFileSync(path.join(skillDir, "SKILL.md"), content);
+    fs.writeFileSync(path.join(skillDir, 'SKILL.md'), content);
+    if (refs) {
+        const refsDir = path.join(skillDir, 'references');
+        fs.mkdirSync(refsDir, { recursive: true });
+        for (const [name, refContent] of Object.entries(refs)) {
+            fs.writeFileSync(path.join(refsDir, name), refContent);
+        }
+    }
 }
 // ─── 테스트 ───────────────────────────────────────────────
-console.log("\n🧪 skill-sync.test.ts\n");
+console.log('\n🧪 skill-sync.test.ts\n');
 // 1. 빈 디렉토리
-console.log("Case 1: 빈 디렉토리");
+console.log('Case 1: 빈 디렉토리');
 tmpDir = setup();
 {
     const skills = (0, skill_sync_1.scanSkills)(tmpDir);
-    assert(skills.length === 0, "skills = 0");
+    assert(skills.length === 0, 'skills = 0');
 }
 cleanup(tmpDir);
 // 2. 봇 전용 스킬 — flat name
-console.log("Case 2: 봇 전용 스킬 flat name");
+console.log('Case 2: 봇 전용 스킬 flat name');
 tmpDir = setup();
 {
-    makeBotSkill(tmpDir, "semiclaw", "github-issue-pipeline", "# GH Pipeline");
+    makeBotSkill(tmpDir, 'semiclaw', 'github-issue-pipeline', '# GH Pipeline');
     const skills = (0, skill_sync_1.scanSkills)(tmpDir);
     assert(skills.length === 1, `skills = 1 (got ${skills.length})`);
-    assert(skills[0].name === "github-issue-pipeline", `name = github-issue-pipeline (got ${skills[0].name})`);
-    assert(skills[0].botId === "semiclaw", "botId = semiclaw");
-    assert(skills[0].package === "openclaw", "package = openclaw");
+    assert(skills[0].name === 'github-issue-pipeline', `name = github-issue-pipeline (got ${skills[0].name})`);
+    assert(skills[0].botId === 'semiclaw', 'botId = semiclaw');
+    assert(skills[0].package === 'openclaw', 'package = openclaw');
 }
 cleanup(tmpDir);
 // 3. 복수 봇의 전용 스킬 — botId 정확성
-console.log("Case 3: 복수 봇 botId 정확성");
+console.log('Case 3: 복수 봇 botId 정확성');
 tmpDir = setup();
 {
-    makeBotSkill(tmpDir, "semiclaw", "skill-a", "# A");
-    makeBotSkill(tmpDir, "semiclaw", "skill-b", "# B");
-    makeBotSkill(tmpDir, "workclaw", "skill-c", "# C");
-    makeBotSkill(tmpDir, "infraclaw", "skill-d", "# D");
+    makeBotSkill(tmpDir, 'semiclaw', 'skill-a', '# A');
+    makeBotSkill(tmpDir, 'semiclaw', 'skill-b', '# B');
+    makeBotSkill(tmpDir, 'workclaw', 'skill-c', '# C');
+    makeBotSkill(tmpDir, 'infraclaw', 'skill-d', '# D');
     const skills = (0, skill_sync_1.scanSkills)(tmpDir);
     assert(skills.length === 4, `총 4개 (got ${skills.length})`);
-    const semiclawSkills = skills.filter((s) => s.botId === "semiclaw");
-    const workclawSkills = skills.filter((s) => s.botId === "workclaw");
-    const infraclawSkills = skills.filter((s) => s.botId === "infraclaw");
+    const semiclawSkills = skills.filter((s) => s.botId === 'semiclaw');
+    const workclawSkills = skills.filter((s) => s.botId === 'workclaw');
+    const infraclawSkills = skills.filter((s) => s.botId === 'infraclaw');
     assert(semiclawSkills.length === 2, `semiclaw: 2개 (got ${semiclawSkills.length})`);
     assert(workclawSkills.length === 1, `workclaw: 1개 (got ${workclawSkills.length})`);
     assert(infraclawSkills.length === 1, `infraclaw: 1개 (got ${infraclawSkills.length})`);
 }
 cleanup(tmpDir);
 // 4. .skill 확장자 디렉토리 → 스킵
-console.log("Case 4: .skill 확장자 디렉토리");
+console.log('Case 4: .skill 확장자 디렉토리');
 tmpDir = setup();
 {
-    const dotSkillDir = path.join(tmpDir, "bot-workspaces", "semiclaw", "skills", "old-format.skill");
+    const dotSkillDir = path.join(tmpDir, 'bot-workspaces', 'semiclaw', 'skills', 'old-format.skill');
     fs.mkdirSync(dotSkillDir, { recursive: true });
-    fs.writeFileSync(path.join(dotSkillDir, "SKILL.md"), "should be skipped");
-    makeBotSkill(tmpDir, "semiclaw", "valid-skill", "# Valid");
+    fs.writeFileSync(path.join(dotSkillDir, 'SKILL.md'), 'should be skipped');
+    makeBotSkill(tmpDir, 'semiclaw', 'valid-skill', '# Valid');
     const skills = (0, skill_sync_1.scanSkills)(tmpDir);
     assert(skills.length === 1, `.skill 디렉토리 스킵, skills = 1 (got ${skills.length})`);
-    assert(skills[0].name === "valid-skill", "올바른 스킬만 반환");
+    assert(skills[0].name === 'valid-skill', '올바른 스킬만 반환');
 }
 cleanup(tmpDir);
 // 5. SKILL.md 없는 디렉토리 → 스킵
-console.log("Case 5: SKILL.md 없는 디렉토리");
+console.log('Case 5: SKILL.md 없는 디렉토리');
 tmpDir = setup();
 {
-    const emptyDir = path.join(tmpDir, "bot-workspaces", "semiclaw", "skills", "no-skill-md");
+    const emptyDir = path.join(tmpDir, 'bot-workspaces', 'semiclaw', 'skills', 'no-skill-md');
     fs.mkdirSync(emptyDir, { recursive: true });
-    makeBotSkill(tmpDir, "semiclaw", "valid-skill", "content");
+    makeBotSkill(tmpDir, 'semiclaw', 'valid-skill', 'content');
     const skills = (0, skill_sync_1.scanSkills)(tmpDir);
     assert(skills.length === 1, `SKILL.md 없는 디렉토리 스킵, skills = 1 (got ${skills.length})`);
 }
 cleanup(tmpDir);
 // 6. 스킬 변경 감지 — 파일 수정 후 재스캔
-console.log("Case 6: 스킬 변경 감지");
+console.log('Case 6: 스킬 변경 감지');
 tmpDir = setup();
 {
-    makeBotSkill(tmpDir, "semiclaw", "review", "# v1 content");
+    makeBotSkill(tmpDir, 'semiclaw', 'review', '# v1 content');
     const scan1 = (0, skill_sync_1.scanSkills)(tmpDir);
-    assert(scan1[0].prompt === "# v1 content", "초기 스캔: v1");
-    fs.writeFileSync(path.join(tmpDir, "bot-workspaces", "semiclaw", "skills", "review", "SKILL.md"), "# v2 updated content");
+    assert(scan1[0].prompt === '# v1 content', '초기 스캔: v1');
+    fs.writeFileSync(path.join(tmpDir, 'bot-workspaces', 'semiclaw', 'skills', 'review', 'SKILL.md'), '# v2 updated content');
     const scan2 = (0, skill_sync_1.scanSkills)(tmpDir);
-    assert(scan2[0].prompt === "# v2 updated content", "재스캔: v2 반영됨");
+    assert(scan2[0].prompt === '# v2 updated content', '재스캔: v2 반영됨');
 }
 cleanup(tmpDir);
 // 7. 스킬 추가 감지 — 새 디렉토리 추가 후 재스캔
-console.log("Case 7: 스킬 추가 감지");
+console.log('Case 7: 스킬 추가 감지');
 tmpDir = setup();
 {
-    makeBotSkill(tmpDir, "semiclaw", "existing", "# Existing");
+    makeBotSkill(tmpDir, 'semiclaw', 'existing', '# Existing');
     const scan1 = (0, skill_sync_1.scanSkills)(tmpDir);
-    assert(scan1.length === 1, "초기: 1개");
-    makeBotSkill(tmpDir, "semiclaw", "new-skill", "# New Skill");
+    assert(scan1.length === 1, '초기: 1개');
+    makeBotSkill(tmpDir, 'semiclaw', 'new-skill', '# New Skill');
     const scan2 = (0, skill_sync_1.scanSkills)(tmpDir);
     assert(scan2.length === 2, `추가 후: 2개 (got ${scan2.length})`);
 }
 cleanup(tmpDir);
 // 8. 스킬 삭제 감지 — SKILL.md 삭제 후 재스캔
-console.log("Case 8: 스킬 삭제 감지");
+console.log('Case 8: 스킬 삭제 감지');
 tmpDir = setup();
 {
-    makeBotSkill(tmpDir, "semiclaw", "to-delete", "# Will be deleted");
-    makeBotSkill(tmpDir, "semiclaw", "keep", "# Keep");
+    makeBotSkill(tmpDir, 'semiclaw', 'to-delete', '# Will be deleted');
+    makeBotSkill(tmpDir, 'semiclaw', 'keep', '# Keep');
     const scan1 = (0, skill_sync_1.scanSkills)(tmpDir);
-    assert(scan1.length === 2, "초기: 2개");
-    fs.unlinkSync(path.join(tmpDir, "bot-workspaces", "semiclaw", "skills", "to-delete", "SKILL.md"));
+    assert(scan1.length === 2, '초기: 2개');
+    fs.unlinkSync(path.join(tmpDir, 'bot-workspaces', 'semiclaw', 'skills', 'to-delete', 'SKILL.md'));
     const scan2 = (0, skill_sync_1.scanSkills)(tmpDir);
     assert(scan2.length === 1, `삭제 후: 1개 (got ${scan2.length})`);
-    assert(scan2[0].name === "keep", "남은 스킬: keep");
+    assert(scan2[0].name === 'keep', '남은 스킬: keep');
+}
+cleanup(tmpDir);
+// 9. references/ 있는 스킬 → referenceFiles 맵 반환
+console.log('Case 9: references/ 있는 스킬');
+tmpDir = setup();
+{
+    makeBotSkill(tmpDir, 'semiclaw', 'adhoc-meeting', '# Adhoc Meeting', {
+        'meeting-template.md': '# Template',
+        'decision-template.md': '# Decision',
+    });
+    const skills = (0, skill_sync_1.scanSkills)(tmpDir);
+    assert(skills.length === 1, 'skills = 1');
+    assert(skills[0].referenceFiles !== undefined, 'referenceFiles 존재');
+    assert(Object.keys(skills[0].referenceFiles).length === 2, 'referenceFiles 2개');
+    assert(skills[0].referenceFiles['meeting-template.md'] === '# Template', 'meeting-template 내용 일치');
+    assert(skills[0].referenceFiles['decision-template.md'] === '# Decision', 'decision-template 내용 일치');
+}
+cleanup(tmpDir);
+// 10. references/ 없는 스킬 → referenceFiles undefined
+console.log('Case 10: references/ 없는 스킬');
+tmpDir = setup();
+{
+    makeBotSkill(tmpDir, 'semiclaw', 'simple-skill', '# Simple');
+    const skills = (0, skill_sync_1.scanSkills)(tmpDir);
+    assert(skills.length === 1, 'skills = 1');
+    assert(skills[0].referenceFiles === undefined, 'referenceFiles undefined');
 }
 cleanup(tmpDir);
 // ─── 결과 ──────────────────────────────────────────────────
-console.log(`\n${"─".repeat(40)}`);
+console.log(`\n${'─'.repeat(40)}`);
 console.log(`총 ${passed + failed}개 테스트: ✅ ${passed} passed, ❌ ${failed} failed\n`);
 process.exit(failed > 0 ? 1 : 0);

package/dist/database.d.ts

@@ -11,7 +11,7 @@
  *   - command_definitions (prompt as content)
  *   - semo.skills / semo.agents / semo.commands 는 하위 호환 뷰
  */
-import { Pool } from "pg";
+import { Pool } from 'pg';
 export declare function getPool(): Pool;
 export interface Skill {
     id: string;
@@ -20,6 +20,7 @@ export interface Skill {
     description: string | null;
     content: string;
     bot_ids: string[];
+    reference_files?: Record<string, string>;
     category: string;
     package: string;
     is_active: boolean;