mark-improving-agent 2.2.0

package/dist/core/memory/dream-consolidation.js

@@ -0,0 +1,366 @@
+// Dream Consolidation - Hippocampal-style memory consolidation during "sleep"
+// Based on:
+// - Dream Sleep Memory Consolidation (Zhang 2009) - Sleep stages, neural replay
+// - AI Hippocampus - Pattern separation/completion, memory transfer
+// - Graph Agent Memory Taxonomy - Memory layers and operations
+// - MetaDreamer - Meta-learning during dreams
+import { randomUUID, randomBytes } from 'crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+// Sleep stage durations in ms (typical 90-min cycle proportions)
+const STAGE_DURATIONS = {
+    awake: 5000,
+    n1: 10 * 60 * 1000, // ~5% of cycle
+    n2: 50 * 60 * 1000, // ~55% of cycle
+    n3: 20 * 60 * 1000, // ~20% of cycle
+    rem: 25 * 60 * 1000, // ~25% of cycle
+};
+// Memory consolidation efficiency by stage
+const STAGE_CONSOLIDATION = {
+    awake: 0.0,
+    n1: 0.1,
+    n2: 0.3,
+    n3: 0.8, // Slow-wave sleep - peak consolidation
+    rem: 0.5, // REM - emotional memory processing
+};
+function getAgeDays(entry) {
+    return (Date.now() - entry.timestamp) / (1000 * 60 * 60 * 24);
+}
+function applyEbbinghausDecay(entry) {
+    const ageDays = getAgeDays(entry);
+    return entry.importance * Math.exp(-ageDays / 7);
+}
+function generateMemoryTrace(entry) {
+    return {
+        id: entry.id,
+        content: entry.content.slice(0, 200),
+        context: entry.tags.join(', '),
+        emotionalWeight: entry.importance,
+        replayCount: 0,
+        lastReplay: Date.now(),
+    };
+}
+function sharpWaveRipple(traces, hippocampalState) {
+    // Sharp-wave ripples (Spx) are high-frequency oscillations in CA3-CA1
+    // that facilitate memory replay and transfer
+    const replayed = [];
+    if (hippocampalState.ca3.associativity > 0.5) {
+        for (const trace of traces) {
+            if (Math.random() < hippocampalState.ca3.associativity * 0.3) {
+                trace.replayCount++;
+                trace.lastReplay = Date.now();
+                replayed.push(trace.id);
+            }
+        }
+    }
+    return replayed;
+}
+function patternSeparation(dentateGyrus) {
+    // DG performs pattern separation to create distinct representations
+    const separated = [];
+    const noise = (Math.random() - 0.5) * 0.2 * dentateGyrus.activity;
+    separated.push(noise);
+    return separated;
+}
+function patternCompletion(ca3, cue) {
+    // CA3 performs pattern completion to retrieve full memory from partial cue
+    if (ca3.patternComplete.includes(cue) && Math.random() < ca3.associativity) {
+        return cue;
+    }
+    return null;
+}
+function tripartiteDialogue(corticalInput, hippocampalOutput, thalamicActivity) {
+    // Simulate the tripartite dialogue: Cortex ↔ Hippocampus ↔ Thalamus
+    // This is the "systems consolidation" mechanism where memories are
+    // transferred from hippocampal to cortical long-term storage
+    const consolidationStrength = Math.min(1, thalamicActivity * 0.3 + 0.2);
+    return {
+        corticalInput: corticalInput.slice(0, 5).join('; '),
+        hippocampalOutput: hippocampalOutput.slice(0, 5).join('; '),
+        thalamicModulation: thalamicActivity,
+        consolidationStrength,
+        replayEvents: hippocampalOutput.slice(0, 3),
+    };
+}
+function simulateSleepStage(stage, traces, hippocampalState) {
+    const startTime = Date.now();
+    const duration = STAGE_DURATIONS[stage];
+    const efficiency = STAGE_CONSOLIDATION[stage];
+    const replayedTraces = [];
+    // Copy hippocampal state for this stage
+    const newHippocampalState = {
+        dentateGyrus: { ...hippocampalState.dentateGyrus },
+        ca3: { ...hippocampalState.ca3 },
+        ca1: { ...hippocampalState.ca1 },
+    };
+    // Stage-specific processing
+    if (stage === 'n2') {
+        // N2: Sleep spindles (thalamic) - memory transfer initiation
+        const spindleCount = Math.floor(Math.random() * 5) + 3;
+        newHippocampalState.ca1.activity += spindleCount * 0.1;
+        // Replay some traces during spindles
+        for (const trace of traces) {
+            if (Math.random() < efficiency * 0.2) {
+                trace.replayCount++;
+                replayedTraces.push(trace.id);
+            }
+        }
+    }
+    else if (stage === 'n3') {
+        // N3: Slow-wave sleep - peak consolidation via sharp-wave ripples
+        // Sharp-wave ripples increase CA3 associativity which triggers replay
+        newHippocampalState.ca3.associativity = Math.min(1, newHippocampalState.ca3.associativity + 0.15);
+        // Sharp-wave ripples in CA3-CA1 trigger memory replay
+        const spxReplayed = sharpWaveRipple(traces, newHippocampalState);
+        replayedTraces.push(...spxReplayed);
+        // Pattern separation in dentate gyrus for new memories
+        patternSeparation(newHippocampalState.dentateGyrus);
+    }
+    else if (stage === 'rem') {
+        // REM: Dreaming - emotional memory processing, cortical integration
+        newHippocampalState.ca3.associativity = Math.min(1, newHippocampalState.ca3.associativity + 0.1);
+        // More associative replay during REM
+        for (const trace of traces) {
+            if (Math.random() < efficiency * 0.3 * trace.emotionalWeight) {
+                trace.replayCount++;
+                replayedTraces.push(trace.id);
+            }
+        }
+    }
+    return {
+        stageInfo: { stage, duration, startTime },
+        replayedTraces,
+        newHippocampalState,
+    };
+}
+function generateInsight(entryA, entryB, mechanism) {
+    const types = [
+        'pattern',
+        'connection',
+        'decay',
+        'correction',
+        'breakthrough',
+        'separation',
+        'completion',
+    ];
+    const typeIndex = randomBytes(1)[0] % types.length;
+    const type = types[typeIndex];
+    return {
+        id: randomUUID(),
+        type,
+        description: `Connection between "${entryA.content.slice(0, 50)}..." and "${entryB.content.slice(0, 50)}..."`,
+        weight: Math.min(entryA.importance, entryB.importance) * 0.5,
+        timestamp: Date.now(),
+        mechanism: mechanism ||
+            (type === 'separation' ? 'pattern_separation' :
+                type === 'completion' ? 'pattern_completion' : undefined),
+    };
+}
+export function createDreamEngine(dataDir) {
+    const statsFile = join(dataDir, 'dream-stats.json');
+    let state = {
+        dreamsPerformed: 0,
+        insightsGenerated: 0,
+        memoriesStrengthened: 0,
+        memoriesPruned: 0,
+        lastDreamAt: null,
+        totalReplayEvents: 0,
+        sharpWaveRipples: 0,
+        cyclesCompleted: 0,
+        traces: [],
+        currentCycle: null,
+    };
+    // Hippocampal state for pattern separation/completion
+    let hippocampalState = {
+        dentateGyrus: { patternSeparated: [], activity: 0.5 },
+        ca3: { patternComplete: [], associativity: 0.3 },
+        ca1: { temporalOrder: [], activity: 0.4 },
+    };
+    function loadState() {
+        try {
+            if (existsSync(statsFile)) {
+                const raw = readFileSync(statsFile, 'utf-8');
+                const parsed = JSON.parse(raw);
+                state = { ...state, ...parsed };
+                if (parsed.hippocampalState) {
+                    hippocampalState = parsed.hippocampalState;
+                }
+            }
+        }
+        catch {
+            // Use defaults
+        }
+    }
+    function persistState() {
+        try {
+            const dir = dirname(statsFile);
+            if (!existsSync(dir)) {
+                mkdirSync(dir, { recursive: true });
+            }
+            const stateWithHippocampal = { ...state, hippocampalState };
+            const tmp = statsFile + '.tmp.' + randomUUID().slice(0, 8);
+            writeFileSync(tmp, JSON.stringify(stateWithHippocampal, null, 2), 'utf-8');
+            require('fs').renameSync(tmp, statsFile);
+        }
+        catch {
+            // Persistence failure is non-fatal
+        }
+    }
+    loadState();
+    async function dream(entries) {
+        const now = Date.now();
+        // Rate limit: max 1 dream per hour
+        if (state.lastDreamAt && now - state.lastDreamAt < 60 * 60 * 1000) {
+            return {
+                strengthenedIds: [],
+                prunedIds: [],
+                insights: [],
+                memoriesArchived: 0,
+                sleepStage: 'awake',
+                replayedTraces: [],
+            };
+        }
+        const strengthenedIds = [];
+        const prunedIds = [];
+        const insights = [];
+        const replayedTraces = [];
+        // Create memory traces for replay
+        const traces = entries.map(generateMemoryTrace);
+        state.traces = traces;
+        // Initialize sleep cycle
+        const cycle = {
+            id: randomUUID(),
+            startTime: now,
+            stages: [],
+            replayedTraces: [],
+            consolidatedMemories: [],
+        };
+        // Simulate full sleep cycle: N1 → N2 → N3 → REM
+        const sleepStages = ['n1', 'n2', 'n3', 'rem'];
+        for (const stage of sleepStages) {
+            const { stageInfo, replayedTraces: stageReplayed, newHippocampalState } = simulateSleepStage(stage, traces, hippocampalState);
+            hippocampalState = newHippocampalState;
+            cycle.stages.push(stageInfo);
+            cycle.replayedTraces.push(...stageReplayed);
+            state.totalReplayEvents += stageReplayed.length;
+            // Track replayed traces
+            for (const traceId of stageReplayed) {
+                const trace = traces.find(t => t.id === traceId);
+                if (trace) {
+                    replayedTraces.push(trace);
+                }
+            }
+        }
+        // Count sharp-wave ripples (Spx) events in N3 stage
+        const n3Stage = cycle.stages.find(s => s.stage === 'n3');
+        if (n3Stage) {
+            state.sharpWaveRipples += Math.floor(Math.random() * 10) + 5;
+        }
+        // Apply consolidation to entries based on trace replay
+        for (const entry of entries) {
+            const trace = traces.find(t => t.id === entry.id);
+            const decayedImportance = applyEbbinghausDecay(entry);
+            const replayBoost = trace ? trace.replayCount * 0.05 : 0;
+            if (decayedImportance < 0.2 && replayBoost < 0.1) {
+                prunedIds.push(entry.id);
+            }
+            else {
+                strengthenedIds.push(entry.id);
+            }
+        }
+        // Generate insights from memory interactions
+        if (entries.length >= 2) {
+            const insightCount = Math.min(5, Math.floor(entries.length / 2));
+            for (let i = 0; i < insightCount; i++) {
+                const randA = randomBytes(2);
+                const randB = randomBytes(2);
+                const a = entries[(randA[0] | (randA[1] << 8)) % entries.length];
+                const b = entries[(randB[0] | (randB[1] << 8)) % entries.length];
+                if (a.id !== b.id) {
+                    const mechanisms = [
+                        'pattern_separation',
+                        'pattern_completion',
+                        'sharp_wave_ripple',
+                        'systems_consolidation',
+                    ];
+                    const mech = mechanisms[randomBytes(1)[0] % mechanisms.length];
+                    insights.push(generateInsight(a, b, mech));
+                }
+            }
+        }
+        // Generate tripartite dialogue for this dream
+        const dialogue = tripartiteDialogue(strengthenedIds, replayedTraces.map(t => t.id), hippocampalState.ca1.activity);
+        // Update stats
+        state.dreamsPerformed++;
+        state.lastDreamAt = now;
+        state.insightsGenerated += insights.length;
+        state.memoriesStrengthened += strengthenedIds.length;
+        state.memoriesPruned += prunedIds.length;
+        state.cyclesCompleted++;
+        state.currentCycle = cycle;
+        persistState();
+        return {
+            strengthenedIds,
+            prunedIds,
+            insights,
+            memoriesArchived: prunedIds.length,
+            sleepStage: 'rem', // Final stage reached
+            replayedTraces,
+            dialogueState: dialogue,
+        };
+    }
+    function applyForgettingCurve(entry) {
+        return applyEbbinghausDecay(entry);
+    }
+    function getMemoryHealth() {
+        const issues = [];
+        if (state.memoriesPruned > state.memoriesStrengthened * 3) {
+            issues.push('High prune rate - memories being lost too quickly');
+        }
+        if (state.dreamsPerformed === 0) {
+            issues.push('No dream consolidation performed yet');
+        }
+        const timeSinceLastDream = state.lastDreamAt ? Date.now() - state.lastDreamAt : Infinity;
+        if (timeSinceLastDream > 7 * 24 * 60 * 60 * 1000) {
+            issues.push('Dream consolidation overdue (no dreams in 7+ days)');
+        }
+        if (state.sharpWaveRipples < 10 && state.dreamsPerformed > 0) {
+            issues.push('Low sharp-wave ripple activity - memory consolidation may be impaired');
+        }
+        // Calculate score: 1.0 = healthy, 0.0 = problematic
+        let score = 1.0;
+        if (issues.length === 1)
+            score = 0.75;
+        else if (issues.length === 2)
+            score = 0.5;
+        else if (issues.length >= 3)
+            score = 0.25;
+        return { score, issues };
+    }
+    function getDreamStats() {
+        return {
+            dreamsPerformed: state.dreamsPerformed,
+            insightsGenerated: state.insightsGenerated,
+            memoriesStrengthened: state.memoriesStrengthened,
+            memoriesPruned: state.memoriesPruned,
+            lastDreamAt: state.lastDreamAt,
+            totalReplayEvents: state.totalReplayEvents,
+            sharpWaveRipples: state.sharpWaveRipples,
+            cyclesCompleted: state.cyclesCompleted,
+        };
+    }
+    function getHippocampalState() {
+        return { ...hippocampalState };
+    }
+    function getCurrentCycle() {
+        return state.currentCycle;
+    }
+    return {
+        dream,
+        applyForgettingCurve,
+        getMemoryHealth,
+        getDreamStats,
+        getHippocampalState,
+        getCurrentCycle,
+    };
+}

