genesis-ai-cli 7.4.5

package/dist/src/active-inference/memory-integration.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Genesis 6.3 - Memory 2.0 Integration with Active Inference
+ *
+ * Connects CognitiveWorkspace to Active Inference for:
+ * - Anticipatory memory pre-loading based on inferred context
+ * - Enhanced recall.memory action using workspace
+ * - Memory state observation for inference
+ *
+ * Usage:
+ * ```typescript
+ * import { integrateMemory } from './memory-integration.js';
+ * import { getMemorySystem } from '../memory/index.js';
+ * import { createAutonomousLoop } from './autonomous-loop.js';
+ *
+ * const memory = getMemorySystem();
+ * const loop = createAutonomousLoop();
+ *
+ * integrateMemory(loop, memory);
+ *
+ * // Now the loop will:
+ * // 1. Anticipate memories before each cycle
+ * // 2. Use cognitive workspace for recall.memory action
+ * // 3. Track memory reuse metrics
+ * ```
+ */
+import { AutonomousLoop } from './autonomous-loop.js';
+import type { MemorySystem, MemoryReuseMetrics } from '../memory/index.js';
+export interface MemoryIntegrationConfig {
+    enableAnticipation: boolean;
+    anticipationDepth: number;
+    recallLimit: number;
+    logMetrics: boolean;
+    metricsInterval: number;
+}
+export declare const DEFAULT_MEMORY_INTEGRATION_CONFIG: MemoryIntegrationConfig;
+/**
+ * Integrate Memory 2.0 with Active Inference loop
+ */
+export declare function integrateMemory(loop: AutonomousLoop, memory: MemorySystem, config?: Partial<MemoryIntegrationConfig>): void;
+/**
+ * Get memory reuse metrics from memory system
+ */
+export declare function getMemoryMetrics(memory: MemorySystem): MemoryReuseMetrics;
+/**
+ * Get workspace state for observation
+ */
+export declare function getWorkspaceState(memory: MemorySystem): {
+    itemCount: number;
+    avgActivation: number;
+    reuseRate: number;
+};

package/dist/src/active-inference/memory-integration.js

