@cartisien/engram 0.2.0 → 0.4.0

package/dist/index.js

@@ -1,279 +1,41 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Engram = exports.TemporalQuery = void 0;
-const crypto_1 = require("crypto");
+import { createHash } from 'crypto';
 /**
- * Temporal query parser for natural language time expressions
- */
-class TemporalQuery {
-    referenceDate;
-    timezoneOffset;
-    constructor(referenceDate = new Date(), timezoneOffset = -referenceDate.getTimezoneOffset()) {
-        this.referenceDate = new Date(referenceDate);
-        this.timezoneOffset = timezoneOffset;
-    }
-    /**
-     * Parse a natural language time expression into a concrete time range
-     *
-     * Supports:
-     * - Relative: 'today', 'yesterday', 'tomorrow'
-     * - Days ago: '3 days ago', 'a week ago', '2 weeks ago'
-     * - Last: 'last monday', 'last week', 'last month'
-     * - This: 'this week', 'this month', 'this year'
-     * - Recent: 'recent', 'lately', 'recently' (last 7 days)
-     * - Between: 'january 15 to january 20', '3/1 to 3/15'
-     */
-    parse(expression) {
-        const normalized = expression.toLowerCase().trim();
-        const now = new Date(this.referenceDate);
-        // Handle 'now', 'recent', 'lately', 'recently' → last 7 days
-        if (/^(now|recent|lately|recently)$/.test(normalized)) {
-            const end = new Date(now);
-            const start = new Date(now);
-            start.setDate(start.getDate() - 7);
-            return { start, end, description: 'last 7 days' };
-        }
-        // Handle 'today'
-        if (normalized === 'today') {
-            const start = this.startOfDay(now);
-            const end = new Date(now);
-            return { start, end, description: 'today' };
-        }
-        // Handle 'yesterday'
-        if (normalized === 'yesterday') {
-            const start = this.startOfDay(now);
-            start.setDate(start.getDate() - 1);
-            const end = this.endOfDay(start);
-            return { start, end, description: 'yesterday' };
-        }
-        // Handle 'tomorrow' (future, but useful for completeness)
-        if (normalized === 'tomorrow') {
-            const start = this.startOfDay(now);
-            start.setDate(start.getDate() + 1);
-            const end = this.endOfDay(start);
-            return { start, end, description: 'tomorrow' };
-        }
-        // Handle 'N days ago' / 'a week ago' / 'N weeks ago'
-        const daysAgoMatch = normalized.match(/^(?:(\d+)|a|one)\s+(day|week|month)s?\s+ago$/);
-        if (daysAgoMatch) {
-            const num = daysAgoMatch[1] ? parseInt(daysAgoMatch[1]) : 1;
-            const unit = daysAgoMatch[2];
-            const start = this.startOfDay(now);
-            const end = this.endOfDay(now);
-            if (unit === 'day') {
-                start.setDate(start.getDate() - num);
-                end.setDate(end.getDate() - num);
-            }
-            else if (unit === 'week') {
-                start.setDate(start.getDate() - (num * 7));
-                end.setDate(end.getDate() - ((num - 1) * 7) - 1);
-            }
-            else if (unit === 'month') {
-                start.setMonth(start.getMonth() - num);
-                start.setDate(1);
-                end.setMonth(end.getMonth() - num + 1);
-                end.setDate(0);
-            }
-            return { start, end, description: `${num} ${unit}${num > 1 ? 's' : ''} ago` };
-        }
-        // Handle 'last N days/weeks/months' (range ending now)
-        const lastNMatch = normalized.match(/^last\s+(?:(\d+)|a|one)\s+(day|week|month)s?$/);
-        if (lastNMatch) {
-            const num = lastNMatch[1] ? parseInt(lastNMatch[1]) : 1;
-            const unit = lastNMatch[2];
-            const start = new Date(now);
-            const end = new Date(now);
-            if (unit === 'day') {
-                start.setDate(start.getDate() - num);
-            }
-            else if (unit === 'week') {
-                start.setDate(start.getDate() - (num * 7));
-            }
-            else if (unit === 'month') {
-                start.setMonth(start.getMonth() - num);
-            }
-            return { start, end, description: `last ${num} ${unit}${num > 1 ? 's' : ''}` };
-        }
-        // Handle 'this week/month/year'
-        const thisMatch = normalized.match(/^this\s+(week|month|year)$/);
-        if (thisMatch) {
-            const unit = thisMatch[1];
-            const start = new Date(now);
-            const end = new Date(now);
-            if (unit === 'week') {
-                const dayOfWeek = start.getDay();
-                start.setDate(start.getDate() - dayOfWeek);
-                start.setHours(0, 0, 0, 0);
-                end.setDate(start.getDate() + 6);
-                end.setHours(23, 59, 59, 999);
-            }
-            else if (unit === 'month') {
-                start.setDate(1);
-                start.setHours(0, 0, 0, 0);
-                end.setMonth(end.getMonth() + 1);
-                end.setDate(0);
-                end.setHours(23, 59, 59, 999);
-            }
-            else if (unit === 'year') {
-                start.setMonth(0, 1);
-                start.setHours(0, 0, 0, 0);
-                end.setMonth(11, 31);
-                end.setHours(23, 59, 59, 999);
-            }
-            return { start, end, description: `this ${unit}` };
-        }
-        // Handle 'last week/month/year' (previous full period)
-        const lastPeriodMatch = normalized.match(/^last\s+(week|month|year)$/);
-        if (lastPeriodMatch) {
-            const unit = lastPeriodMatch[1];
-            const start = new Date(now);
-            const end = new Date(now);
-            if (unit === 'week') {
-                const dayOfWeek = start.getDay();
-                start.setDate(start.getDate() - dayOfWeek - 7);
-                start.setHours(0, 0, 0, 0);
-                end.setDate(start.getDate() + 6);
-                end.setHours(23, 59, 59, 999);
-            }
-            else if (unit === 'month') {
-                start.setMonth(start.getMonth() - 1);
-                start.setDate(1);
-                start.setHours(0, 0, 0, 0);
-                end.setDate(0);
-                end.setHours(23, 59, 59, 999);
-            }
-            else if (unit === 'year') {
-                start.setFullYear(start.getFullYear() - 1);
-                start.setMonth(0, 1);
-                start.setHours(0, 0, 0, 0);
-                end.setMonth(0, 0);
-                end.setHours(23, 59, 59, 999);
-            }
-            return { start, end, description: `last ${unit}` };
-        }
-        // Handle day names: 'monday', 'last monday', 'tuesday', etc.
-        const dayNames = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'];
-        const dayMatch = normalized.match(/^(?:last\s+)?(sunday|monday|tuesday|wednesday|thursday|friday|saturday)$/);
-        if (dayMatch) {
-            const targetDay = dayNames.indexOf(dayMatch[1]);
-            const isLast = normalized.startsWith('last ');
-            const start = this.startOfDay(now);
-            let daysDiff = start.getDay() - targetDay;
-            if (daysDiff <= 0) {
-                daysDiff += 7;
-            }
-            if (isLast && daysDiff === 0) {
-                daysDiff = 7;
-            }
-            start.setDate(start.getDate() - daysDiff);
-            const end = this.endOfDay(start);
-            return { start, end, description: isLast ? `last ${dayMatch[1]}` : dayMatch[1] };
-        }
-        // Handle date ranges: 'jan 15 to jan 20', '3/1 to 3/15', '2024-01-15 to 2024-01-20'
-        const rangeMatch = normalized.match(/^(.+?)\s+(?:to|through|until|-)\s+(.+)$/);
-        if (rangeMatch) {
-            const startDate = this.parseDate(rangeMatch[1]);
-            const endDate = this.parseDate(rangeMatch[2]);
-            if (startDate && endDate) {
-                return {
-                    start: this.startOfDay(startDate),
-                    end: this.endOfDay(endDate),
-                    description: `${rangeMatch[1]} to ${rangeMatch[2]}`
-                };
-            }
-        }
-        // Try to parse as single date
-        const singleDate = this.parseDate(normalized);
-        if (singleDate) {
-            return {
-                start: this.startOfDay(singleDate),
-                end: this.endOfDay(singleDate),
-                description: normalized
-            };
-        }
-        return null;
-    }
-    parseDate(expr) {
-        const normalized = expr.trim().toLowerCase();
-        const now = new Date(this.referenceDate);
-        // Try various date formats
-        const formats = [
-            // MM/DD or MM/DD/YY or MM/DD/YYYY
-            { regex: /^(\d{1,2})\/(\d{1,2})(?:\/(\d{2,4}))?$/, fn: (m) => {
-                    const month = parseInt(m[1]) - 1;
-                    const day = parseInt(m[2]);
-                    let year = now.getFullYear();
-                    if (m[3]) {
-                        const y = parseInt(m[3]);
-                        year = y < 100 ? (y < 50 ? 2000 + y : 1900 + y) : y;
-                    }
-                    return new Date(year, month, day);
-                } },
-            // Month name + day (e.g., "january 15" or "jan 15")
-            { regex: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]*\s+(\d{1,2})(?:,?\s+(\d{4}))?$/i, fn: (m) => {
-                    const months = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec'];
-                    const month = months.indexOf(m[1].toLowerCase().slice(0, 3));
-                    const day = parseInt(m[2]);
-                    let year = now.getFullYear();
-                    if (m[3])
-                        year = parseInt(m[3]);
-                    return new Date(year, month, day);
-                } },
-            // ISO date YYYY-MM-DD
-            { regex: /^(\d{4})-(\d{2})-(\d{2})$/, fn: (m) => {
-                    return new Date(parseInt(m[1]), parseInt(m[2]) - 1, parseInt(m[3]));
-                } }
-        ];
-        for (const format of formats) {
-            const match = normalized.match(format.regex);
-            if (match) {
-                const date = format.fn(match);
-                if (!isNaN(date.getTime()))
-                    return date;
-            }
-        }
-        return null;
-    }
-    startOfDay(date) {
-        const d = new Date(date);
-        d.setHours(0, 0, 0, 0);
-        return d;
-    }
-    endOfDay(date) {
-        const d = new Date(date);
-        d.setHours(23, 59, 59, 999);
-        return d;
-    }
-}
-exports.TemporalQuery = TemporalQuery;
-/**
- * Engram - Persistent memory for AI assistants
+ * Engram - Persistent semantic memory for AI agents
  *
- * A lightweight, SQLite-backed memory system that gives your AI assistants
- * the ability to remember conversations across sessions.
+ * v0.4 adds memory consolidation — working memories are periodically
+ * summarized into long-term memories by a local LLM, keeping context
+ * dense and relevant as conversations grow.
  *
  * @example
  * ```typescript
  * import { Engram } from '@cartisien/engram';
  *
- * const memory = new Engram({ dbPath: './memory.db' });
- *
- * // Store a memory
- * await memory.remember('user_123', 'Jeff loves Triumph motorcycles', 'user');
+ * const memory = new Engram({
+ *   dbPath: './memory.db',
+ *   autoConsolidate: true,
+ *   consolidateThreshold: 100,
+ * });
  *
- * // Retrieve with temporal query
- * const yesterday = await memory.recallByTime('user_123', 'yesterday');
- * const lastWeek = await memory.recallByTime('user_123', 'last week');
+ * // Manual consolidation
+ * const result = await memory.consolidate('session_1');
+ * // → { summarized: 50, created: 4, archived: 50 }
  * ```
  */
