@team-semicolon/semo-cli 4.12.0 → 4.13.0

package/dist/commands/commitments.js

@@ -86,6 +86,9 @@ function registerCommitmentsCommands(program) {
                 JSON.stringify(steps),
             ]);
             console.log(chalk_1.default.green(`✔ commitment created: ${id}`));
+            if (!options.sourceType) {
+                console.log(chalk_1.default.yellow(`⚠ source-type 미지정: 자동 검증 불가. --source-type 권장.`));
+            }
             console.log(JSON.stringify({ id, bot_id: options.botId, title: options.title, deadline_at: deadlineAt }));
         }
         catch (err) {
@@ -239,7 +242,8 @@ function registerCommitmentsCommands(program) {
             }
             const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
             params.push(parseInt(options.limit));
-            const result = await pool.query(`SELECT id, bot_id, status, title, deadline_at::text, steps,
+            const result = await pool.query(`SELECT id, bot_id, status, title, description, source_type, source_ref,
+                  deadline_at::text, steps,
                   last_heartbeat_at::text, created_at::text, completed_at::text, metadata
            FROM semo.bot_commitments
            ${where}
@@ -290,6 +294,8 @@ function registerCommitmentsCommands(program) {
         .command("watch")
         .description("워치독 — 활성 약속의 health 상태 조회")
         .option("--format <type>", "출력 형식 (table|json)", "table")
+        .option("--bot-id <id>", "특정 봇만 필터")
+        .option("--exclude-bot <id>", "특정 봇 제외")
         .action(async (options) => {
         const connected = await (0, database_1.isDbConnected)();
         if (!connected) {
@@ -299,17 +305,33 @@ function registerCommitmentsCommands(program) {
         }
         try {
             const pool = (0, database_1.getPool)();
-            const result = await pool.query(`SELECT id, bot_id, status, title, deadline_at::text,
+            const conditions = [];
+            const params = [];
+            let paramIdx = 1;
+            if (options.botId) {
+                conditions.push(`bot_id = $${paramIdx++}`);
+                params.push(options.botId);
+            }
+            if (options.excludeBot) {
+                conditions.push(`bot_id != $${paramIdx++}`);
+                params.push(options.excludeBot);
+            }
+            const whereClause = conditions.length > 0
+                ? `WHERE ${conditions.join(" AND ")}`
+                : "";
+            const result = await pool.query(`SELECT id, bot_id, status, title, description, source_type, source_ref,
+                  deadline_at::text,
                   health, minutes_since_heartbeat, minutes_overdue,
                   steps, last_heartbeat_at::text, created_at::text, metadata
            FROM semo.v_active_commitments
+           ${whereClause}
            ORDER BY
              CASE health
                WHEN 'overdue' THEN 0
                WHEN 'stale' THEN 1
                ELSE 2
              END,
-             deadline_at ASC NULLS LAST`);
+             deadline_at ASC NULLS LAST`, params);
             if (options.format === "json") {
                 const summary = {
                     total: result.rows.length,

package/dist/commands/commitments.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * commitments 테스트 — bot_commitments CRUD + 워치독 뷰 검증
+ *
+ * 실행: npx ts-node packages/cli/src/commands/commitments.test.ts
+ *
+ * 실제 DB 연결 필요 (semo.bot_commitments 테이블).
+ * 테스트 데이터는 bot_id='__test__' 접두사로 생성하며 종료 시 정리.
+ */
+export {};

package/dist/commands/commitments.test.js

@@ -0,0 +1,223 @@
+"use strict";
+/**
+ * commitments 테스트 — bot_commitments CRUD + 워치독 뷰 검증
+ *
+ * 실행: npx ts-node packages/cli/src/commands/commitments.test.ts
+ *
+ * 실제 DB 연결 필요 (semo.bot_commitments 테이블).
+ * 테스트 데이터는 bot_id='__test__' 접두사로 생성하며 종료 시 정리.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const database_1 = require("../database");
+const TEST_BOT = "__test__";
+let passed = 0;
+let failed = 0;
+const createdIds = [];
+function assert(condition, message) {
+    if (condition) {
+        passed++;
+        console.log(`  ✅ ${message}`);
+    }
+    else {
+        failed++;
+        console.log(`  ❌ ${message}`);
+    }
+}
+function makeId() {
+    const rand = Math.random().toString(36).slice(2, 6);
+    return `cmt-${TEST_BOT}-${Date.now()}-${rand}`;
+}
+async function cleanup() {
+    try {
+        const pool = (0, database_1.getPool)();
+        await pool.query(`DELETE FROM semo.bot_commitments WHERE bot_id = $1`, [TEST_BOT]);
+    }
+    catch { /* ignore */ }
+}
+async function run() {
+    console.log("\n🧪 commitments.test.ts\n");
+    const connected = await (0, database_1.isDbConnected)();
+    if (!connected) {
+        console.log("❌ DB 연결 실패 — 테스트 스킵");
+        process.exit(1);
+    }
+    const pool = (0, database_1.getPool)();
+    // 사전 정리
+    await cleanup();
+    // ── Case 1: CREATE — 기본 생성 ─────────────────────────────────────────────
+    console.log("Case 1: 기본 생성");
+    const id1 = makeId();
+    createdIds.push(id1);
+    {
+        await pool.query(`INSERT INTO semo.bot_commitments (id, bot_id, status, title, deadline_at)
+       VALUES ($1, $2, 'pending', '테스트 약속 1', NOW() + INTERVAL '15 minutes')`, [id1, TEST_BOT]);
+        const r = await pool.query(`SELECT * FROM semo.bot_commitments WHERE id = $1`, [id1]);
+        assert(r.rows.length === 1, "INSERT 성공");
+        assert(r.rows[0].status === "pending", "초기 상태 = pending");
+        assert(r.rows[0].bot_id === TEST_BOT, `bot_id = ${TEST_BOT}`);
+        assert(r.rows[0].completed_at === null, "completed_at = null (아직 완료 전)");
+    }
+    // ── Case 2: CREATE — steps JSON ────────────────────────────────────────────
+    console.log("Case 2: steps JSON 저장");
+    const id2 = makeId();
+    createdIds.push(id2);
+    {
+        const steps = [
+            { label: "Typography", done: false },
+            { label: "Layout", done: false },
+            { label: "Motion", done: false },
+        ];
+        await pool.query(`INSERT INTO semo.bot_commitments (id, bot_id, status, title, steps)
+       VALUES ($1, $2, 'pending', 'Steps 테스트', $3)`, [id2, TEST_BOT, JSON.stringify(steps)]);
+        const r = await pool.query(`SELECT steps FROM semo.bot_commitments WHERE id = $1`, [id2]);
+        const savedSteps = r.rows[0].steps;
+        assert(Array.isArray(savedSteps), "steps는 배열");
+        assert(savedSteps.length === 3, `steps 3개 (got ${savedSteps.length})`);
+        assert(savedSteps[0].label === "Typography", "첫 step label 일치");
+        assert(savedSteps.every((s) => !s.done), "모든 step done=false");
+    }
+    // ── Case 3: UPDATE — heartbeat ─────────────────────────────────────────────
+    console.log("Case 3: heartbeat 갱신");
+    {
+        await pool.query(`UPDATE semo.bot_commitments
+       SET last_heartbeat_at = NOW(),
+           status = CASE WHEN status = 'pending' THEN 'active' ELSE status END
+       WHERE id = $1`, [id1]);
+        const r = await pool.query(`SELECT status, last_heartbeat_at FROM semo.bot_commitments WHERE id = $1`, [id1]);
+        assert(r.rows[0].status === "active", "heartbeat → status = active");
+        assert(r.rows[0].last_heartbeat_at !== null, "last_heartbeat_at 채워짐");
+    }
+    // ── Case 4: UPDATE — step-done ─────────────────────────────────────────────
+    console.log("Case 4: step 완료 처리");
+    {
+        await pool.query(`UPDATE semo.bot_commitments
+       SET steps = (
+         SELECT jsonb_agg(
+           CASE
+             WHEN elem->>'label' = $2 THEN jsonb_set(elem, '{done}', 'true')
+             ELSE elem
+           END
+         )
+         FROM jsonb_array_elements(steps) AS elem
+       )
+       WHERE id = $1`, [id2, "Typography"]);
+        const r = await pool.query(`SELECT steps FROM semo.bot_commitments WHERE id = $1`, [id2]);
+        const steps = r.rows[0].steps;
+        const typo = steps.find((s) => s.label === "Typography");
+        const layout = steps.find((s) => s.label === "Layout");
+        assert(typo.done === true, "Typography done=true");
+        assert(layout.done === false, "Layout 여전히 done=false");
+    }
+    // ── Case 5: DONE — completed_at 트리거 ────────────────────────────────────
+    console.log("Case 5: done → completed_at 자동 채움");
+    {
+        await pool.query(`UPDATE semo.bot_commitments SET status = 'done' WHERE id = $1`, [id1]);
+        const r = await pool.query(`SELECT status, completed_at FROM semo.bot_commitments WHERE id = $1`, [id1]);
+        assert(r.rows[0].status === "done", "status = done");
+        assert(r.rows[0].completed_at !== null, "completed_at 자동 채워짐 (트리거)");
+    }
+    // ── Case 6: FAIL — metadata.fail_reason ────────────────────────────────────
+    console.log("Case 6: fail + reason 저장");
+    const id3 = makeId();
+    createdIds.push(id3);
+    {
+        await pool.query(`INSERT INTO semo.bot_commitments (id, bot_id, status, title)
+       VALUES ($1, $2, 'active', '실패 테스트')`, [id3, TEST_BOT]);
+        await pool.query(`UPDATE semo.bot_commitments
+       SET status = 'failed', metadata = metadata || jsonb_build_object('fail_reason', $2::text)
+       WHERE id = $1`, [id3, "빌드 실패"]);
+        const r = await pool.query(`SELECT status, completed_at, metadata FROM semo.bot_commitments WHERE id = $1`, [id3]);
+        assert(r.rows[0].status === "failed", "status = failed");
+        assert(r.rows[0].completed_at !== null, "completed_at 자동 채워짐");
+        assert(r.rows[0].metadata.fail_reason === "빌드 실패", "metadata.fail_reason 저장됨");
+    }
+    // ── Case 7: updated_at 트리거 ──────────────────────────────────────────────
+    console.log("Case 7: updated_at 자동 갱신");
+    {
+        const before = await pool.query(`SELECT updated_at FROM semo.bot_commitments WHERE id = $1`, [id2]);
+        // 최소 1ms 대기
+        await new Promise((r) => setTimeout(r, 50));
+        await pool.query(`UPDATE semo.bot_commitments SET title = 'Updated title' WHERE id = $1`, [id2]);
+        const after = await pool.query(`SELECT updated_at FROM semo.bot_commitments WHERE id = $1`, [id2]);
+        const t1 = new Date(before.rows[0].updated_at).getTime();
+        const t2 = new Date(after.rows[0].updated_at).getTime();
+        assert(t2 > t1, `updated_at 갱신됨 (${t2 - t1}ms 차이)`);
+    }
+    // ── Case 8: v_active_commitments 뷰 ───────────────────────────────────────
+    console.log("Case 8: v_active_commitments 뷰");
+    const id4 = makeId();
+    createdIds.push(id4);
+    {
+        // overdue commitment 생성 (deadline 과거)
+        await pool.query(`INSERT INTO semo.bot_commitments (id, bot_id, status, title, deadline_at)
+       VALUES ($1, $2, 'active', 'Overdue 테스트', NOW() - INTERVAL '10 minutes')`, [id4, TEST_BOT]);
+        const r = await pool.query(`SELECT health, minutes_overdue FROM semo.v_active_commitments WHERE id = $1`, [id4]);
+        assert(r.rows.length === 1, "뷰에서 조회 가능");
+        assert(r.rows[0].health === "overdue", `health = overdue (got ${r.rows[0].health})`);
+        assert(r.rows[0].minutes_overdue > 0, `minutes_overdue > 0 (got ${r.rows[0].minutes_overdue})`);
+    }
+    // ── Case 9: stale 감지 ─────────────────────────────────────────────────────
+    console.log("Case 9: stale heartbeat 감지");
+    const id5 = makeId();
+    createdIds.push(id5);
+    {
+        await pool.query(`INSERT INTO semo.bot_commitments (id, bot_id, status, title, last_heartbeat_at)
+       VALUES ($1, $2, 'active', 'Stale 테스트', NOW() - INTERVAL '45 minutes')`, [id5, TEST_BOT]);
+        const r = await pool.query(`SELECT health, minutes_since_heartbeat FROM semo.v_active_commitments WHERE id = $1`, [id5]);
+        assert(r.rows[0].health === "stale", `health = stale (got ${r.rows[0].health})`);
+        assert(r.rows[0].minutes_since_heartbeat >= 44, `heartbeat 45분+ 전`);
+    }
+    // ── Case 10: on-track ──────────────────────────────────────────────────────
+    console.log("Case 10: on-track (정상)");
+    const id6 = makeId();
+    createdIds.push(id6);
+    {
+        await pool.query(`INSERT INTO semo.bot_commitments (id, bot_id, status, title, deadline_at, last_heartbeat_at)
+       VALUES ($1, $2, 'active', 'On-track 테스트', NOW() + INTERVAL '30 minutes', NOW())`, [id6, TEST_BOT]);
+        const r = await pool.query(`SELECT health FROM semo.v_active_commitments WHERE id = $1`, [id6]);
+        assert(r.rows[0].health === "on-track", `health = on-track (got ${r.rows[0].health})`);
+    }
+    // ── Case 11: 완료된 건은 뷰에서 제외 ──────────────────────────────────────
+    console.log("Case 11: 완료된 commitment는 뷰에서 제외");
+    {
+        const r = await pool.query(`SELECT * FROM semo.v_active_commitments WHERE id = $1`, [id1] // Case 5에서 done 처리됨
+        );
+        assert(r.rows.length === 0, "done 상태는 v_active_commitments에서 제외");
+    }
+    // ── Case 12: 인덱스 사용 확인 ─────────────────────────────────────────────
+    console.log("Case 12: 인덱스 존재 확인");
+    {
+        const r = await pool.query(`SELECT indexname FROM pg_indexes WHERE tablename = 'bot_commitments' AND schemaname = 'semo' ORDER BY indexname`);
+        const names = r.rows.map((row) => row.indexname);
+        assert(names.includes("idx_commitments_active"), "idx_commitments_active 존재");
+        assert(names.includes("idx_commitments_bot"), "idx_commitments_bot 존재");
+    }
+    // ── Case 13: watch --bot-id 필터 ─────────────────────────────────────────
+    console.log("Case 13: watch --bot-id 필터");
+    {
+        // __test__ 봇의 활성 커밋먼트만 조회 (id4=overdue, id5=stale, id6=on-track)
+        const r = await pool.query(`SELECT id FROM semo.v_active_commitments WHERE bot_id = $1`, [TEST_BOT]);
+        assert(r.rows.length >= 3, `--bot-id 필터: __test__ 항목 3건+ (got ${r.rows.length})`);
+        assert(r.rows.every((row) => row.id.startsWith("cmt-__test__")), "모두 __test__ 봇 소유");
+    }
+    // ── Case 14: watch --exclude-bot 필터 ──────────────────────────────────
+    console.log("Case 14: watch --exclude-bot 필터");
+    {
+        const r = await pool.query(`SELECT id, bot_id FROM semo.v_active_commitments WHERE bot_id != $1`, [TEST_BOT]);
+        const hasTestBot = r.rows.some((row) => row.bot_id === TEST_BOT);
+        assert(!hasTestBot, "--exclude-bot 필터: __test__ 봇 제외됨");
+    }
+    // ── 정리 ──────────────────────────────────────────────────────────────────
+    await cleanup();
+    // ── 결과 ──────────────────────────────────────────────────────────────────
+    console.log(`\n${"─".repeat(40)}`);
+    console.log(`총 ${passed + failed}개 테스트: ✅ ${passed} passed, ❌ ${failed} failed\n`);
+    await (0, database_1.closeConnection)();
+    process.exit(failed > 0 ? 1 : 0);
+}
+run().catch(async (err) => {
+    console.error("테스트 런타임 에러:", err);
+    await cleanup();
+    await (0, database_1.closeConnection)();
+    process.exit(1);
+});

package/dist/commands/service.d.ts

@@ -0,0 +1,10 @@
+/**
+ * semo service — 서비스 관리
+ *
+ * semo service migrate --domain {name}    — 특정 서비스 이식
+ * semo service migrate --all              — 미등록 전체 이식
+ * semo service migrate --all --dry-run    — 미리보기
+ * semo service list                       — 등록/미등록 서비스 목록
+ */
+import { Command } from "commander";
+export declare function registerServiceCommands(program: Command): void;

package/dist/commands/service.js

@@ -0,0 +1,142 @@
+"use strict";
+/**
+ * semo service — 서비스 관리
+ *
+ * semo service migrate --domain {name}    — 특정 서비스 이식
+ * semo service migrate --all              — 미등록 전체 이식
+ * semo service migrate --all --dry-run    — 미리보기
+ * semo service list                       — 등록/미등록 서비스 목록
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerServiceCommands = registerServiceCommands;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const database_1 = require("../database");
+const service_migrate_1 = require("../service-migrate");
+function registerServiceCommands(program) {
+    const service = program
+        .command("service")
+        .description("서비스 관리 — 이식, 목록 조회");
+    // ── semo service migrate ──
+    service
+        .command("migrate")
+        .description("기존 서비스를 service_projects 테이블에 이식")
+        .option("--domain <name>", "특정 서비스 도메인")
+        .option("--all", "미등록 서비스 전체 이식")
+        .option("--dry-run", "미리보기 (DB 변경 없음)")
+        .action(async (options) => {
+        if (!options.domain && !options.all) {
+            console.log(chalk_1.default.yellow("--domain <name> 또는 --all 옵션이 필요합니다."));
+            await (0, database_1.closeConnection)();
+            return;
+        }
+        const pool = (0, database_1.getPool)();
+        const spinner = (0, ora_1.default)("서비스 이식 준비 중...").start();
+        try {
+            // 1. 미등록 서비스 조회
+            const unregistered = await (0, service_migrate_1.getUnregisteredServices)(pool);
+            if (unregistered.length === 0) {
+                spinner.succeed("모든 서비스가 이미 등록되어 있습니다.");
+                await (0, database_1.closeConnection)();
+                return;
+            }
+            // 2. 대상 필터링
+            let targets = unregistered;
+            if (options.domain) {
+                targets = unregistered.filter((s) => s.domain === options.domain);
+                if (targets.length === 0) {
+                    // 도메인이 있는데 미등록 목록에 없으면 → 이미 등록됨 또는 미존재
+                    const registered = await (0, service_migrate_1.getRegisteredServices)(pool);
+                    if (registered.includes(options.domain)) {
+                        spinner.info(`'${options.domain}'은(는) 이미 service_projects에 등록되어 있습니다.`);
+                    }
+                    else {
+                        spinner.fail(`'${options.domain}'은(는) 온톨로지에 service 타입으로 등록되지 않았습니다.`);
+                    }
+                    await (0, database_1.closeConnection)();
+                    return;
+                }
+            }
+            spinner.text = `${targets.length}개 서비스 감사(audit) 중...`;
+            // 3. 각 서비스 audit
+            const results = [];
+            for (const svc of targets) {
+                const audit = await (0, service_migrate_1.auditServiceKBEntries)(pool, svc.domain, svc.description, svc.created_at);
+                if (options.dryRun) {
+                    results.push({ domain: svc.domain, action: "skipped", audit });
+                    continue;
+                }
+                // 4. INSERT
+                try {
+                    const row = (0, service_migrate_1.buildServiceProjectRow)(audit);
+                    // KB 엔트리 수 조회
+                    const countResult = await pool.query("SELECT COUNT(*)::int as cnt FROM semo.knowledge_base WHERE domain = $1", [svc.domain]);
+                    const kbEntryCount = countResult.rows[0]?.cnt ?? 0;
+                    const projectId = await (0, service_migrate_1.insertServiceProject)(pool, row);
+                    // 5. pm-summary projection 쓰기
+                    await (0, service_migrate_1.writePmSummaryToKB)(pool, svc.domain, projectId, row, kbEntryCount);
+                    results.push({
+                        domain: svc.domain,
+                        action: "created",
+                        projectId,
+                        audit,
+                    });
+                }
+                catch (err) {
+                    results.push({
+                        domain: svc.domain,
+                        action: "error",
+                        audit,
+                        error: err.message,
+                    });
+                }
+            }
+            spinner.stop();
+            // 6. 결과 리포트
+            if (options.dryRun) {
+                (0, service_migrate_1.printDryRunReport)(results);
+            }
+            else {
+                (0, service_migrate_1.printAuditReport)(results);
+            }
+        }
+        catch (err) {
+            spinner.fail(`이식 실패: ${err.message}`);
+        }
+        finally {
+            await (0, database_1.closeConnection)();
+        }
+    });
+    // ── semo service list ──
+    service
+        .command("list")
+        .description("서비스 목록 (등록/미등록 상태 포함)")
+        .action(async () => {
+        const pool = (0, database_1.getPool)();
+        try {
+            const registered = await (0, service_migrate_1.getRegisteredServices)(pool);
+            const unregistered = await (0, service_migrate_1.getUnregisteredServices)(pool);
+            console.log(chalk_1.default.cyan.bold("\n📋 서비스 목록\n"));
+            if (registered.length > 0) {
+                console.log(chalk_1.default.green(`  ✓ 등록됨 (${registered.length}개):`));
+                for (const d of registered.sort()) {
+                    console.log(chalk_1.default.gray(`    ${d}`));
+                }
+            }
+            if (unregistered.length > 0) {
+                console.log(chalk_1.default.yellow(`\n  ○ 미등록 (${unregistered.length}개):`));
+                for (const s of unregistered) {
+                    const desc = s.description ? chalk_1.default.gray(` — ${s.description.substring(0, 60)}`) : "";
+                    console.log(`    ${s.domain}${desc}`);
+                }
+            }
+            console.log();
+        }
+        finally {
+            await (0, database_1.closeConnection)();
+        }
+    });
+}

package/dist/index.js

@@ -66,6 +66,7 @@ const db_1 = require("./commands/db");
 const memory_1 = require("./commands/memory");
 const test_1 = require("./commands/test");
 const commitments_1 = require("./commands/commitments");
+const service_1 = require("./commands/service");
 const global_cache_1 = require("./global-cache");
 const semo_workspace_1 = require("./semo-workspace");
 const PACKAGE_NAME = "@team-semicolon/semo-cli";
@@ -2354,6 +2355,7 @@ ontoCmd
 (0, memory_1.registerMemoryCommands)(program);
 (0, test_1.registerTestCommands)(program);
 (0, commitments_1.registerCommitmentsCommands)(program);
+(0, service_1.registerServiceCommands)(program);
 // === semo skills — DB 시딩 ===
 /**
  * SKILL.md frontmatter 파싱 (YAML 파서 없이 regex 기반)

package/dist/kb.js

@@ -773,7 +773,7 @@ async function kbUpsert(pool, entry) {
             const typeResult = await schemaClient.query("SELECT entity_type FROM semo.ontology WHERE domain = $1 AND entity_type IS NOT NULL", [entry.domain]);
             if (typeResult.rows.length > 0) {
                 const entityType = typeResult.rows[0].entity_type;
-                const schemaResult = await schemaClient.query("SELECT scheme_key, COALESCE(key_type, 'singleton') as key_type FROM semo.kb_type_schema WHERE type_key = $1", [entityType]);
+                const schemaResult = await schemaClient.query("SELECT scheme_key, COALESCE(key_type, 'singleton') as key_type, COALESCE(source, 'manual') as source FROM semo.kb_type_schema WHERE type_key = $1", [entityType]);
                 const schemas = schemaResult.rows;
                 if (schemas.length > 0) {
                     const match = schemas.find(s => s.scheme_key === key);
@@ -784,6 +784,16 @@ async function kbUpsert(pool, entry) {
                             error: `키 '${key}'은(는) '${entityType}' 타입의 스키마에 허용되지 않습니다. 허용 키: [${allowedKeys.join(", ")}]`,
                         };
                     }
+                    // Projection key 차단: pm-pipeline만 쓰기 허용
+                    if (match.source === "projection") {
+                        const createdBy = entry.created_by ?? "";
+                        if (!createdBy.startsWith("pm-") && !createdBy.startsWith("gfp-")) {
+                            return {
+                                success: false,
+                                error: `키 '${key}'은(는) projection 키입니다 (PM 파이프라인에서 자동 동기화). 직접 쓰기가 차단됩니다.`,
+                            };
+                        }
+                    }
                     if (match.key_type === "singleton" && subKey !== "") {
                         return { success: false, error: `키 '${key}'은(는) singleton이므로 sub_key가 비어야 합니다.` };
                     }

package/dist/service-migrate.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Service Migration — 기존 운영 서비스를 service_projects 테이블에 이식
+ *
+ * KB 온톨로지에 service 타입으로 등록된 도메인 중 service_projects에 미등록된 것을
+ * 자동으로 이식. KB 엔트리 전수 조사(audit) 후 매핑/비매핑 분류.
+ */
+import { Pool } from "pg";
+export interface AuditEntry {
+    key: string;
+    subKey: string;
+    target: string;
+    value: string;
+}
+export interface AuditResult {
+    domain: string;
+    ontologyDescription: string | null;
+    ontologyCreatedAt: string | null;
+    mapped: {
+        key: string;
+        target: string;
+        value: string;
+    }[];
+    metadata: {
+        key: string;
+        value: string;
+    }[];
+    kbOnly: {
+        key: string;
+        count: number;
+    }[];
+    projection: {
+        key: string;
+        count: number;
+    }[];
+    warnings: {
+        key: string;
+        reason: string;
+        suggestion: string;
+    }[];
+    missingRequired: string[];
+}
+export interface MigrationRow {
+    project_name: string;
+    owner_name: string;
+    service_domain: string;
+    status: string;
+    lifecycle: string;
+    launched_at: string | null;
+    metadata: Record<string, unknown>;
+}
+export interface MigrationResult {
+    domain: string;
+    action: "created" | "skipped" | "error";
+    projectId?: string;
+    audit: AuditResult;
+    error?: string;
+}
+export declare function getUnregisteredServices(pool: Pool): Promise<Array<{
+    domain: string;
+    description: string | null;
+    created_at: string | null;
+}>>;
+export declare function getRegisteredServices(pool: Pool): Promise<string[]>;
+export declare function auditServiceKBEntries(pool: Pool, domain: string, ontologyDescription: string | null, ontologyCreatedAt: string | null): Promise<AuditResult>;
+export declare function buildServiceProjectRow(audit: AuditResult): MigrationRow;
+export declare function insertServiceProject(pool: Pool, row: MigrationRow): Promise<string>;
+export declare function writePmSummaryToKB(pool: Pool, domain: string, projectId: string, row: MigrationRow, kbEntryCount: number): Promise<void>;
+export declare function printAuditReport(results: MigrationResult[]): void;
+export declare function printDryRunReport(results: MigrationResult[]): void;

package/dist/service-migrate.js

@@ -0,0 +1,282 @@
+"use strict";
+/**
+ * Service Migration — 기존 운영 서비스를 service_projects 테이블에 이식
+ *
+ * KB 온톨로지에 service 타입으로 등록된 도메인 중 service_projects에 미등록된 것을
+ * 자동으로 이식. KB 엔트리 전수 조사(audit) 후 매핑/비매핑 분류.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUnregisteredServices = getUnregisteredServices;
+exports.getRegisteredServices = getRegisteredServices;
+exports.auditServiceKBEntries = auditServiceKBEntries;
+exports.buildServiceProjectRow = buildServiceProjectRow;
+exports.insertServiceProject = insertServiceProject;
+exports.writePmSummaryToKB = writePmSummaryToKB;
+exports.printAuditReport = printAuditReport;
+exports.printDryRunReport = printDryRunReport;
+const chalk_1 = __importDefault(require("chalk"));
+const kb_1 = require("./kb");
+// ── KB Status Mapping ──
+const STATUS_MAP = {
+    active: { lifecycle: "ops", status: "active" },
+    hold: { lifecycle: "ops", status: "paused" },
+    maintenance: { lifecycle: "ops", status: "active" },
+    completed: { lifecycle: "sunset", status: "completed" },
+    deprecated: { lifecycle: "sunset", status: "completed" },
+};
+// Keys that map directly to service_projects columns
+const COLUMN_KEYS = {
+    "base-information": "project_name",
+    po: "owner_name",
+    status: "status+lifecycle",
+};
+// Keys that go into metadata JSONB
+const METADATA_KEYS = new Set([
+    "repo",
+    "slack-channel",
+    "tech-stack",
+    "service-url",
+    "bm",
+]);
+// Keys that stay in KB only (normal)
+const KB_ONLY_KEYS = new Set([
+    "current-situation",
+    "kpi",
+    "milestone",
+    "decision",
+    "process",
+    "infra",
+]);
+// Projection keys (auto-managed by pm-pipeline)
+const PROJECTION_KEYS = new Set([
+    "spec",
+    "pm-status",
+    "gfp-status",
+    "gfp-id",
+    "infra-status",
+    "pm-summary",
+]);
+// ── Core Functions ──
+async function getUnregisteredServices(pool) {
+    const result = await pool.query(`SELECT o.domain, o.description, o.created_at::text
+     FROM semo.ontology o
+     WHERE o.entity_type = 'service'
+       AND o.domain NOT LIKE 'e2e-%'
+       AND NOT EXISTS (
+         SELECT 1 FROM semo.service_projects sp WHERE sp.service_domain = o.domain
+       )
+     ORDER BY o.domain`);
+    return result.rows;
+}
+async function getRegisteredServices(pool) {
+    const result = await pool.query(`SELECT service_domain FROM semo.service_projects WHERE service_domain IS NOT NULL`);
+    return result.rows.map((r) => r.service_domain);
+}
+async function auditServiceKBEntries(pool, domain, ontologyDescription, ontologyCreatedAt) {
+    // Fetch ALL KB entries for this domain
+    const entriesResult = await pool.query(`SELECT key, sub_key, content
+     FROM semo.knowledge_base
+     WHERE domain = $1
+     ORDER BY key, sub_key`, [domain]);
+    const entries = entriesResult.rows.map((e) => ({ ...e, content: (e.content ?? "").substring(0, 500) }));
+    // Fetch allowed keys from type schema
+    const schemaResult = await pool.query(`SELECT scheme_key, COALESCE(source, 'manual') as source
+     FROM semo.kb_type_schema WHERE type_key = 'service'`);
+    const allowedKeys = new Set(schemaResult.rows.map((r) => r.scheme_key));
+    const audit = {
+        domain,
+        ontologyDescription,
+        ontologyCreatedAt,
+        mapped: [],
+        metadata: [],
+        kbOnly: [],
+        projection: [],
+        warnings: [],
+        missingRequired: [],
+    };
+    // Group entries by key
+    const byKey = new Map();
+    for (const e of entries) {
+        const arr = byKey.get(e.key) || [];
+        arr.push({ sub_key: e.sub_key, content: e.content });
+        byKey.set(e.key, arr);
+    }
+    for (const [key, items] of byKey) {
+        if (COLUMN_KEYS[key]) {
+            // Maps to service_projects column
+            const firstContent = items[0]?.content ?? "";
+            audit.mapped.push({
+                key,
+                target: COLUMN_KEYS[key],
+                value: firstContent.substring(0, 200),
+            });
+        }
+        else if (METADATA_KEYS.has(key)) {
+            const firstContent = items[0]?.content ?? "";
+            audit.metadata.push({ key, value: firstContent.substring(0, 200) });
+        }
+        else if (KB_ONLY_KEYS.has(key)) {
+            audit.kbOnly.push({ key, count: items.length });
+        }
+        else if (PROJECTION_KEYS.has(key)) {
+            audit.projection.push({ key, count: items.length });
+        }
+        else if (!allowedKeys.has(key)) {
+            // Unknown key — not in type schema
+            audit.warnings.push({
+                key,
+                reason: `'${key}'은(는) service 타입 스키마에 등록되지 않은 키`,
+                suggestion: `semo kb ontology --action add-key --type service --key ${key} --key-type collection`,
+            });
+        }
+        else {
+            // In schema but not in our classification — treat as KB-only
+            audit.kbOnly.push({ key, count: items.length });
+        }
+    }
+    // Check required keys
+    for (const reqKey of ["base-information", "po", "status"]) {
+        if (!byKey.has(reqKey)) {
+            audit.missingRequired.push(reqKey);
+        }
+    }
+    return audit;
+}
+function buildServiceProjectRow(audit) {
+    // Extract project_name from base-information
+    const baseInfo = audit.mapped.find((m) => m.key === "base-information");
+    let projectName = audit.domain; // fallback
+    if (baseInfo) {
+        // Take first line or first sentence as project name
+        const firstLine = baseInfo.value.split("\n")[0].trim();
+        // Try to extract name pattern like "AXOracle — 오라클 정보 플랫폼"
+        const match = firstLine.match(/^([^—–\-]+)/);
+        projectName = match ? match[1].trim() : firstLine.substring(0, 100);
+    }
+    else if (audit.ontologyDescription) {
+        const match = audit.ontologyDescription.match(/^([^—–\-]+)/);
+        projectName = match ? match[1].trim() : audit.ontologyDescription.substring(0, 100);
+    }
+    // Extract owner from po
+    const poEntry = audit.mapped.find((m) => m.key === "po");
+    const ownerName = poEntry ? poEntry.value.split("\n")[0].trim().substring(0, 100) : "TBD";
+    // Map status
+    const statusEntry = audit.mapped.find((m) => m.key === "status");
+    const rawStatus = statusEntry
+        ? statusEntry.value.split("\n")[0].trim().toLowerCase()
+        : "active";
+    const mapping = STATUS_MAP[rawStatus] ?? STATUS_MAP["active"];
+    // Build metadata from repo, slack-channel, tech-stack, etc.
+    const meta = { source: "kb-migration" };
+    for (const m of audit.metadata) {
+        meta[m.key] = m.value;
+    }
+    return {
+        project_name: projectName,
+        owner_name: ownerName,
+        service_domain: audit.domain,
+        status: mapping.status,
+        lifecycle: mapping.lifecycle,
+        launched_at: audit.ontologyCreatedAt,
+        metadata: meta,
+    };
+}
+async function insertServiceProject(pool, row) {
+    const result = await pool.query(`INSERT INTO semo.service_projects
+       (project_name, owner_name, service_domain, status, lifecycle, launched_at, metadata)
+     VALUES ($1, $2, $3, $4, $5, $6, $7)
+     RETURNING gfp_id`, [
+        row.project_name,
+        row.owner_name,
+        row.service_domain,
+        row.status,
+        row.lifecycle,
+        row.launched_at,
+        JSON.stringify(row.metadata),
+    ]);
+    return result.rows[0].gfp_id;
+}
+async function writePmSummaryToKB(pool, domain, projectId, row, kbEntryCount) {
+    const content = [
+        `project_id: ${projectId}`,
+        `project_name: ${row.project_name}`,
+        `lifecycle: ${row.lifecycle}`,
+        `status: ${row.status}`,
+        `source: kb-migration`,
+        `registered_at: ${new Date().toISOString()}`,
+        `kb_entries: ${kbEntryCount}`,
+        `owner: ${row.owner_name}`,
+    ].join("\n");
+    await (0, kb_1.kbUpsert)(pool, {
+        domain,
+        key: "pm-summary",
+        content,
+        created_by: "pm-pipeline",
+    });
+}
+// ── Reporting ──
+function printAuditReport(results) {
+    const created = results.filter((r) => r.action === "created");
+    const skipped = results.filter((r) => r.action === "skipped");
+    const errors = results.filter((r) => r.action === "error");
+    console.log(chalk_1.default.cyan.bold(`\n📊 서비스 이식 결과\n`));
+    console.log(`  ${chalk_1.default.green(`✓ 등록: ${created.length}`)}  ${chalk_1.default.yellow(`⊘ 건너뜀: ${skipped.length}`)}  ${chalk_1.default.red(`✗ 오류: ${errors.length}`)}`);
+    for (const r of results) {
+        const icon = r.action === "created" ? chalk_1.default.green("✓") :
+            r.action === "skipped" ? chalk_1.default.yellow("⊘") :
+                chalk_1.default.red("✗");
+        console.log(`\n  ${icon} ${chalk_1.default.bold(r.domain)}`);
+        if (r.action === "created") {
+            console.log(chalk_1.default.gray(`    project_id: ${r.projectId}\n` +
+                `    mapped: ${r.audit.mapped.map((m) => m.key).join(", ") || "(없음)"}\n` +
+                `    metadata: ${r.audit.metadata.map((m) => m.key).join(", ") || "(없음)"}\n` +
+                `    kb-only: ${r.audit.kbOnly.map((k) => `${k.key}(${k.count})`).join(", ") || "(없음)"}`));
+        }
+        if (r.action === "error") {
+            console.log(chalk_1.default.red(`    ${r.error}`));
+        }
+        // Warnings
+        if (r.audit.warnings.length > 0) {
+            console.log(chalk_1.default.yellow("    ⚠ 비표준 키:"));
+            for (const w of r.audit.warnings) {
+                console.log(chalk_1.default.yellow(`      ${w.key}: ${w.reason}`));
+                console.log(chalk_1.default.gray(`        → ${w.suggestion}`));
+            }
+        }
+        // Missing required
+        if (r.audit.missingRequired.length > 0) {
+            console.log(chalk_1.default.yellow(`    ⚠ 필수 키 누락: ${r.audit.missingRequired.join(", ")}`));
+        }
+    }
+    console.log();
+}
+function printDryRunReport(results) {
+    console.log(chalk_1.default.cyan.bold(`\n🔍 서비스 이식 미리보기 (dry-run)\n`));
+    console.log(chalk_1.default.gray(`  DB 변경 없이 audit 결과만 표시합니다.\n`));
+    for (const r of results) {
+        const row = buildServiceProjectRow(r.audit);
+        console.log(chalk_1.default.bold(`  ${r.domain}`));
+        console.log(chalk_1.default.gray(`    → project_name: ${row.project_name}\n` +
+            `    → owner_name: ${row.owner_name}\n` +
+            `    → lifecycle: ${row.lifecycle}, status: ${row.status}\n` +
+            `    → launched_at: ${row.launched_at ?? 'NOW()'}\n` +
+            `    → metadata keys: ${Object.keys(row.metadata).join(", ")}`));
+        if (r.audit.kbOnly.length > 0) {
+            console.log(chalk_1.default.gray(`    → kb-only: ${r.audit.kbOnly.map((k) => `${k.key}(${k.count})`).join(", ")}`));
+        }
+        if (r.audit.warnings.length > 0) {
+            for (const w of r.audit.warnings) {
+                console.log(chalk_1.default.yellow(`    ⚠ ${w.key}: ${w.reason}`));
+                console.log(chalk_1.default.gray(`      → ${w.suggestion}`));
+            }
+        }
+        if (r.audit.missingRequired.length > 0) {
+            console.log(chalk_1.default.yellow(`    ⚠ 필수 키 누락: ${r.audit.missingRequired.join(", ")}`));
+        }
+        console.log();
+    }
+    console.log(chalk_1.default.cyan(`  총 ${results.length}개 서비스 이식 대상\n`));
+}

package/package.json

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