genesis-ai-cli 7.4.5

package/dist/src/memory/cognitive-workspace.js

@@ -0,0 +1,521 @@
+"use strict";
+/**
+ * Genesis 6.3 - Cognitive Workspace (Memory 2.0)
+ *
+ * Working memory with attention-based selection and anticipatory retrieval.
+ *
+ * Based on:
+ * - Baddeley's Working Memory Model (central executive + buffers)
+ * - Global Workspace Theory (Baars) - capacity-limited broadcast
+ * - Active Inference (anticipatory recall)
+ *
+ * Key features:
+ * - Capacity-limited buffer (like human 7±2 items)
+ * - Attention-based selection and eviction
+ * - Anticipatory pre-loading based on context
+ * - Integration with episodic/semantic/procedural stores
+ *
+ * Architecture:
+ * ```
+ * Context → anticipate() → Pre-load
+ *              ↓
+ *         [Working Memory Buffer]
+ *              ↓
+ *         curate() → Select/Evict
+ *              ↓
+ *         [Active Items for Reasoning]
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CognitiveWorkspace = exports.DEFAULT_WORKSPACE_CONFIG = void 0;
+exports.createCognitiveWorkspace = createCognitiveWorkspace;
+exports.getCognitiveWorkspace = getCognitiveWorkspace;
+exports.resetCognitiveWorkspace = resetCognitiveWorkspace;
+exports.DEFAULT_WORKSPACE_CONFIG = {
+    maxItems: 7,
+    maxTokens: 8192,
+    decayRate: 0.01,
+    boostOnAccess: 0.3,
+    minActivation: 0.1,
+    anticipationDepth: 5,
+    associationStrength: 0.3,
+    curationInterval: 5000,
+    autoCurate: true,
+};
+// ============================================================================
+// Cognitive Workspace
+// ============================================================================
+/**
+ * Working memory with attention-based selection and anticipatory retrieval
+ */
+class CognitiveWorkspace {
+    config;
+    // Working memory buffer
+    buffer = new Map();
+    // Memory stores (injected)
+    episodicStore;
+    semanticStore;
+    proceduralStore;
+    // Metrics
+    metrics = {
+        totalRecalls: 0,
+        cacheHits: 0,
+        storeHits: 0,
+        newCreations: 0,
+        anticipationHits: 0,
+        anticipationMisses: 0,
+        reuseRate: 0,
+        anticipationAccuracy: 0,
+    };
+    // Anticipation tracking
+    anticipatedIds = new Set();
+    // Auto-curation timer
+    curationTimer;
+    constructor(config = {}) {
+        this.config = { ...exports.DEFAULT_WORKSPACE_CONFIG, ...config };
+        if (this.config.autoCurate) {
+            this.startAutoCuration();
+        }
+    }
+    // ============================================================================
+    // Store Integration
+    // ============================================================================
+    /**
+     * Connect to memory stores for retrieval
+     */
+    connectStores(stores) {
+        this.episodicStore = stores.episodic;
+        this.semanticStore = stores.semantic;
+        this.proceduralStore = stores.procedural;
+    }
+    // ============================================================================
+    // Anticipatory Retrieval
+    // ============================================================================
+    /**
+     * Anticipate needed memories based on context
+     *
+     * Uses context cues to predict which memories will be needed,
+     * and pre-loads them into working memory.
+     */
+    async anticipate(context) {
+        const anticipated = [];
+        // Build search query from context
+        const searchTerms = [];
+        if (context.task)
+            searchTerms.push(context.task);
+        if (context.goal)
+            searchTerms.push(context.goal);
+        if (context.keywords)
+            searchTerms.push(...context.keywords);
+        if (context.recentTopics)
+            searchTerms.push(...context.recentTopics.slice(-3));
+        const query = searchTerms.join(' ');
+        if (query && query.length > 0) {
+            // Search each store
+            if (this.episodicStore) {
+                const episodes = this.episodicStore.search(query, this.config.anticipationDepth);
+                anticipated.push(...episodes);
+            }
+            if (this.semanticStore) {
+                const facts = this.semanticStore.search(query, this.config.anticipationDepth);
+                anticipated.push(...facts);
+            }
+            if (this.proceduralStore) {
+                const skills = this.proceduralStore.search(query, this.config.anticipationDepth);
+                anticipated.push(...skills);
+            }
+        }
+        // Add by tags if provided
+        if (context.tags && context.tags.length > 0) {
+            const tagQuery = context.tags.join(' ');
+            if (this.episodicStore) {
+                anticipated.push(...this.episodicStore.search(tagQuery, 3));
+            }
+        }
+        // Calculate relevance scores
+        const items = [];
+        for (const memory of anticipated) {
+            // Skip if already in buffer
+            if (this.buffer.has(memory.id))
+                continue;
+            const relevance = this.calculateRelevance(memory, context);
+            if (relevance < 0.2)
+                continue; // Skip low relevance
+            const item = this.addToBuffer(memory, 'anticipate', relevance);
+            items.push(item);
+            // Track for anticipation metrics
+            this.anticipatedIds.add(memory.id);
+        }
+        return items;
+    }
+    /**
+     * Calculate relevance of a memory to the current context
+     */
+    calculateRelevance(memory, context) {
+        let relevance = 0.5; // Base relevance
+        let factors = 1;
+        // Task/goal match
+        if (context.task || context.goal) {
+            const target = (context.task || '') + ' ' + (context.goal || '');
+            const content = JSON.stringify(memory).toLowerCase();
+            const targetTerms = target.toLowerCase().split(/\s+/);
+            const matches = targetTerms.filter(t => t.length > 2 && content.includes(t)).length;
+            relevance += (matches / Math.max(targetTerms.length, 1)) * 0.3;
+            factors++;
+        }
+        // Keyword match
+        if (context.keywords && context.keywords.length > 0) {
+            const content = JSON.stringify(memory).toLowerCase();
+            const matches = context.keywords.filter(k => content.includes(k.toLowerCase())).length;
+            relevance += (matches / context.keywords.length) * 0.2;
+            factors++;
+        }
+        // Tag match
+        if (context.tags && context.tags.length > 0) {
+            const memoryTags = memory.tags || [];
+            const matches = context.tags.filter(t => memoryTags.includes(t)).length;
+            relevance += (matches / context.tags.length) * 0.3;
+            factors++;
+        }
+        // Recency boost for episodic
+        if (memory.type === 'episodic') {
+            const episodic = memory;
+            const ageHours = (Date.now() - episodic.when.timestamp.getTime()) / (1000 * 60 * 60);
+            if (ageHours < 1)
+                relevance += 0.2;
+            else if (ageHours < 24)
+                relevance += 0.1;
+        }
+        // Importance factor
+        relevance += memory.importance * 0.2;
+        return Math.min(1, relevance / factors);
+    }
+    // ============================================================================
+    // Working Memory Operations
+    // ============================================================================
+    /**
+     * Add a memory to working memory buffer
+     */
+    addToBuffer(memory, source = 'manual', relevance = 0.5) {
+        // Check if already in buffer
+        const existing = this.buffer.get(memory.id);
+        if (existing) {
+            this.access(memory.id);
+            return existing;
+        }
+        const item = {
+            id: memory.id,
+            memory,
+            activation: 1.0, // Start at full activation
+            relevance,
+            accessCount: 1,
+            addedAt: new Date(),
+            lastAccessed: new Date(),
+            source,
+        };
+        this.buffer.set(memory.id, item);
+        // Maintain capacity
+        this.maintainCapacity();
+        return item;
+    }
+    /**
+     * Access a memory in working memory (boosts activation)
+     */
+    access(id) {
+        const item = this.buffer.get(id);
+        if (!item) {
+            this.metrics.totalRecalls++;
+            return undefined;
+        }
+        // Boost activation
+        item.activation = Math.min(1, item.activation + this.config.boostOnAccess);
+        item.accessCount++;
+        item.lastAccessed = new Date();
+        // Track metrics
+        this.metrics.totalRecalls++;
+        this.metrics.cacheHits++;
+        // Track anticipation hit
+        if (this.anticipatedIds.has(id)) {
+            this.metrics.anticipationHits++;
+            this.anticipatedIds.delete(id);
+        }
+        this.updateMetrics();
+        return item;
+    }
+    /**
+     * Recall a memory (from buffer or stores)
+     */
+    recall(id) {
+        // Check buffer first
+        const bufferItem = this.access(id);
+        if (bufferItem) {
+            return bufferItem.memory;
+        }
+        // Search stores
+        let memory;
+        if (this.episodicStore) {
+            memory = this.episodicStore.get(id);
+        }
+        if (!memory && this.semanticStore) {
+            // Semantic store uses concept lookup, skip ID lookup
+        }
+        if (!memory && this.proceduralStore) {
+            // Procedural store uses name lookup, skip ID lookup
+        }
+        if (memory) {
+            this.metrics.storeHits++;
+            this.addToBuffer(memory, 'recall', 0.7);
+            this.updateMetrics();
+            return memory;
+        }
+        this.updateMetrics();
+        return undefined;
+    }
+    /**
+     * Get all items currently in working memory
+     */
+    getActive() {
+        return Array.from(this.buffer.values())
+            .sort((a, b) => b.activation - a.activation);
+    }
+    /**
+     * Get items by type
+     */
+    getByType(type) {
+        return this.getActive().filter(item => item.memory.type === type);
+    }
+    /**
+     * Check if a memory is in working memory
+     */
+    isActive(id) {
+        return this.buffer.has(id);
+    }
+    /**
+     * Get working memory size
+     */
+    size() {
+        return this.buffer.size;
+    }
+    // ============================================================================
+    // Curation
+    // ============================================================================
+    /**
+     * Curate working memory: decay activations and evict low-activation items
+     */
+    curate() {
+        const now = Date.now();
+        let decayed = 0;
+        const evicted = [];
+        for (const [id, item] of this.buffer) {
+            // Decay activation based on time since last access
+            const timeSinceAccess = (now - item.lastAccessed.getTime()) / 1000;
+            const decay = this.config.decayRate * timeSinceAccess;
+            item.activation = Math.max(0, item.activation - decay);
+            decayed++;
+            // Evict if below threshold
+            if (item.activation < this.config.minActivation) {
+                this.buffer.delete(id);
+                evicted.push(id);
+                // Track anticipation miss
+                if (this.anticipatedIds.has(id)) {
+                    this.metrics.anticipationMisses++;
+                    this.anticipatedIds.delete(id);
+                }
+            }
+        }
+        this.updateMetrics();
+        return { decayed, evicted };
+    }
+    /**
+     * Start automatic curation
+     */
+    startAutoCuration() {
+        if (this.curationTimer)
+            return;
+        this.curationTimer = setInterval(() => {
+            this.curate();
+        }, this.config.curationInterval);
+    }
+    /**
+     * Stop automatic curation
+     */
+    stopAutoCuration() {
+        if (this.curationTimer) {
+            clearInterval(this.curationTimer);
+            this.curationTimer = undefined;
+        }
+    }
+    // ============================================================================
+    // Capacity Management
+    // ============================================================================
+    /**
+     * Maintain working memory capacity by evicting low-activation items
+     */
+    maintainCapacity() {
+        // Check item count
+        while (this.buffer.size > this.config.maxItems) {
+            this.evictLowest();
+        }
+        // Check token estimate (rough: 100 chars ≈ 25 tokens)
+        let totalTokens = 0;
+        for (const item of this.buffer.values()) {
+            const content = JSON.stringify(item.memory);
+            totalTokens += Math.ceil(content.length / 4);
+        }
+        while (totalTokens > this.config.maxTokens && this.buffer.size > 0) {
+            const evicted = this.evictLowest();
+            if (evicted) {
+                const content = JSON.stringify(evicted.memory);
+                totalTokens -= Math.ceil(content.length / 4);
+            }
+            else {
+                break;
+            }
+        }
+    }
+    /**
+     * Evict the item with lowest activation
+     */
+    evictLowest() {
+        let lowest;
+        let lowestScore = Infinity;
+        for (const item of this.buffer.values()) {
+            // Score = activation * relevance * importance
+            const score = item.activation * item.relevance * item.memory.importance;
+            if (score < lowestScore) {
+                lowestScore = score;
+                lowest = item;
+            }
+        }
+        if (lowest) {
+            this.buffer.delete(lowest.id);
+            // Track anticipation miss
+            if (this.anticipatedIds.has(lowest.id)) {
+                this.metrics.anticipationMisses++;
+                this.anticipatedIds.delete(lowest.id);
+            }
+        }
+        return lowest;
+    }
+    // ============================================================================
+    // Metrics
+    // ============================================================================
+    /**
+     * Update computed metrics
+     */
+    updateMetrics() {
+        const total = this.metrics.totalRecalls;
+        if (total > 0) {
+            this.metrics.reuseRate = (this.metrics.cacheHits + this.metrics.storeHits) / total;
+        }
+        const anticipationTotal = this.metrics.anticipationHits + this.metrics.anticipationMisses;
+        if (anticipationTotal > 0) {
+            this.metrics.anticipationAccuracy = this.metrics.anticipationHits / anticipationTotal;
+        }
+    }
+    /**
+     * Get memory reuse metrics
+     */
+    getMetrics() {
+        return { ...this.metrics };
+    }
+    /**
+     * Record a new memory creation (for metrics)
+     */
+    recordNewCreation() {
+        this.metrics.newCreations++;
+        this.metrics.totalRecalls++;
+        this.updateMetrics();
+    }
+    /**
+     * Reset metrics
+     */
+    resetMetrics() {
+        this.metrics = {
+            totalRecalls: 0,
+            cacheHits: 0,
+            storeHits: 0,
+            newCreations: 0,
+            anticipationHits: 0,
+            anticipationMisses: 0,
+            reuseRate: 0,
+            anticipationAccuracy: 0,
+        };
+    }
+    // ============================================================================
+    // Workspace State
+    // ============================================================================
+    /**
+     * Get workspace statistics
+     */
+    getStats() {
+        const items = this.getActive();
+        let totalActivation = 0;
+        let totalRelevance = 0;
+        let totalTokens = 0;
+        const byType = { episodic: 0, semantic: 0, procedural: 0 };
+        const bySource = {
+            anticipate: 0, recall: 0, association: 0, manual: 0
+        };
+        for (const item of items) {
+            totalActivation += item.activation;
+            totalRelevance += item.relevance;
+            totalTokens += Math.ceil(JSON.stringify(item.memory).length / 4);
+            byType[item.memory.type]++;
+            bySource[item.source]++;
+        }
+        return {
+            itemCount: items.length,
+            maxItems: this.config.maxItems,
+            estimatedTokens: totalTokens,
+            maxTokens: this.config.maxTokens,
+            avgActivation: items.length > 0 ? totalActivation / items.length : 0,
+            avgRelevance: items.length > 0 ? totalRelevance / items.length : 0,
+            byType,
+            bySource,
+        };
+    }
+    /**
+     * Clear working memory
+     */
+    clear() {
+        // Track all anticipated items as misses
+        for (const id of this.anticipatedIds) {
+            if (this.buffer.has(id)) {
+                this.metrics.anticipationMisses++;
+            }
+        }
+        this.anticipatedIds.clear();
+        this.buffer.clear();
+    }
+    /**
+     * Shutdown workspace
+     */
+    shutdown() {
+        this.stopAutoCuration();
+        this.clear();
+    }
+}
+exports.CognitiveWorkspace = CognitiveWorkspace;
+// ============================================================================
+// Factory
+// ============================================================================
+function createCognitiveWorkspace(config) {
+    return new CognitiveWorkspace(config);
+}
+// ============================================================================
+// Singleton
+// ============================================================================
+let workspaceInstance = null;
+function getCognitiveWorkspace(config) {
+    if (!workspaceInstance) {
+        workspaceInstance = createCognitiveWorkspace(config);
+    }
+    return workspaceInstance;
+}
+function resetCognitiveWorkspace() {
+    if (workspaceInstance) {
+        workspaceInstance.shutdown();
+        workspaceInstance = null;
+    }
+}

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

