@team-semicolon/semo-cli 4.1.5 → 4.3.0

package/dist/kb.d.ts

@@ -27,86 +27,78 @@ export interface KBEntry {
     created_at?: string;
     updated_at?: string;
 }
-export interface BotKBEntry extends KBEntry {
-    bot_id: string;
-    synced_at?: string;
-}
 export interface OntologyDomain {
     domain: string;
     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;
         domains: Record<string, number>;
         lastUpdated: string | null;
     };
-    bot: {
-        total: number;
-        domains: Record<string, number>;
-        lastUpdated: string | null;
-        lastSynced: string | null;
-    };
 }
-export interface KBDiffResult {
-    added: KBEntry[];
-    removed: KBEntry[];
-    modified: Array<{
-        local: KBEntry;
-        remote: KBEntry;
-    }>;
-    unchanged: number;
+export interface KBDigestEntry {
+    domain: string;
+    key: string;
+    content: string;
+    version: number;
+    change_type: 'new' | 'updated';
+    updated_at: string;
+}
+export interface KBDigestResult {
+    changes: KBDigestEntry[];
+    since: string;
+    generatedAt: string;
 }
 export interface SyncState {
-    botId: string;
     lastPull: string | null;
     lastPush: string | null;
     sharedCount: number;
-    botCount: number;
 }
 /**
- * Get shared KB entries from semo.knowledge_base
+ * Pull KB entries from semo.knowledge_base to local .kb/
  */
-export declare function kbPull(pool: Pool, botId: string, domain?: string, cwd?: string): Promise<{
-    shared: KBEntry[];
-    bot: BotKBEntry[];
-}>;
+export declare function kbPull(pool: Pool, domain?: string, cwd?: string): Promise<KBEntry[]>;
 /**
- * Push local KB entries to database
+ * Push local KB entries to database (knowledge_base only)
  */
-export declare function kbPush(pool: Pool, botId: string, entries: KBEntry[], target?: "shared" | "bot", cwd?: string): Promise<{
+export declare function kbPush(pool: Pool, entries: KBEntry[], createdBy?: string, cwd?: string): Promise<{
     upserted: number;
     errors: string[];
 }>;
 /**
- * Get KB status for a bot
+ * Get KB status
  */
-export declare function kbStatus(pool: Pool, botId: string): Promise<KBStatusInfo>;
+export declare function kbStatus(pool: Pool): Promise<KBStatusInfo>;
 /**
  * List KB entries with optional filters
  */
 export declare function kbList(pool: Pool, options: {
     domain?: string;
-    botId?: string;
+    service?: string;
     limit?: number;
     offset?: number;
-}): Promise<{
-    shared: KBEntry[];
-    bot: BotKBEntry[];
-}>;
-/**
- * Diff local KB files against database
- */
-export declare function kbDiff(pool: Pool, botId: string, cwd: string): Promise<KBDiffResult>;
+}): Promise<KBEntry[]>;
 /**
  * Search KB — hybrid: vector similarity (if embedding available) + text fallback
  */
 export declare function kbSearch(pool: Pool, query: string, options: {
     domain?: string;
-    botId?: string;
+    service?: string;
     limit?: number;
     mode?: "semantic" | "text" | "hybrid";
 }): Promise<KBEntry[]>;
@@ -118,6 +110,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)
  */
@@ -128,6 +124,11 @@ export declare function ontoValidate(pool: Pool, domain: string, entries?: KBEnt
         errors: string[];
     }>;
 }>;
+/**
+ * Generate KB change digest based on a since timestamp.
+ * Returns all KB changes since the given ISO timestamp.
+ */
+export declare function kbDigest(pool: Pool, since: string, domain?: string): Promise<KBDigestResult>;
 /**
  * Write ontology schemas to local cache
  */

package/dist/kb.js

@@ -48,11 +48,12 @@ exports.kbPull = kbPull;
 exports.kbPush = kbPush;
 exports.kbStatus = kbStatus;
 exports.kbList = kbList;
