noormme 1.2.3 → 1.2.4

package/dist/esm/agentic/improvement/HiveLink.d.ts

@@ -10,11 +10,13 @@ export declare class HiveLink {
     private cortex;
     private config;
     private knowledgeTable;
+    private promoter;
+    private propagator;
+    private domainMaster;
     constructor(db: Kysely<any>, cortex: Cortex, config?: AgenticConfig);
     private get typedDb();
     /**
      * Promote high-confidence local knowledge to global "Hive" knowledge.
-     * This creates a new, session-agnostic entry or updates an existing global one.
      */
     broadcastKnowledge(options?: {
         minConfidence?: number;
@@ -23,12 +25,10 @@ export declare class HiveLink {
     }): Promise<number>;
     /**
      * Strengthen knowledge related to a specific domain (tag).
-     * Increases confidence of all items with this tag, representing "domain mastery".
      */
     syncDomain(domainTag: string, boostFactor?: number): Promise<number>;
     /**
      * Propagate high-performing capabilities globally using the "Sovereign Draft" protocol.
-     * Uses Bayesian Convergence and Shadow Promotion to avoid deadlocks.
      */
     broadcastSkills(): Promise<number>;
     /**

package/dist/esm/agentic/improvement/HiveLink.js

@@ -1,5 +1,7 @@
 /// <reference types="./HiveLink.d.ts" />
-import { sql } from '../../raw-builder/sql.js';
+import { KnowledgePromoter } from './hive/KnowledgePromoter.js';
+import { SkillPropagator } from './hive/SkillPropagator.js';
+import { DomainMaster } from './hive/DomainMaster.js';
 /**
  * HiveLink facilitates "Collective Intelligence" by synchronizing
  * knowledge and lessons learned across different agent personas.
@@ -9,108 +11,53 @@ export class HiveLink {
     cortex;
     config;
     knowledgeTable;
+    promoter;
+    propagator;
+    domainMaster;
     constructor(db, cortex, config = {}) {
         this.db = db;
         this.cortex = cortex;
         this.config = config;
         this.knowledgeTable = config.knowledgeTable || 'agent_knowledge_base';
+        this.promoter = new KnowledgePromoter();
+        this.propagator = new SkillPropagator();
+        this.domainMaster = new DomainMaster();
     }
     get typedDb() {
         return this.db;
     }
     /**
      * Promote high-confidence local knowledge to global "Hive" knowledge.
-     * This creates a new, session-agnostic entry or updates an existing global one.
      */
     async broadcastKnowledge(options = {}) {
         const minConfidence = options.minConfidence ?? 0.9;
         const limit = options.limit ?? 100;
         const offset = options.offset ?? 0;
         console.log(`[HiveLink] Broadcasting knowledge (limit=${limit}, offset=${offset}) with confidence >= ${minConfidence}`);
-        // Find high-confidence items that are "local" (have a source_session_id)
         const items = (await this.typedDb
             .selectFrom(this.knowledgeTable)
             .selectAll()
             .where('confidence', '>=', minConfidence)
-            .where('source_session_id', 'is not', null) // Only local items
+            .where('source_session_id', 'is not', null)
             .limit(limit)
             .offset(offset)
             .execute());
         let promotedCount = 0;
         for (const item of items) {
-            await this.db.transaction().execute(async (trx) => {
-                // Check if a global version already exists
-                const existingGlobal = await trx
-                    .selectFrom(this.knowledgeTable)
-                    .selectAll()
-                    .where('entity', '=', item.entity)
-                    .where('fact', '=', item.fact)
-                    .where('source_session_id', 'is', null)
-                    .forUpdate() // Audit Phase 15: prevent concurrent promotion duplication
-                    .executeTakeFirst();
-                if (existingGlobal) {
-                    // Reinforce existing global knowledge
-                    const newConfidence = Math.min(0.99, Math.max(existingGlobal.confidence, item.confidence) + 0.01);
-                    await trx
-                        .updateTable(this.knowledgeTable)
-                        .set({
-                        confidence: newConfidence,
-                        updated_at: new Date(),
-                    })
-                        .where('id', '=', existingGlobal.id)
-                        .execute();
-                }
-                else {
-                    // Create new global knowledge
-                    const tags = item.tags ? [...item.tags] : [];
-                    if (!tags.includes('hive_mind'))
-                        tags.push('hive_mind');
-                    await trx
-                        .insertInto(this.knowledgeTable)
-                        .values({
-                        entity: item.entity,
-                        fact: item.fact,
-                        confidence: item.confidence,
-                        source_session_id: null,
-                        tags: JSON.stringify(tags),
-                        metadata: JSON.stringify({
-                            ...item.metadata,
-                            promoted_from: item.id,
-                            promoted_at: new Date(),
-                        }),
-                        created_at: new Date(),
-                        updated_at: new Date(),
-                    })
-                        .execute();
-                    promotedCount++;
-                }
-            });
+            const promoted = await this.promoter.promote(this.db, this.cortex, this.config, this.knowledgeTable, item);
+            if (promoted)
+                promotedCount++;
         }
         return promotedCount;
     }
     /**
      * Strengthen knowledge related to a specific domain (tag).
-     * Increases confidence of all items with this tag, representing "domain mastery".
      */
     async syncDomain(domainTag, boostFactor = 0.05) {
-        console.log(`[HiveLink] Syncing/Boosting domain '${domainTag}' (Set-Based)`);
-        // Use a single SQL update for high throughput
-        const result = await this.db
-            .updateTable(this.knowledgeTable)
-            .set({
-            confidence: sql `MIN(1.0, confidence + ${boostFactor})`,
-            updated_at: new Date(),
-        })
-            .where('tags', 'like', `%"${domainTag}"%`)
-            .where('confidence', '<', 1.0)
-            .execute();
-        // Kysely update .execute() returns an array of results or similar depending on adapter
-        // For simple update, we might just return the count if supported or 1
-        return Number(result[0]?.numUpdatedRows ?? 1);
+        return this.domainMaster.boostDomain(this.db, this.knowledgeTable, domainTag, boostFactor);
     }
     /**
      * Propagate high-performing capabilities globally using the "Sovereign Draft" protocol.
-     * Uses Bayesian Convergence and Shadow Promotion to avoid deadlocks.
      */
     async broadcastSkills() {
         if (!this.config.evolution?.enableHiveLink &&
@@ -119,96 +66,7 @@ export class HiveLink {
             return 0;
         }
         console.log(`[HiveLink] Executing Sovereign Draft for emergent skills...`);
-        let broadcastCount = 0;
-        const capTable = this.config.capabilitiesTable || 'agent_capabilities';
-        // 1. Resolve Verified Skills with Bayesian "Alpha" selection
-        const verifiedSkills = await this.cortex.capabilities.getCapabilities('verified');
-        // Group verified skills by lineage (base tool name)
-        const lineageGroups = new Map();
-        for (const skill of verifiedSkills) {
-            const meta = typeof skill.metadata === 'string' ? JSON.parse(skill.metadata) : (skill.metadata || {});
-            const lineage = meta.lineage || skill.name;
-            if (!lineageGroups.has(lineage))
-                lineageGroups.set(lineage, []);
-            lineageGroups.get(lineage).push({ skill, meta });
-        }
-        for (const [lineage, variants] of lineageGroups.entries()) {
-            // Bayesian Winner Selection
-            // Score = (anchored_reliability * totalCount + K * prior) / (totalCount + K)
-            // For simplicity, we use anchored_reliability which already incorporates this weighting
-            const alphaCandidate = variants.reduce((prev, curr) => {
-                const pAnchored = prev.meta.anchored_reliability ?? 0;
-                const cAnchored = curr.meta.anchored_reliability ?? 0;
-                return cAnchored > pAnchored ? curr : prev;
-            });
-            // Non-Blocking Set Update: Flag Alpha and Shadow versions
-            await this.db.transaction().execute(async (trx) => {
-                const currentMeta = alphaCandidate.meta || {};
-                const updatedMeta = {
-                    ...currentMeta,
-                    is_alpha: true,
-                    broadcasted: true,
-                    broadcasted_at: new Date()
-                };
-                // Flag the winner as Alpha
-                // Audit Phase 15: Lock candidate before promotion
-                const winner = await trx
-                    .selectFrom(capTable)
-                    .select('id')
-                    .where('id', '=', alphaCandidate.skill.id)
-                    .forUpdate()
-                    .executeTakeFirst();
-                if (winner) {
-                    await trx
-                        .updateTable(capTable)
-                        .set({
-                        metadata: JSON.stringify(updatedMeta),
-                    })
-                        .where('id', '=', winner.id)
-                        .execute();
-                }
-                // Flag others in the same lineage as Shadow (Dialect-safe approach)
-                const shadowIds = variants
-                    .filter(v => v.skill.id !== alphaCandidate.skill.id)
-                    .map(v => v.skill.id);
-                if (shadowIds.length > 0) {
-                    // We fetch and update individually or use a bulk update if the dialect supports complex JSON manipulation.
-                    // For maximum compatibility (Postgres/SQLite), we do it in a loop for the shadows if the count is small.
-                    for (const sid of shadowIds) {
-                        const sMatch = variants.find(v => v.skill.id === sid);
-                        const sMeta = sMatch?.meta || {};
-                        await trx.updateTable(capTable)
-                            .set({
-                            metadata: JSON.stringify({ ...sMeta, is_alpha: false, is_shadow: true }),
-                            status: 'experimental'
-                        })
-                            .where('id', '=', sid)
-                            .execute();
-                    }
-                }
-            });
-            broadcastCount += variants.length;
-        }
-        // 2. Broadcast Blacklisted Skills (Immune Prophet)
-        const blacklisted = await this.cortex.capabilities.getCapabilities('blacklisted');
-        const blackIDs = blacklisted
-            .filter(s => {
-            const meta = typeof s.metadata === 'string' ? JSON.parse(s.metadata) : (s.metadata || {});
-            return !meta.broadcasted;
-        })
-            .map(s => s.id);
-        if (blackIDs.length > 0) {
-            await this.db
-                .updateTable(capTable)
-                .set({
-                metadata: sql `json_set(metadata, '$.broadcasted', true, '$.hive_blacklisted', true)`,
-                updated_at: new Date()
-            })
-                .where('id', 'in', blackIDs)
-                .execute();
-            broadcastCount += blackIDs.length;
-        }
-        return broadcastCount;
+        return this.propagator.propagate(this.db, this.cortex, this.config);
     }
     /**
      * Simple semver-style version comparison.

package/dist/esm/agentic/improvement/KnowledgeDistiller.d.ts

@@ -35,50 +35,33 @@ export declare class KnowledgeDistiller {
     private knowledgeTable;
     private linksTable;
     private bloomFilter;
-    constructor(db: Kysely<any>, // accepting any Kysely but casting internally for our specific tables
-    config?: AgenticConfig);
-    /**
-     * typedDb helper to cast the generic DB to our specific schema
-     */
-    private get typedDb();
+    private distiller;
+    private challenger;
+    private architect;
+    private consolidator;
+    constructor(db: Kysely<any>, config?: AgenticConfig);
     /**
      * Add or update a knowledge item with robust merging and transaction support.
      */
     distill(entity: string, fact: string, confidence: number, sourceSessionId?: string | number, tags?: string[], metadata?: Record<string, any>, source?: 'user' | 'assistant' | 'system'): Promise<KnowledgeItem>;
+    /**
+     * Manually challenge an existing fact with competing information.
+     */
+    challengeKnowledge(entity: string, fact: string, confidence: number, trxOrDb?: any): Promise<void>;
     /**
      * Verify and reinforce existing knowledge.
-     * Increases confidence if the fact matches.
      */
     verifyKnowledge(id: number | string, reinforcement?: number): Promise<KnowledgeItem | null>;
     /**
      * Search knowledge by entity with optional tag filtering.
-     * Records a "hit" for each retrieved item to track utility.
      */
     getKnowledgeByEntity(entity: string, filterTags?: string[]): Promise<KnowledgeItem[]>;
     /**
-     * Record a retrieval hit for a knowledge item.
+     * Record a retrieval hit for a knowledge item and emit hotspot telemetry.
      */
     recordHit(id: number | string): Promise<void>;
-    /**
-     * Calculate the "Fitness" of a memory item.
-     * Score = (Confidence * 0.4) + (SignalToNoise * 0.4) + (SourceMultiplier * 0.2)
-     */
-    calculateFitness(item: KnowledgeItem): number;
-    /**
-     * Challenge existing knowledge with new evidence.
-     * If confidence of new fact is high and contradicts existing ones (same entity, different fact),
-     * we degrade the confidence of the old facts.
-     */
-    challengeKnowledge(entity: string, competingFact: string, confidence: number, trxOrDb?: any): Promise<void>;
-    /**
-     * Automatic Semantic Linking
-     * Scans for entity mentions in facts and creates links.
-     * Production Hardening: Uses batched cross-similarity and NER-style tokenization.
-     */
-    private autoLinkKnowledge;
     /**
      * Link two knowledge items together with a relationship.
-     * Transaction-aware version.
      */
     linkKnowledge(sourceId: number | string, targetId: number | string, relationship: string, metadata?: Record<string, any>, trxOrDb?: any): Promise<void>;
     /**
@@ -97,10 +80,13 @@ export declare class KnowledgeDistiller {
     pruneLowConfidence(threshold?: number): Promise<number>;
     /**
      * Consolidate knowledge by merging similar facts for the same entity.
-     * Production Hardening: Iterative bucketed approach to avoid recursive stack issues.
      */
     consolidateKnowledge(): Promise<number>;
-    private mergeItems;
+    /**
+     * Calculate the "Fitness" of a knowledge item.
+     * Score = (Confidence * 0.4) + (SignalToNoise * 0.4) + (SourceMultiplier * 0.2)
+     */
+    calculateFitness(item: KnowledgeItem): number;
     private bloomHash;
     private parseKnowledge;
 }