@@ -0,0 +1,232 @@
+"use strict";
+/**
+ * Genesis 6.3 - Memory 2.0 Integration with Active Inference
+ *
+ * Connects CognitiveWorkspace to Active Inference for:
+ * - Anticipatory memory pre-loading based on inferred context
+ * - Enhanced recall.memory action using workspace
+ * - Memory state observation for inference
+ *
+ * Usage:
+ * ```typescript
+ * import { integrateMemory } from './memory-integration.js';
+ * import { getMemorySystem } from '../memory/index.js';
+ * import { createAutonomousLoop } from './autonomous-loop.js';
+ *
+ * const memory = getMemorySystem();
+ * const loop = createAutonomousLoop();
+ *
+ * integrateMemory(loop, memory);
+ *
+ * // Now the loop will:
+ * // 1. Anticipate memories before each cycle
+ * // 2. Use cognitive workspace for recall.memory action
+ * // 3. Track memory reuse metrics
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MEMORY_INTEGRATION_CONFIG = void 0;
+exports.integrateMemory = integrateMemory;
+exports.getMemoryMetrics = getMemoryMetrics;
+exports.getWorkspaceState = getWorkspaceState;
+const actions_js_1 = require("./actions.js");
+exports.DEFAULT_MEMORY_INTEGRATION_CONFIG = {
+    enableAnticipation: true,
+    anticipationDepth: 5,
+    recallLimit: 10,
+    logMetrics: false,
+    metricsInterval: 10,
+};
+// ============================================================================
+// Context Building
+// ============================================================================
+/**
+ * Build anticipation context from current beliefs and goal
+ */
+function buildAnticipationContext(beliefs, goal, recentActions) {
+    // Extract keywords from goal
+    const keywords = [];
+    if (goal) {
+        keywords.push(...goal.split(/\s+/).filter(w => w.length > 3));
+    }
+    // Map beliefs to context
+    const context = {
+        goal,
+        keywords,
+        recentActions,
+    };
+    // Add tags based on beliefs
+    const tags = [];
+    // Viability tags
+    const viabilityLevel = beliefs.viability.indexOf(Math.max(...beliefs.viability));
+    if (viabilityLevel <= 1)
+        tags.push('energy', 'survival', 'low-energy');
+    else if (viabilityLevel >= 3)
+        tags.push('high-energy', 'optimal');
+    // World state tags
+    const worldStateLevel = beliefs.worldState.indexOf(Math.max(...beliefs.worldState));
+    if (worldStateLevel === 0)
+        tags.push('unknown', 'exploration');
+    else if (worldStateLevel === 1)
+        tags.push('stable', 'routine');
+    else if (worldStateLevel === 2)
+        tags.push('changing', 'adaptation');
+    else if (worldStateLevel === 3)
+        tags.push('hostile', 'threat');
+    // Goal progress tags
+    const goalLevel = beliefs.goalProgress.indexOf(Math.max(...beliefs.goalProgress));
+    if (goalLevel === 0)
+        tags.push('blocked', 'problem');
+    else if (goalLevel === 3)
+        tags.push('achieved', 'success');
+    context.tags = tags;
+    return context;
+}
+// ============================================================================
+// Memory-Enhanced Actions
+// ============================================================================
+/**
+ * Register enhanced recall.memory action that uses CognitiveWorkspace
+ */
+function registerMemoryActions(memory, config) {
+    (0, actions_js_1.registerAction)('recall.memory', async (context) => {
+        const query = context.goal || '';
+        // Try workspace first (cache hit)
+        const activeItems = memory.workspace.getActive();
+        // Filter active items by query
+        const relevant = activeItems.filter(item => {
+            const content = JSON.stringify(item.memory).toLowerCase();
+            const terms = query.toLowerCase().split(/\s+/);
+            return terms.some(t => t.length > 2 && content.includes(t));
+        });
+        if (relevant.length > 0) {
+            // Access items to update metrics
+            relevant.forEach(item => memory.workspace.access(item.id));
+            return {
+                success: true,
+                action: 'recall.memory',
+                data: {
+                    recalled: relevant.map(r => r.memory),
+                    source: 'workspace',
+                    count: relevant.length,
+                },
+                duration: 0,
+            };
+        }
+        // Fall back to store search
+        if (query.length > 0) {
+            const results = memory.recall(query, { limit: config.recallLimit });
+            // Add to workspace for future access
+            results.forEach(mem => {
+                memory.workspace.addToBuffer(mem, 'recall', 0.6);
+            });
+            return {
+                success: true,
+                action: 'recall.memory',
+                data: {
+                    recalled: results,
+                    source: 'store',
+                    count: results.length,
+                },
+                duration: 0,
+            };
+        }
+        return {
+            success: true,
+            action: 'recall.memory',
+            data: {
+                recalled: [],
+                source: 'none',
+                count: 0,
+            },
+            duration: 0,
+        };
+    });
+    // Enhanced dream.cycle that uses consolidation
+    (0, actions_js_1.registerAction)('dream.cycle', async (context) => {
+        try {
+            const result = await memory.consolidate();
+            // Clear workspace to simulate "waking up"
+            const stats = memory.workspace.getStats();
+            memory.workspace.clear();
+            return {
+                success: true,
+                action: 'dream.cycle',
+                data: {
+                    consolidated: result,
+                    workspaceCleared: stats.itemCount,
+                },
+                duration: 0,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                action: 'dream.cycle',
+                error: error instanceof Error ? error.message : String(error),
+                duration: 0,
+            };
+        }
+    });
+}
+// ============================================================================
+// Loop Integration
+// ============================================================================
+/**
+ * Add anticipation hook to autonomous loop
+ */
+function addAnticipationHook(loop, memory, config) {
+    const recentActions = [];
+    // Subscribe to cycle events
+    loop.onCycle((cycle, action, beliefs) => {
+        // Track recent actions
+        recentActions.push(action);
+        if (recentActions.length > 5)
+            recentActions.shift();
+        // Anticipate memories for next cycle
+        if (config.enableAnticipation) {
+            const context = buildAnticipationContext(beliefs, undefined, // goal could come from context
+            recentActions);
+            // Fire and forget - don't block the cycle
+            memory.anticipate(context).catch(() => {
+                // Silently ignore anticipation errors
+            });
+        }
+        // Log metrics periodically
+        if (config.logMetrics && cycle % config.metricsInterval === 0) {
+            const metrics = memory.getReuseMetrics();
+            console.log(`[Memory 2.0] Cycle ${cycle} | Reuse: ${(metrics.reuseRate * 100).toFixed(1)}% | Anticipation: ${(metrics.anticipationAccuracy * 100).toFixed(1)}%`);
+        }
+    });
+}
+// ============================================================================
+// Main Integration Function
+// ============================================================================
+/**
+ * Integrate Memory 2.0 with Active Inference loop
+ */
+function integrateMemory(loop, memory, config = {}) {
+    const fullConfig = { ...exports.DEFAULT_MEMORY_INTEGRATION_CONFIG, ...config };
+    // Register enhanced actions
+    registerMemoryActions(memory, fullConfig);
+    // Add anticipation hook
+    addAnticipationHook(loop, memory, fullConfig);
+}
+/**
+ * Get memory reuse metrics from memory system
+ */
+function getMemoryMetrics(memory) {
+    return memory.getReuseMetrics();
+}
+/**
+ * Get workspace state for observation
+ */
+function getWorkspaceState(memory) {
+    const stats = memory.workspace.getStats();
+    const metrics = memory.getReuseMetrics();
+    return {
+        itemCount: stats.itemCount,
+        avgActivation: stats.avgActivation,
+        reuseRate: metrics.reuseRate,
+    };
+}

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