package/dist/core/memory/embedder.js

@@ -0,0 +1,130 @@
+import { createHash } from 'crypto';
+/**
+ * OpenAI-backed embedder using the completions API.
+ * Note: embed() is async to support API calls - use embedSync() for hash-based fallback.
+ */
+class OpenAIEmbedder {
+    apiKey;
+    model;
+    dimensions;
+    constructor(config) {
+        this.apiKey = config.apiKey;
+        this.model = config.model ?? 'text-embedding-3-small';
+        this.dimensions = config.dimensions ?? 1536;
+    }
+    // Sync version that throws - use HashEmbedder for sync embedding
+    embed(text) {
+        throw new Error('OpenAIEmbedder.embed is async - use HashEmbedder or call embedAsync()');
+    }
+    embedBatch(texts) {
+        throw new Error('OpenAIEmbedder.embedBatch is async - use HashEmbedder or call embedBatchAsync()');
+    }
+    async embedAsync(text) {
+        const response = await fetch('https://api.openai.com/v1/embeddings', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.apiKey}`,
+            },
+            body: JSON.stringify({
+                model: this.model,
+                input: text,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`OpenAI embedding error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        return data.data[0]?.embedding ?? [];
+    }
+    async embedBatchAsync(texts) {
+        const response = await fetch('https://api.openai.com/v1/embeddings', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.apiKey}`,
+            },
+            body: JSON.stringify({
+                model: this.model,
+                input: texts,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`OpenAI embedding error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        // Sort by index to maintain order
+        return data.data
+            .sort((a, b) => 0) // maintain original order
+            .map(item => item.embedding);
+    }
+}
+/**
+ * Hash-based pseudo-embedder for environments without an API key.
+ * Uses SHA256 to generate deterministic pseudo-random floats.
+ * NOT suitable for real semantic similarity but useful for fast lookups.
+ */
+class HashEmbedder {
+    dimensions;
+    cache = new Map();
+    constructor(dimensions = 128) {
+        this.dimensions = dimensions;
+    }
+    embed(text) {
+        const cached = this.cache.get(text);
+        if (cached) {
+            return cached;
+        }
+        const hash = createHash('sha256').update(text).digest('hex');
+        const hashLen = hash.length;
+        const embedding = [];
+        for (let i = 0; i < this.dimensions; i++) {
+            // Parse 8 hex chars at a time to get a pseudo-random float
+            // Wrap around the hash using modulo to handle dimensions > hash segments
+            const offset = ((i % 32) * 8) % hashLen;
+            const hexSegment = hash.slice(offset, offset + 8);
+            const num = parseInt(hexSegment, 16);
+            // Normalize to 0..1 range
+            embedding.push((num % 2000) / 2000);
+        }
+        this.cache.set(text, embedding);
+        return embedding;
+    }
+    embedBatch(texts) {
+        return texts.map(text => this.embed(text));
+    }
+}
+/**
+ * Creates an embedder based on configuration.
+ * If apiKey is provided, uses OpenAI; otherwise uses hash fallback.
+ */
+export function createEmbedder(config) {
+    if (config.apiKey) {
+        return new OpenAIEmbedder({ apiKey: config.apiKey, model: config.model, dimensions: config.dimensions });
+    }
+    return new HashEmbedder(config.dimensions ?? 128);
+}
+/**
+ * Computes cosine similarity between two vectors.
+ * Returns a value between -1 and 1.
+ */
+export function cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+        throw new Error(`Vector dimensions must match: ${a.length} vs ${b.length}`);
+    }
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dotProduct += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+    if (denominator === 0) {
+        return 0;
+    }
+    return dotProduct / denominator;
+}
+// Default embedder using hash fallback (no API key required)
+export const DEFAULT_EMBEDDER = createEmbedder({});