-class Engram {
-    db;
-    maxContextLength;
-    dbPath;
-    initialized = false;
+export class Engram {
     constructor(config = {}) {
+        this.initialized = false;
         this.dbPath = config.dbPath || ':memory:';
         this.maxContextLength = config.maxContextLength || 4000;
+        this.embeddingUrl = config.embeddingUrl || 'http://192.168.68.73:11434';
+        this.embeddingModel = config.embeddingModel || 'nomic-embed-text';
+        this.semanticSearch = config.semanticSearch !== false;
+        this.graphMemory = config.graphMemory === true;
+        this.graphModel = config.graphModel || 'qwen2.5:32b';
+        this.autoConsolidate = config.autoConsolidate === true;
+        this.consolidateThreshold = config.consolidateThreshold ?? 100;
+        this.consolidateKeep = config.consolidateKeep ?? 20;
+        this.consolidateBatch = config.consolidateBatch ?? 50;
+        this.consolidateModel = config.consolidateModel || config.graphModel || 'qwen2.5:32b';
     }
     async init() {
         if (this.initialized)
@@ -284,7 +46,7 @@ class Engram {
             filename: this.dbPath,
             driver: sqlite3.Database
         });
-        // Create memories table
+        // Memories table
         await this.db.exec(`
       CREATE TABLE IF NOT EXISTS memories (
         id TEXT PRIMARY KEY,
@@ -293,83 +55,323 @@ class Engram {
         role TEXT CHECK(role IN ('user', 'assistant', 'system')),
         timestamp INTEGER NOT NULL,
         metadata TEXT,
-        content_hash TEXT NOT NULL
+        content_hash TEXT NOT NULL,
+        embedding TEXT,
+        tier TEXT NOT NULL DEFAULT 'working',
+        consolidated_from TEXT
+      );
+    `);
+        // Migrations for existing databases
+        const migrations = [
+            `ALTER TABLE memories ADD COLUMN embedding TEXT`,
+            `ALTER TABLE memories ADD COLUMN tier TEXT NOT NULL DEFAULT 'working'`,
+            `ALTER TABLE memories ADD COLUMN consolidated_from TEXT`,
+        ];
+        for (const m of migrations) {
+            try {
+                await this.db.exec(m);
+            }
+            catch { /* column exists */ }
+        }
+        // v0.3: Graph tables
+        await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS graph_nodes (
+        id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        entity TEXT NOT NULL,
+        type TEXT,
+        created_at INTEGER NOT NULL
+      );
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_node_entity
+        ON graph_nodes(session_id, entity);
+    `);
+        await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS graph_edges (
+        id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        from_entity TEXT NOT NULL,
+        relation TEXT NOT NULL,
+        to_entity TEXT NOT NULL,
+        confidence REAL DEFAULT 1.0,
+        memory_id TEXT,
+        created_at INTEGER NOT NULL
       );
+      CREATE INDEX IF NOT EXISTS idx_edge_from
+        ON graph_edges(session_id, from_entity);
+      CREATE INDEX IF NOT EXISTS idx_edge_to
+        ON graph_edges(session_id, to_entity);
     `);
-        // Create index for fast session lookups
         await this.db.exec(`
-      CREATE INDEX IF NOT EXISTS idx_session_timestamp 
+      CREATE INDEX IF NOT EXISTS idx_session_timestamp
       ON memories(session_id, timestamp DESC);
     `);
-        // Create index for content search
         await this.db.exec(`
-      CREATE INDEX IF NOT EXISTS idx_content 
-      ON memories(content);
+      CREATE INDEX IF NOT EXISTS idx_session_tier
+      ON memories(session_id, tier);
     `);
         this.initialized = true;
     }
