mark-improving-agent 2.3.0 → 2.3.2

package/VERSION

@@ -1 +1 @@
-2.3.0
+2.3.2

package/dist/core/behavior-playbook.js

@@ -0,0 +1,211 @@
+/**
+ * Behavior Playbook - Pattern-Based Playbook Extraction System
+ *
+ * Inspired by ReflexioAI's self-improvement framework:
+ * - Extracts actionable playbooks from user correction patterns
+ * - Clusters similar behaviors and aggregates into reusable playbooks
+ * - Tracks playbook effectiveness through success/failure metrics
+ * - Enables cross-session learning (what one user teaches, all sessions benefit)
+ *
+ * @module core/behavior-playbook
+ * @fileoverview Playbook extraction from interaction patterns
+ */
+import { createLogger } from '../utils/logger.js';
+import { atomicWriteJSON, readJSON, ensureDir } from '../storage/archive.js';
+import { randomUUID } from 'crypto';
+const logger = createLogger('[BehaviorPlaybook]');
+const DEFAULT_CONFIG = {
+    minConfidence: 0.6,
+    maxPlaybooks: 100,
+    clusterThreshold: 0.8,
+    autoExtract: true,
+};
+const PLAYBOOKS_FILE = 'behavior-playbooks.json';
+const CORRECTIONS_FILE = 'correction-events.json';
+function extractContext(text) {
+    if (text.length <= 50)
+        return text;
+    return text.slice(0, 47) + '...';
+}
+function extractPlaybookFromCorrection(event) {
+    const { userMessage, correction } = event;
+    if (correction.length < 5 || userMessage.length < 5)
+        return null;
+    let trigger = '';
+    let action = '';
+    const tags = [];
+    const lowerCorrection = correction.toLowerCase();
+    if (lowerCorrection.startsWith("don't") || lowerCorrection.startsWith("do not") || lowerCorrection.startsWith("never")) {
+        const match = correction.match(/(?:don't|do not|never)\s+(.+)/i);
+        if (match) {
+            const avoided = match[1].trim();
+            trigger = `When about to: ${avoided}`;
+            action = `Avoid: ${avoided}`;
+            tags.push('avoid', 'user-warning');
+        }
+    }
+    else if (lowerCorrection.startsWith("you should") || lowerCorrection.startsWith("you need to") || lowerCorrection.startsWith("always")) {
+        const match = correction.match(/(?:you should|you need to|always)\s+(.+)/i);
+        if (match) {
+            const required = match[1].trim();
+            trigger = `When encountering relevant situation`;
+            action = `Always: ${required}`;
+            tags.push('positive', 'user-guidance');
+        }
+    }
+    else {
+        // Generic extraction
+        trigger = extractContext(userMessage);
+        action = correction;
+        tags.push('general', 'user-correction');
+    }
+    if (!trigger || !action)
+        return null;
+    return { trigger, action, tags, source: 'user-correction' };
+}
+function cosineSimilarity(a, b) {
+    const wordsA = new Set(a.toLowerCase().split(/\s+/));
+    const wordsB = new Set(b.toLowerCase().split(/\s+/));
+    const intersection = new Set([...wordsA].filter(x => wordsB.has(x)));
+    const union = new Set([...wordsA, ...wordsB]);
+    if (union.size === 0)
+        return 0;
+    return intersection.size / union.size;
+}
+export function createBehaviorPlaybook(dataDir, config = {}) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    const playbooks = [];
+    const corrections = [];
+    let dirty = false;
+    async function persist() {
+        if (!dirty)
+            return;
+        await Promise.all([
+            atomicWriteJSON(`${dataDir}/${PLAYBOOKS_FILE}`, playbooks),
+            atomicWriteJSON(`${dataDir}/${CORRECTIONS_FILE}`, corrections),
+        ]);
+        dirty = false;
+    }
+    async function boot() {
+        await ensureDir(dataDir);
+        const [loadedPlaybooks, loadedCorrections] = await Promise.all([
+            readJSON(`${dataDir}/${PLAYBOOKS_FILE}`, []),
+            readJSON(`${dataDir}/${CORRECTIONS_FILE}`, []),
+        ]);
+        if (loadedPlaybooks?.length)
+            playbooks.push(...loadedPlaybooks);
+        if (loadedCorrections?.length)
+            corrections.push(...loadedCorrections);
+        logger.info(`Booted with ${playbooks.length} playbooks, ${corrections.length} corrections`);
+    }
+    function addCorrection(event) {
+        const full = { ...event, id: randomUUID(), timestamp: Date.now() };
+        corrections.push(full);
+        if (corrections.length > 500)
+            corrections.splice(0, corrections.length - 500);
+        if (cfg.autoExtract)
+            extractPlaybook(full);
+        return full;
+    }
+    function extractPlaybook(event) {
+        const partial = extractPlaybookFromCorrection(event);
+        if (!partial)
+            return null;
+        // Check for similar existing playbook
+        for (const existing of playbooks) {
+            if (cosineSimilarity(existing.action, partial.action) > cfg.clusterThreshold) {
+                // Update existing playbook's confidence
+                existing.successCount++;
+                existing.confidence = Math.min(0.95, existing.confidence + 0.05);
+                existing.lastUsed = Date.now();
+                dirty = true;
+                return existing;
+            }
+        }
+        const playbook = {
+            id: randomUUID(),
+            trigger: partial.trigger,
+            action: partial.action,
+            confidence: 0.5,
+            successCount: 0,
+            failureCount: 0,
+            source: partial.source,
+            createdAt: Date.now(),
+            lastUsed: Date.now(),
+            tags: partial.tags,
+            version: 1,
+        };
+        playbooks.push(playbook);
+        if (playbooks.length > cfg.maxPlaybooks) {
+            playbooks.splice(0, playbooks.length - cfg.maxPlaybooks);
+        }
+        dirty = true;
+        logger.info(`Extracted playbook: ${playbook.action.slice(0, 50)}`);
+        return playbook;
+    }
+    function getPlaybook(id) {
+        return playbooks.find(p => p.id === id) ?? null;
+    }
+    function searchPlaybooks(query, limit = 5) {
+        const results = [];
+        for (const p of playbooks) {
+            if (p.confidence < cfg.minConfidence)
+                continue;
+            const queryLower = query.toLowerCase();
+            const triggerMatch = p.trigger.toLowerCase().includes(queryLower);
+            const actionMatch = p.action.toLowerCase().includes(queryLower);
+            const tagMatch = p.tags.some(t => t.toLowerCase().includes(queryLower));
+            if (!triggerMatch && !actionMatch && !tagMatch)
+                continue;
+            let score = 0;
+            let matchType = 'fuzzy';
+            if (actionMatch) {
+                score += 0.6;
+                matchType = 'exact';
+            }
+            if (triggerMatch)
+                score += 0.3;
+            if (tagMatch) {
+                score += 0.2;
+                if (matchType !== 'exact')
+                    matchType = 'tag';
+            }
+            score *= p.confidence;
+            results.push({ playbook: p, relevanceScore: score, matchType });
+        }
+        return results.sort((a, b) => b.relevanceScore - a.relevanceScore).slice(0, limit);
+    }
+    function getPlaybooksByTag(tag) {
+        return playbooks.filter(p => p.tags.some(t => t.toLowerCase().includes(tag.toLowerCase())));
+    }
+    function markPlaybookHit(id, success) {
+        const p = playbooks.find(p => p.id === id);
+        if (!p)
+            return;
+        if (success) {
+            p.successCount++;
+            p.confidence = Math.min(0.95, p.confidence + (0.95 - p.confidence) * 0.1);
+        }
+        else {
+            p.failureCount++;
+            p.confidence = Math.max(0.3, p.confidence - 0.05);
+        }
+        p.lastUsed = Date.now();
+        dirty = true;
+    }
+    function getActivePlaybooks() {
+        return playbooks.filter(p => p.confidence >= cfg.minConfidence);
+    }
+    function getStats() {
+        const avgConfidence = playbooks.length ? playbooks.reduce((s, p) => s + p.confidence, 0) / playbooks.length : 0;
+        const tagCounts = new Map();
+        for (const p of playbooks) {
+            for (const t of p.tags) {
+                tagCounts.set(t, (tagCounts.get(t) ?? 0) + 1);
+            }
+        }
+        const topTags = [...tagCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([t]) => t);
+        return { totalPlaybooks: playbooks.length, avgConfidence, topTags };
+    }
+    return { addCorrection, extractPlaybook, getPlaybook, searchPlaybooks, getPlaybooksByTag, markPlaybookHit, getActivePlaybooks, getStats, boot, persist };
+}

package/dist/core/memory/index.js

@@ -9,3 +9,4 @@ 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';

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/index.js

@@ -10,3 +10,4 @@ export { createMCPProtocol } from './core/collaboration/mcp-protocol.js';
 export { createTruthTeller, formatTruthStatement } from './core/truth-teller.js';
 export { createActiveInferenceEngine, formatFreeEnergyMetrics, formatBeliefState } from './core/cognition/active-inference.js';
 export { createExpertModelsEngine } from './core/expert-models/index.js';
+export { createBehaviorPlaybook } from './core/behavior-playbook.js';

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '2.3.0';
+export const VERSION = '2.3.2';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mark-improving-agent",
-  "version": "2.3.0",
+  "version": "2.3.2",
   "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",