@team-semicolon/semo-cli 4.12.0 → 4.15.0

package/dist/semo-workspace.js

@@ -322,6 +322,57 @@ function generateThinRouter(kbFirstBlock) {
 - 사용자가 "다른 탭에서 뭐 돌아가고 있어?" 같은 질문을 하면 cmux 명령어로 확인
 
 ${kbFirstBlock}
+
+---
+
+## 3자 동기화 규칙 (NON-NEGOTIABLE)
+
+> 모든 SEMO 프로젝트의 변경은 3자 동기화 관점에서 평가되어야 한다.
+> 3자 = **소스코드** ↔ **KB 포함 DB** ↔ **OpenClaw 봇 워크스페이스 로컬 파일**
+
+| 축 | 위치 | 예시 |
+|----|------|------|
+| **소스코드** | 각 프로젝트 레포 | API 라우트, 타입, 마이그레이션 |
+| **KB 포함 DB** | semo-kb (PostgreSQL + 벡터 임베딩) | 프로세스, 봇 역할, 온톨로지 |
+| **봇 로컬 파일** | \`~/.openclaw-{botId}/workspace/\` + \`~/.claude/semo/\` | SOUL.md, skills/, memory/ |
+
+**변경 시 체크리스트**:
+1. **소스코드 변경** → KB와 봇 파일에 반영할 내용이 있는가?
+2. **KB 변경** → 소스코드나 봇 파일과 불일치가 생기지 않는가?
+3. **봇 파일 변경** → KB에 기록할 사항이 있는가? 소스코드와 정합성이 맞는가?
+
+**추가 규칙**:
+- SoT 위치: DB → DB에서 읽기 (하드코딩 금지). KB → \`semo kb get/search\` 조회.
+- KB 쓰기: 반드시 \`semo kb upsert\` CLI 사용 (임베딩 + 스키마 검증 포함). raw SQL INSERT 금지.
+
+---
+
+## KB CLI 참조 가이드
+
+| 정보 | 조회 명령 |
+|------|-----------|
+| 봇 프로필 | \`semo kb get {botId} identity\` |
+| 봇 역할 | \`semo kb get {botId} role\` |
+| SEMO 워크스페이스 규격 | \`semo kb get semo spec workspace-v2\` |
+| 환경변수 | \`semo kb get semo infra env-config\` |
+| 코딩 컨벤션 | \`semo kb get semo process coding-convention\` |
+| 인시던트 기록 | \`semo kb get {service} incident {slug}\` |
+| 의사결정 기록 | \`semo kb get semicolon decision {slug}\` |
+| 경로 모를 때 | \`semo kb search "검색어"\` 또는 \`semo kb ontology --action routing-table\` |
+
+---
+
+## 공통 Enforcement Hooks
+
+아래 훅은 \`~/.openclaw-shared/hooks/\`에 위치하며, 봇 + 로컬 세션 양쪽에서 사용:
+
+| 훅 | 트리거 | 역할 |
+|----|--------|------|
+| \`context-router.sh\` | UserPromptSubmit | 메시지 키워드 → KB/GFP/INFRA 컨텍스트 힌트 주입 |
+| \`decision-reminder.sh\` | Stop | 의사결정 패턴 감지 → KB 기록 안 했으면 차단 |
+| \`commitment-guard.sh\` | Stop | 한국어 약속 패턴 → commitment 미등록 시 차단 |
+| \`kb-first-guard.sh\` | Stop | KB 필요 질문에 KB 조회 없이 답변 시 차단 |
+| \`response-length-guard.sh\` | Stop | 봇 응답 20줄 초과 시 차단 |
 `;
     // 기존 파일 백업 (마이그레이션)
     if (fs.existsSync(globalClaudeMd)) {

package/dist/service-migrate.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Service Migration — 기존 운영 서비스를 services 테이블에 이식
+ *
+ * KB 온톨로지에 service 타입으로 등록된 도메인 중 services에 미등록된 것을
+ * 자동으로 이식. 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 const STATUS_MAP: Record<string, {
+    lifecycle: string;
+    status: 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;
+export interface ServiceProjectRow {
+    service_id: string;
+    project_name: string;
+    service_domain: string | null;
+    owner_name: string;
+    owner_contact: string | null;
+    current_phase: number;
+    infra_phase: number | null;
+    status: string;
+    lifecycle: string;
+    launched_at: string | null;
+    metadata: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+export declare function getServiceProjectByDomain(pool: Pool, domain: string): Promise<ServiceProjectRow | null>;
+export interface ServiceProjectUpdate {
+    status?: string;
+    lifecycle?: string;
+    current_phase?: number;
+    project_name?: string;
+    owner_name?: string;
+    metadata?: Record<string, unknown>;
+}
+export declare function updateServiceProject(pool: Pool, domain: string, updates: ServiceProjectUpdate): Promise<ServiceProjectRow | null>;
+export interface DiagnoseMismatch {
+    field: string;
+    kbValue: string;
+    spValue: string;
+    expected: string;
+}
+export interface DiagnoseResult {
+    domain: string;
+    verdict: "healthy" | "mismatch" | "kb-only" | "sp-only" | "missing";
+    kbEntryCount: number;
+    kbKeys: string[];
+    serviceProject: ServiceProjectRow | null;
+    mismatches: DiagnoseMismatch[];
+    missingRequired: string[];
+}
+export declare function diagnoseServiceStatus(pool: Pool, domain: string): Promise<DiagnoseResult>;

package/dist/service-migrate.js

@@ -0,0 +1,457 @@
+"use strict";
+/**
+ * Service Migration — 기존 운영 서비스를 services 테이블에 이식
+ *
+ * KB 온톨로지에 service 타입으로 등록된 도메인 중 services에 미등록된 것을
+ * 자동으로 이식. KB 엔트리 전수 조사(audit) 후 매핑/비매핑 분류.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATUS_MAP = void 0;
+exports.getUnregisteredServices = getUnregisteredServices;
+exports.getRegisteredServices = getRegisteredServices;
+exports.auditServiceKBEntries = auditServiceKBEntries;
+exports.buildServiceProjectRow = buildServiceProjectRow;
+exports.insertServiceProject = insertServiceProject;
+exports.writePmSummaryToKB = writePmSummaryToKB;
+exports.printAuditReport = printAuditReport;
+exports.printDryRunReport = printDryRunReport;
+exports.getServiceProjectByDomain = getServiceProjectByDomain;
+exports.updateServiceProject = updateServiceProject;
+exports.diagnoseServiceStatus = diagnoseServiceStatus;
+const chalk_1 = __importDefault(require("chalk"));
+const kb_1 = require("./kb");
+// ── KB Status Mapping ──
+exports.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 services 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.services 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.services 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 services 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 = exports.STATUS_MAP[rawStatus] ?? exports.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.services
+       (project_name, owner_name, service_domain, status, lifecycle, launched_at, metadata)
+     VALUES ($1, $2, $3, $4, $5, $6, $7)
+     RETURNING service_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].service_id;
+}
+async function writePmSummaryToKB(pool, domain, projectId, row, kbEntryCount) {
+    const content = [
+        `service_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(`    service_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`));
+}
+async function getServiceProjectByDomain(pool, domain) {
+    const result = await pool.query(`SELECT service_id, project_name, service_domain, owner_name, owner_contact,
+            current_phase, infra_phase, status, lifecycle,
+            launched_at::text, metadata,
+            created_at::text, updated_at::text
+     FROM semo.services
+     WHERE service_domain = $1`, [domain]);
+    return result.rows[0] ?? null;
+}
+async function updateServiceProject(pool, domain, updates) {
+    const sets = [];
+    const params = [];
+    let idx = 1;
+    if (updates.project_name !== undefined) {
+        sets.push(`project_name = $${idx++}`);
+        params.push(updates.project_name);
+    }
+    if (updates.owner_name !== undefined) {
+        sets.push(`owner_name = $${idx++}`);
+        params.push(updates.owner_name);
+    }
+    if (updates.current_phase !== undefined) {
+        sets.push(`current_phase = $${idx++}`);
+        params.push(updates.current_phase);
+    }
+    if (updates.status !== undefined) {
+        sets.push(`status = $${idx++}`);
+        params.push(updates.status);
+    }
+    if (updates.lifecycle !== undefined) {
+        sets.push(`lifecycle = $${idx++}`);
+        params.push(updates.lifecycle);
+        // ops 전환 시 launched_at 자동 설정
+        if (updates.lifecycle === "ops") {
+            sets.push(`launched_at = COALESCE(launched_at, NOW())`);
+        }
+    }
+    if (updates.metadata !== undefined) {
+        sets.push(`metadata = COALESCE(metadata, '{}'::jsonb) || $${idx++}::jsonb`);
+        params.push(JSON.stringify(updates.metadata));
+    }
+    if (sets.length === 0)
+        return getServiceProjectByDomain(pool, domain);
+    params.push(domain);
+    const result = await pool.query(`UPDATE semo.services SET ${sets.join(", ")}
+     WHERE service_domain = $${idx}
+     RETURNING service_id, project_name, service_domain, owner_name, owner_contact,
+               current_phase, infra_phase, status, lifecycle,
+               launched_at::text, metadata, created_at::text, updated_at::text`, params);
+    return result.rows[0] ?? null;
+}
+async function diagnoseServiceStatus(pool, domain) {
+    // 1. KB 도메인 존재 확인
+    const ontoResult = await pool.query(`SELECT domain, description, created_at::text
+     FROM semo.ontology WHERE domain = $1 AND entity_type = 'service'`, [domain]);
+    const kbExists = ontoResult.rows.length > 0;
+    // 2. services 조회
+    const sp = await getServiceProjectByDomain(pool, domain);
+    // 3. 분류
+    if (!kbExists && !sp) {
+        return {
+            domain,
+            verdict: "missing",
+            kbEntryCount: 0,
+            kbKeys: [],
+            serviceProject: null,
+            mismatches: [],
+            missingRequired: [],
+        };
+    }
+    if (!kbExists && sp) {
+        return {
+            domain,
+            verdict: "sp-only",
+            kbEntryCount: 0,
+            kbKeys: [],
+            serviceProject: sp,
+            mismatches: [],
+            missingRequired: [],
+        };
+    }
+    // KB 엔트리 목록
+    const entriesResult = await pool.query(`SELECT DISTINCT key FROM semo.knowledge_base WHERE domain = $1 ORDER BY key`, [domain]);
+    const kbKeys = entriesResult.rows.map((r) => r.key);
+    const countResult = await pool.query(`SELECT COUNT(*)::int as cnt FROM semo.knowledge_base WHERE domain = $1`, [domain]);
+    const kbEntryCount = countResult.rows[0]?.cnt ?? 0;
+    if (kbExists && !sp) {
+        // 필수 키 체크
+        const missingRequired = [];
+        for (const req of ["base-information", "po", "status"]) {
+            if (!kbKeys.includes(req))
+                missingRequired.push(req);
+        }
+        return {
+            domain,
+            verdict: "kb-only",
+            kbEntryCount,
+            kbKeys,
+            serviceProject: null,
+            mismatches: [],
+            missingRequired,
+        };
+    }
+    // 4. 양쪽 다 존재 → 교차 비교
+    const mismatches = [];
+    // KB status vs services status/lifecycle
+    const statusEntry = await pool.query(`SELECT content FROM semo.knowledge_base
+     WHERE domain = $1 AND key = 'status' AND (sub_key IS NULL OR sub_key = '')
+     LIMIT 1`, [domain]);
+    if (statusEntry.rows.length > 0 && sp) {
+        const kbStatus = statusEntry.rows[0].content.split("\n")[0].trim().toLowerCase();
+        const expected = exports.STATUS_MAP[kbStatus];
+        if (expected) {
+            if (expected.lifecycle !== sp.lifecycle) {
+                mismatches.push({
+                    field: "lifecycle",
+                    kbValue: `status=${kbStatus} → lifecycle=${expected.lifecycle}`,
+                    spValue: sp.lifecycle,
+                    expected: expected.lifecycle,
+                });
+            }
+            if (expected.status !== sp.status) {
+                mismatches.push({
+                    field: "status",
+                    kbValue: `status=${kbStatus} → status=${expected.status}`,
+                    spValue: sp.status,
+                    expected: expected.status,
+                });
+            }
+        }
+    }
+    // KB po vs services owner_name
+    const poEntry = await pool.query(`SELECT content FROM semo.knowledge_base
+     WHERE domain = $1 AND key = 'po' AND (sub_key IS NULL OR sub_key = '')
+     LIMIT 1`, [domain]);
+    if (poEntry.rows.length > 0 && sp) {
+        const kbPo = poEntry.rows[0].content.split("\n")[0].trim().toLowerCase();
+        if (kbPo !== sp.owner_name.toLowerCase()) {
+            mismatches.push({
+                field: "owner",
+                kbValue: kbPo,
+                spValue: sp.owner_name,
+                expected: kbPo,
+            });
+        }
+    }
+    // section 존재 여부 vs current_phase
+    if (sp && sp.lifecycle === "build" && sp.current_phase > 0) {
+        const sectionResult = await pool.query(`SELECT COUNT(*)::int as cnt
+       FROM semo.service_sections
+       WHERE service_id = $1 AND status = 'approved'`, [sp.service_id]);
+        const approvedSections = sectionResult.rows[0]?.cnt ?? 0;
+        if (approvedSections === 0 && sp.current_phase > 0) {
+            mismatches.push({
+                field: "phase",
+                kbValue: "승인된 섹션 0개",
+                spValue: `current_phase=${sp.current_phase}`,
+                expected: "phase=0 (승인된 섹션 없음)",
+            });
+        }
+    }
+    return {
+        domain,
+        verdict: mismatches.length > 0 ? "mismatch" : "healthy",
+        kbEntryCount,
+        kbKeys,
+        serviceProject: sp,
+        mismatches,
+        missingRequired: [],
+    };
+}

package/dist/templates/harness/commit-msg

@@ -0,0 +1 @@
+npx --no -- commitlint --edit $1

package/dist/templates/harness/commitlint.config.js

@@ -0,0 +1,11 @@
+module.exports = {
+  extends: ['@commitlint/config-conventional'],
+  rules: {
+    'type-enum': [
+      2,
+      'always',
+      ['feat', 'fix', 'refactor', 'docs', 'test', 'chore', 'ci', 'perf', 'style'],
+    ],
+    'subject-max-length': [2, 'always', 100],
+  },
+};

package/dist/templates/harness/eslint.config.mjs

@@ -0,0 +1,17 @@
+import eslint from '@eslint/js';
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
+  {
+    ignores: ['dist/', 'node_modules/'],
+  },
+  {
+    rules: {
+      '@typescript-eslint/no-unused-vars': ['warn', { argsIgnorePattern: '^_' }],
+      '@typescript-eslint/no-explicit-any': 'warn',
+      '@typescript-eslint/no-require-imports': 'off',
+    },
+  },
+);

package/dist/templates/harness/pr-quality-gate.yml

@@ -0,0 +1,19 @@
+name: PR Quality Gate
+
+on:
+  pull_request:
+    branches: [dev, main]
+
+jobs:
+  quality-check:
+    name: Lint + Type Check + Build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm ci
+      - run: npm run lint
+      - run: npx tsc --noEmit
+      - run: npm run build

package/dist/templates/harness/pre-commit

@@ -0,0 +1 @@
+npx lint-staged

package/dist/templates/harness/pre-push

@@ -0,0 +1 @@
+npm run lint && npx tsc --noEmit