@team-semicolon/semo-cli 4.2.0 → 4.4.0

package/dist/kb.d.ts

@@ -20,6 +20,7 @@ export declare function generateEmbeddings(texts: string[]): Promise<(number[] |
 export interface KBEntry {
     domain: string;
     key: string;
+    sub_key?: string;
     content: string;
     metadata?: Record<string, unknown>;
     created_by?: string;
@@ -32,8 +33,18 @@ export interface OntologyDomain {
     schema: Record<string, unknown>;
     description: string | null;
     version: number;
+    service?: string | null;
+    entity_type?: string | null;
+    parent?: string | null;
+    tags?: string[];
     updated_at?: string;
 }
+export interface OntologyType {
+    type_key: string;
+    schema: Record<string, unknown>;
+    description: string | null;
+    version: number;
+}
 export interface KBStatusInfo {
     shared: {
         total: number;
@@ -44,6 +55,7 @@ export interface KBStatusInfo {
 export interface KBDigestEntry {
     domain: string;
     key: string;
+    sub_key?: string;
     content: string;
     version: number;
     change_type: 'new' | 'updated';
@@ -79,6 +91,7 @@ export declare function kbStatus(pool: Pool): Promise<KBStatusInfo>;
  */
 export declare function kbList(pool: Pool, options: {
     domain?: string;
+    service?: string;
     limit?: number;
     offset?: number;
 }): Promise<KBEntry[]>;
@@ -87,6 +100,7 @@ export declare function kbList(pool: Pool, options: {
  */
 export declare function kbSearch(pool: Pool, query: string, options: {
     domain?: string;
+    service?: string;
     limit?: number;
     mode?: "semantic" | "text" | "hybrid";
 }): Promise<KBEntry[]>;
@@ -98,6 +112,10 @@ export declare function ontoList(pool: Pool): Promise<OntologyDomain[]>;
  * Show ontology detail for a domain
  */
 export declare function ontoShow(pool: Pool, domain: string): Promise<OntologyDomain | null>;
+/**
+ * List all ontology types (structural templates)
+ */
+export declare function ontoListTypes(pool: Pool): Promise<OntologyType[]>;
 /**
  * Validate KB entries against ontology schema (basic JSON Schema validation)
  */
@@ -113,6 +131,73 @@ export declare function ontoValidate(pool: Pool, domain: string, entries?: KBEnt
  * Returns all KB changes since the given ISO timestamp.
  */
 export declare function kbDigest(pool: Pool, since: string, domain?: string): Promise<KBDigestResult>;
+/**
+ * Get a single KB entry by domain + key + sub_key
+ */
+export declare function kbGet(pool: Pool, domain: string, rawKey: string, rawSubKey?: string): Promise<KBEntry | null>;
+/**
+ * Upsert a single KB entry with domain/key validation and embedding generation
+ */
+export declare function kbUpsert(pool: Pool, entry: {
+    domain: string;
+    key: string;
+    sub_key?: string;
+    content: string;
+    metadata?: Record<string, unknown>;
+    created_by?: string;
+}): Promise<{
+    success: boolean;
+    error?: string;
+    warnings?: string[];
+}>;
+export interface TypeSchemaEntry {
+    type_key: string;
+    scheme_key: string;
+    scheme_description: string;
+    required: boolean;
+    value_hint: string | null;
+    sort_order: number;
+    key_type: "singleton" | "collection";
+}
+export interface RoutingEntry {
+    domain: string;
+    entity_type: string;
+    service: string | null;
+    domain_description: string | null;
+    scheme_key: string;
+    key_type: string;
+    scheme_description: string;
+    value_hint: string | null;
+}
+export interface ServiceInfo {
+    service: string;
+    domain_count: number;
+    domains: string[];
+}
+export interface ServiceInstance {
+    domain: string;
+    description: string | null;
+    service: string;
+    tags: string[];
+    scoped_domains: string[];
+    entry_count: number;
+}
+/**
+ * List type schema entries for a given entity type
+ */
+export declare function ontoListSchema(pool: Pool, typeKey: string): Promise<TypeSchemaEntry[]>;
+/**
+ * Full domain→key routing table for bot auto-classification
+ */
+export declare function ontoRoutingTable(pool: Pool): Promise<RoutingEntry[]>;
+/**
+ * List services grouped with domain counts
+ */
+export declare function ontoListServices(pool: Pool): Promise<ServiceInfo[]>;
+/**
+ * List service instances (entity_type = 'service')
+ */
+export declare function ontoListInstances(pool: Pool): Promise<ServiceInstance[]>;
 /**
  * Write ontology schemas to local cache
  */

package/dist/kb.js

@@ -51,11 +51,27 @@ exports.kbList = kbList;
 exports.kbSearch = kbSearch;
 exports.ontoList = ontoList;
 exports.ontoShow = ontoShow;
+exports.ontoListTypes = ontoListTypes;
 exports.ontoValidate = ontoValidate;
 exports.kbDigest = kbDigest;
+exports.kbGet = kbGet;
+exports.kbUpsert = kbUpsert;
+exports.ontoListSchema = ontoListSchema;
+exports.ontoRoutingTable = ontoRoutingTable;
+exports.ontoListServices = ontoListServices;
+exports.ontoListInstances = ontoListInstances;
 exports.ontoPullToLocal = ontoPullToLocal;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+function splitKey(combinedKey) {
+    const idx = combinedKey.indexOf('/');
+    if (idx === -1)
+        return { key: combinedKey, subKey: '' };
+    return { key: combinedKey.substring(0, idx), subKey: combinedKey.substring(idx + 1) };
+}
+function combineKey(key, subKey) {
+    return subKey ? `${key}/${subKey}` : key;
+}
 // ============================================================
 // Embedding
 // ============================================================
@@ -184,7 +200,7 @@ async function kbPull(pool, domain, cwd) {
     const client = await pool.connect();
     try {
         let query = `
-      SELECT domain, key, content, metadata, created_by, version,
+      SELECT domain, key, sub_key, content, metadata, created_by, version,
              created_at::text, updated_at::text
       FROM semo.knowledge_base
     `;
@@ -241,12 +257,13 @@ async function kbPush(pool, entries, createdBy, cwd) {
             try {
                 const embedding = embeddings[i];
                 const embeddingStr = embedding ? `[${embedding.join(",")}]` : null;
-                await client.query(`INSERT INTO semo.knowledge_base (domain, key, content, metadata, created_by, embedding)
-           VALUES ($1, $2, $3, $4, $5, $6::vector)
-           ON CONFLICT (domain, key) DO UPDATE SET
+                const { key: flatKey, subKey } = splitKey(entry.key);
+                await client.query(`INSERT INTO semo.knowledge_base (domain, key, sub_key, content, metadata, created_by, embedding)
+           VALUES ($1, $2, $3, $4, $5, $6, $7::vector)
+           ON CONFLICT (domain, key, sub_key) DO UPDATE SET
              content = EXCLUDED.content,
              metadata = EXCLUDED.metadata,
-             embedding = EXCLUDED.embedding`, [entry.domain, entry.key, entry.content, JSON.stringify(entry.metadata || {}), entry.created_by || createdBy || "unknown", embeddingStr]);
+             embedding = EXCLUDED.embedding`, [entry.domain, flatKey, subKey, entry.content, JSON.stringify(entry.metadata || {}), entry.created_by || createdBy || "unknown", embeddingStr]);
                 upserted++;
             }
             catch (err) {
@@ -306,14 +323,22 @@ async function kbList(pool, options) {
     const limit = options.limit || 50;
     const offset = options.offset || 0;
     try {
-        let query = "SELECT domain, key, content, metadata, created_by, version, updated_at::text FROM semo.knowledge_base";
+        let query = "SELECT domain, key, sub_key, content, metadata, created_by, version, updated_at::text FROM semo.knowledge_base";
         const params = [];
         let paramIdx = 1;
         if (options.domain) {
             query += ` WHERE domain = $${paramIdx++}`;
             params.push(options.domain);
         }
-        query += ` ORDER BY domain, key LIMIT $${paramIdx++} OFFSET $${paramIdx++}`;
+        else if (options.service) {
+            // Resolve service to domain list: service name itself + dot-notation domains
+            const serviceDomains = await resolveServiceDomainsLocal(client, options.service);
+            if (serviceDomains.length > 0) {
+                query += ` WHERE domain = ANY($${paramIdx++})`;
+                params.push(serviceDomains);
+            }
+        }
+        query += ` ORDER BY domain, key, sub_key LIMIT $${paramIdx++} OFFSET $${paramIdx++}`;
         params.push(limit, offset);
         const result = await client.query(query, params);
         return result.rows;
@@ -329,6 +354,11 @@ async function kbSearch(pool, query, options) {
     const client = await pool.connect();
     const limit = options.limit || 10;
     const mode = options.mode || "hybrid";
+    // Resolve service → domain list for filtering
+    let serviceDomains = null;
+    if (options.service && !options.domain) {
+        serviceDomains = await resolveServiceDomainsLocal(client, options.service);
+    }
     try {
         let results = [];
         // Try semantic search first (if mode allows and embedding API available)
@@ -338,7 +368,7 @@ async function kbSearch(pool, query, options) {
                 const embeddingStr = `[${queryEmbedding.join(",")}]`;
                 // Vector search on shared KB
                 let sql = `
-          SELECT domain, key, content, metadata, created_by, version, updated_at::text,
+          SELECT domain, key, sub_key, content, metadata, created_by, version, updated_at::text,
                  1 - (embedding <=> $1::vector) as score
           FROM semo.knowledge_base
           WHERE embedding IS NOT NULL
@@ -349,6 +379,10 @@ async function kbSearch(pool, query, options) {
                     sql += ` AND domain = $${paramIdx++}`;
                     params.push(options.domain);
                 }
+                else if (serviceDomains && serviceDomains.length > 0) {
+                    sql += ` AND domain = ANY($${paramIdx++})`;
+                    params.push(serviceDomains);
+                }
                 sql += ` ORDER BY embedding <=> $1::vector LIMIT $${paramIdx++}`;
                 params.push(limit);
                 const sharedResult = await client.query(sql, params);
@@ -368,7 +402,7 @@ async function kbSearch(pool, query, options) {
             // Build per-token ILIKE conditions + count matching tokens for scoring
             const tokenConditions = tokens.map(token => {
                 textParams.push(`%${token}%`);
-                return `(CASE WHEN content ILIKE $${tIdx} OR key ILIKE $${tIdx++} THEN 1 ELSE 0 END)`;
+                return `(CASE WHEN content ILIKE $${tIdx} OR key ILIKE $${tIdx} OR sub_key ILIKE $${tIdx++} THEN 1 ELSE 0 END)`;
             });
             // Score = 0.7 base + 0.15 * (matched_tokens / total_tokens), capped at 0.95
             const matchCountExpr = tokenConditions.length > 0
@@ -376,12 +410,12 @@ async function kbSearch(pool, query, options) {
                 : "0";
             const scoreExpr = `LEAST(0.95, 0.7 + 0.15 * (${matchCountExpr})::float / ${Math.max(tokens.length, 1)})`;
             // WHERE: any token matches
-            const whereTokens = tokens.map((_, i) => `(content ILIKE $${i + 1} OR key ILIKE $${i + 1})`);
+            const whereTokens = tokens.map((_, i) => `(content ILIKE $${i + 1} OR key ILIKE $${i + 1} OR sub_key ILIKE $${i + 1})`);
             const whereClause = whereTokens.length > 0
                 ? whereTokens.join(" OR ")
                 : "FALSE";
             let textSql = `
-        SELECT domain, key, content, metadata, created_by, version, updated_at::text,
+        SELECT domain, key, sub_key, content, metadata, created_by, version, updated_at::text,
                ${scoreExpr} as score
         FROM semo.knowledge_base
         WHERE ${whereClause}
@@ -390,6 +424,10 @@ async function kbSearch(pool, query, options) {
                 textSql += ` AND domain = $${tIdx++}`;
                 textParams.push(options.domain);
             }
+            else if (serviceDomains && serviceDomains.length > 0) {
+                textSql += ` AND domain = ANY($${tIdx++})`;
+                textParams.push(serviceDomains);
+            }
             textSql += ` ORDER BY score DESC, updated_at DESC LIMIT $${tIdx++}`;
             textParams.push(limit);
             const textResult = await client.query(textSql, textParams);
@@ -397,10 +435,10 @@ async function kbSearch(pool, query, options) {
             // Deduplicate by domain/key; if already in semantic results, boost its score
             const resultMap = new Map();
             for (const r of results) {
-                resultMap.set(`${r.domain}/${r.key}`, r);
+                resultMap.set(`${r.domain}/${r.key}/${r.sub_key}`, r);
             }
             for (const row of textResult.rows) {
-                const k = `${row.domain}/${row.key}`;
+                const k = `${row.domain}/${row.key}/${row.sub_key}`;
                 const existing = resultMap.get(k);
                 if (existing) {
                     // Boost: semantic match + text match = highest relevance
@@ -418,9 +456,9 @@ async function kbSearch(pool, query, options) {
     catch {
         // Ultimate fallback: simple ILIKE
         let sql = `
-      SELECT domain, key, content, metadata, created_by, version, updated_at::text
+      SELECT domain, key, sub_key, content, metadata, created_by, version, updated_at::text
       FROM semo.knowledge_base
-      WHERE content ILIKE $1 OR key ILIKE $1
+      WHERE content ILIKE $1 OR key ILIKE $1 OR sub_key ILIKE $1
     `;
         const params = [`%${query}%`];
         let paramIdx = 2;
@@ -447,8 +485,10 @@ async function ontoList(pool) {
     const client = await pool.connect();
     try {
         const result = await client.query(`
-      SELECT domain, schema, description, version, updated_at::text
-      FROM semo.ontology ORDER BY domain
+      SELECT domain, schema, description, version,
+             service, entity_type, parent, tags,
+             updated_at::text
+      FROM semo.ontology ORDER BY service NULLS FIRST, domain
     `);
         return result.rows;
     }
@@ -462,13 +502,52 @@ async function ontoList(pool) {
 async function ontoShow(pool, domain) {
     const client = await pool.connect();
     try {
-        const result = await client.query(`SELECT domain, schema, description, version, updated_at::text FROM semo.ontology WHERE domain = $1`, [domain]);
+        const result = await client.query(`SELECT domain, schema, description, version,
+              service, entity_type, parent, tags,
+              updated_at::text
+       FROM semo.ontology WHERE domain = $1`, [domain]);
         return result.rows[0] || null;
     }
     finally {
         client.release();
     }
 }
+/**
+ * List all ontology types (structural templates)
+ */
+async function ontoListTypes(pool) {
+    const client = await pool.connect();
+    try {
+        const result = await client.query(`
+      SELECT type_key, schema, description, version
+      FROM semo.ontology_types ORDER BY type_key
+    `);
+        return result.rows;
+    }
+    catch {
+        return []; // Table may not exist yet (pre-016 migration)
+    }
+    finally {
+        client.release();
+    }
+}
+/**
+ * Resolve a service name to its associated domain list.
+ * Uses ontology.service column + dot-notation domain detection.
+ */
+async function resolveServiceDomainsLocal(client, service) {
+    try {
+        const result = await client.query(`SELECT domain FROM semo.ontology WHERE service = $1
+       UNION
+       SELECT domain FROM semo.ontology WHERE domain LIKE $2
+       UNION
+       SELECT domain FROM semo.ontology WHERE domain = $1`, [service, `${service}.%`]);
+        return result.rows.map((r) => r.domain);
+    }
+    catch {
+        return [];
+    }
+}
 /**
  * Validate KB entries against ontology schema (basic JSON Schema validation)
  */
@@ -540,7 +619,7 @@ async function kbDigest(pool, since, domain) {
     const generatedAt = new Date().toISOString();
     try {
         let sql = `
-      SELECT domain, key, content, version, updated_at::text,
+      SELECT domain, key, sub_key, content, version, updated_at::text,
              CASE WHEN created_at > $1 THEN 'new' ELSE 'updated' END as change_type
       FROM semo.knowledge_base
       WHERE updated_at > $1 OR created_at > $1
@@ -559,6 +638,239 @@ async function kbDigest(pool, since, domain) {
         client.release();
     }
 }
+// ============================================================
+// KB Get / Upsert (CLI counterparts of MCP kb functions)
+// ============================================================
+/**
+ * Get a single KB entry by domain + key + sub_key
+ */
+async function kbGet(pool, domain, rawKey, rawSubKey) {
+    let key;
+    let subKey;
+    if (rawSubKey !== undefined) {
+        key = rawKey;
+        subKey = rawSubKey;
+    }
+    else {
+        const split = splitKey(rawKey);
+        key = split.key;
+        subKey = split.subKey;
+    }
+    const client = await pool.connect();
+    try {
+        const result = await client.query(`SELECT domain, key, sub_key, content, metadata, created_by, version,
+              created_at::text, updated_at::text
+       FROM semo.knowledge_base
+       WHERE domain = $1 AND key = $2 AND sub_key = $3`, [domain, key, subKey]);
+        return result.rows[0] || null;
+    }
+    finally {
+        client.release();
+    }
+}
+/**
+ * Upsert a single KB entry with domain/key validation and embedding generation
+ */
+async function kbUpsert(pool, entry) {
+    let key;
+    let subKey;
+    if (entry.sub_key !== undefined) {
+        key = entry.key;
+        subKey = entry.sub_key;
+    }
+    else {
+        const split = splitKey(entry.key);
+        key = split.key;
+        subKey = split.subKey;
+    }
+    // Domain validation
+    const client = await pool.connect();
+    try {
+        const ontoCheck = await client.query("SELECT domain FROM semo.ontology WHERE domain = $1", [entry.domain]);
+        if (ontoCheck.rows.length === 0) {
+            const known = await client.query("SELECT domain FROM semo.ontology ORDER BY domain");
+            const knownDomains = known.rows.map((r) => r.domain);
+            return {
+                success: false,
+                error: `도메인 '${entry.domain}'은(는) 온톨로지에 등록되지 않았습니다. 등록된 도메인: [${knownDomains.join(", ")}]`,
+            };
+        }
+    }
+    finally {
+        client.release();
+    }
+    // Key validation against type schema
+    try {
+        const schemaClient = await pool.connect();
+        try {
+            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 schemas = schemaResult.rows;
+                if (schemas.length > 0) {
+                    const match = schemas.find(s => s.scheme_key === key);
+                    if (!match) {
+                        const allowedKeys = schemas.map(s => s.key_type === "singleton" ? s.scheme_key : `${s.scheme_key}/{sub_key}`);
+                        return {
+                            success: false,
+                            error: `키 '${key}'은(는) '${entityType}' 타입의 스키마에 허용되지 않습니다. 허용 키: [${allowedKeys.join(", ")}]`,
+                        };
+                    }
+                    if (match.key_type === "singleton" && subKey !== "") {
+                        return { success: false, error: `키 '${key}'은(는) singleton이므로 sub_key가 비어야 합니다.` };
+                    }
+                    if (match.key_type === "collection" && subKey === "") {
+                        return { success: false, error: `키 '${key}'은(는) collection이므로 sub_key가 필요합니다.` };
+                    }
+                }
+            }
+        }
+        finally {
+            schemaClient.release();
+        }
+    }
+    catch {
+        // Validation failure is non-fatal
+    }
+    // Generate embedding (mandatory)
+    const fullKey = combineKey(key, subKey);
+    const text = `${fullKey}: ${entry.content}`;
+    const embedding = await generateEmbedding(text);
+    if (!embedding) {
+        const reason = process.env.OPENAI_API_KEY
+            ? "임베딩 생성 API 호출 실패"
+            : "OPENAI_API_KEY가 설정되지 않음";
+        return {
+            success: false,
+            error: `임베딩 생성 실패 — ${reason}. 임베딩 없이 저장하면 벡터 검색에서 누락되므로 저장이 거부됩니다.`,
+        };
+    }
+    const embeddingStr = `[${embedding.join(",")}]`;
+    const writeClient = await pool.connect();
+    try {
+        await writeClient.query(`INSERT INTO semo.knowledge_base (domain, key, sub_key, content, metadata, created_by, embedding)
+       VALUES ($1, $2, $3, $4, $5, $6, $7::vector)
+       ON CONFLICT (domain, key, sub_key) DO UPDATE SET
+         content = EXCLUDED.content,
+         metadata = EXCLUDED.metadata,
+         embedding = EXCLUDED.embedding`, [
+            entry.domain,
+            key,
+            subKey,
+            entry.content,
+            JSON.stringify(entry.metadata || {}),
+            entry.created_by || "semo-cli",
+            embeddingStr,
+        ]);
+        return { success: true };
+    }
+    catch (err) {
+        return { success: false, error: String(err) };
+    }
+    finally {
+        writeClient.release();
+    }
+}
+/**
+ * List type schema entries for a given entity type
+ */
+async function ontoListSchema(pool, typeKey) {
+    const client = await pool.connect();
+    try {
+        const result = await client.query(`SELECT type_key, scheme_key, scheme_description, required, value_hint, sort_order,
+              COALESCE(key_type, 'singleton') as key_type
+       FROM semo.kb_type_schema
+       WHERE type_key = $1
+       ORDER BY sort_order, scheme_key`, [typeKey]);
+        return result.rows;
+    }
+    catch {
+        return [];
+    }
+    finally {
+        client.release();
+    }
+}
+/**
+ * Full domain→key routing table for bot auto-classification
+ */
+async function ontoRoutingTable(pool) {
+    const client = await pool.connect();
+    try {
+        const result = await client.query(`
+      SELECT
+        o.domain,
+        o.entity_type,
+        o.service,
+        o.description AS domain_description,
+        s.scheme_key,
+        s.key_type,
+        s.scheme_description,
+        s.value_hint
+      FROM semo.ontology o
+      JOIN semo.kb_type_schema s ON s.type_key = o.entity_type
+      ORDER BY o.domain, s.sort_order
+    `);
+        return result.rows;
+    }
+    finally {
+        client.release();
+    }
+}
+/**
+ * List services grouped with domain counts
+ */
+async function ontoListServices(pool) {
+    const client = await pool.connect();
+    try {
+        const result = await client.query(`
+      SELECT service, COUNT(*)::int as domain_count,
+             ARRAY_AGG(domain ORDER BY domain) as domains
+      FROM semo.ontology
+      WHERE service IS NOT NULL
+      GROUP BY service
+      ORDER BY service
+    `);
+        return result.rows;
+    }
+    catch {
+        return [];
+    }
+    finally {
+        client.release();
+    }
+}
+/**
+ * List service instances (entity_type = 'service')
+ */
+async function ontoListInstances(pool) {
+    const client = await pool.connect();
+    try {
+        const result = await client.query(`
+      SELECT o.domain, o.description, o.service, o.tags,
+             COALESCE(
+               (SELECT ARRAY_AGG(o2.domain ORDER BY o2.domain)
+                FROM semo.ontology o2
+                WHERE o2.service = o.service AND o2.domain != o.domain),
+               '{}'
+             ) as scoped_domains,
+             (SELECT COUNT(*)::int FROM semo.knowledge_base k
+              WHERE k.domain = o.domain
+                 OR k.domain LIKE o.service || '.%') as entry_count
+      FROM semo.ontology o
+      WHERE o.entity_type = 'service'
+      ORDER BY o.domain
+    `);
+        return result.rows;
+    }
+    catch {
+        return [];
+    }
+    finally {
+        client.release();
+    }
+}
 /**
  * Write ontology schemas to local cache
  */

package/dist/slack-notify.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Slack 알림 유틸리티
+ *
+ * SLACK_WEBHOOK 환경변수에서 URL을 읽어 알림 전송.
+ * ~/.semo.env에서 자동 로드됨 (database.ts loadSemoEnv).
+ */
+export declare function sendSlackNotification(message: string, webhookUrl?: string): Promise<boolean>;
+export declare function formatTestFailureMessage(suiteId: string, runId: string, pass: number, fail: number, warn: number, failedLabels: string[]): string;

package/dist/slack-notify.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Slack 알림 유틸리티
+ *
+ * SLACK_WEBHOOK 환경변수에서 URL을 읽어 알림 전송.
+ * ~/.semo.env에서 자동 로드됨 (database.ts loadSemoEnv).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendSlackNotification = sendSlackNotification;
+exports.formatTestFailureMessage = formatTestFailureMessage;
+async function sendSlackNotification(message, webhookUrl) {
+    const url = webhookUrl || process.env.SLACK_WEBHOOK;
+    if (!url)
+        return false;
+    try {
+        const res = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ text: message }),
+            signal: AbortSignal.timeout(10000),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+function formatTestFailureMessage(suiteId, runId, pass, fail, warn, failedLabels) {
+    const timestamp = new Date().toLocaleString("ko-KR", {
+        timeZone: "Asia/Seoul",
+    });
+    const topFailed = failedLabels.slice(0, 10);
+    const more = failedLabels.length > 10 ? `\n  ... +${failedLabels.length - 10}건` : "";
+    return [
+        `🚨 *Test Suite Failed* — ${suiteId}`,
+        `Run: \`${runId.substring(0, 8)}\` | ${timestamp}`,
+        `Pass: ${pass} | Fail: ${fail} | Warn: ${warn}`,
+        ``,
+        `Failed:`,
+        ...topFailed.map((l) => `  • ${l}`),
+        more,
+    ]
+        .filter(Boolean)
+        .join("\n");
+}

package/dist/test-runners/workspace-audit.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Declarative Workspace Audit Runner
+ *
+ * bot_workspace_standard 테이블에서 규칙을 로드하고,
+ * bot_status에서 봇 목록을 가져와 동적으로 TC를 생성·실행.
+ *
+ * 로컬 스크립트 의존성 없음 — DB가 SoT.
+ */
+import { Pool } from "pg";
+export interface TestOutputLine {
+    type: "case" | "summary";
+    id?: string;
+    status?: "pass" | "fail" | "warn" | "skip";
+    label?: string;
+    detail?: string;
+}
+export declare function runDeclarativeWorkspaceAudit(pool: Pool): Promise<TestOutputLine[]>;