genesis-ai-cli 10.3.0 → 10.5.0

package/dist/src/active-inference/core.d.ts

@@ -59,6 +59,11 @@ export declare class ActiveInferenceEngine {
     private computeLikelihoods;
     private updateFactor;
     private computeEFE;
+    /**
+     * Compute expected information gain for an action
+     * This is the epistemic value - how much the action teaches us about the world
+     */
+    private computeInformationGain;
     private predictNextState;
     private computeSurprise;
     /**

package/dist/src/active-inference/core.js

@@ -54,9 +54,9 @@ function entropy(probs) {
 }
 /**
  * KL divergence: D_KL(P || Q)
- * Reserved for future variational free energy computation
+ * Used for information gain and variational free energy computation
  */
-function _klDivergence(p, q) {
+function klDivergence(p, q) {
     return p.reduce((acc, pi, i) => {
         if (pi > 1e-10 && q[i] > 1e-10) {
             return acc + pi * Math.log(pi / q[i]);
@@ -442,28 +442,86 @@ class ActiveInferenceEngine {
     }
     computeEFE(actionIdx) {
         // Expected Free Energy for a single action
+        // EFE = Ambiguity + Risk - Information Gain (Friston 2017)
+        //
+        // - Ambiguity: H(o|s,π) - observational uncertainty
+        // - Risk: D_KL[Q(s|π) || P(s)] - divergence from preferred outcomes
+        // - Information Gain: E[D_KL[Q(s|o,π) || Q(s|π)]] - epistemic value (SUBTRACTED!)
         // 1. Predicted next state distribution Q(s'|a)
         const predictedViability = this.predictNextState(this.beliefs.viability, this.B.viability, actionIdx);
         const predictedWorldState = this.predictNextState(this.beliefs.worldState, this.B.worldState, actionIdx);
         const predictedCoupling = this.predictNextState(this.beliefs.coupling, this.B.coupling, actionIdx);
         const predictedGoalProgress = this.predictNextState(this.beliefs.goalProgress, this.B.goalProgress, actionIdx);
-        // 2. Expected observations under predicted states
+        // 2. Expected observations under predicted states P(o|s')
         const expectedEnergy = matVec(this.A.energy, predictedViability);
         const expectedPhi = matVec(this.A.phi, predictedWorldState);
         const expectedTool = matVec(this.A.tool, predictedCoupling);
         const expectedTask = matVec(this.A.task, predictedGoalProgress);
-        // 3. Ambiguity: entropy of predicted observations
+        // 3. Ambiguity: H(o|s,π) - entropy of predicted observations
+        //    High ambiguity = uncertain what we'll observe = BAD
         const ambiguity = entropy(expectedEnergy) +
             entropy(expectedPhi) +
             entropy(expectedTool) +
             entropy(expectedTask);
-        // 4. Risk: negative expected utility (preferences)
+        // 4. Risk: negative expected utility (pragmatic value)
+        //    High risk = far from preferred outcomes = BAD
         const risk = -dot(expectedEnergy, this.C.energy) +
             -dot(expectedPhi, this.C.phi) +
             -dot(expectedTool, this.C.tool) +
             -dot(expectedTask, this.C.task);
-        // EFE = ambiguity + risk
-        return ambiguity + risk;
+        // 5. Information Gain (epistemic value): E[D_KL[Q(s|o,π) || Q(s|π)]]
+        //    Approximated as mutual information between states and observations
+        //    High info gain = action will teach us something = GOOD (subtract from EFE)
+        const infoGain = this.computeInformationGain(actionIdx, predictedViability, predictedWorldState, predictedCoupling, predictedGoalProgress);
+        // EFE = ambiguity + risk - infoGain
+        // Lower is better: reduce ambiguity, reduce risk, increase information gain
+        return ambiguity + risk - this.config.explorationBonus * infoGain;
+    }
+    /**
+     * Compute expected information gain for an action
+     * This is the epistemic value - how much the action teaches us about the world
+     */
+    computeInformationGain(actionIdx, predViability, predWorld, predCoupling, predGoal) {
+        // Information gain ≈ I(S'; O|a) = H(O|a) - H(O|S',a)
+        // = entropy of predicted observations - expected conditional entropy
+        // Predicted observation distributions
+        const predObs = {
+            energy: matVec(this.A.energy, predViability),
+            phi: matVec(this.A.phi, predWorld),
+            tool: matVec(this.A.tool, predCoupling),
+            task: matVec(this.A.task, predGoal),
+        };
+        // Marginal entropy of observations H(O|a)
+        const marginalEntropy = entropy(predObs.energy) +
+            entropy(predObs.phi) +
+            entropy(predObs.tool) +
+            entropy(predObs.task);
+        // Conditional entropy H(O|S',a) - weighted average of observation entropy per state
+        // This is lower when the A matrices are more deterministic (less ambiguous)
+        let conditionalEntropy = 0;
+        // For each state, compute weighted entropy of observations
+        for (let s = 0; s < predViability.length; s++) {
+            if (predViability[s] > 1e-10) {
+                conditionalEntropy += predViability[s] * entropy(this.A.energy[s] || []);
+            }
+        }
+        for (let s = 0; s < predWorld.length; s++) {
+            if (predWorld[s] > 1e-10) {
+                conditionalEntropy += predWorld[s] * entropy(this.A.phi[s] || []);
+            }
+        }
+        for (let s = 0; s < predCoupling.length; s++) {
+            if (predCoupling[s] > 1e-10) {
+                conditionalEntropy += predCoupling[s] * entropy(this.A.tool[s] || []);
+            }
+        }
+        for (let s = 0; s < predGoal.length; s++) {
+            if (predGoal[s] > 1e-10) {
+                conditionalEntropy += predGoal[s] * entropy(this.A.task[s] || []);
+            }
+        }
+        // Information gain = marginal - conditional (always >= 0 by data processing inequality)
+        return Math.max(0, marginalEntropy - conditionalEntropy);
     }
     predictNextState(currentBeliefs, transitionMatrix, actionIdx) {
         // P(s'|a) = sum_s P(s'|s,a) * P(s)

package/dist/src/active-inference/types.d.ts

@@ -143,6 +143,7 @@ export interface ActiveInferenceConfig {
     priorWeight: number;
     learningRateA: number;
     learningRateB: number;
+    explorationBonus: number;
 }
 export declare const DEFAULT_CONFIG: ActiveInferenceConfig;
 export type AIEventType = 'beliefs_updated' | 'policy_inferred' | 'action_selected' | 'action_executed' | 'observation_received' | 'surprise_high' | 'goal_achieved' | 'energy_critical';

package/dist/src/active-inference/types.js

@@ -85,4 +85,5 @@ exports.DEFAULT_CONFIG = {
     priorWeight: 0.1,
     learningRateA: 0.01,
     learningRateB: 0.01,
+    explorationBonus: 1.0, // Balance exploration vs exploitation (higher = more exploration)
 };

package/dist/src/agents/agent-pool.js

@@ -335,29 +335,40 @@ class AgentPool {
     }
     async getFromPool(agentType) {
         const poolEntries = this.pool.get(agentType) || [];
-        // Find available (not busy) agent
+        // Atomically find and claim available agent
         const available = poolEntries.find(e => !e.busy && e.agent.state === 'idle');
         if (available) {
+            // Mark as busy immediately to prevent race conditions
+            available.busy = true;
             return available;
         }
         // Check if we can spawn more
         if (poolEntries.length >= this.config.maxAgentsPerType) {
             // Wait for one to become available
-            await new Promise(resolve => {
+            const claimed = await new Promise(resolve => {
+                let resolved = false;
                 const check = setInterval(() => {
+                    if (resolved)
+                        return;
+                    // Atomically claim first free agent
                     const free = poolEntries.find(e => !e.busy);
                     if (free) {
+                        free.busy = true; // Claim it immediately
+                        resolved = true;
                         clearInterval(check);
-                        resolve();
+                        resolve(free);
                     }
                 }, 100);
                 // Timeout after 5s
                 setTimeout(() => {
-                    clearInterval(check);
-                    resolve();
+                    if (!resolved) {
+                        resolved = true;
+                        clearInterval(check);
+                        resolve(null);
+                    }
                 }, 5000);
             });
-            return poolEntries.find(e => !e.busy) || null;
+            return claimed;
         }
         return null;
     }

package/dist/src/agents/memory.d.ts

@@ -28,6 +28,10 @@ export declare class MemoryAgent extends BaseAgent {
         associations?: string[];
     }): MemoryItem;
     private addToWorkingMemory;
+    private addToShortTermMemory;
+    private evictWeakestFromShortTerm;
+    private addToLongTermMemory;
+    private evictWeakestFromLongTerm;
     private handleRetrieve;
     retrieve(query: MemoryQuery): MemoryItem[];
     private matchesQuery;

package/dist/src/agents/memory.js

@@ -119,8 +119,54 @@ class MemoryAgent extends base_agent_js_1.BaseAgent {
         // Enforce capacity limit
         while (this.workingMemory.length > MEMORY_LIMITS.WORKING) {
             const evicted = this.workingMemory.shift();
-            // Move to short-term
-            this.shortTermMemory.set(evicted.id, evicted);
+            // Move to short-term (with size limit enforcement)
+            this.addToShortTermMemory(evicted);
+        }
+    }
+    addToShortTermMemory(memory) {
+        // Enforce short-term capacity - evict weakest if full
+        if (this.shortTermMemory.size >= MEMORY_LIMITS.SHORT_TERM) {
+            this.evictWeakestFromShortTerm();
+        }
+        this.shortTermMemory.set(memory.id, memory);
+    }
+    evictWeakestFromShortTerm() {
+        let weakestId = null;
+        let weakestScore = Infinity;
+        for (const [id, memory] of this.shortTermMemory) {
+            const score = this.calculateConsolidationScore(memory);
+            if (score < weakestScore) {
+                weakestScore = score;
+                weakestId = id;
+            }
+        }
+        if (weakestId) {
+            const evicted = this.shortTermMemory.get(weakestId);
+            this.shortTermMemory.delete(weakestId);
+            this.removeAssociations(evicted);
+        }
+    }
+    addToLongTermMemory(memory) {
+        // Enforce long-term capacity - evict weakest if full
+        if (this.longTermMemory.size >= MEMORY_LIMITS.LONG_TERM) {
+            this.evictWeakestFromLongTerm();
+        }
+        this.longTermMemory.set(memory.id, memory);
+    }
+    evictWeakestFromLongTerm() {
+        let weakestId = null;
+        let weakestRetention = Infinity;
+        for (const [id, memory] of this.longTermMemory) {
+            const retention = this.getRetention(memory);
+            if (retention < weakestRetention) {
+                weakestRetention = retention;
+                weakestId = id;
+            }
+        }
+        if (weakestId) {
+            const evicted = this.longTermMemory.get(weakestId);
+            this.longTermMemory.delete(weakestId);
+            this.removeAssociations(evicted);
         }
     }
     // ============================================================================
@@ -252,7 +298,6 @@ class MemoryAgent extends base_agent_js_1.BaseAgent {
      * 5. Prune weak memories
      */
     consolidate() {
-        this.log('Starting consolidation cycle...');
         let consolidated = 0;
         let forgotten = 0;
         let kept = 0;
@@ -260,9 +305,9 @@ class MemoryAgent extends base_agent_js_1.BaseAgent {
         for (const [id, memory] of this.shortTermMemory) {
             const score = this.calculateConsolidationScore(memory);
             if (score >= MEMORY_THRESHOLDS.CONSOLIDATE) {
-                // Move to long-term
+                // Move to long-term (with size limit enforcement)
                 memory.consolidated = true;
-                this.longTermMemory.set(id, memory);
+                this.addToLongTermMemory(memory);
                 this.shortTermMemory.delete(id);
                 consolidated++;
             }
@@ -286,15 +331,20 @@ class MemoryAgent extends base_agent_js_1.BaseAgent {
             }
         }
         this.lastConsolidation = new Date();
-        this.log(`Consolidation complete: ${consolidated} consolidated, ${forgotten} forgotten, ${kept} kept`);
-        // Broadcast consolidation event
-        this.broadcast('MEMORY_STORE', {
-            event: 'consolidation',
-            consolidated,
-            forgotten,
-            kept,
-            totalMemories: this.getTotalMemoryCount(),
-        });
+        // Only log if something happened
+        if (consolidated > 0 || forgotten > 0) {
+            this.log(`Consolidation: ${consolidated} consolidated, ${forgotten} forgotten, ${kept} kept`);
+        }
+        // Broadcast consolidation event only if something changed
+        if (consolidated > 0 || forgotten > 0) {
+            this.broadcast('MEMORY_STORE', {
+                event: 'consolidation',
+                consolidated,
+                forgotten,
+                kept,
+                totalMemories: this.getTotalMemoryCount(),
+            });
+        }
     }
     calculateConsolidationScore(memory) {
         const retention = this.getRetention(memory);

package/dist/src/brain/index.d.ts

@@ -38,6 +38,7 @@
  * ```
  */
 import { BrainState, BrainConfig, BrainMetrics, BrainEventHandler } from './types.js';
+import { UnifiedMemoryQuery } from '../memory/unified-query.js';
 export declare class Brain {
     private config;
     private workspace;
@@ -54,6 +55,7 @@ export declare class Brain {
     private worldModel;
     private darwinGodel;
     private persistence;
+    private unifiedQuery;
     private toolCache;
     private readonly TOOL_CACHE_TTL;
     private readonly TOOL_CACHE_MAX_SIZE;
@@ -68,6 +70,35 @@ export declare class Brain {
      * v7.18: Connect real PhiMonitor and dispatcher for full integration
      */
     private initializeV713Modules;
+    /**
+     * v10.4.2: Wire all memory sources to the unified query interface
+     */
+    private wireUnifiedMemoryQuery;
+    /**
+     * v10.4.1: Register Brain modules as GWT modules for proper cognitive broadcasting
+     */
+    private registerModulesInGlobalWorkspace;
+    /**
+     * Create a GWT memory module adapter for the Cognitive Workspace
+     */
+    private createMemoryModule;
+    /**
+     * Create a GWT executive module adapter for the Thinking Engine
+     */
+    private createExecutiveModule;
+    /**
+     * Create a GWT perceptual/motor module adapter for the LLM Bridge
+     */
+    private createLLMModule;
+    /**
+     * v10.4.1: Wire PhiMonitor to real system state for actual φ calculation
+     * Without this, PhiMonitor just simulates random values
+     */
+    private wirePhiMonitorToRealState;
+    /**
+     * Build SystemState from actual Brain components for φ calculation
+     */
+    private buildSystemState;
     /**
      * Start the brain (initializes consciousness monitoring)
      */
@@ -286,6 +317,18 @@ export declare class Brain {
      * Reset metrics
      */
     resetMetrics(): void;
+    /**
+     * v10.4.2: Get unified memory query for cross-store searches
+     */
+    getUnifiedQuery(): UnifiedMemoryQuery;
+    /**
+     * v10.4.2: Search all memory sources with a single query
+     */
+    searchAllMemory(query: string, options?: {
+        limit?: number;
+        types?: ('episodic' | 'semantic' | 'procedural' | 'item')[];
+        minImportance?: number;
+    }): Promise<import('../memory/unified-query.js').UnifiedSearchResult>;
     /**
      * Subscribe to brain events
      */