@devflow-tools/memory-engine 0.13.3 → 0.14.1

package/dist/memory-engine.js

@@ -5,20 +5,27 @@ import { MemoryStore } from './memory-store.js';
 import { EmbeddingProvider } from './embedding-provider.js';
 import { HybridSearch } from './hybrid-search.js';
 import { GraphStore } from './graph-store.js';
-import { extractMemories, extractFromEvents, isExtractionAvailable } from './extractor.js';
+import { extractMemories, extractFromEvents } from './extractor.js';
 import { checkOllama } from './ollama-checker.js';
+import { setLLMClient } from './llm-provider.js';
+import { setL2LLMClient } from './l2-evaluator.js';
 export class MemoryEngine {
     store;
     embedder;
     searcher;
     graph;
     rootPath;
-    constructor(rootPath, embedder) {
+    constructor(rootPath, embedder, llmClient) {
         this.rootPath = rootPath;
         this.store = new MemoryStore(rootPath);
         this.embedder = embedder ?? new EmbeddingProvider();
         this.searcher = new HybridSearch(this.store, this.embedder, this);
         this.graph = new GraphStore(this.store);
+        if (llmClient) {
+            setLLMClient(llmClient);
+            setL2LLMClient(llmClient);
+            console.log('[MemoryEngine] LLM client connected', { provider: llmClient.name });
+        }
     }
     _initPromise = null;
     _embedderAvailable = true;
@@ -46,11 +53,12 @@ export class MemoryEngine {
         // User preferences kept minimal — not stored in memory system
     }
     async getProjectContext() {
-        const memories = this.store.listByCategory('semantic');
+        const projectTypes = ['project_knowledge', 'semantic', 'pattern', 'constraint', 'preference'];
+        const memories = this.store.listByTypes(projectTypes);
         return {
             stack: this.detectTechStack(),
             conventions: memories.map(m => ({
-                key: m.scope || this.deriveConventionKey(m.content, m.category),
+                key: m.scope || this.deriveConventionKey(m.content, m.type),
                 value: m.content,
                 source: m.source,
                 confidence: m.confidence,
@@ -125,24 +133,54 @@ export class MemoryEngine {
         return ctx.conventions;
     }
     async createSession(task) {
-        return `session:${Date.now()}:${task.slice(0, 20)}`;
+        const id = `session:${Date.now().toString(36)}:${task.slice(0, 20)}`;
+        this.store.createSession(id, this.rootPath, task);
+        return id;
     }
     async appendToSession(_sessionId, _entry) {
         // Session tracking delegated to existing IDataProvider
     }
     async getSession(sessionId) {
+        const row = this.store.getSession(sessionId);
+        if (row) {
+            return { sessionId, task: row.task, entries: [], createdAt: row.created_at };
+        }
         return { sessionId, task: '', entries: [], createdAt: Date.now() };
     }
     async closeSession(sessionId) {
-        void sessionId;
+        // Close in DB
+        this.store.closeSession(sessionId);
+        // Update session stats from events
+        const events = this.store.getSessionEvents(sessionId);
+        this.store.updateSessionStats(sessionId, {
+            tool_count: events.length,
+            error_count: events.filter(e => e.exit_code !== 0 && e.exit_code != null).length,
+        });
+        // Run summarizer to produce observations
+        await this.summarizeSessionEvents(sessionId, this.rootPath);
+        // Run consolidator for cross-session aggregation
+        try {
+            const { consolidate } = await import('./consolidator.js');
+            await consolidate(this.store, this.rootPath);
+        }
+        catch (err) {
+            console.warn('[MemoryEngine] Consolidator failed', { error: err.message });
+        }
+        // Run retention sweep (incremental — sweeps all candidates)
+        try {
+            this.store.runRetentionSweep(this.rootPath);
+        }
+        catch (err) {
+            console.warn('[MemoryEngine] Retention sweep failed', { error: err.message });
+        }
     }
     async searchGlobal(query) {
         await this.ensureInit();
         const results = await this.searcher.search(query, { limit: 10 });
         return results.map(r => ({
             id: r.entry.id,
-            source: r.entry.category,
-            title: r.entry.content.slice(0, 80),
+            source: r.entry.type,
+            title: r.entry.title || r.entry.content.slice(0, 80),
             content: r.entry.content,
             embedding: [],
         }));
@@ -163,7 +201,7 @@ export class MemoryEngine {
         return pending.map(m => ({
             id: m.id,
             type: 'project',
-            content: { category: m.category, content: m.content, confidence: m.confidence, scope: m.scope },
+            content: { category: m.type, content: m.content, confidence: m.confidence, scope: m.scope },
             confidence: m.confidence,
             source: m.source,
         }));
@@ -183,7 +221,7 @@ export class MemoryEngine {
         if (results.length > limit) {
             try {
                 const { claudeRerank } = await import('@devflow-tools/context-engine/claude-rerank.js');
-                const reranked = await claudeRerank(query, results.map(r => ({ id: r.entry.id, name: r.entry.category, snippet: r.entry.content.slice(0, 150), score: r.score })), { topK: limit });
+                const reranked = await claudeRerank(query, results.map(r => ({ id: r.entry.id, name: r.entry.type, snippet: r.entry.content.slice(0, 150), score: r.score })), { topK: limit });
                 const rerankIds = new Set(reranked.map(r => r.id));
                 return results.filter(r => rerankIds.has(r.entry.id)).slice(0, limit);
             }
@@ -192,24 +230,16 @@ export class MemoryEngine {
         return results;
     }
     async listMemories(filter) {
-        const rows = this.store.list(filter);
-        return rows.map(r => ({
-            id: r.id,
-            category: r.category,
-            content: r.content,
-            originalText: r.original_text ?? undefined,
-            source: r.source,
-            status: r.status,
-            confidence: r.confidence,
-            scope: r.scope,
-            sessionId: r.session_id ?? undefined,
-            createdAt: r.created_at,
-            approvedAt: r.approved_at ?? undefined,
-        }));
+        const rows = this.store.list({
+            type: filter?.category,
+            status: filter?.status,
+            scope: filter?.scope,
+        });
+        return rows.map(r => this._rowToRecord(r));
     }
     async addMemory(entry) {
         await this.ensureInit();
-        // 1. SHA-256 content hash exact dedup (all statuses)
+        // 1. SHA-256 content hash exact dedup
         const normalizedContent = entry.content
             .replace(/\/Users\/[^/\s]+(\/\S+)?/g, '{PROJECT_ROOT}$1')
             .replace(/\/tmp\/[^/\s]+/g, '{TMP}')
@@ -226,26 +256,15 @@ export class MemoryEngine {
         });
         if (dupe) {
             this.store.incrementAccess(dupe.id);
-            return {
-                id: dupe.id,
-                category: dupe.category,
-                content: dupe.content,
-                originalText: dupe.original_text ?? undefined,
-                source: dupe.source,
-                status: dupe.status,
-                confidence: dupe.confidence,
-                scope: dupe.scope,
-                sessionId: dupe.session_id ?? undefined,
-                createdAt: dupe.created_at,
-                approvedAt: dupe.approved_at ?? undefined,
-            };
+            return this._rowToRecord(dupe);
         }
-        // 2. Semantic dedup by embedding similarity (all statuses)
+        // 2. Semantic dedup by embedding similarity + contradiction detection
         let insertStatus = 'approved';
+        let newEmb = null;
         if (this._embedderAvailable) {
             try {
-                const newEmb = await this.embedder.embed(entry.content);
-                const all = this.store.list({ category: entry.category });
+                newEmb = await this.embedder.embed(entry.content);
+                const all = this.store.list({ type: entry.category });
                 let bestSim = 0;
                 let bestMatch = null;
                 for (const m of all.slice(0, 200)) {
@@ -269,27 +288,78 @@ export class MemoryEngine {
                 }
                 if (bestSim > 0.85 && bestMatch) {
                     if (entry.content.length > bestMatch.content.length) {
-                        this.store.update(bestMatch.id, { content: entry.content });
+                        const newRow = this.store.add({
+                            type: bestMatch.type,
+                            category: entry.category,
+                            content: entry.content,
+                            originalText: entry.originalText,
+                            source: entry.source,
+                            status: bestMatch.status,
+                            confidence: entry.confidence ?? bestMatch.confidence,
+                            scope: entry.scope ?? bestMatch.scope,
+                            sessionId: entry.sessionId,
+                        });
+                        this.store.update(newRow.id, {
+                            version: (bestMatch.version || 1) + 1,
+                            supersedes: bestMatch.id,
+                        });
+                        this.store.update(bestMatch.id, {
+                            status: 'superseded',
+                            superseded_by: newRow.id,
+                        });
+                        this.store.recordHistory({
+                            memoryId: bestMatch.id,
+                            event: 'SUPERSEDE',
+                            oldContent: bestMatch.content,
+                            newContent: entry.content,
+                            oldStrength: bestMatch.strength,
+                            reason: `superseded_by:${newRow.id}`,
+                        });
+                        console.log('[MemoryEngine] Memory versioned', {
+                            oldId: bestMatch.id,
+                            newId: newRow.id,
+                            version: (bestMatch.version || 1) + 1,
+                        });
+                        return this._rowToRecord(newRow);
                     }
-                    return {
-                        id: bestMatch.id,
-                        category: bestMatch.category,
-                        content: bestMatch.content,
-                        originalText: bestMatch.original_text ?? undefined,
-                        source: bestMatch.source,
-                        status: bestMatch.status,
-                        confidence: bestMatch.confidence,
-                        scope: bestMatch.scope,
-                        sessionId: bestMatch.session_id ?? undefined,
-                        createdAt: bestMatch.created_at,
-                        approvedAt: bestMatch.approved_at ?? undefined,
-                    };
+                    this.store.incrementAccess(bestMatch.id);
+                    return this._rowToRecord(bestMatch);
                 }
                 if (bestSim > 0.7) {
                     insertStatus = 'pending';
                 }
             }
-            catch { /* Semantic dedup failed — continue without it */ }
+            catch { /* Semantic dedup failed */ }
+        }
+        // 3. Contradiction detection (blocking, before write)
+        if (newEmb) {
+            try {
+                const arbitration = await this.detectAndArbitrateContradiction(entry.content, newEmb);
+                if (arbitration.decision === 'skip') {
+                    console.log('[MemoryEngine] Memory skipped by contradiction arbitration', { reason: arbitration.reason });
+                    return null;
+                }
+                if (arbitration.decision === 'merge' && arbitration.conflictingId) {
+                    const mergedContent = arbitration.mergedContent || `${entry.content}`;
+                    this.store.update(arbitration.conflictingId, { content: mergedContent });
+                    this.store.incrementAccess(arbitration.conflictingId);
+                    this.store.recordHistory({
+                        memoryId: arbitration.conflictingId,
+                        event: 'UPDATE',
+                        newContent: mergedContent,
+                        reason: `contradiction_merged: ${arbitration.reason ?? 'unknown'}`,
+                    });
+                    console.log('[MemoryEngine] Memory merged via contradiction arbitration', {
+                        conflictingId: arbitration.conflictingId,
+                        reason: arbitration.reason,
+                    });
+                    const mergedRow = this.store.get(arbitration.conflictingId);
+                    return mergedRow ? this._rowToRecord(mergedRow) : null;
+                }
+            }
+            catch (err) {
+                console.warn('[MemoryEngine] Contradiction detection failed, proceeding with write', { error: err.message });
+            }
         }
         const row = this.store.add({
             category: entry.category,
@@ -301,29 +371,70 @@ export class MemoryEngine {
             scope: entry.scope,
             sessionId: entry.sessionId,
         });
-        this.embedder.embed(entry.content).then(emb => {
-            this.store.insertEmbedding(row.id, emb);
-        }).catch(() => { });
+        // 4. Audit: record ADD event
+        this.store.recordHistory({
+            memoryId: row.id,
+            event: 'ADD',
+            newContent: entry.content,
+            newStrength: entry.confidence ?? 0.5,
+            reason: entry.source === 'manual' ? 'manual' : entry.source === 'consolidation' ? 'consolidation' : 'auto',
+        });
+        // 5. Post-processing (async, non-blocking)
+        if (newEmb) {
+            this.store.insertEmbedding(row.id, newEmb);
+        }
+        else {
+            this.embedder.embed(entry.content).then(emb => {
+                this.store.insertEmbedding(row.id, emb);
+            }).catch(() => { });
+        }
         this.graph.buildEdges(row.id).catch(() => { });
-        this.detectContradictions(row.id).catch(() => { });
+        return this._rowToRecord(row);
+    }
+    /** Map internal MemoryRow → SDK MemoryEntryRecord */
+    _rowToRecord(row) {
+        const sdkStatus = row.status === 'active' ? 'approved' :
+            row.status === 'superseded' ? 'expired' :
+                row.status;
         return {
             id: row.id,
-            category: row.category,
+            category: row.type,
             content: row.content,
             originalText: row.original_text ?? undefined,
             source: row.source,
-            status: row.status,
+            status: sdkStatus,
             confidence: row.confidence,
             scope: row.scope,
             sessionId: row.session_id ?? undefined,
             createdAt: row.created_at,
-            approvedAt: row.approved_at ?? undefined,
+            approvedAt: (row.status === 'active' || row.status === 'approved') ? row.updated_at : undefined,
         };
     }
     async updateMemory(id, updates) {
+        const old = this.store.get(id);
         this.store.update(id, updates);
+        if (old) {
+            this.store.recordHistory({
+                memoryId: id,
+                event: 'UPDATE',
+                oldContent: updates.content ? old.content : undefined,
+                newContent: updates.content,
+                oldStrength: old.confidence,
+                newStrength: updates.status ? old.confidence : undefined,
+                reason: 'manual_update',
+            });
+        }
     }
     async deleteMemory(id) {
+        const old = this.store.get(id);
+        if (old) {
+            this.store.recordHistory({
+                memoryId: id,
+                event: 'DELETE',
+                oldContent: old.content,
+                reason: 'manual_delete',
+            });
+        }
         this.store.delete(id);
     }
     async getPendingMemories() {
@@ -331,6 +442,11 @@ export class MemoryEngine {
     }
     async approveMemory(id) {
         this.store.update(id, { status: 'approved' });
+        this.store.recordHistory({
+            memoryId: id,
+            event: 'REINFORCE',
+            reason: 'user_approved',
+        });
     }
     async rejectMemory(id) {
         this.store.delete(id);
@@ -375,7 +491,7 @@ export class MemoryEngine {
             .map(e => e.command)
             .filter(Boolean)
             .slice(0, 20);
-        const errorCount = events.filter(e => e.exitCode !== 0 && e.exitCode != null).length;
+        const errorCount = events.filter(e => e.exit_code !== 0 && e.exit_code != null).length;
         const summary = [
             `Session involved ${events.length} tool calls across ${toolSet.size} distinct tools`,
             touchFiles.length > 0 ? `Touched files: ${touchFiles.join(', ')}` : null,
@@ -392,54 +508,101 @@ export class MemoryEngine {
         this.store.setExpires(entry.id, expiresAt);
         return entry;
     }
-    async detectContradictions(memoryId) {
-        const row = this.store.get(memoryId);
-        if (!row)
-            return;
+    /**
+     * Pre-write contradiction check with LLM arbitration.
+     * Returns the decision: 'keep' (write new), 'merge' (update existing), 'skip' (don't write).
+     */
+    async detectAndArbitrateContradiction(content, embedding) {
         const NEGATION_WORDS = /\b(not|never|don't|doesn't|no longer|instead|rather than|avoid)\b/i;
-        if (!NEGATION_WORDS.test(row.content))
-            return;
-        let newEmb = null;
-        try {
-            newEmb = await this.embedder.embed(row.content);
-        }
-        catch {
-            return;
-        }
+        const hasNegation = NEGATION_WORDS.test(content);
         const allApproved = this.store.list({ status: 'approved' });
         for (const existing of allApproved.slice(0, 100)) {
-            if (existing.id === memoryId)
-                continue;
             const embBuf = this.store.getEmbedding(existing.id);
             if (!embBuf)
                 continue;
             const existEmb = new Float32Array(embBuf.buffer, embBuf.byteOffset, embBuf.byteLength / 4);
-            if (existEmb.length !== newEmb.length)
+            if (existEmb.length !== embedding.length)
                 continue;
             let dot = 0, normA = 0, normB = 0;
-            for (let i = 0; i < newEmb.length; i++) {
-                dot += newEmb[i] * existEmb[i];
-                normA += newEmb[i] * newEmb[i];
+            for (let i = 0; i < embedding.length; i++) {
+                dot += embedding[i] * existEmb[i];
+                normA += embedding[i] * embedding[i];
                 normB += existEmb[i] * existEmb[i];
             }
             const sim = dot / (Math.sqrt(normA) * Math.sqrt(normB));
-            if (sim > 0.85) {
-                this.store.addEdge(memoryId, existing.id, 'contradicts', 0.9);
-                this.store.addEdge(existing.id, memoryId, 'contradicts', 0.9);
+            if (sim < 0.85)
+                continue;
+            console.log('[MemoryEngine] Contradiction detected', {
+                memoryId: existing.id,
+                conflictingContent: content.slice(0, 100),
+                similarity: sim,
+            });
+            // Try LLM arbitration
+            try {
+                const { callLLM } = await import('./llm-provider.js');
+                const ARBITRATION_SYSTEM = `You are a knowledge arbitrator. Two memory entries appear to contradict each other.
+Decide what to do:
+- "keep": the new entry is correct, keep it as-is
+- "merge": merge the new information into the existing entry (provide the merged text)
+- "skip": the new entry is wrong or redundant, discard it
+
+Output ONLY a JSON object: {"decision":"keep|merge|skip","mergedContent":"...","confidence":0.0-1.0,"reason":"..."}`;
+                const arbitrationPrompt = `Existing memory: "${existing.content}"
+New entry: "${content}"
+Similarity: ${sim.toFixed(3)}
+Has negation words: ${hasNegation}
+
+Decision:`;
+                const response = await callLLM(ARBITRATION_SYSTEM, arbitrationPrompt);
+                if (response.provider !== 'rules') {
+                    const result = JSON.parse(response.content);
+                    console.log('[MemoryEngine] Contradiction LLM arbitration', {
+                        decision: result.decision,
+                        confidence: result.confidence,
+                    });
+                    return {
+                        decision: result.decision,
+                        conflictingId: existing.id,
+                        mergedContent: result.mergedContent,
+                        confidence: result.confidence,
+                        reason: result.reason,
+                    };
+                }
+            }
+            catch (err) {
+                console.warn('[MemoryEngine] LLM arbitration failed, using rule fallback', { error: err.message });
+            }
+            // Rule fallback
+            if (hasNegation) {
+                return {
+                    decision: 'merge',
+                    conflictingId: existing.id,
+                    mergedContent: `${existing.content}\n\nUpdated: ${content}`,
+                    confidence: 0.5,
+                    reason: 'negation_rule_fallback',
+                };
             }
+            return { decision: 'keep', confidence: 0.5, reason: 'rule_fallback_no_negation' };
         }
+        return { decision: 'keep' };
     }
     close() {
         this.store.close();
     }
     // --- Event Recording & Extraction Pipeline ---
     async recordEvent(event) {
-        this.store.recordEvent(event);
+        this.store.recordEvent({
+            ...event,
+            project: event.sessionId ? undefined : undefined,
+        });
+    }
+    recordSignals(signals) {
+        this.store.recordSignals(signals);
     }
     getEffectiveConfidence(entry) {
         const now = Date.now();
         const ageDays = (now - entry.createdAt) / (1000 * 60 * 60 * 24);
-        const lambdaBase = 0.05;
+        const lambdaBase = 0.006;
         const accessCount = entry.accessCount ?? 0;
         const lambdaActual = lambdaBase / (1 + 0.1 * accessCount);
         return entry.confidence * Math.exp(-lambdaActual * ageDays);
@@ -447,7 +610,9 @@ export class MemoryEngine {
     applyDecisionMatrix(category, confidence) {
         switch (category) {
             case 'procedural': return confidence >= 0.85 ? 'approved' : 'pending';
-            case 'failure_lesson': return confidence >= 0.85 ? 'approved' : 'pending';
+            case 'failure_lesson': return 'pending';
+            case 'mcp_correction': return confidence >= 0.8 ? 'approved' : 'pending';
+            case 'project_knowledge': return 'approved';
             case 'semantic': return confidence >= 0.65 ? 'approved' : 'pending';
             case 'episodic': return 'pending';
             default: return 'pending';
@@ -478,106 +643,34 @@ export class MemoryEngine {
     async processSessionEvents() {
         await this.ensureInit();
         const unprocessed = this.store.getUnprocessedEvents();
-        let ruleCount = 0;
-        if (unprocessed.length > 0) {
-            const HIGH_VALUE_TOOLS = new Set([
-                'Write', 'Edit', 'Read',
-                'mcp__devflow__get_project_context', 'mcp__devflow__get_memory',
-                'mcp__devflow__get_knowledge', 'mcp__devflow__search_symbol',
-                'mcp__devflow__get_dependency_graph', 'mcp__devflow__run_workflow',
-            ]);
-            const LOW_VALUE_FIRST_WORDS = new Set([
-                'cat', 'ls', 'grep', 'find', 'echo', 'cd', 'pwd', 'which',
-                'head', 'tail', 'wc', 'date', 'tsc', 'npm', 'npx', 'mkdir',
-            ]);
-            const filtered = unprocessed.filter(e => {
-                if (!HIGH_VALUE_TOOLS.has(e.tool))
-                    return false;
-                if (e.tool === 'Bash' && e.command) {
-                    const firstWord = e.command.split(' ')[0] ?? '';
-                    if (LOW_VALUE_FIRST_WORDS.has(firstWord))
-                        return false;
-                }
-                return true;
-            });
-            // 1. Rule engine fallback on filtered events
-            const eventsToProcess = filtered.length > 0 ? filtered : unprocessed;
-            const ruleResults = await this.extractFromEventsRealtime(eventsToProcess.map(e => ({ tool: e.tool, command: e.command ?? undefined, exitCode: e.exitCode ?? undefined, stderr: e.stderr ?? undefined })));
-            ruleCount = ruleResults.length;
-            // 2. AI extraction via Ollama
-            const ollamaStatus = await checkOllama();
-            if (ollamaStatus.installed && ollamaStatus.running && ollamaStatus.modelAvailable) {
-                const compressed = compressEvents(eventsToProcess);
-                try {
-                    const aiCandidates = await extractMemories(compressed, ollamaStatus);
-                    for (const c of aiCandidates) {
-                        await this.addMemory({
-                            category: c.category,
-                            content: c.content,
-                            originalText: c.originalText,
-                            source: 'ai_extract',
-                            confidence: c.confidence,
-                            scope: '',
-                        });
-                    }
-                }
-                catch {
-                    // AI extraction failed — rule engine results are already saved
-                }
-            }
-            else if (isExtractionAvailable()) {
-                // 2.5. Claude API fallback when Ollama unavailable
-                try {
-                    const { extractViaClaudeAPI } = await import('./extractor.js');
-                    const eventsForExtraction = filtered.length > 0 ? filtered : unprocessed;
-                    const compressed = compressEvents(eventsForExtraction);
-                    const aiCandidates = await extractViaClaudeAPI(compressed, `session:${Date.now().toString(36)}`);
-                    for (const c of aiCandidates) {
-                        await this.addMemory({
-                            category: c.category,
-                            content: c.content,
-                            source: 'claude_api',
-                            confidence: c.confidence,
-                            scope: '',
-                        });
-                    }
-                }
-                catch (err) {
-                    console.error('[devflow] Claude API extraction failed:', err.message);
-                }
-            }
-            // 3. Mark events processed
-            this.store.markEventsProcessed(unprocessed.map(e => e.id));
+        if (unprocessed.length === 0) {
+            this.store.cleanupExpired();
+            return { extracted: 0, approved: 0, pending: 0 };
         }
-        // 4. Run cleanup
+        // Use Session Summarizer pipeline (event grouping → triage → LLM → observations)
+        const { summarizeSession } = await import('./session-summarizer.js');
+        const result = await summarizeSession(this.store, `session:${Date.now().toString(36)}`, this.rootPath);
+        // Mark events as processed
+        this.store.markEventsProcessed(unprocessed.map(e => e.id));
+        // Run cleanup
         this.store.cleanupExpired();
-        this.store.cleanupLowQuality();
         const allMemories = this.store.list();
+        console.log('[MemoryEngine] Session events processed', {
+            observations: result.observationCount,
+            provider: result.provider,
+            latencyMs: result.latencyMs,
+        });
         return {
-            extracted: ruleCount,
-            approved: allMemories.filter(m => m.status === 'approved').length,
+            extracted: result.observationCount,
+            approved: allMemories.filter(m => m.status === 'active' || m.status === 'approved').length,
             pending: allMemories.filter(m => m.status === 'pending').length,
         };
     }
-}
-function compressEvents(events) {
-    const compressed = [];
-    for (let i = 0; i < events.length; i++) {
-        const e = events[i];
-        if (!e)
-            continue;
-        const prev = compressed[compressed.length - 1];
-        if (prev && prev.tool === e.tool && prev.command === e.command && prev.exitCode === e.exitCode) {
-            continue;
-        }
-        compressed.push({
-            toolName: e.tool,
-            command: e.command,
-            error: e.exitCode !== 0 ? (e.stderr ?? `exit code ${e.exitCode}`) : undefined,
-            errorMessage: e.stderr,
-            exitCode: e.exitCode,
-        });
+    /** New: summarize a specific session's events into observations. */
+    async summarizeSessionEvents(sessionId, projectRoot) {
+        await this.ensureInit();
+        const { summarizeSession } = await import('./session-summarizer.js');
+        return summarizeSession(this.store, sessionId, projectRoot);
     }
-    return compressed;
 }
 //# sourceMappingURL=memory-engine.js.map