@@ -0,0 +1,99 @@
+/**
+ * Genesis 6.0 - Memory Consolidation Service
+ *
+ * Implements sleep-based memory consolidation:
+ * - Episodic → Semantic (pattern extraction)
+ * - Episodic → Procedural (skill learning)
+ * - Forgetting weak memories
+ * - Merging similar memories
+ *
+ * Inspired by:
+ * - Memory consolidation during sleep (Walker & Stickgold, 2006)
+ * - Systems consolidation theory (McClelland et al., 1995)
+ * - Schema theory (Bartlett, 1932)
+ */
+import { ConsolidationResult, ConsolidationConfig, MemoryEvent } from './types.js';
+import { EpisodicStore } from './episodic.js';
+import { SemanticStore } from './semantic.js';
+import { ProceduralStore } from './procedural.js';
+import { calculateForgettingStats } from './forgetting.js';
+export declare class ConsolidationService {
+    private episodicStore;
+    private semanticStore;
+    private proceduralStore;
+    private config;
+    private backgroundTimer;
+    private isConsolidating;
+    private lastConsolidation;
+    private consolidationHistory;
+    private eventLog;
+    constructor(episodicStore: EpisodicStore, semanticStore: SemanticStore, proceduralStore: ProceduralStore, config?: Partial<ConsolidationConfig>);
+    /**
+     * Run full consolidation cycle (sleep mode)
+     */
+    sleep(): Promise<ConsolidationResult>;
+    /**
+     * Run quick consolidation (background)
+     */
+    backgroundConsolidate(): Promise<ConsolidationResult>;
+    /**
+     * Run immediate consolidation for specific memories
+     */
+    immediateConsolidate(episodeIds: string[]): Promise<ConsolidationResult>;
+    /**
+     * Core consolidation logic
+     */
+    private consolidate;
+    /**
+     * Process a batch of episodes
+     */
+    private processEpisodes;
+    /**
+     * Group similar episodes together
+     */
+    private groupSimilarEpisodes;
+    /**
+     * Calculate similarity between two episodes
+     */
+    private episodeSimilarity;
+    /**
+     * Extract a semantic fact from a group of similar episodes
+     */
+    private extractFact;
+    /**
+     * Extract a procedural skill from a group of similar episodes
+     */
+    private extractProcedure;
+    /**
+     * Merge multiple similar episodes into one
+     */
+    private mergeEpisodes;
+    /**
+     * Start background consolidation timer
+     */
+    startBackground(): void;
+    /**
+     * Stop background consolidation
+     */
+    stopBackground(): void;
+    /**
+     * Check if background consolidation is running
+     */
+    isBackgroundRunning(): boolean;
+    private logEvent;
+    getStats(): {
+        lastConsolidation: Date | null;
+        isConsolidating: boolean;
+        backgroundRunning: boolean;
+        totalConsolidations: number;
+        recentResults: ConsolidationResult[];
+        memoryStats: {
+            episodic: ReturnType<typeof calculateForgettingStats>;
+            semantic: ReturnType<typeof calculateForgettingStats>;
+            procedural: ReturnType<typeof calculateForgettingStats>;
+        };
+    };
+    getHistory(limit?: number): ConsolidationResult[];
+    getEventLog(limit?: number): MemoryEvent[];
+}
+export declare function createConsolidationService(episodicStore: EpisodicStore, semanticStore: SemanticStore, proceduralStore: ProceduralStore, config?: Partial<ConsolidationConfig>): ConsolidationService;