@dot-ai/ext-sqlite-memory 0.9.0

package/dist/sqlite-memory.js

@@ -0,0 +1,184 @@
+import Database from 'better-sqlite3';
+import { join } from 'node:path';
+/**
+ * Compute Jaccard similarity between two strings (word-level).
+ * similarity = |intersection| / |union|
+ */
+function jaccardSimilarity(a, b) {
+    const wordsA = new Set(a.toLowerCase().replace(/[^\w\s]/g, ' ').split(/\s+/).filter(w => w.length > 1));
+    const wordsB = new Set(b.toLowerCase().replace(/[^\w\s]/g, ' ').split(/\s+/).filter(w => w.length > 1));
+    if (wordsA.size === 0 && wordsB.size === 0)
+        return 1;
+    if (wordsA.size === 0 || wordsB.size === 0)
+        return 0;
+    let intersection = 0;
+    for (const w of wordsA) {
+        if (wordsB.has(w))
+            intersection++;
+    }
+    const union = wordsA.size + wordsB.size - intersection;
+    return intersection / union;
+}
+export class SqliteMemoryProvider {
+    db;
+    constructor(options = {}) {
+        const root = options.root ?? process.cwd();
+        const rawPath = options.path ?? ':memory:';
+        const dbPath = rawPath === ':memory:' ? rawPath : (rawPath.startsWith('/') ? rawPath : join(root, rawPath));
+        this.db = new Database(dbPath);
+        this.db.pragma('journal_mode = WAL');
+        this.init();
+    }
+    init() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS memories (
+        id           INTEGER PRIMARY KEY AUTOINCREMENT,
+        content      TEXT    NOT NULL,
+        type         TEXT    NOT NULL DEFAULT 'log',
+        date         TEXT,
+        labels       TEXT    DEFAULT '[]',
+        node         TEXT,
+        source       TEXT    DEFAULT 'sqlite-memory',
+        created      INTEGER DEFAULT (unixepoch())
+      );
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+        content,
+        labels,
+        node,
+        content='memories',
+        content_rowid='id'
+      );
+
+      CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+        INSERT INTO memories_fts(rowid, content, labels, node)
+        VALUES (new.id, new.content, new.labels, new.node);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+        INSERT INTO memories_fts(memories_fts, rowid, content, labels, node)
+        VALUES ('delete', old.id, old.content, old.labels, old.node);
+      END;
+    `);
+        // Graceful migration: add lifecycle columns if they don't exist
+        const existingCols = this.db.prepare(`PRAGMA table_info(memories)`).all()
+            .map(c => c.name);
+        if (!existingCols.includes('score')) {
+            this.db.exec(`ALTER TABLE memories ADD COLUMN score REAL DEFAULT 1.0`);
+        }
+        if (!existingCols.includes('last_recalled')) {
+            this.db.exec(`ALTER TABLE memories ADD COLUMN last_recalled TEXT`);
+        }
+        if (!existingCols.includes('recall_count')) {
+            this.db.exec(`ALTER TABLE memories ADD COLUMN recall_count INTEGER DEFAULT 0`);
+        }
+    }
+    async store(entry) {
+        const content = entry.content;
+        // Extract key terms for FTS dedup check
+        const queryWords = content
+            .replace(/[^\w\s]/g, ' ')
+            .split(/\s+/)
+            .filter(w => w.length > 1);
+        if (queryWords.length > 0) {
+            const ftsQuery = queryWords.join(' OR ');
+            let candidates = [];
+            try {
+                candidates = this.db.prepare(`
+          SELECT m.id, m.content
+          FROM memories_fts
+          JOIN memories m ON m.id = memories_fts.rowid
+          WHERE memories_fts MATCH ?
+          LIMIT 10
+        `).all(ftsQuery);
+            }
+            catch {
+                // FTS error — fall through to insert
+            }
+            for (const candidate of candidates) {
+                const similarity = jaccardSimilarity(content, candidate.content);
+                if (similarity > 0.85) {
+                    // Duplicate found — update existing entry instead of inserting
+                    this.db.prepare(`UPDATE memories SET content = ?, date = ?, score = MIN(score + 0.1, 5.0) WHERE id = ?`).run(content, entry.date ?? new Date().toISOString().slice(0, 10), candidate.id);
+                    // Update FTS index for the modified row
+                    this.db.prepare(`INSERT INTO memories_fts(memories_fts, rowid, content, labels, node) VALUES ('delete', ?, ?, ?, ?)`).run(candidate.id, candidate.content, '[]', null);
+                    const updated = this.db.prepare(`SELECT content, labels, node FROM memories WHERE id = ?`).get(candidate.id);
+                    this.db.prepare(`INSERT INTO memories_fts(rowid, content, labels, node) VALUES (?, ?, ?, ?)`).run(candidate.id, updated.content, updated.labels, updated.node);
+                    return;
+                }
+            }
+        }
+        // No duplicate found — insert new entry
+        const stmt = this.db.prepare('INSERT INTO memories (content, type, date, labels, node, score, recall_count) VALUES (?, ?, ?, ?, ?, 1.0, 0)');
+        stmt.run(entry.content, entry.type ?? 'log', entry.date ?? new Date().toISOString().slice(0, 10), JSON.stringify(entry.labels ?? []), entry.node ?? null);
+    }
+    async search(query, labels) {
+        const queryWords = query
+            .replace(/[^\w\s]/g, ' ')
+            .split(/\s+/)
+            .filter(w => w.length > 1);
+        const labelWords = (labels ?? [])
+            .map(l => l.replace(/[^\w\s]/g, '').trim())
+            .filter(w => w.length > 1);
+        const allTerms = [...new Set([...queryWords, ...labelWords])];
+        const cleanQuery = allTerms.join(' OR ');
+        if (!cleanQuery)
+            return [];
+        let rows;
+        try {
+            rows = this.db.prepare(`
+        SELECT m.id, m.content, m.type, m.date, m.labels, m.node, m.score,
+               bm25(memories_fts) AS rank
+        FROM memories_fts
+        JOIN memories m ON m.id = memories_fts.rowid
+        WHERE memories_fts MATCH ?
+        ORDER BY rank
+        LIMIT 20
+      `).all(cleanQuery);
+        }
+        catch {
+            return [];
+        }
+        // Score bump: increment score, update last_recalled, increment recall_count
+        if (rows.length > 0) {
+            const today = new Date().toISOString().slice(0, 10);
+            const updateStmt = this.db.prepare(`
+        UPDATE memories
+        SET score = MIN(score + 0.1, 5.0),
+            last_recalled = ?,
+            recall_count = recall_count + 1
+        WHERE id = ?
+      `);
+            for (const row of rows) {
+                updateStmt.run(today, row.id);
+            }
+        }
+        return rows.map(row => ({
+            content: row.content,
+            type: row.type,
+            source: 'sqlite-memory',
+            date: row.date ?? undefined,
+            labels: JSON.parse(row.labels),
+            node: row.node ?? undefined,
+        }));
+    }
+    async consolidate() {
+        const now = Date.now();
+        const day = 86400000;
+        const deletedLogs = this.db.prepare(`DELETE FROM memories WHERE type = 'log' AND date < ? AND score < 0.3`).run(new Date(now - 30 * day).toISOString().slice(0, 10));
+        const deletedNotes = this.db.prepare(`DELETE FROM memories WHERE type = 'note' AND date < ? AND score < 0.3`).run(new Date(now - 60 * day).toISOString().slice(0, 10));
+        const deletedOld = this.db.prepare(`DELETE FROM memories WHERE type NOT IN ('lesson', 'decision', 'fact') AND date < ? AND score < 0.1`).run(new Date(now - 90 * day).toISOString().slice(0, 10));
+        return {
+            archived: 0,
+            deleted: deletedLogs.changes + deletedNotes.changes + deletedOld.changes,
+        };
+    }
+    describe() {
+        const count = this.db.prepare('SELECT COUNT(*) as count FROM memories').get().count;
+        return `Memory: SQLite with FTS5 full-text search (${count} entries). Use memory_recall to search, memory_store to save. This is the ONLY memory system — do not read or write memory/*.md files.`;
+    }
+    close() {
+        this.db.close();
+    }
+}
+//# sourceMappingURL=sqlite-memory.js.map

package/dist/sqlite-memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-memory.js","sourceRoot":"","sources":["../src/sqlite-memory.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@dot-ai/ext-sqlite-memory",
+  "version": "0.9.0",
+  "description": "SQLite FTS5 memory extension for dot-ai",
+  "type": "module",
+  "main": "dist/extension.js",
+  "types": "dist/extension.d.ts",
+  "dot-ai": {
+    "extensions": [
+      "./dist/extension.js"
+    ]
+  },
+  "dependencies": {
+    "better-sqlite3": "^11.0.0",
+    "@dot-ai/core": "0.9.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.0",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jogelin/dot-ai",
+    "directory": "packages/ext-sqlite-memory"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run"
+  }
+}

package/src/__tests__/lifecycle.test.ts

@@ -0,0 +1,209 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { SqliteMemoryProvider } from '../sqlite-memory.js';
+
+describe('SqliteMemoryProvider — deduplication on store()', () => {
+  let provider: SqliteMemoryProvider;
+
+  beforeEach(() => {
+    provider = new SqliteMemoryProvider({ path: ':memory:' });
+  });
+
+  afterEach(() => {
+    provider.close();
+  });
+
+  it('stores similar content twice → only 1 entry in DB', async () => {
+    await provider.store({ content: 'Jo prefers French language for conversations', type: 'fact' });
+    await provider.store({ content: 'Jo prefers French language for conversations', type: 'fact' });
+
+    const results = await provider.search('Jo prefers French');
+    expect(results).toHaveLength(1);
+  });
+
+  it('stores nearly identical content → deduplicates (Jaccard > 0.85)', async () => {
+    await provider.store({ content: 'Jonathan prefers working in French language', type: 'fact' });
+    await provider.store({ content: 'Jonathan prefers working in French language', type: 'fact' });
+
+    const results = await provider.search('Jonathan French language');
+    expect(results).toHaveLength(1);
+  });
+
+  it('stores different content → 2 entries', async () => {
+    await provider.store({ content: 'Jo prefers French language for conversations', type: 'fact' });
+    await provider.store({ content: 'The authentication system uses JWT tokens for authorization', type: 'fact' });
+
+    const frenchResults = await provider.search('Jo prefers French');
+    const authResults = await provider.search('authentication JWT tokens');
+    expect(frenchResults).toHaveLength(1);
+    expect(authResults).toHaveLength(1);
+  });
+
+  it('describes correct count after dedup (2 similar → 1 entry)', async () => {
+    await provider.store({ content: 'Jo prefers French language for conversations', type: 'fact' });
+    await provider.store({ content: 'Jo prefers French language for conversations', type: 'fact' });
+
+    const description = provider.describe();
+    expect(description).toContain('1 entries');
+  });
+});
+
+describe('SqliteMemoryProvider — score bump on search()', () => {
+  let provider: SqliteMemoryProvider;
+
+  beforeEach(() => {
+    provider = new SqliteMemoryProvider({ path: ':memory:' });
+  });
+
+  afterEach(() => {
+    provider.close();
+  });
+
+  it('searching for memories increments recall_count and sets last_recalled', async () => {
+    await provider.store({ content: 'Fixed the auth middleware N+1 bug properly', type: 'log' });
+
+    // Search once
+    const results1 = await provider.search('auth middleware');
+    expect(results1).toHaveLength(1);
+
+    // Verify recall_count was bumped in the DB
+    const row = (provider as unknown as { db: import('better-sqlite3').Database })
+      .db
+      .prepare(`SELECT recall_count, last_recalled, score FROM memories WHERE content LIKE '%auth middleware%'`)
+      .get() as { recall_count: number; last_recalled: string; score: number } | undefined;
+
+    expect(row).toBeDefined();
+    expect(row!.recall_count).toBe(1);
+    expect(row!.last_recalled).toBe(new Date().toISOString().slice(0, 10));
+    expect(row!.score).toBeCloseTo(1.1, 5);
+  });
+
+  it('searching multiple times accumulates score', async () => {
+    await provider.store({ content: 'The routing logic determines model selection carefully', type: 'fact' });
+
+    await provider.search('routing logic');
+    await provider.search('routing logic');
+    await provider.search('routing logic');
+
+    const row = (provider as unknown as { db: import('better-sqlite3').Database })
+      .db
+      .prepare(`SELECT recall_count, score FROM memories WHERE content LIKE '%routing%'`)
+      .get() as { recall_count: number; score: number } | undefined;
+
+    expect(row).toBeDefined();
+    expect(row!.recall_count).toBe(3);
+    expect(row!.score).toBeCloseTo(1.3, 5);
+  });
+
+  it('score is capped at 5.0', async () => {
+    await provider.store({ content: 'Critical architectural decision for the system', type: 'decision' });
+
+    // Search 50 times to exceed cap
+    for (let i = 0; i < 50; i++) {
+      await provider.search('architectural decision');
+    }
+
+    const row = (provider as unknown as { db: import('better-sqlite3').Database })
+      .db
+      .prepare(`SELECT score FROM memories WHERE content LIKE '%architectural%'`)
+      .get() as { score: number } | undefined;
+
+    expect(row).toBeDefined();
+    expect(row!.score).toBeLessThanOrEqual(5.0);
+  });
+});
+
+describe('SqliteMemoryProvider — consolidate()', () => {
+  let provider: SqliteMemoryProvider;
+
+  beforeEach(() => {
+    provider = new SqliteMemoryProvider({ path: ':memory:' });
+  });
+
+  afterEach(() => {
+    provider.close();
+  });
+
+  it('deletes old logs with low score', async () => {
+    // Insert an old log entry directly with low score
+    const db = (provider as unknown as { db: import('better-sqlite3').Database }).db;
+    const oldDate = new Date(Date.now() - 35 * 86400000).toISOString().slice(0, 10); // 35 days ago
+    db.prepare(
+      `INSERT INTO memories (content, type, date, labels, score) VALUES (?, 'log', ?, '[]', 0.1)`
+    ).run('Old low-score log entry from long ago', oldDate);
+
+    const before = db.prepare('SELECT COUNT(*) as c FROM memories').get() as { c: number };
+    expect(before.c).toBe(1);
+
+    const report = await provider.consolidate();
+    expect(report.deleted).toBeGreaterThanOrEqual(1);
+
+    const after = db.prepare('SELECT COUNT(*) as c FROM memories').get() as { c: number };
+    expect(after.c).toBe(0);
+  });
+
+  it('keeps recent entries even with low score', async () => {
+    const db = (provider as unknown as { db: import('better-sqlite3').Database }).db;
+    const recentDate = new Date().toISOString().slice(0, 10); // today
+    db.prepare(
+      `INSERT INTO memories (content, type, date, labels, score) VALUES (?, 'log', ?, '[]', 0.1)`
+    ).run('Recent low-score log entry', recentDate);
+
+    const report = await provider.consolidate();
+    expect(report.deleted).toBe(0);
+
+    const after = db.prepare('SELECT COUNT(*) as c FROM memories').get() as { c: number };
+    expect(after.c).toBe(1);
+  });
+
+  it('keeps lessons/decisions/facts even when old and low score', async () => {
+    const db = (provider as unknown as { db: import('better-sqlite3').Database }).db;
+    const veryOldDate = new Date(Date.now() - 100 * 86400000).toISOString().slice(0, 10); // 100 days ago
+
+    db.prepare(
+      `INSERT INTO memories (content, type, date, labels, score) VALUES (?, 'lesson', ?, '[]', 0.05)`
+    ).run('Important lesson learned from a past mistake', veryOldDate);
+    db.prepare(
+      `INSERT INTO memories (content, type, date, labels, score) VALUES (?, 'decision', ?, '[]', 0.05)`
+    ).run('Key architectural decision made last year', veryOldDate);
+    db.prepare(
+      `INSERT INTO memories (content, type, date, labels, score) VALUES (?, 'fact', ?, '[]', 0.05)`
+    ).run('Critical fact about the system design', veryOldDate);
+
+    const report = await provider.consolidate();
+    expect(report.deleted).toBe(0);
+
+    const after = db.prepare('SELECT COUNT(*) as c FROM memories').get() as { c: number };
+    expect(after.c).toBe(3);
+  });
+
+  it('consolidate returns archived=0 and deleted count', async () => {
+    const report = await provider.consolidate();
+    expect(report).toHaveProperty('archived', 0);
+    expect(report).toHaveProperty('deleted');
+    expect(typeof report.deleted).toBe('number');
+  });
+
+  it('deletes mixed old entries but preserves protected types', async () => {
+    const db = (provider as unknown as { db: import('better-sqlite3').Database }).db;
+    const oldDate = new Date(Date.now() - 35 * 86400000).toISOString().slice(0, 10);
+    const veryOldDate = new Date(Date.now() - 100 * 86400000).toISOString().slice(0, 10);
+
+    // Should be deleted (old log, low score)
+    db.prepare(`INSERT INTO memories (content, type, date, labels, score) VALUES (?, 'log', ?, '[]', 0.1)`)
+      .run('Old log entry that should be removed', oldDate);
+
+    // Should be kept (lesson, even very old and low score)
+    db.prepare(`INSERT INTO memories (content, type, date, labels, score) VALUES (?, 'lesson', ?, '[]', 0.05)`)
+      .run('Important lesson to keep forever', veryOldDate);
+
+    // Should be kept (recent log, even low score)
+    db.prepare(`INSERT INTO memories (content, type, date, labels, score) VALUES (?, 'log', ?, '[]', 0.1)`)
+      .run('Recent log entry to keep', new Date().toISOString().slice(0, 10));
+
+    const report = await provider.consolidate();
+    expect(report.deleted).toBe(1);
+
+    const after = db.prepare('SELECT COUNT(*) as c FROM memories').get() as { c: number };
+    expect(after.c).toBe(2);
+  });
+});

package/src/__tests__/sqlite-memory.test.ts

@@ -0,0 +1,99 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { SqliteMemoryProvider } from '../sqlite-memory.js';
+
+describe('SqliteMemoryProvider', () => {
+  let provider: SqliteMemoryProvider;
+
+  beforeEach(() => {
+    // Use in-memory DB for tests — fast, no cleanup needed
+    provider = new SqliteMemoryProvider({ path: ':memory:' });
+  });
+
+  afterEach(() => {
+    provider.close();
+  });
+
+  it('returns empty array when no memories stored', async () => {
+    const results = await provider.search('anything');
+    expect(results).toEqual([]);
+  });
+
+  it('stores and retrieves a memory', async () => {
+    await provider.store({ content: 'Fixed the auth middleware N+1 bug', type: 'log' });
+    const results = await provider.search('auth middleware');
+    expect(results).toHaveLength(1);
+    expect(results[0].content).toContain('auth middleware');
+    expect(results[0].source).toBe('sqlite-memory');
+  });
+
+  it('stores with labels and date', async () => {
+    await provider.store({
+      content: 'Rate limiting added to auth endpoints',
+      type: 'decision',
+      date: '2026-03-01',
+      labels: ['auth', 'api'],
+    });
+    const results = await provider.search('rate limiting');
+    expect(results[0].date).toBe('2026-03-01');
+    expect(results[0].labels).toContain('auth');
+  });
+
+  it('ranks results by BM25 relevance', async () => {
+    await provider.store({ content: 'The auth system uses JWT tokens', type: 'fact' });
+    await provider.store({ content: 'Auth auth auth security auth', type: 'log' });
+    await provider.store({ content: 'Unrelated content about React components', type: 'log' });
+
+    const results = await provider.search('auth');
+    expect(results.length).toBeGreaterThanOrEqual(2);
+    // "auth" appears more in second entry, should rank higher
+    expect(results.some(r => r.content.includes('React'))).toBe(false);
+  });
+
+  it('expands search with labels (OR semantics)', async () => {
+    await provider.store({ content: 'Auth fix for backend', type: 'log', labels: ['auth', 'backend'] });
+    await provider.store({ content: 'Testing framework setup', type: 'log', labels: ['testing'] });
+    await provider.store({ content: 'Unrelated React component', type: 'log', labels: ['frontend'] });
+
+    // Labels expand the search: 'auth' matches first, 'testing' matches second
+    const results = await provider.search('auth', ['testing']);
+    expect(results).toHaveLength(2);
+    expect(results.some(r => r.content.includes('Auth fix'))).toBe(true);
+    expect(results.some(r => r.content.includes('Testing framework'))).toBe(true);
+  });
+
+  it('handles multiple stores and searches', async () => {
+    const topics = [
+      'Fixed the authentication bug in the login flow',
+      'Refactored the database connection pooling logic',
+      'Added rate limiting to the REST API endpoints',
+      'Migrated the frontend components to TypeScript',
+      'Implemented caching layer using Redis for performance',
+      'Updated the deployment pipeline for continuous delivery',
+      'Resolved memory leak in the background job processor',
+      'Designed the new microservices architecture diagram',
+      'Configured monitoring alerts for production incidents',
+      'Optimized SQL queries reducing response time by half',
+    ];
+    for (const content of topics) {
+      await provider.store({ content, type: 'log' });
+    }
+    // All entries have unique content — count them directly via describe()
+    const description = provider.describe();
+    expect(description).toContain('10 entries');
+  });
+
+  it('returns empty for queries with no matching words', async () => {
+    await provider.store({ content: 'Something about JavaScript', type: 'fact' });
+    const results = await provider.search('python django');
+    expect(results).toEqual([]);
+  });
+
+  it('satisfies the same contract as FileMemoryProvider', async () => {
+    // This test validates the contract: search returns MemoryEntry[]
+    await provider.store({ content: 'Test entry', type: 'fact' });
+    const results = await provider.search('test');
+    expect(results[0]).toHaveProperty('content');
+    expect(results[0]).toHaveProperty('type');
+    expect(results[0]).toHaveProperty('source');
+  });
+});

package/src/extension.ts

@@ -0,0 +1,102 @@
+import type { ExtensionAPI } from '@dot-ai/core';
+import { SqliteMemoryProvider } from './sqlite-memory.js';
+
+export default function(api: ExtensionAPI) {
+  const provider = new SqliteMemoryProvider({ ...api.config, root: api.workspaceRoot });
+
+  api.on('session_end', async () => {
+    try {
+      await provider.consolidate?.();
+    } catch { /* ignore */ }
+    try {
+      provider.close();
+    } catch { /* ignore */ }
+  });
+
+  api.on('context_enrich', async (event) => {
+    const labelNames = event.labels.map(l => l.name);
+    const memories = await provider.search(event.prompt, labelNames);
+    if (memories.length === 0) return;
+
+    const lines = memories.slice(0, 10).map(m => {
+      const date = m.date ? ` (${m.date})` : '';
+      return `- ${m.content}${date}`;
+    });
+
+    return {
+      sections: [{
+        id: 'memory:recall',
+        title: 'Relevant Memory',
+        content: `> ${provider.describe()}\n\n${lines.join('\n')}`,
+        priority: 80,
+        source: 'ext-sqlite-memory',
+        trimStrategy: 'truncate' as const,
+      }],
+    };
+  });
+
+  api.on('agent_end', async (event) => {
+    const response = event.response;
+    if (!response || response.length < 100) return;
+    if (response.includes('NO_REPLY') || response.includes('HEARTBEAT_OK')) return;
+    const CONVERSATIONAL_PREFIXES = ['OK', 'Done', "Here's", "I've", 'Sure', 'No problem', 'Voilà', "C'est fait"];
+    const trimmed = response.trimStart();
+    if (CONVERSATIONAL_PREFIXES.some(prefix => trimmed.startsWith(prefix))) return;
+
+    const MAX_LEARN_LENGTH = 500;
+    const truncated = response.length > MAX_LEARN_LENGTH
+      ? response.slice(0, MAX_LEARN_LENGTH) + '…'
+      : response;
+
+    try {
+      await provider.store({
+        content: truncated,
+        type: 'log',
+        date: new Date().toISOString().slice(0, 10),
+      });
+    } catch { /* ignore store errors */ }
+  });
+
+  api.registerTool({
+    name: 'memory_recall',
+    description: `Search stored memories. ${provider.describe()}`,
+    parameters: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Search query to find relevant memories.' },
+        limit: { type: 'number', description: 'Maximum results. Defaults to 10.' },
+      },
+      required: ['query'],
+    },
+    async execute(input) {
+      const query = input['query'];
+      if (typeof query !== 'string') return { content: 'Error: "query" must be a string.', isError: true };
+      const limit = typeof input['limit'] === 'number' ? input['limit'] : 10;
+      const entries = await provider.search(query);
+      const results = entries.slice(0, limit);
+      if (results.length === 0) return { content: 'No memories found.' };
+      const lines = results.map((e, i) => `${i + 1}. [${e.type}] ${e.content}${e.date ? ` (${e.date})` : ''}`);
+      return { content: lines.join('\n'), details: { count: results.length } };
+    },
+  });
+
+  api.registerTool({
+    name: 'memory_store',
+    description: 'Store a new entry in memory for future recall.',
+    parameters: {
+      type: 'object',
+      properties: {
+        text: { type: 'string', description: 'Content to store.' },
+        type: { type: 'string', description: 'Memory type: fact, decision, lesson, log, pattern. Defaults to log.' },
+      },
+      required: ['text'],
+    },
+    async execute(input) {
+      const text = input['text'];
+      if (typeof text !== 'string') return { content: 'Error: "text" must be a string.', isError: true };
+      const type = typeof input['type'] === 'string' ? input['type'] : 'log';
+      await provider.store({ content: text, type, date: new Date().toISOString().slice(0, 10) });
+      return { content: `Memory stored (type: ${type}).` };
+    },
+  });
+}