@jungjaehoon/mama-core 1.3.3 → 1.4.1

package/dist/db-adapter/node-sqlite-adapter.js

@@ -18,19 +18,34 @@ const debug_logger_js_1 = require("../debug-logger.js");
 const embeddings_js_1 = require("../embeddings.js");
 const LEGACY_DB_PATH = path_1.default.join(os_1.default.homedir(), '.spinelift', 'memories.db');
 const DEFAULT_DB_PATH = path_1.default.join(os_1.default.homedir(), '.claude', 'mama-memory.db');
+// Prefer better-sqlite3 (includes FTS5) over node:sqlite (lacks FTS5)
+let BetterSQLite3 = null;
 let DatabaseSync = null;
 try {
     // eslint-disable-next-line @typescript-eslint/no-require-imports
-    ({ DatabaseSync } = require('node:sqlite'));
+    const bs3 = require('better-sqlite3');
+    BetterSQLite3 = 'default' in bs3 ? bs3.default : bs3;
 }
 catch {
-    DatabaseSync = null;
+    BetterSQLite3 = null;
+}
+if (!BetterSQLite3) {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        ({ DatabaseSync } = require('node:sqlite'));
+    }
+    catch {
+        DatabaseSync = null;
+    }
 }
 class NodeSQLiteConnection {
     db;
     connected = true;
+    isBetterSQLite3;
     constructor(db) {
         this.db = db;
+        // better-sqlite3 databases have a native .pragma() method
+        this.isBetterSQLite3 = typeof db.pragma === 'function';
     }
     prepare(sql) {
         return this.db.prepare(sql);
@@ -40,6 +55,11 @@ class NodeSQLiteConnection {
     }
     pragma(sql, options) {
         const query = sql.trim().replace(/^PRAGMA\s+/i, '');
+        if (this.isBetterSQLite3) {
+            // better-sqlite3 has a native pragma method that handles both read and write pragmas
+            return this.db.pragma(query, options);
+        }
+        // node:sqlite fallback: use prepare()
         const stmt = this.db.prepare(`PRAGMA ${query}`);
         if (options?.simple) {
             const row = stmt.get();
@@ -65,6 +85,8 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
     config;
     db = null;
     _vectorSearchEnabled = true;
+    vectorCache = new Map();
+    topicCache = new Map();
     constructor(config = {}) {
         super();
         this.config = config;
@@ -90,27 +112,67 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
         if (this.db) {
             return this.db;
         }
-        if (!DatabaseSync) {
-            throw new Error('node:sqlite is not available in this Node.js runtime. Use Node 22.13+.');
+        const Driver = BetterSQLite3 || DatabaseSync;
+        if (!Driver) {
+            throw new Error('No SQLite driver available. Install better-sqlite3 or use Node 22.13+ (node:sqlite).');
         }
+        const driverName = BetterSQLite3 ? 'better-sqlite3' : 'node:sqlite';
         const dbPath = this.getDbPath();
         const dbDir = path_1.default.dirname(dbPath);
         if (!fs_1.default.existsSync(dbDir)) {
             fs_1.default.mkdirSync(dbDir, { recursive: true });
-            (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Created database directory: ${dbDir}`);
+            (0, debug_logger_js_1.info)(`[sqlite-adapter] Created database directory: ${dbDir}`);
         }
-        const database = new DatabaseSync(dbPath);
+        const database = new Driver(dbPath);
         this.db = new NodeSQLiteConnection(database);
-        (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Opened database at: ${dbPath}`);
+        (0, debug_logger_js_1.info)(`[sqlite-adapter] Opened database at: ${dbPath} (driver: ${driverName})`);
         this.db.pragma('journal_mode = WAL');
         this.db.pragma('busy_timeout = 5000');
         this.db.pragma('synchronous = NORMAL');
         this.db.pragma('cache_size = -64000');
         this.db.pragma('temp_store = MEMORY');
         this.db.pragma('foreign_keys = ON');
-        (0, debug_logger_js_1.info)('[node-sqlite-adapter] Vector search: pure TS cosine similarity (no native extensions)');
+        (0, debug_logger_js_1.info)('[sqlite-adapter] Vector search: pure TS cosine similarity (no native extensions)');
+        this.loadVectorCache();
         return this.db;
     }
+    reloadVectorCache() {
+        this.loadVectorCache();
+    }
+    loadVectorCache() {
+        if (!this.db)
+            return;
+        const tableCheck = this.db
+            .prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='embeddings'`)
+            .all();
+        if (tableCheck.length === 0) {
+            this.vectorCache.clear();
+            this.topicCache.clear();
+            return;
+        }
+        const start = Date.now();
+        const rows = this.db.prepare('SELECT rowid, embedding FROM embeddings').all();
+        const CACHE_WARN_THRESHOLD = 100_000;
+        this.vectorCache.clear();
+        for (const row of rows) {
+            const vec = bytesToVector(row.embedding);
+            if (vec) {
+                this.vectorCache.set(row.rowid, vec);
+            }
+        }
+        // Load topic cache for scoped vector search
+        this.topicCache.clear();
+        const topicRows = this.db.prepare('SELECT rowid, topic FROM decisions').all();
+        for (const row of topicRows) {
+            this.topicCache.set(row.rowid, row.topic);
+        }
+        const count = this.vectorCache.size;
+        const elapsed = Date.now() - start;
+        (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Vector cache loaded: ${count} embeddings in ${elapsed}ms`);
+        if (count > CACHE_WARN_THRESHOLD) {
+            (0, debug_logger_js_1.warn)(`[node-sqlite-adapter] Vector cache holds ${count} embeddings — consider LRU eviction or on-demand loading for large datasets`);
+        }
+    }
     disconnect() {
         if (this.db) {
             this.db.close();
@@ -157,53 +219,39 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
             throw error;
         }
     }
-    vectorSearch(embedding, limit = 5) {
+    vectorSearch(embedding, limit = 5, topicPrefix) {
         if (!this.isConnected()) {
             throw new Error('Database not connected');
         }
         const queryVector = embedding instanceof Float32Array ? embedding : Float32Array.from(embedding);
-        const tableCheck = this.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='embeddings'`).all();
-        if (tableCheck.length === 0) {
-            throw new Error('Embeddings table missing');
-        }
         const effectiveLimit = Math.max(limit, 1);
-        const batchSize = 500;
         const bestMatches = [];
-        let offset = 0;
-        let hasMoreRows = true;
-        while (hasMoreRows) {
-            const rows = this.prepare('SELECT rowid, embedding FROM embeddings LIMIT ? OFFSET ?').all(batchSize, offset);
-            if (rows.length === 0) {
-                hasMoreRows = false;
+        let minScore = -Infinity;
+        for (const [rowid, candidate] of this.vectorCache) {
+            if (candidate.length !== queryVector.length)
                 continue;
-            }
-            for (const row of rows) {
-                const candidate = bytesToVector(row.embedding);
-                if (!candidate)
-                    continue;
-                if (candidate.length !== queryVector.length) {
-                    (0, debug_logger_js_1.warn)(`Skipping rowid ${row.rowid}: dimension mismatch (${candidate.length} vs ${queryVector.length})`);
+            // Pre-filter by topic prefix before computing similarity
+            if (topicPrefix) {
+                const topic = this.topicCache.get(rowid);
+                if (!topic || !topic.startsWith(topicPrefix))
                     continue;
-                }
-                const similarity = (0, embeddings_js_1.cosineSimilarity)(candidate, queryVector);
-                const scoredRow = {
-                    rowid: row.rowid,
-                    similarity,
-                    distance: 1 - similarity,
-                };
-                if (bestMatches.length < effectiveLimit) {
-                    bestMatches.push(scoredRow);
-                    bestMatches.sort((a, b) => (b.similarity ?? 0) - (a.similarity ?? 0));
-                    continue;
-                }
-                const weakestMatch = bestMatches[bestMatches.length - 1];
-                if ((scoredRow.similarity ?? 0) > (weakestMatch.similarity ?? 0)) {
-                    bestMatches.pop();
-                    bestMatches.push(scoredRow);
+            }
+            const similarity = (0, embeddings_js_1.cosineSimilarity)(candidate, queryVector);
+            if (bestMatches.length < effectiveLimit) {
+                bestMatches.push({ rowid, similarity, distance: 1 - similarity });
+                if (bestMatches.length === effectiveLimit) {
                     bestMatches.sort((a, b) => (b.similarity ?? 0) - (a.similarity ?? 0));
+                    minScore = bestMatches[bestMatches.length - 1].similarity ?? -Infinity;
                 }
             }
-            offset += rows.length;
+            else if (similarity > minScore) {
+                bestMatches[bestMatches.length - 1] = { rowid, similarity, distance: 1 - similarity };
+                bestMatches.sort((a, b) => (b.similarity ?? 0) - (a.similarity ?? 0));
+                minScore = bestMatches[bestMatches.length - 1].similarity ?? -Infinity;
+            }
+        }
+        if (bestMatches.length < effectiveLimit) {
+            bestMatches.sort((a, b) => (b.similarity ?? 0) - (a.similarity ?? 0));
         }
         return bestMatches;
     }
@@ -217,7 +265,13 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
       INSERT OR REPLACE INTO embeddings(rowid, embedding)
       VALUES (?, ?)
     `);
-        return stmt.run(rowid, buffer);
+        const result = stmt.run(rowid, buffer);
+        // Keep in-memory caches in sync
+        this.vectorCache.set(rowid, vec);
+        const topicRow = this.prepare('SELECT topic FROM decisions WHERE rowid = ?').get(rowid);
+        if (topicRow)
+            this.topicCache.set(rowid, topicRow.topic);
+        return result;
     }
     getLastInsertRowid() {
         if (!this.isConnected()) {

package/dist/db-manager.d.ts

@@ -26,8 +26,9 @@ export interface DatabaseAdapter {
     prepare: (sql: string) => PreparedStatement;
     transaction: <T>(fn: () => T) => T;
     insertEmbedding: (rowid: number, embedding: Float32Array | number[]) => void;
-    vectorSearch: (embedding: Float32Array | number[], limit: number) => Promise<VectorSearchResult[] | null>;
+    vectorSearch: (embedding: Float32Array | number[], limit: number, topicPrefix?: string) => Promise<VectorSearchResult[] | null> | VectorSearchResult[] | null;
     vectorSearchEnabled: boolean;
+    reloadVectorCache?: () => void;
     getDbPath?: () => string;
     dbPath?: string;
     constructor: {
@@ -54,6 +55,8 @@ export interface DecisionRecord {
     created_at: number;
     updated_at?: number;
     edges?: DecisionEdgeRow[];
+    /** ISO 8601 date when the event actually occurred. Null if not set. */
+    event_date?: string | null;
 }
 export interface OutcomeData {
     outcome?: string | null;
@@ -67,6 +70,7 @@ export interface VectorSearchParams {
     limit?: number;
     threshold?: number;
     timeWindow?: number;
+    includeSuperseded?: boolean;
 }
 export interface DecisionEdgeRow {
     from_id: string;
@@ -140,13 +144,19 @@ export declare function getAdapter(): DatabaseAdapter;
  * Call this on process exit
  */
 export declare function closeDB(): Promise<void>;
+export declare function ensureMemoryScope(kind: string, externalId: string): Promise<string>;
+export declare function bindMemoryToScope(memoryId: string, scopeId: string, isPrimary?: boolean): Promise<void>;
+export declare function listScopesForMemory(memoryId: string): Promise<Array<{
+    kind: string;
+    id: string;
+}>>;
 /**
  * Insert embedding into vector search table
  *
  * Stores embedding in the embeddings table for vector similarity search
  *
  * @param decisionRowid - SQLite rowid
- * @param embedding - 384-dim embedding vector
+ * @param embedding - 1024-dim embedding vector
  */
 export declare function insertEmbedding(decisionRowid: number, embedding: Float32Array | number[]): Promise<void>;
 /**
@@ -154,12 +164,12 @@ export declare function insertEmbedding(decisionRowid: number, embedding: Float3
  *
  * Returns empty array if vector search not available (no keyword fallback)
  *
- * @param queryEmbedding - Query embedding (384-dim)
+ * @param queryEmbedding - Query embedding (1024-dim)
  * @param limit - Max results to return (default: 5)
  * @param threshold - Minimum similarity threshold (default: 0.7)
  * @returns Array of decisions with similarity scores, or empty array
  */
-export declare function vectorSearch(queryEmbedding: Float32Array | number[], limit?: number, threshold?: number): Promise<DecisionRecord[]>;
+export declare function vectorSearch(queryEmbedding: Float32Array | number[], limit?: number, threshold?: number, topicPrefix?: string): Promise<DecisionRecord[]>;
 /**
  * Decision input for storage
  */
@@ -190,6 +200,8 @@ export interface DecisionInput {
     evidence?: string | null;
     alternatives?: string | null;
     risks?: string | null;
+    /** ISO 8601 date string for when the event actually occurred (e.g. "2023-01-15") */
+    event_date?: string | null;
 }
 /**
  * Insert decision with embedding
@@ -271,4 +283,20 @@ export declare function resetDBState(options?: {
  * Returns true if MAMA_TEST_MODE or VITEST env vars are set
  */
 export declare function isTestMode(): boolean;
+/**
+ * FTS5 keyword search on decisions table.
+ * Returns matching decision IDs with BM25 rank scores.
+ */
+export declare function fts5Search(query: string, limit?: number): Promise<{
+    id: string;
+    rank: number;
+}[]>;
+/**
+ * Re-generate all embeddings using the currently configured model.
+ * Call this after changing the embedding model in config.json.
+ *
+ * @param onProgress - Optional callback with (completed, total) counts
+ * @returns Number of embeddings regenerated
+ */
+export declare function reindexEmbeddings(onProgress?: (completed: number, total: number) => void): Promise<number>;
 //# sourceMappingURL=db-manager.d.ts.map

package/dist/db-manager.js

@@ -26,6 +26,9 @@ exports.initDB = initDB;
 exports.getDB = getDB;
 exports.getAdapter = getAdapter;
 exports.closeDB = closeDB;
+exports.ensureMemoryScope = ensureMemoryScope;
+exports.bindMemoryToScope = bindMemoryToScope;
+exports.listScopesForMemory = listScopesForMemory;
 exports.insertEmbedding = insertEmbedding;
 exports.vectorSearch = vectorSearch;
 exports.insertDecisionWithEmbedding = insertDecisionWithEmbedding;
@@ -37,6 +40,8 @@ exports.getPreparedStmt = getPreparedStmt;
 exports.getDbPath = getDbPath;
 exports.resetDBState = resetDBState;
 exports.isTestMode = isTestMode;
+exports.fts5Search = fts5Search;
+exports.reindexEmbeddings = reindexEmbeddings;
 const path_1 = __importDefault(require("path"));
 const debug_logger_js_1 = require("./debug-logger.js");
 const progress_indicator_js_1 = require("./progress-indicator.js");
@@ -78,6 +83,10 @@ async function initDB() {
             dbConnection = await dbAdapter.connect();
             // Run migrations (includes 012-create-checkpoints-table.sql)
             await dbAdapter.runMigrations(MIGRATIONS_DIR);
+            // Reload vector cache after migrations (new tables/rows may now exist)
+            if (typeof dbAdapter.reloadVectorCache === 'function') {
+                dbAdapter.reloadVectorCache();
+            }
             isInitialized = true;
             (0, debug_logger_js_1.info)(`[db-manager] Database initialized (${dbAdapter.constructor.name})`);
             (0, progress_indicator_js_1.logComplete)('Database ready');
@@ -124,6 +133,9 @@ function getAdapter() {
     }
     return dbAdapter;
 }
+function buildMemoryScopeId(kind, externalId) {
+    return `scope_${kind}_${Buffer.from(externalId).toString('base64url')}`;
+}
 /**
  * Close database connection
  *
@@ -139,13 +151,45 @@ async function closeDB() {
         (0, debug_logger_js_1.info)('[db-manager] Database connection closed');
     }
 }
+async function ensureMemoryScope(kind, externalId) {
+    const adapter = getAdapter();
+    const id = buildMemoryScopeId(kind, externalId);
+    adapter
+        .prepare(`
+        INSERT OR IGNORE INTO memory_scopes (id, kind, external_id)
+        VALUES (?, ?, ?)
+      `)
+        .run(id, kind, externalId);
+    return id;
+}
+async function bindMemoryToScope(memoryId, scopeId, isPrimary = false) {
+    const adapter = getAdapter();
+    adapter
+        .prepare(`
+        INSERT OR REPLACE INTO memory_scope_bindings (memory_id, scope_id, is_primary)
+        VALUES (?, ?, ?)
+      `)
+        .run(memoryId, scopeId, isPrimary ? 1 : 0);
+}
+async function listScopesForMemory(memoryId) {
+    const adapter = getAdapter();
+    return adapter
+        .prepare(`
+        SELECT ms.kind, ms.external_id AS id
+        FROM memory_scope_bindings msb
+        JOIN memory_scopes ms ON ms.id = msb.scope_id
+        WHERE msb.memory_id = ?
+        ORDER BY msb.is_primary DESC, ms.created_at ASC
+      `)
+        .all(memoryId);
+}
 /**
  * Insert embedding into vector search table
  *
  * Stores embedding in the embeddings table for vector similarity search
  *
  * @param decisionRowid - SQLite rowid
- * @param embedding - 384-dim embedding vector
+ * @param embedding - 1024-dim embedding vector
  */
 async function insertEmbedding(decisionRowid, embedding) {
     const adapter = getAdapter();
@@ -163,16 +207,16 @@ async function insertEmbedding(decisionRowid, embedding) {
  *
  * Returns empty array if vector search not available (no keyword fallback)
  *
- * @param queryEmbedding - Query embedding (384-dim)
+ * @param queryEmbedding - Query embedding (1024-dim)
  * @param limit - Max results to return (default: 5)
  * @param threshold - Minimum similarity threshold (default: 0.7)
  * @returns Array of decisions with similarity scores, or empty array
  */
-async function vectorSearch(queryEmbedding, limit = 5, threshold = 0.7) {
+async function vectorSearch(queryEmbedding, limit = 5, threshold = 0.7, topicPrefix) {
     const adapter = getAdapter();
     try {
-        // Brute-force cosine similarity over all embeddings
-        const results = await adapter.vectorSearch(queryEmbedding, limit * 3);
+        // Brute-force cosine similarity over all embeddings (with optional topic pre-filter)
+        const results = await adapter.vectorSearch(queryEmbedding, limit * 3, topicPrefix);
         if (!results || results.length === 0) {
             return []; // No keyword fallback - fast fail
         }
@@ -216,6 +260,13 @@ async function vectorSearch(queryEmbedding, limit = 5, threshold = 0.7) {
 async function insertDecisionWithEmbedding(decision) {
     const adapter = getAdapter();
     const { generateEnhancedEmbedding } = await import('./embeddings.js');
+    // Validate event_date before any DB operations
+    if (decision.event_date !== null && decision.event_date !== undefined) {
+        const d = decision.event_date;
+        if (!/^\d{4}-\d{2}-\d{2}$/.test(d) || isNaN(new Date(d).getTime())) {
+            throw new Error(`Invalid event_date: must be ISO 8601 YYYY-MM-DD (got: ${d})`);
+        }
+    }
     try {
         // Generate embedding BEFORE transaction (required for SQLite's sync transaction)
         // Note: Redact topic for privacy - only log length
@@ -248,14 +299,14 @@ async function insertDecisionWithEmbedding(decision) {
           confidence, created_at, updated_at,
           needs_validation, validation_attempts, last_validated_at, usage_count,
           trust_context, usage_success, usage_failure, time_saved,
-          evidence, alternatives, risks
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          evidence, alternatives, risks, event_date
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       `);
             const insertResult = stmt.run(decision.id, decision.topic, decision.decision, decision.reasoning || null, decision.outcome || null, decision.failure_reason || null, decision.limitation || null, decision.user_involvement || null, decision.session_id || null, decision.supersedes || null, decision.superseded_by || null, decision.refined_from ? JSON.stringify(decision.refined_from) : null, decision.confidence !== undefined ? decision.confidence : 0.5, 
             // IMPORTANT: All timestamps are stored in milliseconds (Date.now()).
             // The schema DEFAULT uses unixepoch() (seconds) but is never used
             // since all inserts go through this function which always provides ms.
-            decision.created_at || Date.now(), decision.updated_at || Date.now(), decision.needs_validation !== undefined ? decision.needs_validation : 0, decision.validation_attempts || 0, decision.last_validated_at || null, decision.usage_count || 0, decision.trust_context || null, decision.usage_success || 0, decision.usage_failure || 0, decision.time_saved || 0, decision.evidence || null, decision.alternatives || null, decision.risks || null);
+            decision.created_at || Date.now(), decision.updated_at || Date.now(), decision.needs_validation !== undefined ? decision.needs_validation : 0, decision.validation_attempts || 0, decision.last_validated_at || null, decision.usage_count || 0, decision.trust_context || null, decision.usage_success || 0, decision.usage_failure || 0, decision.time_saved || 0, decision.evidence || null, decision.alternatives || null, decision.risks || null, decision.event_date || null);
             const rowid = Number(insertResult.lastInsertRowid);
             // Insert embedding in same transaction to ensure rowid matching
             (0, debug_logger_js_1.info)(`[db-manager] Vector search enabled: ${adapter.vectorSearchEnabled}`);
@@ -485,6 +536,10 @@ async function queryVectorSearch(params) {
             if (similarity < threshold) {
                 continue;
             }
+            // Filter out superseded decisions unless explicitly requested
+            if (!params.includeSuperseded && decision.superseded_by) {
+                continue;
+            }
             results.push({
                 ...decision,
                 similarity,
@@ -618,4 +673,74 @@ function resetDBState(options = {}) {
 function isTestMode() {
     return !!(process.env.MAMA_TEST_MODE || process.env.VITEST);
 }
+/**
+ * FTS5 keyword search on decisions table.
+ * Returns matching decision IDs with BM25 rank scores.
+ */
+async function fts5Search(query, limit = 10) {
+    const adapter = getAdapter();
+    // Check if FTS5 table exists (swallow errors — table may not exist yet)
+    let tableCheck;
+    try {
+        tableCheck = adapter
+            .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='decisions_fts'")
+            .get();
+    }
+    catch {
+        return [];
+    }
+    if (!tableCheck)
+        return [];
+    // Query execution — let errors propagate to the caller
+    const stmt = adapter.prepare(`
+    SELECT d.id, rank
+    FROM decisions_fts
+    JOIN decisions d ON decisions_fts.rowid = d.rowid
+    WHERE decisions_fts MATCH ?
+    ORDER BY rank
+    LIMIT ?
+  `);
+    return stmt.all(query, limit);
+}
+/**
+ * Re-generate all embeddings using the currently configured model.
+ * Call this after changing the embedding model in config.json.
+ *
+ * @param onProgress - Optional callback with (completed, total) counts
+ * @returns Number of embeddings regenerated
+ */
+async function reindexEmbeddings(onProgress) {
+    const adapter = getAdapter();
+    const { generateEnhancedEmbedding } = await import('./embeddings.js');
+    const decisions = adapter
+        .prepare('SELECT rowid, topic, decision, reasoning, outcome, confidence FROM decisions')
+        .all();
+    if (typeof adapter.insertEmbedding !== 'function') {
+        throw new Error('Embedding insertion is not available on this adapter');
+    }
+    const total = decisions.length;
+    let completed = 0;
+    for (const row of decisions) {
+        try {
+            const embedding = await generateEnhancedEmbedding({
+                topic: row.topic,
+                decision: row.decision,
+                reasoning: row.reasoning || undefined,
+                outcome: row.outcome || undefined,
+                confidence: row.confidence ?? undefined,
+            });
+            adapter.insertEmbedding(row.rowid, embedding);
+            completed++;
+            if (onProgress && completed % 50 === 0) {
+                onProgress(completed, total);
+            }
+        }
+        catch (e) {
+            (0, debug_logger_js_1.error)(`[db-manager] Failed to reindex rowid ${row.rowid}: ${e}`);
+        }
+    }
+    onProgress?.(completed, total);
+    (0, debug_logger_js_1.info)(`[db-manager] Reindexed ${completed}/${total} embeddings`);
+    return completed;
+}
 //# sourceMappingURL=db-manager.js.map

package/dist/decision-formatter.d.ts

@@ -36,6 +36,8 @@ export interface DecisionForFormat {
     evidence?: string | string[] | unknown;
     alternatives?: string | string[] | unknown;
     risks?: string;
+    /** ISO 8601 date when the event actually occurred. Null if not set. */
+    event_date?: string | null;
 }
 /**
  * Trust context object

package/dist/embedding-server/mobile/session-manager.js

@@ -31,7 +31,7 @@ exports.DEFAULT_DB_PATH = process.env.MAMA_DB_PATH || path_1.default.join(os_1.d
 exports.CREATE_SESSIONS_TABLE = `
   CREATE TABLE IF NOT EXISTS sessions (
     id TEXT PRIMARY KEY,
-    project_dir TEXT NOT NULL,
+    project_path TEXT,
     created_at TEXT DEFAULT (datetime('now')),
     last_active TEXT DEFAULT (datetime('now')),
     status TEXT DEFAULT 'active',
@@ -83,6 +83,21 @@ class SessionManager {
             // Create sessions table if not exists
             this.db.exec(exports.CREATE_SESSIONS_TABLE);
             this.db.exec(CREATE_STATUS_INDEX);
+            // Add missing columns for older databases
+            for (const col of [
+                'pid INTEGER',
+                'client_id TEXT',
+                "status TEXT DEFAULT 'active'",
+                'last_active TEXT',
+                'created_at TEXT',
+            ]) {
+                try {
+                    this.db.exec(`ALTER TABLE sessions ADD COLUMN ${col}`);
+                }
+                catch {
+                    // Column already exists
+                }
+            }
             // Mark any orphaned 'active' sessions as 'terminated'
             // (from previous server crashes)
             this.db
@@ -121,7 +136,7 @@ class SessionManager {
             await daemon.spawn();
             // Insert into database
             const stmt = this.db.prepare(`
-        INSERT INTO sessions (id, project_dir, status, pid)
+        INSERT INTO sessions (id, project_path, status, pid)
         VALUES (?, ?, 'active', ?)
       `);
             stmt.run(sessionId, projectDir, daemon.getPid());
@@ -154,10 +169,10 @@ class SessionManager {
             await this.initDB();
         }
         const stmt = this.db.prepare(`
-      SELECT id, project_dir, started_at, last_active_at, status, pid, client_id
+      SELECT id, project_path, created_at, last_active, status, pid, client_id
       FROM sessions
       WHERE status = 'active'
-      ORDER BY started_at DESC
+      ORDER BY created_at DESC
     `);
         const rows = stmt.all();
         // Enrich with in-memory data
@@ -165,9 +180,9 @@ class SessionManager {
             const memSession = this.sessions.get(row.id);
             return {
                 id: row.id,
-                projectDir: row.project_dir,
-                createdAt: row.started_at,
-                lastActive: row.last_active_at,
+                projectDir: row.project_path ?? '',
+                createdAt: row.created_at,
+                lastActive: row.last_active,
                 status: row.status,
                 pid: row.pid,
                 clientId: row.client_id,

package/dist/embeddings.d.ts

@@ -2,7 +2,7 @@
  * MAMA (Memory-Augmented MCP Architecture) - Embedding Generation
  *
  * Story M1.4: Configurable embedding model selection
- * Generates embeddings using configurable model (default: multilingual-e5-small)
+ * Generates embeddings using configurable model (default: multilingual-e5-large)
  * Supports: Korean-English cross-lingual similarity, enhanced metadata
  *
  * @module embeddings
@@ -43,7 +43,7 @@ export declare function generateEmbedding(text: string): Promise<Float32Array>;
  * Inspired by A-mem: Content + Metadata for richer semantic representation
  *
  * @param decision - Decision object
- * @returns 384-dim enhanced embedding
+ * @returns 1024-dim enhanced embedding
  */
 export declare function generateEnhancedEmbedding(decision: DecisionForEmbedding): Promise<Float32Array>;
 /**

package/dist/embeddings.js

@@ -3,7 +3,7 @@
  * MAMA (Memory-Augmented MCP Architecture) - Embedding Generation
  *
  * Story M1.4: Configurable embedding model selection
- * Generates embeddings using configurable model (default: multilingual-e5-small)
+ * Generates embeddings using configurable model (default: multilingual-e5-large)
  * Supports: Korean-English cross-lingual similarity, enhanced metadata
  *
  * @module embeddings
@@ -142,7 +142,7 @@ async function generateEmbedding(text) {
  * Inspired by A-mem: Content + Metadata for richer semantic representation
  *
  * @param decision - Decision object
- * @returns 384-dim enhanced embedding
+ * @returns 1024-dim enhanced embedding
  */
 async function generateEnhancedEmbedding(decision) {
     // Construct enriched text representation with narrative fields (Story 2.2)

package/dist/index.d.ts

@@ -10,11 +10,15 @@
 export { generateEmbedding, generateEnhancedEmbedding, generateBatchEmbeddings, cosineSimilarity, embeddingCache, EMBEDDING_DIM, MODEL_NAME, } from './embeddings.js';
 export { EmbeddingCache } from './embedding-cache.js';
 export { getEmbeddingFromServer, getServerStatus, isServerRunning, getServerPort, DEFAULT_PORT, HOST, TIMEOUT_MS, type ServerStatus, } from './embedding-client.js';
-export { initDB, getDB, getAdapter, closeDB, insertEmbedding, vectorSearch, queryVectorSearch, insertDecisionWithEmbedding, queryDecisionGraph, querySemanticEdges, updateDecisionOutcome, getPreparedStmt, getDbPath, type DatabaseAdapter as DBManagerAdapter, type PreparedStatement, type DecisionRecord, type OutcomeData, type VectorSearchParams, type SemanticEdges, type SemanticEdgeItem, type DecisionInput, } from './db-manager.js';
+export { initDB, getDB, getAdapter, closeDB, insertEmbedding, vectorSearch, queryVectorSearch, insertDecisionWithEmbedding, queryDecisionGraph, querySemanticEdges, updateDecisionOutcome, getPreparedStmt, getDbPath, fts5Search, reindexEmbeddings, type DatabaseAdapter as DBManagerAdapter, type PreparedStatement, type DecisionRecord, type OutcomeData, type VectorSearchParams, type SemanticEdges, type SemanticEdgeItem, type DecisionInput, } from './db-manager.js';
 export { createAdapter, DatabaseAdapter, SQLiteAdapter, type AdapterConfig, type Statement, type VectorSearchResult, type RunResult, } from './db-adapter/index.js';
 export { getSessionDecisions, incrementUsageSuccess, incrementUsageFailure, getDecisionById, traverseDecisionChain, DB_PATH, DB_DIR, LEGACY_DB_PATH, DEFAULT_DB_PATH, } from './memory-store.js';
 import mama from './mama-api.js';
 export { mama };
+export { MEMORY_SCOPE_KINDS, MEMORY_KINDS, MEMORY_STATUSES, MEMORY_EDGE_TYPES, createEmptyRecallBundle, type MemoryScopeKind, type MemoryKind, type MemoryStatus, type MemoryEdgeType, type MemoryScopeRef, type MemoryRecord, type MemoryEdge, type ProfileSnapshot, type RecallBundle, type ConversationMessage, type IngestConversationInput, type ExtractedMemoryUnit, type IngestConversationResult, } from './memory/types.js';
+export { saveMemory, recallMemory, buildProfile, ingestMemory, evolveMemory, buildMemoryBootstrap, createAuditAck, recordMemoryAudit, ingestConversation, setExtractionFn, upsertChannelSummary, getChannelSummary, } from './memory/api.js';
+export { buildExtractionPrompt, parseExtractionResponse } from './memory/extraction-prompt.js';
+export { listRecentMemoryEvents } from './memory/event-store.js';
 export { loadConfig, getModelName, getEmbeddingDim, getCacheDir, updateConfig, getConfigPath, DEFAULT_CONFIG, type MAMAConfig, type ConfigUpdates, } from './config-loader.js';
 export { calculateRelevance, selectTopDecisions, formatTopNContext, testRelevanceScoring, type DecisionWithEmbedding, type QueryContext, type FormattedContext, type TestResult, } from './relevance-scorer.js';
 export { learnDecision, generateDecisionId, getPreviousDecision, createEdge, createSupersedesEdge, markSuperseded, calculateCombinedConfidence, detectRefinement, parseReasoningForRelationships, createEdgesFromReasoning, getSupersededChainDepth, updateConfidence, VALID_EDGE_TYPES, type EdgeType, type DecisionDetection, type ToolExecution, type SessionContext, type LearnDecisionResult, type ParsedRelationship, type EvidenceItem, } from './decision-tracker.js';