+    async embed(text) {
+        try {
+            const response = await fetch(`${this.embeddingUrl}/api/embeddings`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ model: this.embeddingModel, prompt: text }),
+                signal: AbortSignal.timeout(5000)
+            });
+            if (!response.ok)
+                return null;
+            const data = await response.json();
+            return data.embedding ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async extractGraph(text) {
+        const prompt = `Extract entity-relationship triples from this text. Return ONLY a JSON array of objects with keys: "from", "relation", "to". Be concise. Max 5 triples. If nothing to extract, return [].
+
+Text: "${text}"
+
+JSON array:`;
+        try {
+            const response = await fetch(`${this.embeddingUrl}/api/generate`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    model: this.graphModel,
+                    prompt,
+                    stream: false,
+                    options: { temperature: 0, num_predict: 200 }
+                }),
+                signal: AbortSignal.timeout(15000)
+            });
+            if (!response.ok)
+                return [];
+            const data = await response.json();
+            const raw = data.response.trim();
+            const match = raw.match(/\[[\s\S]*\]/);
+            if (!match)
+                return [];
+            const triples = JSON.parse(match[0]);
+            return triples
+                .filter(t => t.from && t.relation && t.to)
+                .map(t => ({
+                from: t.from.toLowerCase().trim(),
+                relation: t.relation.toLowerCase().trim(),
+                to: t.to.toLowerCase().trim(),
+                confidence: 0.9
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    async upsertNode(sessionId, entity, type) {
+        const id = createHash('sha256').update(`${sessionId}:${entity}`).digest('hex').slice(0, 16);
+        await this.db.run(`INSERT OR IGNORE INTO graph_nodes (id, session_id, entity, type, created_at)
+       VALUES (?, ?, ?, ?, ?)`, [id, sessionId, entity, type || null, Date.now()]);
+    }
+    async storeEdge(sessionId, edge, memoryId) {
+        const id = createHash('sha256')
+            .update(`${sessionId}:${edge.from}:${edge.relation}:${edge.to}`)
+            .digest('hex').slice(0, 16);
+        await this.upsertNode(sessionId, edge.from);
+        await this.upsertNode(sessionId, edge.to);
+        await this.db.run(`INSERT OR REPLACE INTO graph_edges
+       (id, session_id, from_entity, relation, to_entity, confidence, memory_id, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [id, sessionId, edge.from, edge.relation, edge.to, edge.confidence ?? 1.0, memoryId, Date.now()]);
+    }
+    cosineSimilarity(a, b) {
+        let dot = 0, magA = 0, magB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dot += (a[i] ?? 0) * (b[i] ?? 0);
+            magA += (a[i] ?? 0) * (a[i] ?? 0);
+            magB += (b[i] ?? 0) * (b[i] ?? 0);
+        }
+        const denom = Math.sqrt(magA) * Math.sqrt(magB);
+        return denom === 0 ? 0 : dot / denom;
+    }
+    /**
+     * Call LLM to summarize a batch of memories into consolidated entries.
+     * Returns an array of summary strings (typically 2-5 per batch).
+     */
+    async summarizeMemories(entries, model) {
+        const numbered = entries
+            .map((e, i) => `[${i + 1}] (${e.role}) ${e.content}`)
+            .join('\n');
+        const prompt = `You are a memory consolidation system. Given these conversation memories, produce 2-5 concise summary entries that preserve all important facts: names, dates, decisions, preferences, and technical details. Each summary should be a single dense sentence or short paragraph. Return ONLY a JSON array of strings.
+
+Memories:
+${numbered}
+
+JSON array of summary strings:`;
+        try {
+            const response = await fetch(`${this.embeddingUrl}/api/generate`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    model,
+                    prompt,
+                    stream: false,
+                    options: { temperature: 0.2, num_predict: 800 }
+                }),
+                signal: AbortSignal.timeout(60000)
+            });
+            if (!response.ok)
+                return [];
+            const data = await response.json();
+            const raw = data.response.trim();
+            const match = raw.match(/\[[\s\S]*\]/);
+            if (!match)
+                return [];
+            const summaries = JSON.parse(match[0]);
+            return summaries.filter(s => typeof s === 'string' && s.trim().length > 0);
+        }
+        catch {
+            return [];
+        }
+    }
     /**
-     * Store a memory entry
+     * v0.4: Consolidate working memories into long-term summaries.
+     *
+     * Takes the oldest `batch` working memories (excluding the `keep` most recent),
+     * summarizes them via LLM, stores summaries as `long_term` tier, and archives
+     * the originals.
+     *
+     * @example
+     * ```typescript
+     * const result = await memory.consolidate('session_1');
+     * // → { summarized: 50, created: 4, archived: 50 }
+     *
+     * // Preview without writing
+     * const preview = await memory.consolidate('session_1', { dryRun: true });
+     * // → { summarized: 50, created: 0, archived: 0, previews: ['...', '...'] }
+     * ```
+     */
+    async consolidate(sessionId, options = {}) {
+        await this.init();
+        const batch = options.batch ?? this.consolidateBatch;
+        const keep = options.keep ?? this.consolidateKeep;
+        const model = options.model ?? this.consolidateModel;
+        // Fetch working memories oldest-first, excluding the N most recent
+        const rows = await this.db.all(`SELECT id, session_id, content, role, timestamp, metadata, tier, consolidated_from
+       FROM memories
+       WHERE session_id = ? AND tier = 'working'
+       ORDER BY timestamp ASC
+       LIMIT ?`, [sessionId, batch + keep]);
+        // Drop the most recent `keep` entries — leave them as working memory
+        const candidates = rows.slice(0, Math.max(0, rows.length - keep));
+        if (candidates.length === 0) {
+            return { summarized: 0, created: 0, archived: 0 };
+        }
+        const entries = candidates.map((row) => ({
+            id: row.id,
+            sessionId: row.session_id,
+            content: row.content,
+            role: row.role,
+            timestamp: new Date(row.timestamp),
+            tier: row.tier,
+            metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+        }));
+        // Get summaries from LLM
+        const summaries = await this.summarizeMemories(entries, model);
+        if (summaries.length === 0) {
+            return { summarized: entries.length, created: 0, archived: 0 };
+        }
+        if (options.dryRun) {
+            return {
+                summarized: entries.length,
+                created: 0,
+                archived: 0,
+                previews: summaries
+            };
+        }
+        const sourceIds = entries.map(e => e.id);
+        const consolidatedFromJson = JSON.stringify(sourceIds);
+        // Store each summary as a long_term memory
+        for (const summary of summaries) {
+            const id = createHash('sha256')
+                .update(`${sessionId}:lt:${summary}:${Date.now()}`)
+                .digest('hex').slice(0, 16);
+            const contentHash = createHash('sha256').update(summary).digest('hex').slice(0, 16);
+            // Embed the summary
+            let embeddingJson = null;
+            if (this.semanticSearch) {
+                const vector = await this.embed(summary);
+                if (vector)
+                    embeddingJson = JSON.stringify(vector);
+            }
+            await this.db.run(`INSERT INTO memories
+         (id, session_id, content, role, timestamp, metadata, content_hash, embedding, tier, consolidated_from)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'long_term', ?)`, [id, sessionId, summary.slice(0, this.maxContextLength), 'system',
+                Date.now(), null, contentHash, embeddingJson, consolidatedFromJson]);
+        }
+        // Archive the originals
+        const placeholders = sourceIds.map(() => '?').join(',');
+        await this.db.run(`UPDATE memories SET tier = 'archived' WHERE id IN (${placeholders})`, sourceIds);
+        return {
+            summarized: entries.length,
+            created: summaries.length,
+            archived: entries.length
+        };
+    }
+    /**
+     * Store a memory entry. With autoConsolidate enabled, triggers consolidation
+     * when working memory count exceeds the configured threshold.
      */
     async remember(sessionId, content, role = 'user', metadata) {
         await this.init();
-        const id = (0, crypto_1.createHash)('sha256')
+        const id = createHash('sha256')
             .update(`${sessionId}:${content}:${Date.now()}`)
-            .digest('hex')
-            .slice(0, 16);
-        const contentHash = (0, crypto_1.createHash)('sha256')
-            .update(content)
-            .digest('hex')
-            .slice(0, 16);
+            .digest('hex').slice(0, 16);
+        const contentHash = createHash('sha256').update(content).digest('hex').slice(0, 16);
+        const truncated = content.slice(0, this.maxContextLength);
+        let embeddingJson = null;
+        if (this.semanticSearch) {
+            const vector = await this.embed(truncated);
+            if (vector)
+                embeddingJson = JSON.stringify(vector);
+        }
         const entry = {
-            id,
-            sessionId,
-            content: content.slice(0, this.maxContextLength),
-            role,
-            timestamp: new Date(),
-            metadata
+            id, sessionId, content: truncated, role,
+            timestamp: new Date(), tier: 'working',
+            ...(metadata !== undefined && { metadata })
         };
-        await this.db.run(`INSERT INTO memories (id, session_id, content, role, timestamp, metadata, content_hash)
-       VALUES (?, ?, ?, ?, ?, ?, ?)`, [
-            entry.id,
-            entry.sessionId,
-            entry.content,
-            entry.role,
-            entry.timestamp.getTime(),
-            metadata ? JSON.stringify(metadata) : null,
-            contentHash
-        ]);
+        await this.db.run(`INSERT INTO memories
+       (id, session_id, content, role, timestamp, metadata, content_hash, embedding, tier)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'working')`, [id, sessionId, truncated, role, entry.timestamp.getTime(),
+            metadata ? JSON.stringify(metadata) : null, contentHash, embeddingJson]);
+        // v0.3: Extract graph relationships
+        if (this.graphMemory) {
+            const edges = await this.extractGraph(truncated);
+            for (const edge of edges) {
+                await this.storeEdge(sessionId, edge, id);
+            }
+        }
+        // v0.4: Auto-consolidate if threshold exceeded
+        if (this.autoConsolidate) {
+            const countRow = await this.db.get(`SELECT COUNT(*) as count FROM memories WHERE session_id = ? AND tier = 'working'`, [sessionId]);
+            if ((countRow?.count ?? 0) > this.consolidateThreshold) {
+                // Fire-and-forget — don't block the caller
+                this.consolidate(sessionId).catch(() => { });
+            }
+        }
         return entry;
     }
     /**
-     * Recall memories for a session
-     *
-     * Supports temporal queries via options.temporalQuery:
-     * - 'yesterday', 'today', 'tomorrow'
-     * - '3 days ago', 'a week ago', '2 weeks ago'
-     * - 'last monday', 'last week', 'last month'
-     * - 'this week', 'this month'
-     * - 'last 3 days', 'last week'
-     * - 'january 15', '3/15', '2024-01-15'
-     * - 'jan 15 to jan 20', '3/1 to 3/15'
+     * Recall memories. Searches working and long_term tiers by default.
+     * Archived memories (consolidated originals) are excluded unless explicitly requested.
      */
     async recall(sessionId, query, limit = 10, options = {}) {
         await this.init();
-        // Handle temporal query if provided
-        if (options.temporalQuery) {
-            const temporal = new TemporalQuery(new Date(), options.timezoneOffset);
-            const range = temporal.parse(options.temporalQuery);
-            if (range) {
-                options.after = range.start;
-                options.before = range.end;
-            }
-        }
+        const tiers = options.tiers ?? ['working', 'long_term'];
+        const tierPlaceholders = tiers.map(() => '?').join(',');
         let sql = `
-      SELECT id, session_id, content, role, timestamp, metadata
-      FROM memories
-      WHERE session_id = ?
+      SELECT id, session_id, content, role, timestamp, metadata, embedding, tier, consolidated_from
+      FROM memories WHERE session_id = ? AND tier IN (${tierPlaceholders})
     `;
-        const params = [sessionId];
+        const params = [sessionId, ...tiers];
         if (options.role) {
             sql += ` AND role = ?`;
             params.push(options.role);
@@ -382,7 +384,49 @@ class Engram {
             sql += ` AND timestamp <= ?`;
             params.push(options.before.getTime());
         }
-        // Simple keyword matching if query provided
+        const mapRow = (row, similarity) => {
+            const entry = {
+                id: row.id,
+                sessionId: row.session_id,
+                content: row.content,
+                role: row.role,
+                timestamp: new Date(row.timestamp),
+                tier: row.tier,
+            };
+            if (row.consolidated_from)
+                entry.consolidatedFrom = JSON.parse(row.consolidated_from);
+            if (row.metadata)
+                entry.metadata = JSON.parse(row.metadata);
+            if (similarity !== undefined)
+                entry.similarity = similarity;
+            return entry;
+        };
+        // Semantic search
+        if (query && query.trim() && this.semanticSearch) {
+            const queryVector = await this.embed(query);
+            if (queryVector) {
+                const rows = await this.db.all(sql + ` ORDER BY timestamp DESC`, params);
+                const scored = rows
+                    .map((row) => {
+                    let similarity = 0;
+                    if (row.embedding) {
+                        try {
+                            similarity = this.cosineSimilarity(queryVector, JSON.parse(row.embedding));
+                        }
+                        catch { /* skip */ }
+                    }
+                    return { row, similarity };
+                })
+                    .sort((a, b) => b.similarity - a.similarity)
+                    .slice(0, limit);
+                const results = scored.map(({ row, similarity }) => mapRow(row, similarity));
+                if (this.graphMemory && options.includeGraph !== false) {
+                    return this.augmentWithGraph(sessionId, results, limit);
+                }
+                return results;
+            }
+        }
+        // Keyword fallback
         if (query && query.trim()) {
             const keywords = query.toLowerCase().split(/\s+/).filter(k => k.length > 2);
             if (keywords.length > 0) {
@@ -393,127 +437,99 @@ class Engram {
         sql += ` ORDER BY timestamp DESC LIMIT ?`;
         params.push(limit);
         const rows = await this.db.all(sql, params);
-        return rows.map((row) => ({
+        return rows.map((row) => mapRow(row));
+    }
+    async augmentWithGraph(sessionId, results, limit) {
+        const seenIds = new Set(results.map(r => r.id));
+        const graphMemoryIds = new Set();
+        for (const result of results.slice(0, 3)) {
+            const edges = await this.db.all(`SELECT memory_id FROM graph_edges WHERE session_id = ? AND memory_id IS NOT NULL
+         AND (from_entity IN (
+           SELECT from_entity FROM graph_edges WHERE memory_id = ?
+           UNION SELECT to_entity FROM graph_edges WHERE memory_id = ?
+         ))
+         LIMIT 5`, [sessionId, result.id, result.id]);
+            for (const edge of edges) {
+                if (edge.memory_id && !seenIds.has(edge.memory_id)) {
+                    graphMemoryIds.add(edge.memory_id);
+                }
+            }
+        }
+        if (graphMemoryIds.size === 0)
+            return results;
+        const placeholders = Array.from(graphMemoryIds).map(() => '?').join(',');
+        const connectedRows = await this.db.all(`SELECT id, session_id, content, role, timestamp, metadata, tier, consolidated_from
+       FROM memories WHERE id IN (${placeholders})`, Array.from(graphMemoryIds));
+        const connected = connectedRows.map((row) => ({
             id: row.id,
             sessionId: row.session_id,
             content: row.content,
             role: row.role,
             timestamp: new Date(row.timestamp),
-            metadata: row.metadata ? JSON.parse(row.metadata) : undefined
+            tier: row.tier,
+            consolidatedFrom: row.consolidated_from ? JSON.parse(row.consolidated_from) : undefined,
+            metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+            similarity: 0
         }));
+        return [...results, ...connected].slice(0, limit);
     }
-    /**
-     * Recall memories by natural language time expression
-     *
-     * @example
-     * ```typescript
-     * // Get yesterday's memories
-     * const yesterday = await memory.recallByTime('session_123', 'yesterday');
-     *
-     * // Get last week's memories
-     * const lastWeek = await memory.recallByTime('session_123', 'last week');
-     *
-     * // Get memories from 3 days ago
-     * const threeDaysAgo = await memory.recallByTime('session_123', '3 days ago');
-     * ```
-     */
-    async recallByTime(sessionId, temporalQuery, query, limit = 50, options = {}) {
-        const temporal = new TemporalQuery(new Date(), options.timezoneOffset);
-        const range = temporal.parse(temporalQuery);
-        if (!range) {
-            throw new Error(`Unable to parse temporal query: "${temporalQuery}"`);
-        }
-        const entries = await this.recall(sessionId, query, limit, {
-            ...options,
-            after: range.start,
-            before: range.end
-        });
-        return { entries, range };
-    }
-    /**
-     * Get memories from the last N days
-     */
-    async recallRecent(sessionId, days = 7, query, limit = 50, options = {}) {
-        const since = new Date();
-        since.setDate(since.getDate() - days);
-        since.setHours(0, 0, 0, 0);
-        const entries = await this.recall(sessionId, query, limit, {
-            ...options,
-            after: since
-        });
-        return { entries, days, since };
-    }
-    /**
-     * Get memories since a specific date
-     */
-    async recallSince(sessionId, since, query, limit = 50, options = {}) {
-        const entries = await this.recall(sessionId, query, limit, {
-            ...options,
-            after: since
-        });
-        return { entries, since, count: entries.length };
-    }
-    /**
-     * Get memories between two dates
-     */
-    async recallBetween(sessionId, start, end, query, limit = 50, options = {}) {
-        const entries = await this.recall(sessionId, query, limit, {
-            ...options,
-            after: start,
-            before: end
-        });
-        return { entries, start, end, count: entries.length };
-    }
-    /**
-     * Get a daily summary of memories
-     *
-     * Returns memories grouped by day, useful for "what happened each day" views
-     */
-    async dailySummary(sessionId, days = 7) {
+    async graph(sessionId, entity) {
         await this.init();
-        const since = new Date();
-        since.setDate(since.getDate() - days);
-        since.setHours(0, 0, 0, 0);
-        const entries = await this.recall(sessionId, undefined, 1000, { after: since });
-        // Group by day
-        const grouped = new Map();
-        for (const entry of entries) {
-            const dateKey = entry.timestamp.toISOString().split('T')[0];
-            if (!grouped.has(dateKey)) {
-                grouped.set(dateKey, []);
-            }
-            grouped.get(dateKey).push(entry);
+        const ent = entity.toLowerCase().trim();
+        const outgoing = await this.db.all(`SELECT relation, to_entity, confidence, memory_id FROM graph_edges
+       WHERE session_id = ? AND from_entity = ?`, [sessionId, ent]);
+        const incoming = await this.db.all(`SELECT relation, from_entity, confidence, memory_id FROM graph_edges
+       WHERE session_id = ? AND to_entity = ?`, [sessionId, ent]);
+        const relationships = [
+            ...outgoing.map((e) => ({
+                type: 'outgoing',
+                relation: e.relation,
+                target: e.to_entity,
+                confidence: e.confidence
+            })),
+            ...incoming.map((e) => ({
+                type: 'incoming',
+                relation: e.relation,
+                target: e.from_entity,
+                confidence: e.confidence
+            }))
+        ];
+        const memoryIds = [
+            ...outgoing.map((e) => e.memory_id),
+            ...incoming.map((e) => e.memory_id)
+        ].filter(Boolean);
+        let relatedMemories = [];
+        if (memoryIds.length > 0) {
+            const placeholders = memoryIds.map(() => '?').join(',');
+            const rows = await this.db.all(`SELECT id, session_id, content, role, timestamp, metadata, tier, consolidated_from
+         FROM memories WHERE id IN (${placeholders})`, memoryIds);
+            relatedMemories = rows.map((row) => ({
+                id: row.id,
+                sessionId: row.session_id,
+                content: row.content,
+                role: row.role,
+                timestamp: new Date(row.timestamp),
+                tier: row.tier,
+                consolidatedFrom: row.consolidated_from ? JSON.parse(row.consolidated_from) : undefined,
+                metadata: row.metadata ? JSON.parse(row.metadata) : undefined
+            }));
         }
-        // Convert to sorted array
-        return Array.from(grouped.entries())
-            .sort((a, b) => b[0].localeCompare(a[0])) // Descending date order
-            .map(([dateKey, dayEntries]) => ({
-            date: new Date(dateKey),
-            entries: dayEntries.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime()),
-            count: dayEntries.length
-        }));
+        return { entity: ent, relationships, relatedMemories };
     }
-    /**
-     * Get recent conversation history for a session
-     */
     async history(sessionId, limit = 20) {
         return this.recall(sessionId, undefined, limit, {});
     }
-    /**
-     * Forget (delete) memories
-     */
     async forget(sessionId, options) {
         await this.init();
+        const tiers = options?.includeLongTerm
+            ? `('working', 'long_term', 'archived')`
+            : `('working', 'long_term')`;
         if (options?.id) {
-            const result = await this.db.run('DELETE FROM memories WHERE session_id = ? AND id = ?', [sessionId, options.id]);
+            const result = await this.db.run(`DELETE FROM memories WHERE session_id = ? AND id = ?`, [sessionId, options.id]);
             return result.changes || 0;
         }
-        let sql = 'DELETE FROM memories WHERE session_id = ?';
+        let sql = `DELETE FROM memories WHERE session_id = ? AND tier IN ${tiers}`;
         const params = [sessionId];
-        if (options?.after) {
-            sql += ' AND timestamp >= ?';
-            params.push(options.after.getTime());
-        }
         if (options?.before) {
             sql += ' AND timestamp < ?';
             params.push(options.before.getTime());
@@ -521,60 +537,35 @@ class Engram {
         const result = await this.db.run(sql, params);
         return result.changes || 0;
     }
-    /**
-     * Get memory statistics for a session
-     */
     async stats(sessionId) {
         await this.init();
-        const totalRow = await this.db.get('SELECT COUNT(*) as count FROM memories WHERE session_id = ?', [sessionId]);
-        const total = totalRow?.count || 0;
-        const roleRows = await this.db.all('SELECT role, COUNT(*) as count FROM memories WHERE session_id = ? GROUP BY role', [sessionId]);
+        const totalRow = await this.db.get(`SELECT COUNT(*) as count FROM memories WHERE session_id = ? AND tier != 'archived'`, [sessionId]);
+        const roleRows = await this.db.all(`SELECT role, COUNT(*) as count FROM memories WHERE session_id = ? AND tier != 'archived' GROUP BY role`, [sessionId]);
+        const tierRows = await this.db.all(`SELECT tier, COUNT(*) as count FROM memories WHERE session_id = ? GROUP BY tier`, [sessionId]);
         const byRole = {};
-        roleRows.forEach((row) => {
-            byRole[row.role] = row.count;
-        });
-        const range = await this.db.get('SELECT MIN(timestamp) as oldest, MAX(timestamp) as newest FROM memories WHERE session_id = ?', [sessionId]);
-        return {
-            total,
+        roleRows.forEach((row) => { byRole[row.role] = row.count; });
+        const byTier = { working: 0, long_term: 0, archived: 0 };
+        tierRows.forEach((row) => { byTier[row.tier] = row.count; });
+        const range = await this.db.get(`SELECT MIN(timestamp) as oldest, MAX(timestamp) as newest
+       FROM memories WHERE session_id = ? AND tier != 'archived'`, [sessionId]);
+        const embRow = await this.db.get(`SELECT COUNT(*) as count FROM memories
+       WHERE session_id = ? AND tier != 'archived' AND embedding IS NOT NULL`, [sessionId]);
+        const result = {
+            total: totalRow?.count || 0,
             byRole,
+            byTier,
             oldest: range?.oldest ? new Date(range.oldest) : null,
-            newest: range?.newest ? new Date(range.newest) : null
+            newest: range?.newest ? new Date(range.newest) : null,
+            withEmbeddings: embRow?.count || 0,
         };
-    }
-    /**
-     * Get temporal statistics for a session
-     *
-     * Returns memory counts grouped by day, useful for activity visualization
-     */
-    async temporalStats(sessionId, days = 30) {
-        await this.init();
-        const since = new Date();
-        since.setDate(since.getDate() - days);
-        const rows = await this.db.all(`SELECT 
-        date(timestamp / 1000, 'unixepoch', 'localtime') as date,
-        role,
-        COUNT(*) as count
-      FROM memories 
-      WHERE session_id = ? AND timestamp >= ?
-      GROUP BY date, role
-      ORDER BY date DESC`, [sessionId, since.getTime()]);
-        // Aggregate by date
-        const byDate = new Map();
-        for (const row of rows) {
-            if (!byDate.has(row.date)) {
-                byDate.set(row.date, { count: 0, byRole: {} });
-            }
-            const day = byDate.get(row.date);
-            day.count += row.count;
-            day.byRole[row.role] = row.count;
+        if (this.graphMemory) {
+            const nodeRow = await this.db.get(`SELECT COUNT(*) as count FROM graph_nodes WHERE session_id = ?`, [sessionId]);
+            const edgeRow = await this.db.get(`SELECT COUNT(*) as count FROM graph_edges WHERE session_id = ?`, [sessionId]);
+            result.graphNodes = nodeRow?.count || 0;
+            result.graphEdges = edgeRow?.count || 0;
         }
-        return Array.from(byDate.entries())
-            .sort((a, b) => b[0].localeCompare(a[0]))
-            .map(([date, stats]) => ({ date, ...stats }));
+        return result;
     }
-    /**
-     * Close the database connection
-     */
     async close() {
         if (this.db) {
             await this.db.close();
@@ -582,6 +573,5 @@ class Engram {
         }
     }
 }
-exports.Engram = Engram;
-exports.default = Engram;
+export default Engram;
 //# sourceMappingURL=index.js.map