@@ -0,0 +1,67 @@
+/**
+ * Genesis 6.1 - Observations Bridge
+ *
+ * Connects existing agents to Active Inference observations.
+ *
+ * Maps:
+ * - SensorAgent → tool perception
+ * - FeelingAgent → interoceptive state
+ * - PhiMonitor → consciousness level
+ * - WorldModel → coherence metric
+ * - Kernel → energy/task status
+ */
+import { Observation } from './types.js';
+export interface KernelState {
+    energy: number;
+    state: string;
+    taskStatus?: 'none' | 'pending' | 'running' | 'completed' | 'failed';
+}
+export interface PhiState {
+    phi: number;
+    state: 'dormant' | 'alert' | 'aware' | 'drowsy' | 'fragmented';
+}
+export interface SensorResult {
+    success: boolean;
+    latency: number;
+    error?: string;
+}
+export interface WorldModelState {
+    consistent: boolean;
+    issues: number;
+}
+export declare class ObservationGatherer {
+    private getKernelState?;
+    private getPhiState?;
+    private getSensorResult?;
+    private getWorldModelState?;
+    /**
+     * Configure observation sources
+     */
+    configure(sources: {
+        kernelState?: () => KernelState;
+        phiState?: () => PhiState;
+        sensorResult?: () => Promise<SensorResult>;
+        worldModelState?: () => WorldModelState;
+    }): void;
+    /**
+     * Gather all observations from system components
+     */
+    gather(): Promise<Observation>;
+    /**
+     * Create observation from raw values (for testing)
+     */
+    fromRaw(raw: {
+        energy?: number;
+        phi?: number;
+        toolSuccess?: boolean;
+        coherent?: boolean;
+        taskStatus?: string;
+    }): Observation;
+    private mapEnergy;
+    private mapPhi;
+    private mapTool;
+    private mapCoherence;
+    private mapTask;
+}
+export declare function createObservationGatherer(): ObservationGatherer;
+export declare function getObservationGatherer(): ObservationGatherer;

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

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * Genesis 6.1 - Observations Bridge
+ *
+ * Connects existing agents to Active Inference observations.
+ *
+ * Maps:
+ * - SensorAgent → tool perception
+ * - FeelingAgent → interoceptive state
+ * - PhiMonitor → consciousness level
+ * - WorldModel → coherence metric
+ * - Kernel → energy/task status
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservationGatherer = void 0;
+exports.createObservationGatherer = createObservationGatherer;
+exports.getObservationGatherer = getObservationGatherer;
+// ============================================================================
+// Observation Gatherer
+// ============================================================================
+class ObservationGatherer {
+    // References to system components (injected)
+    getKernelState;
+    getPhiState;
+    getSensorResult;
+    getWorldModelState;
+    /**
+     * Configure observation sources
+     */
+    configure(sources) {
+        if (sources.kernelState)
+            this.getKernelState = sources.kernelState;
+        if (sources.phiState)
+            this.getPhiState = sources.phiState;
+        if (sources.sensorResult)
+            this.getSensorResult = sources.sensorResult;
+        if (sources.worldModelState)
+            this.getWorldModelState = sources.worldModelState;
+    }
+    /**
+     * Gather all observations from system components
+     */
+    async gather() {
+        // Get states from components (with defaults if not configured)
+        const kernelState = this.getKernelState?.() ?? {
+            energy: 0.5,
+            state: 'idle',
+            taskStatus: 'none',
+        };
+        const phiState = this.getPhiState?.() ?? {
+            phi: 0.5,
+            state: 'aware',
+        };
+        const sensorResult = this.getSensorResult
+            ? await this.getSensorResult()
+            : { success: true, latency: 100 };
+        const worldModelState = this.getWorldModelState?.() ?? {
+            consistent: true,
+            issues: 0,
+        };
+        // Map to discrete observations
+        return {
+            energy: this.mapEnergy(kernelState.energy),
+            phi: this.mapPhi(phiState),
+            tool: this.mapTool(sensorResult),
+            coherence: this.mapCoherence(worldModelState),
+            task: this.mapTask(kernelState.taskStatus),
+        };
+    }
+    /**
+     * Create observation from raw values (for testing)
+     */
+    fromRaw(raw) {
+        return {
+            energy: this.mapEnergy(raw.energy ?? 0.5),
+            phi: this.mapPhi({ phi: raw.phi ?? 0.5, state: 'aware' }),
+            tool: raw.toolSuccess === undefined ? 1 : (raw.toolSuccess ? 2 : 0),
+            coherence: raw.coherent === undefined ? 2 : (raw.coherent ? 2 : 0),
+            task: this.mapTask(raw.taskStatus ?? 'none'),
+        };
+    }
+    // ============================================================================
+    // Mapping Functions
+    // ============================================================================
+    mapEnergy(energy) {
+        // Map 0.0-1.0 to 0-4
+        if (energy < 0.1)
+            return 0; // depleted
+        if (energy < 0.3)
+            return 1; // low
+        if (energy < 0.6)
+            return 2; // medium
+        if (energy < 0.85)
+            return 3; // high
+        return 4; // full
+    }
+    mapPhi(phiState) {
+        // Map phi level and state to 0-3
+        if (phiState.state === 'dormant' || phiState.phi < 0.1)
+            return 0;
+        if (phiState.phi < 0.4)
+            return 1; // low
+        if (phiState.phi < 0.7)
+            return 2; // medium
+        return 3; // high
+    }
+    mapTool(result) {
+        // Map sensor result to 0-2
+        if (!result.success)
+            return 0; // failed
+        if (result.latency > 5000)
+            return 1; // partial (slow)
+        return 2; // success
+    }
+    mapCoherence(state) {
+        // Map world model consistency to 0-2
+        if (!state.consistent || state.issues > 5)
+            return 0; // broken
+        if (state.issues > 0)
+            return 1; // degraded
+        return 2; // consistent
+    }
+    mapTask(status) {
+        switch (status) {
+            case 'pending': return 1;
+            case 'running': return 2;
+            case 'completed': return 3;
+            case 'failed': return 0;
+            case 'none':
+            default: return 0;
+        }
+    }
+}
+exports.ObservationGatherer = ObservationGatherer;
+// ============================================================================
+// Factory
+// ============================================================================
+let gathererInstance = null;
+function createObservationGatherer() {
+    return new ObservationGatherer();
+}
+function getObservationGatherer() {
+    if (!gathererInstance) {
+        gathererInstance = createObservationGatherer();
+    }
+    return gathererInstance;
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Genesis 6.1 - Active Inference Tests
+ *
+ * Tests for the autonomous decision-making system.
+ *
+ * Run: node --test dist/active-inference/test-active-inference.js
+ */
+export {};