-exports.kbDiff = kbDiff;
 exports.kbSearch = kbSearch;
 exports.ontoList = ontoList;
 exports.ontoShow = ontoShow;
+exports.ontoListTypes = ontoListTypes;
 exports.ontoValidate = ontoValidate;
+exports.kbDigest = kbDigest;
 exports.ontoPullToLocal = ontoPullToLocal;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -153,7 +154,7 @@ function readSyncState(cwd) {
             // corrupted file
         }
     }
-    return { botId: "", lastPull: null, lastPush: null, sharedCount: 0, botCount: 0 };
+    return { lastPull: null, lastPush: null, sharedCount: 0 };
 }
 function writeSyncState(cwd, state) {
     const kbDir = ensureKBDir(cwd);
@@ -178,88 +179,75 @@ function readKBFile(cwd, filename) {
 // Database Operations
 // ============================================================
 /**
- * Get shared KB entries from semo.knowledge_base
+ * Pull KB entries from semo.knowledge_base to local .kb/
  */
-async function kbPull(pool, botId, domain, cwd) {
+async function kbPull(pool, domain, cwd) {
     const client = await pool.connect();
     try {
-        // Shared KB
-        let sharedQuery = `
+        let query = `
       SELECT domain, key, content, metadata, created_by, version,
              created_at::text, updated_at::text
       FROM semo.knowledge_base
     `;
-        const sharedParams = [];
+        const params = [];
         if (domain) {
-            sharedQuery += " WHERE domain = $1";
-            sharedParams.push(domain);
+            query += " WHERE domain = $1";
+            params.push(domain);
         }
-        sharedQuery += " ORDER BY domain, key";
-        const sharedResult = await client.query(sharedQuery, sharedParams);
-        const shared = sharedResult.rows;
-        // Bot-specific KB
-        let botQuery = `
-      SELECT bot_id, domain, key, content, metadata, version,
-             synced_at::text, created_at::text, updated_at::text
-      FROM semo.bot_knowledge
-      WHERE bot_id = $1
-    `;
-        const botParams = [botId];
-        if (domain) {
-            botQuery += " AND domain = $2";
-            botParams.push(domain);
-        }
-        botQuery += " ORDER BY domain, key";
-        const botResult = await client.query(botQuery, botParams);
-        const bot = botResult.rows;
-        // Write to local files if cwd provided
+        query += " ORDER BY domain, key";
+        const result = await client.query(query, params);
+        const entries = result.rows;
         if (cwd) {
-            writeKBFile(cwd, "team.json", shared);
-            writeKBFile(cwd, "bot.json", bot);
+            writeKBFile(cwd, "team.json", entries);
             const state = readSyncState(cwd);
-            state.botId = botId;
             state.lastPull = new Date().toISOString();
-            state.sharedCount = shared.length;
-            state.botCount = bot.length;
+            state.sharedCount = entries.length;
             writeSyncState(cwd, state);
         }
-        return { shared, bot };
+        return entries;
     }
     finally {
         client.release();
     }
 }
 /**
- * Push local KB entries to database
+ * Push local KB entries to database (knowledge_base only)
  */
-async function kbPush(pool, botId, entries, target = "bot", cwd) {
+async function kbPush(pool, entries, createdBy, cwd) {
     const client = await pool.connect();
     let upserted = 0;
     const errors = [];
     try {
-        await client.query("BEGIN");
+        // Domain validation: check all domains against ontology before transaction
+        const ontologyResult = await client.query("SELECT domain FROM semo.ontology");
+        const knownDomains = new Set(ontologyResult.rows.map((r) => r.domain));
+        const invalidEntries = [];
+        const validEntries = [];
         for (const entry of entries) {
+            if (knownDomains.has(entry.domain)) {
+                validEntries.push(entry);
+            }
+            else {
+                invalidEntries.push(`${entry.domain}/${entry.key}: 미등록 도메인 '${entry.domain}'`);
+            }
+        }
+        if (invalidEntries.length > 0) {
+            errors.push(...invalidEntries);
+        }
+        await client.query("BEGIN");
+        const texts = validEntries.map(e => `${e.key}: ${e.content}`);
+        const embeddings = await generateEmbeddings(texts);
+        for (let i = 0; i < validEntries.length; i++) {
+            const entry = validEntries[i];
             try {
-                // Generate embedding for content
-                const embedding = await generateEmbedding(`${entry.key}: ${entry.content}`);
+                const embedding = embeddings[i];
                 const embeddingStr = embedding ? `[${embedding.join(",")}]` : null;
-                if (target === "shared") {
-                    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
-               content = EXCLUDED.content,
-               metadata = EXCLUDED.metadata,
-               embedding = EXCLUDED.embedding`, [entry.domain, entry.key, entry.content, JSON.stringify(entry.metadata || {}), entry.created_by || botId, embeddingStr]);
-                }
-                else {
-                    await client.query(`INSERT INTO semo.bot_knowledge (bot_id, domain, key, content, metadata, synced_at, embedding)
-             VALUES ($1, $2, $3, $4, $5, NOW(), $6::vector)
-             ON CONFLICT (bot_id, domain, key) DO UPDATE SET
-               content = EXCLUDED.content,
-               metadata = EXCLUDED.metadata,
-               synced_at = NOW(),
-               embedding = EXCLUDED.embedding`, [botId, entry.domain, entry.key, entry.content, JSON.stringify(entry.metadata || {}), embeddingStr]);
-                }
+                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
+             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]);
                 upserted++;
             }
             catch (err) {
@@ -269,7 +257,6 @@ async function kbPush(pool, botId, entries, target = "bot", cwd) {
         await client.query("COMMIT");
         if (cwd) {
             const state = readSyncState(cwd);
-            state.botId = botId;
             state.lastPush = new Date().toISOString();
             writeSyncState(cwd, state);
         }
@@ -284,12 +271,11 @@ async function kbPush(pool, botId, entries, target = "bot", cwd) {
     return { upserted, errors };
 }
 /**
- * Get KB status for a bot
+ * Get KB status
  */
-async function kbStatus(pool, botId) {
+async function kbStatus(pool) {
     const client = await pool.connect();
     try {
-        // Shared KB stats
         const sharedStats = await client.query(`
       SELECT domain, COUNT(*)::int as count
       FROM semo.knowledge_base
@@ -301,31 +287,12 @@ async function kbStatus(pool, botId) {
         for (const row of sharedStats.rows) {
             sharedDomains[row.domain] = row.count;
         }
-        // Bot KB stats
-        const botStats = await client.query(`
-      SELECT domain, COUNT(*)::int as count
-      FROM semo.bot_knowledge WHERE bot_id = $1
-      GROUP BY domain ORDER BY domain
-    `, [botId]);
-        const botTotal = await client.query(`SELECT COUNT(*)::int as total FROM semo.bot_knowledge WHERE bot_id = $1`, [botId]);
-        const botLastUpdated = await client.query(`SELECT MAX(updated_at)::text as last FROM semo.bot_knowledge WHERE bot_id = $1`, [botId]);
-        const botLastSynced = await client.query(`SELECT MAX(synced_at)::text as last FROM semo.bot_knowledge WHERE bot_id = $1`, [botId]);
-        const botDomains = {};
-        for (const row of botStats.rows) {
-            botDomains[row.domain] = row.count;
-        }
         return {
             shared: {
                 total: sharedTotal.rows[0]?.total || 0,
                 domains: sharedDomains,
                 lastUpdated: sharedLastUpdated.rows[0]?.last || null,
             },
-            bot: {
-                total: botTotal.rows[0]?.total || 0,
-                domains: botDomains,
-                lastUpdated: botLastUpdated.rows[0]?.last || null,
-                lastSynced: botLastSynced.rows[0]?.last || null,
-            },
         };
     }
     finally {
@@ -340,79 +307,30 @@ async function kbList(pool, options) {
     const limit = options.limit || 50;
     const offset = options.offset || 0;
     try {
-        // Shared
-        let sharedQuery = "SELECT domain, key, content, metadata, created_by, version, updated_at::text FROM semo.knowledge_base";
-        const sharedParams = [];
+        let query = "SELECT domain, key, content, metadata, created_by, version, updated_at::text FROM semo.knowledge_base";
+        const params = [];
         let paramIdx = 1;
         if (options.domain) {
-            sharedQuery += ` WHERE domain = $${paramIdx++}`;
-            sharedParams.push(options.domain);
+            query += ` WHERE domain = $${paramIdx++}`;
+            params.push(options.domain);
         }
-        sharedQuery += ` ORDER BY domain, key LIMIT $${paramIdx++} OFFSET $${paramIdx++}`;
-        sharedParams.push(limit, offset);
-        const sharedResult = await client.query(sharedQuery, sharedParams);
-        // Bot
-        let bot = [];
-        if (options.botId) {
-            let botQuery = "SELECT bot_id, domain, key, content, metadata, version, synced_at::text, updated_at::text FROM semo.bot_knowledge WHERE bot_id = $1";
-            const botParams = [options.botId];
-            let bParamIdx = 2;
-            if (options.domain) {
-                botQuery += ` AND domain = $${bParamIdx++}`;
-                botParams.push(options.domain);
+        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);
             }
-            botQuery += ` ORDER BY domain, key LIMIT $${bParamIdx++} OFFSET $${bParamIdx++}`;
-            botParams.push(limit, offset);
-            const botResult = await client.query(botQuery, botParams);
-            bot = botResult.rows;
         }
-        return { shared: sharedResult.rows, bot };
+        query += ` ORDER BY domain, key LIMIT $${paramIdx++} OFFSET $${paramIdx++}`;
+        params.push(limit, offset);
+        const result = await client.query(query, params);
+        return result.rows;
     }
     finally {
         client.release();
     }
 }
-/**
- * Diff local KB files against database
- */
-async function kbDiff(pool, botId, cwd) {
-    const localShared = readKBFile(cwd, "team.json");
-    const localBot = readKBFile(cwd, "bot.json");
-    const localAll = [...localShared, ...localBot];
-    const { shared: remoteShared, bot: remoteBot } = await kbPull(pool, botId);
-    const remoteAll = [...remoteShared, ...remoteBot];
-    const localMap = new Map(localAll.map(e => [`${e.domain}/${e.key}`, e]));
-    const remoteMap = new Map(remoteAll.map(e => [`${e.domain}/${e.key}`, e]));
-    const added = [];
-    const removed = [];
-    const modified = [];
-    let unchanged = 0;
-    // Remote entries not in local → added
-    for (const [k, v] of remoteMap) {
-        if (!localMap.has(k)) {
-            added.push(v);
-        }
-    }
-    // Local entries not in remote → removed
-    for (const [k, v] of localMap) {
-        if (!remoteMap.has(k)) {
-            removed.push(v);
-        }
-    }
-    // Both exist → check content
-    for (const [k, local] of localMap) {
-        const remote = remoteMap.get(k);
-        if (remote) {
-            if (local.content !== remote.content || JSON.stringify(local.metadata) !== JSON.stringify(remote.metadata)) {
-                modified.push({ local, remote });
-            }
-            else {
-                unchanged++;
-            }
-        }
-    }
-    return { added, removed, modified, unchanged };
-}
 /**
  * Search KB — hybrid: vector similarity (if embedding available) + text fallback
  */
@@ -420,6 +338,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)
@@ -440,31 +363,14 @@ 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);
                 results = sharedResult.rows;
-                // Also search bot_knowledge if botId specified
-                if (options.botId) {
-                    let botSql = `
-            SELECT bot_id, domain, key, content, metadata, version, updated_at::text,
-                   1 - (embedding <=> $1::vector) as score
-            FROM semo.bot_knowledge
-            WHERE bot_id = $2 AND embedding IS NOT NULL
-          `;
-                    const botParams = [embeddingStr, options.botId];
-                    let bIdx = 3;
-                    if (options.domain) {
-                        botSql += ` AND domain = $${bIdx++}`;
-                        botParams.push(options.domain);
-                    }
-                    botSql += ` ORDER BY embedding <=> $1::vector LIMIT $${bIdx++}`;
-                    botParams.push(limit);
-                    const botResult = await client.query(botSql, botParams);
-                    results = [...results, ...botResult.rows]
-                        .sort((a, b) => (b.score || 0) - (a.score || 0))
-                        .slice(0, limit);
-                }
                 // If we got results from semantic search and mode is not hybrid, return
                 if (results.length > 0 && mode === "semantic") {
                     return results;
@@ -472,31 +378,62 @@ async function kbSearch(pool, query, options) {
             }
         }
         // Text search (fallback or hybrid supplement)
+        // Split query into tokens and match ANY token via ILIKE (Korean-friendly)
         if (mode !== "semantic" || results.length === 0) {
+            const tokens = query.split(/\s+/).filter(t => t.length >= 2);
+            const textParams = [];
+            let tIdx = 1;
+            // 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)`;
+            });
+            // Score = 0.7 base + 0.15 * (matched_tokens / total_tokens), capped at 0.95
+            const matchCountExpr = tokenConditions.length > 0
+                ? tokenConditions.join(" + ")
+                : "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 whereClause = whereTokens.length > 0
+                ? whereTokens.join(" OR ")
+                : "FALSE";
             let textSql = `
         SELECT domain, key, content, metadata, created_by, version, updated_at::text,
-               0.0 as score
+               ${scoreExpr} as score
         FROM semo.knowledge_base
-        WHERE content ILIKE $1 OR key ILIKE $1
+        WHERE ${whereClause}
       `;
-            const textParams = [`%${query}%`];
-            let tIdx = 2;
             if (options.domain) {
                 textSql += ` AND domain = $${tIdx++}`;
                 textParams.push(options.domain);
             }
-            textSql += ` ORDER BY updated_at DESC LIMIT $${tIdx++}`;
+            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);
-            // Merge: deduplicate by domain/key, prefer semantic results
-            const seen = new Set(results.map((r) => `${r.domain}/${r.key}`));
+            // Merge: text matches get priority score (0.85) for exact keyword hits
+            // 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);
+            }
             for (const row of textResult.rows) {
                 const k = `${row.domain}/${row.key}`;
-                if (!seen.has(k)) {
-                    results.push(row);
-                    seen.add(k);
+                const existing = resultMap.get(k);
+                if (existing) {
+                    // Boost: semantic match + text match = highest relevance
+                    existing.score = Math.max(Number(existing.score), 0.85);
+                }
+                else {
+                    resultMap.set(k, row);
                 }
             }
+            // Sort by score descending
+            results = Array.from(resultMap.values()).sort((a, b) => Number(b.score) - Number(a.score));
         }
         return results.slice(0, limit);
     }
@@ -532,8 +469,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;
     }
@@ -547,13 +486,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)
  */
@@ -613,6 +591,37 @@ async function ontoValidate(pool, domain, entries) {
     }
     return { valid, invalid };
 }
+// ============================================================
+// KB Digest
+// ============================================================
+/**
+ * Generate KB change digest based on a since timestamp.
+ * Returns all KB changes since the given ISO timestamp.
+ */
+async function kbDigest(pool, since, domain) {
+    const client = await pool.connect();
+    const generatedAt = new Date().toISOString();
+    try {
+        let sql = `
+      SELECT domain, 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
+    `;
+        const params = [since];
+        let paramIdx = 2;
+        if (domain) {
+            sql += ` AND domain = $${paramIdx++}`;
+            params.push(domain);
+        }
+        sql += ` ORDER BY updated_at DESC LIMIT 100`;
+        const result = await client.query(sql, params);
+        return { changes: result.rows, since, generatedAt };
+    }
+    finally {
+        client.release();
+    }
+}
 /**
  * Write ontology schemas to local cache
  */

package/package.json

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