package/dist/core/memory/hopfield-network.js

@@ -0,0 +1,128 @@
+/**
+ * Hopfield Network - Associative Memory
+ *
+ * Paper: "A Cognitive Architecture for Autonomous Agents Based on Hopfield Networks"
+ * Concept: Associative memory with energy-based pattern storage
+ *
+ * Key mechanisms:
+ * - Energy minimization for pattern storage
+ * - Associative retrieval (content-addressable)
+ * - Two-stage retrieval: fast associative + slow refinement
+ * - Continuous knowledge updates
+ */
+import { randomUUID } from 'crypto';
+export function createHopfieldNetwork() {
+    const nodes = new Map();
+    /**
+     * Compute energy for a pattern (simplified Hopfield energy)
+     */
+    function computeEnergy(pattern, connections) {
+        // Energy based on pattern complexity and connection strength
+        const patternComplexity = pattern.length / 100;
+        const connectionStrength = connections.length * 0.1;
+        return patternComplexity - connectionStrength;
+    }
+    function store(pattern, associations = []) {
+        const id = `hf-${Date.now()}-${randomUUID().slice(0, 8)}`;
+        const energy = computeEnergy(pattern, associations);
+        const node = {
+            id,
+            pattern,
+            energy,
+            activation: 1.0,
+            connections: associations,
+            lastUpdated: Date.now(),
+            retrievalCount: 0,
+        };
+        nodes.set(id, node);
+        // Update connections for associated nodes
+        for (const assocId of associations) {
+            const assocNode = nodes.get(assocId);
+            if (assocNode && !assocNode.connections.includes(id)) {
+                assocNode.connections.push(id);
+                assocNode.lastUpdated = Date.now();
+            }
+        }
+        return node;
+    }
+    function retrieve(query) {
+        const queryLower = query.toLowerCase();
+        const results = [];
+        for (const node of nodes.values()) {
+            const patternLower = node.pattern.toLowerCase();
+            // Calculate similarity score
+            const queryWords = queryLower.split(/\s+/);
+            const patternWords = patternLower.split(/\s+/);
+            let matches = 0;
+            for (const qWord of queryWords) {
+                if (patternWords.some(p => p.includes(qWord) || qWord.includes(p))) {
+                    matches++;
+                }
+            }
+            const similarity = queryWords.length > 0 ? matches / queryWords.length : 0;
+            if (similarity > 0.3) {
+                node.retrievalCount++;
+                node.lastUpdated = Date.now();
+                results.push(node);
+            }
+        }
+        // Sort by activation and retrieval count
+        return results
+            .sort((a, b) => {
+            const scoreA = a.activation * 0.6 + a.retrievalCount * 0.001;
+            const scoreB = b.activation * 0.6 + b.retrievalCount * 0.001;
+            return scoreB - scoreA;
+        })
+            .slice(0, 5);
+    }
+    function updateEnergy(nodeId, delta) {
+        const node = nodes.get(nodeId);
+        if (node) {
+            node.energy += delta;
+            node.lastUpdated = Date.now();
+        }
+    }
+    function getAssociated(nodeId) {
+        const node = nodes.get(nodeId);
+        if (!node)
+            return [];
+        return node.connections
+            .map(id => nodes.get(id))
+            .filter((n) => n !== undefined);
+    }
+    function pruneWeakNodes(threshold) {
+        let pruned = 0;
+        for (const [id, node] of nodes.entries()) {
+            if (node.energy > threshold && node.retrievalCount < 2) {
+                nodes.delete(id);
+                pruned++;
+                // Remove from other nodes' connections
+                for (const other of nodes.values()) {
+                    other.connections = other.connections.filter(cid => cid !== id);
+                }
+            }
+        }
+        return pruned;
+    }
+    function getStats() {
+        let totalEnergy = 0;
+        let totalConnections = 0;
+        for (const node of nodes.values()) {
+            totalEnergy += node.energy;
+            totalConnections += node.connections.length;
+        }
+        return {
+            nodes: nodes.size,
+            avgEnergy: nodes.size > 0 ? totalEnergy / nodes.size : 0,
+            avgConnections: nodes.size > 0 ? totalConnections / nodes.size : 0,
+        };
+    }
+    return {
+        store,
+        retrieve,
+        updateEnergy,
+        getAssociated,
+        pruneWeakNodes,
+        getStats,
+    };
+}

package/dist/core/memory/index.js

@@ -0,0 +1,9 @@
+export * from './types.js';
+export * from './embedder.js';
+export * from './store.js';
+export * from './archive-store.js';
+export * from './knowledge-graph.js';
+export * from './dream-consolidation.js';
+export * from './spaced-repetition.js';
+export * from './hopfield-network.js';
+export * from './adaptive-rag.js';