@dotsetlabs/dotclaw 1.1.0

package/dist/memory-store.js

@@ -0,0 +1,787 @@
+import Database from 'better-sqlite3';
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import { MAIN_GROUP_FOLDER, STORE_DIR } from './config.js';
+import { loadRuntimeConfig } from './runtime-config.js';
+const MEMORY_DB_PATH = path.join(STORE_DIR, 'memory.db');
+let memoryDb = null;
+let ftsEnabled = true;
+const MEMORY_SCHEMA_VERSION = 3;
+function getUserVersion(db) {
+    const version = db.pragma('user_version', { simple: true });
+    return Number.isFinite(version) ? version : 0;
+}
+function setUserVersion(db, version) {
+    db.pragma(`user_version = ${Math.max(0, Math.floor(version))}`);
+}
+function getMemoryColumns(db) {
+    const rows = db.prepare(`PRAGMA table_info(memory_items)`).all();
+    const columns = new Set();
+    for (const row of rows) {
+        if (row?.name)
+            columns.add(String(row.name));
+    }
+    return columns;
+}
+function ensureColumn(db, columns, name, ddl) {
+    if (columns.has(name))
+        return;
+    db.exec(ddl);
+    columns.add(name);
+}
+function ensureMemorySchema(db) {
+    const currentVersion = getUserVersion(db);
+    const columns = getMemoryColumns(db);
+    if (columns.size === 0) {
+        // Table might not exist yet; caller should have created it.
+        return;
+    }
+    ensureColumn(db, columns, 'embedding_json', `ALTER TABLE memory_items ADD COLUMN embedding_json TEXT`);
+    ensureColumn(db, columns, 'embedding_model', `ALTER TABLE memory_items ADD COLUMN embedding_model TEXT`);
+    ensureColumn(db, columns, 'embedding_updated_at', `ALTER TABLE memory_items ADD COLUMN embedding_updated_at TEXT`);
+    ensureColumn(db, columns, 'kind', `ALTER TABLE memory_items ADD COLUMN kind TEXT`);
+    ensureColumn(db, columns, 'conflict_key', `ALTER TABLE memory_items ADD COLUMN conflict_key TEXT`);
+    ensureColumn(db, columns, 'access_count', `ALTER TABLE memory_items ADD COLUMN access_count INTEGER DEFAULT 0`);
+    ensureColumn(db, columns, 'priority', `ALTER TABLE memory_items ADD COLUMN priority TEXT DEFAULT 'normal'`);
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_memory_conflict ON memory_items(group_folder, scope, subject_id, type, conflict_key)`);
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS memory_meta (
+      key TEXT PRIMARY KEY,
+      value TEXT
+    );
+  `);
+    if (currentVersion !== MEMORY_SCHEMA_VERSION) {
+        setUserVersion(db, MEMORY_SCHEMA_VERSION);
+    }
+}
+function getMemoryMeta(db, key) {
+    const row = db.prepare(`SELECT value FROM memory_meta WHERE key = ?`).get(key);
+    return row?.value ?? null;
+}
+function setMemoryMeta(db, key, value) {
+    db.prepare(`
+    INSERT INTO memory_meta (key, value)
+    VALUES (?, ?)
+    ON CONFLICT(key) DO UPDATE SET value = excluded.value
+  `).run(key, value);
+}
+function getDb() {
+    if (!memoryDb) {
+        initMemoryStore();
+    }
+    if (!memoryDb) {
+        throw new Error('Memory store is not initialized');
+    }
+    return memoryDb;
+}
+export function initMemoryStore() {
+    if (memoryDb)
+        return;
+    fs.mkdirSync(STORE_DIR, { recursive: true });
+    memoryDb = new Database(MEMORY_DB_PATH);
+    memoryDb.pragma('journal_mode = WAL');
+    memoryDb.pragma('busy_timeout = 3000');
+    memoryDb.exec(`
+    CREATE TABLE IF NOT EXISTS memory_items (
+      id TEXT PRIMARY KEY,
+      group_folder TEXT NOT NULL,
+      scope TEXT NOT NULL,
+      subject_id TEXT,
+      type TEXT NOT NULL,
+      kind TEXT,
+      conflict_key TEXT,
+      content TEXT NOT NULL,
+      normalized TEXT NOT NULL,
+      importance REAL NOT NULL,
+      confidence REAL NOT NULL,
+      tags_json TEXT,
+      tags_text TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      last_accessed_at TEXT,
+      expires_at TEXT,
+      source TEXT,
+      metadata_json TEXT,
+      embedding_json TEXT,
+      embedding_model TEXT,
+      embedding_updated_at TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_memory_group_scope ON memory_items(group_folder, scope, subject_id);
+    CREATE INDEX IF NOT EXISTS idx_memory_updated_at ON memory_items(updated_at);
+
+    CREATE TABLE IF NOT EXISTS memory_sources (
+      id TEXT PRIMARY KEY,
+      group_folder TEXT NOT NULL,
+      source_type TEXT NOT NULL,
+      source_path TEXT NOT NULL,
+      source_hash TEXT,
+      indexed_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_memory_sources_group ON memory_sources(group_folder, source_type);
+  `);
+    try {
+        memoryDb.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(
+        id,
+        content,
+        tags,
+        tokenize = 'porter'
+      );
+
+      CREATE TRIGGER IF NOT EXISTS memory_items_ai AFTER INSERT ON memory_items BEGIN
+        INSERT INTO memory_fts (id, content, tags)
+        VALUES (new.id, new.content, new.tags_text);
+      END;
+      CREATE TRIGGER IF NOT EXISTS memory_items_au AFTER UPDATE ON memory_items BEGIN
+        UPDATE memory_fts
+        SET content = new.content, tags = new.tags_text
+        WHERE id = new.id;
+      END;
+      CREATE TRIGGER IF NOT EXISTS memory_items_ad AFTER DELETE ON memory_items BEGIN
+        DELETE FROM memory_fts WHERE id = old.id;
+      END;
+    `);
+        ftsEnabled = true;
+    }
+    catch {
+        ftsEnabled = false;
+    }
+    try {
+        ensureMemorySchema(memoryDb);
+    }
+    catch (err) {
+        console.error(`[memory-store] Schema check failed: ${err instanceof Error ? err.message : String(err)}`);
+        throw err;
+    }
+}
+function normalizeContent(content) {
+    return content
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function clamp(value, min, max) {
+    if (!Number.isFinite(value))
+        return min;
+    return Math.min(max, Math.max(min, value));
+}
+function tagsToText(tags) {
+    if (!tags || tags.length === 0)
+        return '';
+    return tags
+        .map(tag => tag.trim().toLowerCase())
+        .filter(Boolean)
+        .join(' ');
+}
+function getExpiresAt(ttlDays) {
+    if (!ttlDays || !Number.isFinite(ttlDays) || ttlDays <= 0)
+        return null;
+    const ms = ttlDays * 24 * 60 * 60 * 1000;
+    return new Date(Date.now() + ms).toISOString();
+}
+function resolveScope(input, groupFolder) {
+    if (input.scope === 'global' && groupFolder !== MAIN_GROUP_FOLDER) {
+        return 'group';
+    }
+    return input.scope;
+}
+function resolveKind(input) {
+    if (input.kind === 'semantic' || input.kind === 'episodic' || input.kind === 'procedural' || input.kind === 'preference') {
+        return input.kind;
+    }
+    if (input.type === 'preference')
+        return 'preference';
+    if (input.type === 'task' || input.type === 'project')
+        return 'procedural';
+    if (input.type === 'archive')
+        return 'episodic';
+    return 'semantic';
+}
+function normalizeConflictKey(value) {
+    if (!value || typeof value !== 'string')
+        return null;
+    const trimmed = value.trim().toLowerCase();
+    return trimmed ? trimmed : null;
+}
+function parseJsonArray(raw) {
+    if (!raw)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed)) {
+            return parsed.filter((item) => typeof item === 'string');
+        }
+    }
+    catch {
+        // ignore parse errors
+    }
+    return [];
+}
+function parseJsonRecord(raw) {
+    if (!raw)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // ignore parse errors
+    }
+    return null;
+}
+export function upsertMemoryItems(groupFolder, items, source) {
+    if (items.length === 0)
+        return [];
+    const db = getDb();
+    const now = new Date().toISOString();
+    const results = [];
+    const selectStmt = db.prepare(`
+    SELECT id, content, importance, confidence, tags_json, tags_text, embedding_json, embedding_model, embedding_updated_at, kind, conflict_key
+    FROM memory_items
+    WHERE group_folder = ? AND scope = ? AND IFNULL(subject_id, '') = ? AND type = ? AND normalized = ?
+  `);
+    const deleteConflictStmt = db.prepare(`
+    DELETE FROM memory_items
+    WHERE group_folder = ? AND scope = ? AND IFNULL(subject_id, '') = ? AND type = ? AND conflict_key = ?
+  `);
+    const insertStmt = db.prepare(`
+    INSERT INTO memory_items (
+      id, group_folder, scope, subject_id, type, kind, conflict_key, content, normalized,
+      importance, confidence, tags_json, tags_text, created_at, updated_at,
+      last_accessed_at, expires_at, source, metadata_json,
+      embedding_json, embedding_model, embedding_updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+    const updateStmt = db.prepare(`
+    UPDATE memory_items
+    SET content = ?, importance = ?, confidence = ?, tags_json = ?, tags_text = ?,
+        updated_at = ?, expires_at = ?, source = ?, metadata_json = ?,
+        embedding_json = ?, embedding_model = ?, embedding_updated_at = ?,
+        kind = ?, conflict_key = ?
+    WHERE id = ?
+  `);
+    const transaction = db.transaction((inputs) => {
+        for (const item of inputs) {
+            if (!item.content || typeof item.content !== 'string')
+                continue;
+            const normalized = normalizeContent(item.content);
+            if (!normalized)
+                continue;
+            const scope = resolveScope(item, groupFolder);
+            const kind = resolveKind(item);
+            const conflictKey = normalizeConflictKey(item.conflict_key);
+            const subjectId = scope === 'user' ? (item.subject_id || null) : null;
+            const importance = clamp(item.importance ?? 0.5, 0, 1);
+            const confidence = clamp(item.confidence ?? 0.6, 0, 1);
+            const tagsJson = item.tags ? JSON.stringify(item.tags) : null;
+            const tagsText = tagsToText(item.tags);
+            const expiresAt = getExpiresAt(item.ttl_days ?? null);
+            const metadataJson = item.metadata ? JSON.stringify(item.metadata) : null;
+            if (conflictKey) {
+                deleteConflictStmt.run(groupFolder, scope, subjectId || '', item.type, conflictKey);
+            }
+            const existing = selectStmt.get(groupFolder, scope, subjectId || '', item.type, normalized);
+            if (existing) {
+                const mergedImportance = Math.max(existing.importance, importance);
+                const mergedConfidence = Math.max(existing.confidence, confidence);
+                const mergedContent = existing.content.length >= item.content.length ? existing.content : item.content;
+                const mergedTags = Array.from(new Set([...(existing.tags_text || '').split(' ').filter(Boolean), ...tagsText.split(' ').filter(Boolean)])).join(' ');
+                const contentChanged = mergedContent !== existing.content;
+                const nextEmbeddingJson = contentChanged ? null : existing.embedding_json;
+                const nextEmbeddingModel = contentChanged ? null : existing.embedding_model;
+                const nextEmbeddingUpdatedAt = contentChanged ? null : existing.embedding_updated_at;
+                updateStmt.run(mergedContent, mergedImportance, mergedConfidence, tagsJson || existing.tags_json, mergedTags || existing.tags_text || '', now, expiresAt, item.source || source, metadataJson, nextEmbeddingJson, nextEmbeddingModel, nextEmbeddingUpdatedAt, kind, conflictKey, existing.id);
+                results.push({
+                    id: existing.id,
+                    group_folder: groupFolder,
+                    scope,
+                    subject_id: subjectId,
+                    type: item.type,
+                    kind,
+                    conflict_key: conflictKey,
+                    content: mergedContent,
+                    normalized,
+                    importance: mergedImportance,
+                    confidence: mergedConfidence,
+                    tags: item.tags,
+                    tags_text: mergedTags || existing.tags_text || '',
+                    created_at: now,
+                    updated_at: now,
+                    last_accessed_at: null,
+                    expires_at: expiresAt,
+                    ttl_days: item.ttl_days,
+                    source: item.source || source,
+                    metadata: item.metadata,
+                    embedding_json: nextEmbeddingJson,
+                    embedding_model: nextEmbeddingModel,
+                    embedding_updated_at: nextEmbeddingUpdatedAt
+                });
+                continue;
+            }
+            const id = `mem-${crypto.randomUUID()}`;
+            insertStmt.run(id, groupFolder, scope, subjectId, item.type, kind, conflictKey, item.content, normalized, importance, confidence, tagsJson, tagsText, now, now, null, expiresAt, item.source || source, metadataJson, null, null, null);
+            results.push({
+                id,
+                group_folder: groupFolder,
+                scope,
+                subject_id: subjectId,
+                type: item.type,
+                kind,
+                conflict_key: conflictKey,
+                content: item.content,
+                normalized,
+                importance,
+                confidence,
+                tags: item.tags,
+                tags_text: tagsText,
+                created_at: now,
+                updated_at: now,
+                last_accessed_at: null,
+                expires_at: expiresAt,
+                ttl_days: item.ttl_days,
+                source: item.source || source,
+                metadata: item.metadata,
+                embedding_json: null,
+                embedding_model: null,
+                embedding_updated_at: null
+            });
+        }
+    });
+    transaction(items);
+    return results;
+}
+function buildFtsQuery(text) {
+    const tokens = text.toLowerCase().match(/[a-z0-9]+/g) || [];
+    if (tokens.length === 0)
+        return null;
+    const unique = Array.from(new Set(tokens)).slice(0, 10);
+    return unique.map(token => `${token}*`).join(' OR ');
+}
+export function searchMemories(params) {
+    const db = getDb();
+    if (!ftsEnabled) {
+        return searchMemoriesFallback(params);
+    }
+    const ftsQuery = buildFtsQuery(params.query);
+    if (!ftsQuery)
+        return [];
+    const now = new Date().toISOString();
+    const limit = Math.min(params.limit || 12, 50);
+    const rows = db.prepare(`
+    SELECT m.*, bm25(memory_fts) AS bm25
+    FROM memory_fts
+    JOIN memory_items m ON m.id = memory_fts.id
+    WHERE memory_fts MATCH ?
+      AND (m.group_folder = ? OR m.group_folder = 'global')
+      AND (m.scope != 'user' OR m.subject_id = ?)
+      AND (m.expires_at IS NULL OR m.expires_at > ?)
+    ORDER BY bm25
+    LIMIT ?
+  `).all(ftsQuery, params.groupFolder, params.userId || '', now, limit);
+    const scored = rows.map(row => {
+        const ageDays = row.updated_at ? (Date.now() - new Date(row.updated_at).getTime()) / (1000 * 60 * 60 * 24) : 365;
+        const recency = Math.exp(-ageDays / 30);
+        const bm25Score = 1 / (1 + (row.bm25 || 0));
+        const score = (bm25Score * 0.55) + (row.importance * 0.3) + (recency * 0.15);
+        return { ...row, score };
+    });
+    scored.sort((a, b) => b.score - a.score);
+    return scored;
+}
+function searchMemoriesFallback(params) {
+    const db = getDb();
+    const normalizedQuery = normalizeContent(params.query);
+    const tokens = normalizedQuery.split(' ').filter(Boolean).slice(0, 10);
+    if (tokens.length === 0)
+        return [];
+    const clauses = tokens.map(() => '(m.normalized LIKE ? OR m.tags_text LIKE ?)');
+    const values = [];
+    for (const token of tokens) {
+        const pattern = `%${token}%`;
+        values.push(pattern, pattern);
+    }
+    const now = new Date().toISOString();
+    const limit = Math.min(params.limit || 12, 50);
+    const rows = db.prepare(`
+    SELECT m.*
+    FROM memory_items m
+    WHERE ${clauses.join(' AND ')}
+      AND (m.group_folder = ? OR m.group_folder = 'global')
+      AND (m.scope != 'user' OR m.subject_id = ?)
+      AND (m.expires_at IS NULL OR m.expires_at > ?)
+    ORDER BY m.updated_at DESC
+    LIMIT ?
+  `).all(...values, params.groupFolder, params.userId || '', now, limit);
+    const scored = rows.map(row => {
+        const normalized = row.normalized || '';
+        const tagsText = row.tags_text || '';
+        let matches = 0;
+        for (const token of tokens) {
+            if (normalized.includes(token) || tagsText.includes(token)) {
+                matches += 1;
+            }
+        }
+        const matchScore = tokens.length > 0 ? matches / tokens.length : 0;
+        const ageDays = row.updated_at ? (Date.now() - new Date(row.updated_at).getTime()) / (1000 * 60 * 60 * 24) : 365;
+        const recency = Math.exp(-ageDays / 30);
+        const score = (matchScore * 0.5) + (row.importance * 0.3) + (recency * 0.2);
+        return { ...row, bm25: 0, score };
+    });
+    scored.sort((a, b) => b.score - a.score);
+    return scored;
+}
+export function listMemories(params) {
+    const db = getDb();
+    const clauses = ['group_folder = ?'];
+    const values = [params.groupFolder];
+    if (params.scope) {
+        clauses.push('scope = ?');
+        values.push(params.scope);
+    }
+    if (params.type) {
+        clauses.push('type = ?');
+        values.push(params.type);
+    }
+    if (params.scope === 'user') {
+        clauses.push('subject_id = ?');
+        values.push(params.userId || '');
+    }
+    const limit = Math.min(params.limit || 50, 200);
+    const sql = `
+    SELECT * FROM memory_items
+    WHERE ${clauses.join(' AND ')}
+    ORDER BY updated_at DESC
+    LIMIT ?
+  `;
+    return db.prepare(sql).all(...values, limit);
+}
+export function forgetMemories(params) {
+    const db = getDb();
+    if (params.ids && params.ids.length > 0) {
+        const placeholders = params.ids.map(() => '?').join(',');
+        const stmt = db.prepare(`DELETE FROM memory_items WHERE group_folder = ? AND id IN (${placeholders})`);
+        const info = stmt.run(params.groupFolder, ...params.ids);
+        return info.changes;
+    }
+    if (params.content) {
+        const normalized = normalizeContent(params.content);
+        const clauses = ['group_folder = ?', 'normalized = ?'];
+        const values = [params.groupFolder, normalized];
+        if (params.scope) {
+            clauses.push('scope = ?');
+            values.push(params.scope);
+        }
+        if (params.scope === 'user') {
+            clauses.push('subject_id = ?');
+            values.push(params.userId || '');
+        }
+        const stmt = db.prepare(`DELETE FROM memory_items WHERE ${clauses.join(' AND ')}`);
+        const info = stmt.run(...values);
+        return info.changes;
+    }
+    return 0;
+}
+export function getMemoryStats(params) {
+    const db = getDb();
+    const total = db.prepare(`SELECT COUNT(*) as count FROM memory_items WHERE group_folder = ? OR group_folder = 'global'`)
+        .get(params.groupFolder);
+    const user = db.prepare(`
+    SELECT COUNT(*) as count FROM memory_items
+    WHERE group_folder = ? AND scope = 'user' AND subject_id = ?
+  `).get(params.groupFolder, params.userId || '');
+    const group = db.prepare(`
+    SELECT COUNT(*) as count FROM memory_items
+    WHERE group_folder = ? AND scope = 'group'
+  `).get(params.groupFolder);
+    const global = db.prepare(`
+    SELECT COUNT(*) as count FROM memory_items
+    WHERE group_folder = 'global'
+  `).get();
+    return {
+        total: total?.count || 0,
+        user: user?.count || 0,
+        group: group?.count || 0,
+        global: global?.count || 0
+    };
+}
+export function cleanupExpiredMemories() {
+    const db = getDb();
+    const now = new Date().toISOString();
+    const info = db.prepare(`DELETE FROM memory_items WHERE expires_at IS NOT NULL AND expires_at <= ?`).run(now);
+    return info.changes;
+}
+/**
+ * Record memory access: update last_accessed_at, increment access_count, and boost importance
+ * Called when memories are recalled for context
+ */
+export function recordMemoryAccess(ids) {
+    if (ids.length === 0)
+        return;
+    const db = getDb();
+    const now = new Date().toISOString();
+    // Boost importance by 2% per access, capped at 1.0
+    const placeholders = ids.map(() => '?').join(',');
+    db.prepare(`
+    UPDATE memory_items
+    SET last_accessed_at = ?,
+        access_count = COALESCE(access_count, 0) + 1,
+        importance = MIN(1.0, importance + 0.02)
+    WHERE id IN (${placeholders})
+  `).run(now, ...ids);
+}
+/**
+ * Decay importance for memories not accessed recently
+ * Reduces importance by 1% for memories not accessed in 30+ days (minimum 0.1)
+ * Also doesn't decay critical priority memories
+ */
+export function decayUnusedMemories() {
+    const db = getDb();
+    const info = db.prepare(`
+    UPDATE memory_items
+    SET importance = MAX(0.1, importance - 0.01)
+    WHERE (last_accessed_at IS NULL OR last_accessed_at < datetime('now', '-30 days'))
+      AND importance > 0.1
+      AND (priority IS NULL OR priority != 'critical')
+  `).run();
+    return info.changes;
+}
+/**
+ * Set priority for a memory item
+ * Priority values: 'critical', 'normal', 'low'
+ * Critical memories are never pruned
+ */
+export function setMemoryPriority(id, priority) {
+    const db = getDb();
+    const info = db.prepare(`UPDATE memory_items SET priority = ? WHERE id = ?`).run(priority, id);
+    return info.changes > 0;
+}
+/**
+ * Get memory by ID
+ */
+export function getMemoryById(id) {
+    const db = getDb();
+    const row = db.prepare(`SELECT * FROM memory_items WHERE id = ?`).get(id);
+    return row ? row : null;
+}
+export function pruneMemoryOverflow(params) {
+    const db = getDb();
+    const maxItems = Math.max(0, Math.floor(params.maxItems));
+    if (maxItems <= 0)
+        return 0;
+    const total = db.prepare(`SELECT COUNT(*) as count FROM memory_items`).get();
+    if (!total || total.count <= maxItems)
+        return 0;
+    let remaining = total.count - maxItems;
+    let removed = 0;
+    // First pass: delete low-importance items (excluding critical priority)
+    const deleteByThreshold = db.prepare(`
+    DELETE FROM memory_items
+    WHERE id IN (
+      SELECT id FROM memory_items
+      WHERE importance <= ?
+        AND (priority IS NULL OR priority != 'critical')
+      ORDER BY importance ASC, updated_at ASC
+      LIMIT ?
+    )
+  `);
+    const infoThreshold = deleteByThreshold.run(params.importanceThreshold, remaining);
+    removed += infoThreshold.changes;
+    remaining -= infoThreshold.changes;
+    // Second pass: delete by overflow (still excluding critical)
+    if (remaining > 0) {
+        const deleteByOverflow = db.prepare(`
+      DELETE FROM memory_items
+      WHERE id IN (
+        SELECT id FROM memory_items
+        WHERE (priority IS NULL OR priority != 'critical')
+        ORDER BY importance ASC, updated_at ASC
+        LIMIT ?
+      )
+    `);
+        const infoOverflow = deleteByOverflow.run(remaining);
+        removed += infoOverflow.changes;
+    }
+    return removed;
+}
+export function runMemoryMaintenance() {
+    const db = getDb();
+    const expired = cleanupExpiredMemories();
+    // Decay importance for unused memories
+    const decayed = decayUnusedMemories();
+    const runtime = loadRuntimeConfig();
+    const maintenance = runtime.host.memory.maintenance;
+    const maxItems = maintenance.maxItems;
+    const threshold = maintenance.pruneImportanceThreshold;
+    const pruned = pruneMemoryOverflow({ maxItems, importanceThreshold: threshold });
+    const shouldVacuum = maintenance.vacuumEnabled;
+    const vacuumIntervalDays = maintenance.vacuumIntervalDays;
+    const analyzeEnabled = maintenance.analyzeEnabled;
+    let vacuumed = false;
+    let analyzed = false;
+    if ((expired + pruned) > 0 && shouldVacuum && vacuumIntervalDays > 0) {
+        const now = Date.now();
+        const lastVacuumRaw = getMemoryMeta(db, 'last_vacuum_at');
+        const lastVacuum = lastVacuumRaw ? Date.parse(lastVacuumRaw) : 0;
+        const intervalMs = vacuumIntervalDays * 24 * 60 * 60 * 1000;
+        if (!Number.isFinite(lastVacuum) || (now - lastVacuum) >= intervalMs) {
+            try {
+                db.exec('VACUUM');
+                setMemoryMeta(db, 'last_vacuum_at', new Date(now).toISOString());
+                vacuumed = true;
+            }
+            catch {
+                // ignore vacuum errors
+            }
+        }
+    }
+    if ((expired + pruned) > 0 && analyzeEnabled) {
+        try {
+            db.exec('ANALYZE');
+            analyzed = true;
+        }
+        catch {
+            // ignore analyze errors
+        }
+    }
+    return { expired, pruned, decayed, vacuumed, analyzed };
+}
+export function buildUserProfile(params) {
+    if (!params.userId)
+        return null;
+    const db = getDb();
+    const limit = Math.min(params.limit || 8, 20);
+    const rows = db.prepare(`
+    SELECT content, type
+    FROM memory_items
+    WHERE group_folder = ? AND scope = 'user' AND subject_id = ?
+      AND type IN ('identity', 'preference', 'relationship', 'project')
+    ORDER BY importance DESC, updated_at DESC
+    LIMIT ?
+  `).all(params.groupFolder, params.userId, limit);
+    if (rows.length === 0)
+        return null;
+    return rows.map(row => `- (${row.type}) ${row.content}`).join('\n');
+}
+export function listMemoriesMissingEmbeddings(params) {
+    const db = getDb();
+    const limit = Math.min(params.limit || 100, 1000);
+    if (params.groupFolder) {
+        return db.prepare(`
+      SELECT id, content, group_folder
+      FROM memory_items
+      WHERE group_folder = ?
+        AND content IS NOT NULL
+        AND (embedding_json IS NULL OR embedding_json = '')
+      ORDER BY updated_at DESC
+      LIMIT ?
+    `).all(params.groupFolder, limit);
+    }
+    return db.prepare(`
+    SELECT id, content, group_folder
+    FROM memory_items
+    WHERE content IS NOT NULL
+      AND (embedding_json IS NULL OR embedding_json = '')
+    ORDER BY updated_at DESC
+    LIMIT ?
+  `).all(limit);
+}
+export function countMemoriesMissingEmbeddings(params) {
+    const db = getDb();
+    if (params.groupFolder) {
+        const row = db.prepare(`
+      SELECT COUNT(*) as count
+      FROM memory_items
+      WHERE group_folder = ?
+        AND content IS NOT NULL
+        AND (embedding_json IS NULL OR embedding_json = '')
+    `).get(params.groupFolder);
+        return row?.count ? Number(row.count) : 0;
+    }
+    const row = db.prepare(`
+    SELECT COUNT(*) as count
+    FROM memory_items
+    WHERE content IS NOT NULL
+      AND (embedding_json IS NULL OR embedding_json = '')
+  `).get();
+    return row?.count ? Number(row.count) : 0;
+}
+export function updateMemoryEmbedding(params) {
+    const db = getDb();
+    const now = new Date().toISOString();
+    const embeddingJson = JSON.stringify(params.embedding);
+    db.prepare(`
+    UPDATE memory_items
+    SET embedding_json = ?, embedding_model = ?, embedding_updated_at = ?
+    WHERE id = ?
+  `).run(embeddingJson, params.model, now, params.id);
+}
+export function listEmbeddedMemories(params) {
+    const db = getDb();
+    const limit = Math.min(params.limit || 2000, 5000);
+    const now = new Date().toISOString();
+    return db.prepare(`
+    SELECT id, content, type, importance, updated_at, embedding_json
+    FROM memory_items
+    WHERE (group_folder = ? OR group_folder = 'global')
+      AND (scope != 'user' OR subject_id = ?)
+      AND (expires_at IS NULL OR expires_at > ?)
+      AND embedding_json IS NOT NULL
+    ORDER BY updated_at DESC
+    LIMIT ?
+  `).all(params.groupFolder, params.userId || '', now, limit);
+}
+export function listPreferenceMemories(params) {
+    const db = getDb();
+    const limit = Math.min(params.limit || 50, 200);
+    if (params.userId) {
+        const rows = db.prepare(`
+      SELECT conflict_key, content, tags_json, metadata_json, scope, subject_id, updated_at, importance
+      FROM memory_items
+      WHERE (group_folder = ? OR group_folder = 'global')
+        AND type = 'preference'
+        AND conflict_key IS NOT NULL
+        AND (
+          (scope = 'user' AND subject_id = ?)
+          OR scope = 'group'
+          OR scope = 'global'
+        )
+      ORDER BY updated_at DESC
+      LIMIT ?
+    `).all(params.groupFolder, params.userId, limit);
+        return rows.map(row => ({
+            conflict_key: String(row.conflict_key),
+            content: row.content ? String(row.content) : '',
+            tags: parseJsonArray(row.tags_json ? String(row.tags_json) : null),
+            metadata: parseJsonRecord(row.metadata_json ? String(row.metadata_json) : null),
+            scope: row.scope === 'user' || row.scope === 'group' || row.scope === 'global' ? row.scope : 'group',
+            subject_id: row.subject_id ? String(row.subject_id) : null,
+            updated_at: row.updated_at ? String(row.updated_at) : new Date(0).toISOString(),
+            importance: typeof row.importance === 'number' ? row.importance : Number(row.importance || 0)
+        }));
+    }
+    const rows = db.prepare(`
+    SELECT conflict_key, content, tags_json, metadata_json, scope, subject_id, updated_at, importance
+    FROM memory_items
+    WHERE (group_folder = ? OR group_folder = 'global')
+      AND type = 'preference'
+      AND conflict_key IS NOT NULL
+      AND (scope = 'group' OR scope = 'global')
+    ORDER BY updated_at DESC
+    LIMIT ?
+  `).all(params.groupFolder, limit);
+    return rows.map(row => ({
+        conflict_key: String(row.conflict_key),
+        content: row.content ? String(row.content) : '',
+        tags: parseJsonArray(row.tags_json ? String(row.tags_json) : null),
+        metadata: parseJsonRecord(row.metadata_json ? String(row.metadata_json) : null),
+        scope: row.scope === 'user' || row.scope === 'group' || row.scope === 'global' ? row.scope : 'group',
+        subject_id: row.subject_id ? String(row.subject_id) : null,
+        updated_at: row.updated_at ? String(row.updated_at) : new Date(0).toISOString(),
+        importance: typeof row.importance === 'number' ? row.importance : Number(row.importance || 0)
+    }));
+}
+//# sourceMappingURL=memory-store.js.map