mark-improving-agent 2.3.1 → 2.3.3

package/VERSION

@@ -1 +1 @@
-2.3.1
+2.3.3

package/dist/core/memory/index.js

@@ -9,3 +9,5 @@ export * from './hopfield-network.js';
 export * from './adaptive-rag.js';
 export { createContextFragmentationEngine } from './context-fragmentation.js';
 export { createHybridSearchEngine, createBM25Index, bm25Score, normalizeBM25Scores, DEFAULT_HYBRID_CONFIG } from './hybrid-search.js';
+export { createPatternRecognizer } from './pattern-recognizer.js';
+export { createMemoryObserver } from './observer.js';

package/dist/core/memory/observer.js

@@ -0,0 +1,350 @@
+/**
+ * Memory Observer - Silent Background Memory Writer
+ *
+ * Implements the Mnemostroma-inspired Observer pattern: the AI agent NEVER writes
+ * memory directly. Instead, this Observer sidecar silently watches all I/O,
+ * extracts entities, embeds, scores, and indexes content automatically.
+ *
+ * Key principles:
+ * - AI never writes memory — Observer does it silently
+ * - Dual async pipeline: Observer (write) + Content Branch (versioned artifacts)
+ * - Memory Hulling: separates conversational noise from extractable kernels
+ * - 20ms hot buffer retrieval, ~50ms full extraction latency
+ *
+ * Based on: GG-QandV/mnemostroma (https://github.com/GG-QandV/mnemostroma)
+ *
+ * @module core/memory
+ * @fileoverview Observer pattern for silent memory writing
+ */
+import { randomUUID } from 'crypto';
+import { createLogger } from '../../utils/logger.js';
+import { createEmbedder, cosineSimilarity } from './embedder.js';
+const logger = createLogger('[MemoryObserver]');
+const DEFAULT_OBSERVER_CONFIG = {
+    importanceThreshold: 0.3,
+    hotBufferSize: 50,
+    autoExtract: true,
+    debounceMs: 100,
+    maxShellAge: 5 * 60 * 1000, // 5 minutes
+    embedder: createEmbedder({ dimensions: 128 }),
+};
+/**
+ * Noise patterns that indicate conversational shell (not worth storing)
+ */
+const SHELL_PATTERNS = [
+    /^(hi|hello|hey|what's up|howdy)\b/i,
+    /^(thanks?|thank you|thx|ty|much appreciated)\b/i,
+    /^(okay|ok|okk|kk|sure|yes|no|nah|yeah|yep|nope)\b/i,
+    /^(lol|lmao|rofl|haha|heh)\b/i,
+    /^(bye|goodbye|see you|cya|good night|night)\b/i,
+    /^(sorry|apologies|my bad|whoops)\b/i,
+    /^(please|pls|plz|could you|would you)\b/i,
+    /^(interesting|cool|nice|awesome|great|good)\b/i,
+    /^(i see|i understand|i get it|got it|understood)\b/i,
+    /^[\s.,!?;:]*$/,
+    /^(oh|ah|uh|um|hmm|well)\b/i,
+    /^(let me know|feel free|take care|talk later)\b/i,
+];
+/**
+ * Anchor patterns that indicate important kernels (decisions, deadlines, facts)
+ */
+const ANCHOR_PATTERNS = [
+    /\b(decided|decision|agreed|chosen|selected|picked|settled)\b/i,
+    /\b(must|have to|need to|required|mandatory|essential)\b/i,
+    /\b(deadline|due|by|before|after|until|timing)\b/i,
+    /\b(never|always|don't|do not|must not|forbidden)\b/i,
+    /\b(important|critical|key|vital|priority)\b/i,
+    /\b(remember|forget|keep in mind|note that)\b/i,
+    /\b(because|since|reason|why|therefore|thus)\b/i,
+    /\b(fact|true|real|actually|indeed|in fact)\b/i,
+    /\b(but|however|although|except|except for)\b/i,
+    /\b(name|date|location|price|cost|amount)\b/i,
+    /\b(user|client|customer|they|their)\b.*\b(want|need|prefer|like)\b/i,
+];
+/**
+ * Kernel type classifiers
+ */
+function classifyKernel(content, context) {
+    const lower = content.toLowerCase();
+    const fullText = [content, ...context].join(' ').toLowerCase();
+    if (/deadline|due|by |before |after |timing/i.test(lower))
+        return 'constraint';
+    if (/decided|agreed|chosen|picked|selected/i.test(lower))
+        return 'decision';
+    if (/must|have to|need to|required|mandatory/i.test(lower))
+        return 'rule';
+    if (/fact|true|actual|indeed|in fact|real/i.test(fullText))
+        return 'fact';
+    if (/remember|forget|note|keep in mind/i.test(lower))
+        return 'context';
+    if (/name|date|location|price|amount/i.test(lower))
+        return 'entity';
+    return 'context';
+}
+/**
+ * Score importance based on content features
+ */
+function scoreImportance(content, isAnchor) {
+    let score = 0.5;
+    if (isAnchor)
+        score += 0.2;
+    const words = content.split(/\s+/).length;
+    if (words >= 5 && words <= 50)
+        score += 0.15;
+    else if (words > 100)
+        score -= 0.1;
+    if (/\d+/.test(content))
+        score += 0.1;
+    if (/[A-Z][a-z]+\s+[A-Z][a-z]+/.test(content))
+        score += 0.1;
+    if (/\?$/.test(content))
+        score += 0.05;
+    if (/!$/.test(content))
+        score += 0.05;
+    return Math.max(0, Math.min(1, score));
+}
+/**
+ * Check if content is shell (noise)
+ */
+function isShell(content) {
+    const trimmed = content.trim();
+    if (trimmed.length < 3)
+        return true;
+    for (const pattern of SHELL_PATTERNS) {
+        if (pattern.test(trimmed))
+            return true;
+    }
+    return false;
+}
+/**
+ * Extract anchors from content
+ */
+function extractAnchors(content) {
+    const anchors = [];
+    for (const pattern of ANCHOR_PATTERNS) {
+        const match = content.match(pattern);
+        if (match) {
+            anchors.push(match[0]);
+        }
+    }
+    return anchors;
+}
+function buildMemoryObserver(config = {}) {
+    const cfg = { ...DEFAULT_OBSERVER_CONFIG, ...config };
+    const hotBuffer = [];
+    const anchorIndex = new Map();
+    const tagIndex = new Map();
+    let kernelsExtracted = 0;
+    let shellDiscarded = 0;
+    let lastFlush = null;
+    let sessionId = randomUUID();
+    let previousSessionId = null;
+    /**
+     * Hull content — separate kernels from shell
+     */
+    function hull(content, context = []) {
+        const kernels = [];
+        const shell = [];
+        const sentences = content.split(/[.!?]+/).map(s => s.trim()).filter(s => s.length > 2);
+        for (const sentence of sentences) {
+            if (isShell(sentence)) {
+                shell.push(sentence);
+                shellDiscarded++;
+                continue;
+            }
+            const anchors = extractAnchors(sentence);
+            const isAnchor = anchors.length > 0;
+            const importance = scoreImportance(sentence, isAnchor);
+            if (importance >= cfg.importanceThreshold) {
+                const type = classifyKernel(sentence, context);
+                const kernel = {
+                    type,
+                    content: sentence,
+                    importance,
+                    tags: [type],
+                    anchors,
+                    sourceExcerpt: sentence.slice(0, 200),
+                };
+                if (isAnchor) {
+                    kernel.tags.push('anchor');
+                }
+                kernels.push(kernel);
+                kernelsExtracted++;
+                for (const anchor of anchors) {
+                    anchorIndex.set(anchor, {
+                        content: sentence,
+                        type,
+                        timestamp: Date.now(),
+                    });
+                }
+                for (const tag of kernel.tags) {
+                    if (!tagIndex.has(tag)) {
+                        tagIndex.set(tag, []);
+                    }
+                    tagIndex.get(tag).push(kernel);
+                }
+            }
+            else {
+                shell.push(sentence);
+                shellDiscarded++;
+            }
+        }
+        return { kernels, shell };
+    }
+    function maintainHotBuffer() {
+        while (hotBuffer.length > cfg.hotBufferSize) {
+            let minIdx = 0;
+            let minImportance = Infinity;
+            for (let i = 0; i < hotBuffer.length; i++) {
+                if (hotBuffer[i].importance < minImportance) {
+                    minImportance = hotBuffer[i].importance;
+                    minIdx = i;
+                }
+            }
+            hotBuffer.splice(minIdx, 1);
+        }
+    }
+    async function semanticSearch(query, limit = 5) {
+        try {
+            const queryEmbedding = cfg.embedder.embed(query);
+            const results = [];
+            for (const kernel of hotBuffer) {
+                const kernelEmbedding = cfg.embedder.embed(kernel.content);
+                const similarity = cosineSimilarity(queryEmbedding, kernelEmbedding);
+                if (similarity > 0.3) {
+                    results.push({ content: kernel.content, score: similarity });
+                }
+            }
+            results.sort((a, b) => b.score - a.score);
+            return results.slice(0, limit);
+        }
+        catch (err) {
+            logger.warn('Semantic search failed, falling back to keyword', { error: err });
+            const queryLower = query.toLowerCase();
+            return hotBuffer
+                .filter(k => k.content.toLowerCase().includes(queryLower))
+                .slice(0, limit)
+                .map(k => ({ content: k.content, score: k.importance }));
+        }
+    }
+    return {
+        observe(content, stream = 'semantic', context) {
+            const start = Date.now();
+            const { kernels, shell } = hull(content, context);
+            hotBuffer.push(...kernels);
+            maintainHotBuffer();
+            const processingMs = Date.now() - start;
+            logger.debug(`Observed [${stream}]: ${kernels.length} kernels extracted, ${shell.length} shell discarded (${processingMs}ms)`);
+            return {
+                id: randomUUID(),
+                stream,
+                kernels,
+                shell,
+                timestamp: Date.now(),
+                processingMs,
+            };
+        },
+        async flush(tier = 'learned') {
+            if (hotBuffer.length === 0)
+                return [];
+            const entries = [];
+            for (const kernel of hotBuffer) {
+                const entry = {
+                    id: randomUUID(),
+                    tier,
+                    content: kernel.content,
+                    importance: kernel.importance,
+                    tags: kernel.tags,
+                    timestamp: Date.now(),
+                    accessCount: 0,
+                    lastAccessed: Date.now(),
+                    source: 'self',
+                };
+                entries.push(entry);
+            }
+            lastFlush = Date.now();
+            logger.info(`Flushed ${entries.length} kernels to ${tier} tier`);
+            return entries;
+        },
+        async ctx_semantic(query, limit = 5) {
+            return semanticSearch(query, limit);
+        },
+        ctx_anchors(limit = 20) {
+            const results = Array.from(anchorIndex.entries())
+                .map(([, data]) => ({
+                content: data.content,
+                type: data.type,
+                timestamp: data.timestamp,
+            }))
+                .sort((a, b) => b.timestamp - a.timestamp);
+            return results.slice(0, limit);
+        },
+        async ctx_search(tags, limit = 10) {
+            const matchingKernels = [];
+            for (const tag of tags) {
+                const kernels = tagIndex.get(tag) || [];
+                matchingKernels.push(...kernels);
+            }
+            const seen = new Set();
+            const unique = matchingKernels.filter(k => {
+                if (seen.has(k.content))
+                    return false;
+                seen.add(k.content);
+                return true;
+            });
+            return unique.slice(0, limit).map(k => ({
+                id: randomUUID(),
+                tier: 'learned',
+                content: k.content,
+                importance: k.importance,
+                tags: k.tags,
+                timestamp: Date.now(),
+                accessCount: 0,
+                lastAccessed: Date.now(),
+            }));
+        },
+        ctx_bridge(prevSessionId) {
+            const decisions = Array.from(anchorIndex.entries())
+                .filter(([, data]) => data.type === 'decision')
+                .map(([, data]) => data.content);
+            const constraints = Array.from(anchorIndex.entries())
+                .filter(([, data]) => data.type === 'constraint' || data.type === 'rule')
+                .map(([, data]) => data.content);
+            const importantFacts = Array.from(anchorIndex.entries())
+                .filter(([, data]) => data.type === 'fact')
+                .map(([, data]) => ({
+                fact: data.content,
+                certainty: 0.8,
+            }));
+            const contextSummary = hotBuffer.length > 0
+                ? hotBuffer.slice(0, 5).map(k => k.content).join(' ')
+                : '';
+            const packet = {
+                sessionId,
+                previousSessionId: prevSessionId || previousSessionId,
+                context: contextSummary,
+                decisions,
+                constraints,
+                pendingTasks: [],
+                importantFacts,
+                timestamp: Date.now(),
+                agentVersion: '2.3.3',
+            };
+            previousSessionId = sessionId;
+            sessionId = randomUUID();
+            return packet;
+        },
+        getStats() {
+            return {
+                hotBufferSize: hotBuffer.length,
+                kernelsExtracted,
+                shellDiscarded,
+                lastFlush,
+            };
+        },
+    };
+}
+export function createMemoryObserver(config) {
+    logger.info('Creating Memory Observer (Mnemostroma-inspired)');
+    return buildMemoryObserver(config);
+}

package/dist/core/memory/pattern-recognizer.js

@@ -0,0 +1,358 @@
+/**
+ * Memory Pattern Recognizer
+ *
+ * Analyzes recurring patterns in memory storage and retrieval to enable
+ * personalized memory prioritization. Detects temporal patterns, interaction
+ * styles, and topic frequencies to optimize memory consolidation.
+ *
+ * Based on: Adaptive Memory Systems research - patterns in when/how users store memories
+ *
+ * @module core/memory
+ * @fileoverview Pattern recognition for memory optimization
+ */
+import { createLogger } from '../../utils/logger.js';
+const logger = createLogger('[PatternRecognizer]');
+const DEFAULT_CONFIG = {
+    minMemories: 10,
+    temporalWindowDays: 30,
+    enableAnomalyDetection: true,
+};
+/**
+ * Creates a Memory Pattern Recognizer
+ *
+ * Analyzes memory entries to detect patterns in:
+ * - Temporal distribution (when memories are stored)
+ * - Topic frequency and coherence
+ * - Tag co-occurrence
+ * - User interaction styles
+ *
+ * @param entries - Memory entries to analyze
+ * @param config - Configuration options
+ * @returns Pattern analysis results
+ */
+export function createPatternRecognizer(entries, config = {}) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    return new PatternRecognizerImpl(entries, cfg);
+}
+class PatternRecognizerImpl {
+    entries;
+    config;
+    tagCooccurrence = new Map();
+    analysisCache = null;
+    constructor(entries, config) {
+        this.entries = entries;
+        this.config = config;
+        this.buildTagCooccurrence();
+    }
+    /**
+     * Build tag co-occurrence matrix for pattern detection
+     */
+    buildTagCooccurrence() {
+        this.tagCooccurrence.clear();
+        for (const entry of this.entries) {
+            for (const tag of entry.tags) {
+                if (!this.tagCooccurrence.has(tag)) {
+                    this.tagCooccurrence.set(tag, {
+                        tag,
+                        cooccursWith: new Map(),
+                        totalCount: 0,
+                    });
+                }
+                const tagData = this.tagCooccurrence.get(tag);
+                tagData.totalCount++;
+                // Count co-occurrences with other tags
+                for (const otherTag of entry.tags) {
+                    if (otherTag !== tag) {
+                        const current = tagData.cooccursWith.get(otherTag) || 0;
+                        tagData.cooccursWith.set(otherTag, current + 1);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Perform full pattern analysis
+     */
+    analyze() {
+        if (this.entries.length < this.config.minMemories) {
+            logger.info(`Not enough memories for pattern analysis (${this.entries.length} < ${this.config.minMemories})`);
+            return this.createEmptyAnalysis();
+        }
+        logger.info(`Analyzing patterns across ${this.entries.length} memories`);
+        const temporalPatterns = this.getTemporalPatterns();
+        const topicPatterns = this.getTopicPatterns();
+        const interactionStyle = this.getInteractionStyle();
+        const optimalRecallTimes = this.getOptimalRecallTimes();
+        const predictedHighValueTags = this.getPredictedHighValueTags();
+        const anomalyScore = this.getAnomalyScore();
+        const analysis = {
+            temporalPatterns,
+            topicPatterns,
+            interactionStyle,
+            optimalRecallTimes,
+            predictedHighValueTags,
+            anomalyScore,
+            analyzedAt: Date.now(),
+        };
+        this.analysisCache = analysis;
+        return analysis;
+    }
+    /**
+     * Create empty analysis when insufficient data
+     */
+    createEmptyAnalysis() {
+        return {
+            temporalPatterns: [],
+            topicPatterns: [],
+            interactionStyle: {
+                style: 'mixed',
+                confidence: 0,
+                indicators: [],
+                dominantTags: [],
+            },
+            optimalRecallTimes: [],
+            predictedHighValueTags: [],
+            anomalyScore: 0,
+            analyzedAt: Date.now(),
+        };
+    }
+    /**
+     * Get temporal patterns (when user stores memories)
+     */
+    getTemporalPatterns() {
+        const patterns = [];
+        const now = Date.now();
+        const cutoff = now - (this.config.temporalWindowDays * 24 * 60 * 60 * 1000);
+        // Filter to time window
+        const recentEntries = this.entries.filter(e => e.timestamp >= cutoff);
+        // Hour patterns
+        const hourMap = new Map();
+        for (const entry of recentEntries) {
+            const d = new Date(entry.timestamp);
+            const hour = d.getHours();
+            const existing = hourMap.get(hour) || { count: 0, importance: 0, tags: [] };
+            existing.count++;
+            existing.importance += entry.importance;
+            existing.tags.push(...entry.tags.slice(0, 2));
+            hourMap.set(hour, existing);
+        }
+        for (const [hour, data] of hourMap) {
+            patterns.push({
+                window: 'hour',
+                value: hour,
+                count: data.count,
+                avgImportance: data.importance / data.count,
+                topTags: this.getTopTags(data.tags, 3),
+            });
+        }
+        // Day patterns (0=Sun, 6=Sat)
+        const dayMap = new Map();
+        for (const entry of recentEntries) {
+            const d = new Date(entry.timestamp);
+            const day = d.getDay();
+            const existing = dayMap.get(day) || { count: 0, importance: 0, tags: [] };
+            existing.count++;
+            existing.importance += entry.importance;
+            existing.tags.push(...entry.tags.slice(0, 2));
+            dayMap.set(day, existing);
+        }
+        for (const [day, data] of dayMap) {
+            patterns.push({
+                window: 'day',
+                value: day,
+                count: data.count,
+                avgImportance: data.importance / data.count,
+                topTags: this.getTopTags(data.tags, 3),
+            });
+        }
+        return patterns;
+    }
+    /**
+     * Get top tags from a list
+     */
+    getTopTags(tags, limit) {
+        const counts = new Map();
+        for (const tag of tags) {
+            counts.set(tag, (counts.get(tag) || 0) + 1);
+        }
+        return Array.from(counts.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, limit)
+            .map(([tag]) => tag);
+    }
+    /**
+     * Get topic patterns based on tag frequency and recency
+     */
+    getTopicPatterns() {
+        const patterns = [];
+        for (const [tag, data] of this.tagCooccurrence) {
+            const recency = Math.max(...this.entries
+                .filter(e => e.tags.includes(tag))
+                .map(e => e.timestamp));
+            // Calculate coherence: how consistently this tag appears
+            const entriesWithTag = this.entries.filter(e => e.tags.includes(tag));
+            const coherence = entriesWithTag.length / this.entries.length;
+            patterns.push({
+                topic: tag,
+                frequency: data.totalCount,
+                avgImportance: data.totalCount / this.entries.length, // normalized
+                recency,
+                coherence: Math.min(coherence * 10, 1), // scale to 0-1
+            });
+        }
+        return patterns.sort((a, b) => b.frequency - a.frequency);
+    }
+    /**
+     * Detect user's interaction style based on tag patterns
+     */
+    getInteractionStyle() {
+        const tagData = Array.from(this.tagCooccurrence.entries())
+            .map(([tagName, data]) => ({
+            tag: tagName,
+            cooccursWith: data.cooccursWith,
+            totalCount: data.totalCount
+        }))
+            .sort((a, b) => b.totalCount - a.totalCount);
+        const topTags = tagData.slice(0, 10).map(d => d.tag);
+        // Style indicators
+        const indicators = [];
+        // Analytical: code, technical, system, data, logic
+        const analyticalTags = ['code', 'technical', 'system', 'data', 'logic', 'debug', 'architecture'];
+        const analyticalCount = topTags.filter(t => analyticalTags.includes(t.toLowerCase())).length;
+        if (analyticalCount >= 2)
+            indicators.push('anytical patterns detected');
+        // Creative: idea, design, creative, story, write, art
+        const creativeTags = ['idea', 'design', 'creative', 'story', 'write', 'art', 'content'];
+        const creativeCount = topTags.filter(t => creativeTags.some(c => t.toLowerCase().includes(c))).length;
+        if (creativeCount >= 2)
+            indicators.push('creative patterns detected');
+        // Operational: task, project, plan, schedule, workflow
+        const operationalTags = ['task', 'project', 'plan', 'schedule', 'workflow', 'routine'];
+        const operationalCount = topTags.filter(t => operationalTags.some(o => t.toLowerCase().includes(o))).length;
+        if (operationalCount >= 2)
+            indicators.push('operational patterns detected');
+        // Social: user, people, team, communication, feedback
+        const socialTags = ['user', 'people', 'team', 'communication', 'feedback', 'review', 'collaboration'];
+        const socialCount = topTags.filter(t => socialTags.some(s => t.toLowerCase().includes(s))).length;
+        if (socialCount >= 2)
+            indicators.push('social patterns detected');
+        // Determine dominant style
+        const counts = { analytical: analyticalCount, creative: creativeCount, operational: operationalCount, social: socialCount };
+        const maxCount = Math.max(...Object.values(counts));
+        const dominantStyles = Object.entries(counts).filter(([, c]) => c === maxCount).map(([s]) => s);
+        let style = 'mixed';
+        let confidence = 0.5;
+        if (dominantStyles.length === 1 && maxCount >= 2) {
+            style = dominantStyles[0];
+            confidence = Math.min(maxCount / 5, 0.95); // higher confidence with more matches
+        }
+        return {
+            style,
+            confidence,
+            indicators,
+            dominantTags: topTags.slice(0, 5),
+        };
+    }
+    /**
+     * Calculate optimal times for memory recall based on temporal patterns
+     */
+    getOptimalRecallTimes() {
+        const hourCounts = new Map();
+        for (const entry of this.entries) {
+            const d = new Date(entry.timestamp);
+            const hour = d.getHours();
+            hourCounts.set(hour, (hourCounts.get(hour) || 0) + 1);
+        }
+        const maxCount = Math.max(...hourCounts.values());
+        const results = [];
+        for (let h = 0; h < 24; h++) {
+            const count = hourCounts.get(h) || 0;
+            results.push({
+                hour: h,
+                score: count / maxCount,
+            });
+        }
+        return results.sort((a, b) => b.score - a.score);
+    }
+    /**
+     * Predict which tags will be high-value based on patterns
+     */
+    getPredictedHighValueTags() {
+        // Tags that appear frequently with high importance
+        const tagScores = new Map();
+        for (const entry of this.entries) {
+            for (const tag of entry.tags) {
+                const currentScore = tagScores.get(tag) || 0;
+                // Score = importance * recency boost * frequency
+                const recencyBoost = this.getRecencyBoost(entry.timestamp);
+                tagScores.set(tag, currentScore + (entry.importance * recencyBoost));
+            }
+        }
+        return Array.from(tagScores.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 10)
+            .map(([tag]) => tag);
+    }
+    /**
+     * Get recency boost factor (higher for recent entries)
+     */
+    getRecencyBoost(timestamp) {
+        const now = Date.now();
+        const age = now - timestamp;
+        const dayMs = 24 * 60 * 60 * 1000;
+        const daysOld = age / dayMs;
+        // Exponential decay: more recent = higher boost
+        return Math.exp(-daysOld / 7); // 7-day half-life
+    }
+    /**
+     * Calculate anomaly score for recent memories
+     * Compares recent patterns to historical baseline
+     */
+    getAnomalyScore() {
+        if (!this.config.enableAnomalyDetection || this.entries.length < 20) {
+            return 0;
+        }
+        const now = Date.now();
+        const dayMs = 24 * 60 * 60 * 1000;
+        const weekMs = 7 * dayMs;
+        // Split into recent (last 3 days) and baseline (before that)
+        const recentCutoff = now - (3 * dayMs);
+        const baselineCutoff = now - weekMs;
+        const recentEntries = this.entries.filter(e => e.timestamp >= recentCutoff);
+        const baselineEntries = this.entries.filter(e => e.timestamp >= baselineCutoff && e.timestamp < recentCutoff);
+        if (recentEntries.length === 0 || baselineEntries.length === 0) {
+            return 0;
+        }
+        // Compare tag distribution
+        const recentTags = this.getTagDistribution(recentEntries);
+        const baselineTags = this.getTagDistribution(baselineEntries);
+        // Calculate KL-like divergence (simplified)
+        let divergence = 0;
+        const allTags = new Set([...recentTags.keys(), ...baselineTags.keys()]);
+        for (const tag of allTags) {
+            const p = recentTags.get(tag) || 0.001;
+            const q = baselineTags.get(tag) || 0.001;
+            divergence += p * Math.log(p / q);
+        }
+        // Normalize to 0-1 range (typical divergence is 0-2)
+        return Math.min(divergence / 2, 1);
+    }
+    /**
+     * Get tag distribution as proportions
+     */
+    getTagDistribution(entries) {
+        const counts = new Map();
+        let total = 0;
+        for (const entry of entries) {
+            for (const tag of entry.tags) {
+                counts.set(tag, (counts.get(tag) || 0) + 1);
+                total++;
+            }
+        }
+        const dist = new Map();
+        for (const [tag, count] of counts) {
+            dist.set(tag, count / total);
+        }
+        return dist;
+    }
+}

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '2.3.1';
+export const VERSION = '2.3.3';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mark-improving-agent",
-  "version": "2.3.1",
+  "version": "2.3.3",
   "description": "Self-evolving AI agent with permanent memory, identity continuity, and self-evolution — for AI agents that need to remember, learn, and evolve across sessions",
   "type": "module",
   "main": "./dist/index.js",