@jungjaehoon/mama-core 1.2.0 → 1.3.1

package/README.md

@@ -107,7 +107,7 @@ const mamaApi = require('@jungjaehoon/mama-core/mama-api');
 ## Dependencies
 
 - **@huggingface/transformers** - Local embedding generation
-- **better-sqlite3** - SQLite database
+- **node:sqlite** - Built-in SQLite runtime (Node.js 22+)
 - **Pure-TS cosine similarity** - Vector search (no native extensions)
 
 ## Development

package/dist/config-loader.d.ts

@@ -15,6 +15,7 @@
 export interface MAMAConfig {
     modelName: string;
     embeddingDim: number;
+    quantized: boolean;
     cacheDir: string;
     [key: string]: unknown;
 }
@@ -36,6 +37,10 @@ export declare function getModelName(): string;
  * Get current embedding dimension
  */
 export declare function getEmbeddingDim(): number;
+/**
+ * Get whether to use quantized model
+ */
+export declare function getQuantized(): boolean;
 /**
  * Get current cache directory
  */
@@ -43,6 +48,7 @@ export declare function getCacheDir(): string;
 export interface ConfigUpdates {
     modelName?: string;
     embeddingDim?: number;
+    quantized?: boolean;
     cacheDir?: string;
 }
 /**

package/dist/config-loader.js

@@ -21,6 +21,7 @@ exports.DEFAULT_CONFIG = void 0;
 exports.loadConfig = loadConfig;
 exports.getModelName = getModelName;
 exports.getEmbeddingDim = getEmbeddingDim;
+exports.getQuantized = getQuantized;
 exports.getCacheDir = getCacheDir;
 exports.updateConfig = updateConfig;
 exports.getConfigPath = getConfigPath;
@@ -32,6 +33,7 @@ const debug_logger_js_1 = require("./debug-logger.js");
 exports.DEFAULT_CONFIG = {
     modelName: 'Xenova/multilingual-e5-small',
     embeddingDim: 384,
+    quantized: true,
     cacheDir: path_1.default.join(os_1.default.homedir(), '.cache', 'huggingface', 'transformers'),
 };
 // Config file path
@@ -129,6 +131,13 @@ function getEmbeddingDim() {
     const config = loadConfig();
     return config.embeddingDim;
 }
+/**
+ * Get whether to use quantized model
+ */
+function getQuantized() {
+    const config = loadConfig();
+    return config.quantized;
+}
 /**
  * Get current cache directory
  */

package/dist/db-adapter/index.d.ts

@@ -7,9 +7,10 @@
  * @module db-adapter
  */
 import { SQLiteAdapter } from './sqlite-adapter.js';
+import { NodeSQLiteAdapter } from './node-sqlite-adapter.js';
 import { DatabaseAdapter, type VectorSearchResult, type RunResult } from './base-adapter.js';
 import type { Statement } from './statement.js';
-export { DatabaseAdapter, SQLiteAdapter };
+export { DatabaseAdapter, SQLiteAdapter, NodeSQLiteAdapter };
 export type { Statement, VectorSearchResult, RunResult };
 export interface AdapterConfig {
     dbPath?: string;

package/dist/db-adapter/index.js

@@ -8,11 +8,13 @@
  * @module db-adapter
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SQLiteAdapter = exports.DatabaseAdapter = void 0;
+exports.NodeSQLiteAdapter = exports.SQLiteAdapter = exports.DatabaseAdapter = void 0;
 exports.createAdapter = createAdapter;
 const debug_logger_js_1 = require("../debug-logger.js");
 const sqlite_adapter_js_1 = require("./sqlite-adapter.js");
 Object.defineProperty(exports, "SQLiteAdapter", { enumerable: true, get: function () { return sqlite_adapter_js_1.SQLiteAdapter; } });
+const node_sqlite_adapter_js_1 = require("./node-sqlite-adapter.js");
+Object.defineProperty(exports, "NodeSQLiteAdapter", { enumerable: true, get: function () { return node_sqlite_adapter_js_1.NodeSQLiteAdapter; } });
 const base_adapter_js_1 = require("./base-adapter.js");
 Object.defineProperty(exports, "DatabaseAdapter", { enumerable: true, get: function () { return base_adapter_js_1.DatabaseAdapter; } });
 /**
@@ -22,7 +24,14 @@ Object.defineProperty(exports, "DatabaseAdapter", { enumerable: true, get: funct
  * @returns Configured SQLite adapter instance
  */
 function createAdapter(config = {}) {
-    (0, debug_logger_js_1.info)('[db-adapter] Using SQLite adapter (plugin mode)');
+    const configuredDriver = process.env.MAMA_SQLITE_DRIVER;
+    if (configuredDriver &&
+        configuredDriver !== 'node-sqlite' &&
+        configuredDriver !== 'node:sqlite' &&
+        configuredDriver !== 'auto') {
+        throw new Error(`Unsupported SQLite driver "${configuredDriver}". MAMA now requires node:sqlite.`);
+    }
+    (0, debug_logger_js_1.info)('[db-adapter] Using node:sqlite adapter');
     const dbPath = config.dbPath || process.env.MAMA_DB_PATH;
     return new sqlite_adapter_js_1.SQLiteAdapter({ dbPath });
 }

package/dist/db-adapter/node-sqlite-adapter.d.ts

@@ -0,0 +1,56 @@
+/**
+ * SQLite Database Adapter using node:sqlite
+ *
+ * Keeps the existing DatabaseAdapter surface while avoiding external native addon installation.
+ */
+import { DatabaseAdapter, type VectorSearchResult, type RunResult } from './base-adapter.js';
+import { type Statement } from './statement.js';
+interface SQLiteAdapterConfig {
+    dbPath?: string;
+}
+interface NodeSQLiteDatabaseLike {
+    exec(sql: string): void;
+    close(): void;
+    prepare(sql: string): NodeSQLiteStatementLike;
+}
+interface NodeSQLiteStatementLike {
+    all: (...params: unknown[]) => unknown[];
+    get: (...params: unknown[]) => unknown;
+    run: (...params: unknown[]) => {
+        changes: number;
+        lastInsertRowid: number | bigint;
+    };
+}
+declare class NodeSQLiteConnection {
+    private db;
+    private connected;
+    constructor(db: NodeSQLiteDatabaseLike);
+    prepare(sql: string): NodeSQLiteStatementLike;
+    exec(sql: string): void;
+    pragma(sql: string, options?: {
+        simple?: boolean;
+    }): unknown;
+    close(): void;
+    get open(): boolean;
+}
+export declare class NodeSQLiteAdapter extends DatabaseAdapter {
+    private config;
+    private db;
+    private _vectorSearchEnabled;
+    constructor(config?: SQLiteAdapterConfig);
+    get vectorSearchEnabled(): boolean;
+    getDbPath(): string;
+    connect(): NodeSQLiteConnection;
+    disconnect(): void;
+    isConnected(): boolean;
+    prepare(sql: string): Statement;
+    exec(sql: string): void;
+    transaction<T>(fn: () => T): T;
+    vectorSearch(embedding: Float32Array | number[], limit?: number): VectorSearchResult[] | null;
+    insertEmbedding(rowid: number, embedding: Float32Array | number[]): RunResult | null;
+    getLastInsertRowid(): number;
+    runMigrations(migrationsDir: string): void;
+    private migrateFromVssMemories;
+}
+export default NodeSQLiteAdapter;
+//# sourceMappingURL=node-sqlite-adapter.d.ts.map

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

@@ -0,0 +1,334 @@
+"use strict";
+/**
+ * SQLite Database Adapter using node:sqlite
+ *
+ * Keeps the existing DatabaseAdapter surface while avoiding external native addon installation.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeSQLiteAdapter = void 0;
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const fs_1 = __importDefault(require("fs"));
+const base_adapter_js_1 = require("./base-adapter.js");
+const node_sqlite_statement_js_1 = require("./node-sqlite-statement.js");
+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');
+let DatabaseSync = null;
+try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    ({ DatabaseSync } = require('node:sqlite'));
+}
+catch {
+    DatabaseSync = null;
+}
+class NodeSQLiteConnection {
+    db;
+    connected = true;
+    constructor(db) {
+        this.db = db;
+    }
+    prepare(sql) {
+        return this.db.prepare(sql);
+    }
+    exec(sql) {
+        this.db.exec(sql);
+    }
+    pragma(sql, options) {
+        const query = sql.trim().replace(/^PRAGMA\s+/i, '');
+        const stmt = this.db.prepare(`PRAGMA ${query}`);
+        if (options?.simple) {
+            const row = stmt.get();
+            if (!row) {
+                return undefined;
+            }
+            return Object.values(row)[0];
+        }
+        return stmt.all();
+    }
+    close() {
+        if (!this.connected) {
+            return;
+        }
+        this.db.close();
+        this.connected = false;
+    }
+    get open() {
+        return this.connected;
+    }
+}
+class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
+    config;
+    db = null;
+    _vectorSearchEnabled = true;
+    constructor(config = {}) {
+        super();
+        this.config = config;
+    }
+    get vectorSearchEnabled() {
+        return this._vectorSearchEnabled;
+    }
+    getDbPath() {
+        const envPath = process.env.MAMA_DB_PATH || process.env.MAMA_DATABASE_PATH;
+        const configPath = this.config.dbPath;
+        let expandedEnvPath = envPath;
+        if (envPath) {
+            expandedEnvPath = envPath.replace(/\$\{HOME\}/g, os_1.default.homedir()).replace(/^~/, os_1.default.homedir());
+        }
+        const targetPath = configPath || expandedEnvPath || DEFAULT_DB_PATH;
+        if (!configPath && !envPath && fs_1.default.existsSync(LEGACY_DB_PATH)) {
+            (0, debug_logger_js_1.info)('[node-sqlite-adapter] Found legacy database at ~/.spinelift/memories.db, using it for backward compatibility');
+            return LEGACY_DB_PATH;
+        }
+        return targetPath;
+    }
+    connect() {
+        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 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}`);
+        }
+        const database = new DatabaseSync(dbPath);
+        this.db = new NodeSQLiteConnection(database);
+        (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Opened database at: ${dbPath}`);
+        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)');
+        return this.db;
+    }
+    disconnect() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+            (0, debug_logger_js_1.info)('[node-sqlite-adapter] Disconnected from database');
+        }
+    }
+    isConnected() {
+        return this.db !== null && this.db.open;
+    }
+    prepare(sql) {
+        if (!this.isConnected() || !this.db) {
+            throw new Error('Database not connected');
+        }
+        return new node_sqlite_statement_js_1.NodeSQLiteStatement(this.db.prepare(sql));
+    }
+    exec(sql) {
+        if (!this.isConnected() || !this.db) {
+            throw new Error('Database not connected');
+        }
+        this.db.exec(sql);
+    }
+    transaction(fn) {
+        if (!this.isConnected()) {
+            throw new Error('Database not connected');
+        }
+        this.exec('BEGIN TRANSACTION');
+        try {
+            const result = fn();
+            if (((typeof result === 'object' && result !== null) || typeof result === 'function') &&
+                typeof result.then === 'function') {
+                throw new Error('DatabaseAdapter.transaction() callbacks must be synchronous');
+            }
+            this.exec('COMMIT');
+            return result;
+        }
+        catch (error) {
+            try {
+                this.exec('ROLLBACK');
+            }
+            catch {
+                // Preserve the original transaction failure when rollback also fails.
+            }
+            throw error;
+        }
+    }
+    vectorSearch(embedding, limit = 5) {
+        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;
+                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})`);
+                    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);
+                    bestMatches.sort((a, b) => (b.similarity ?? 0) - (a.similarity ?? 0));
+                }
+            }
+            offset += rows.length;
+        }
+        return bestMatches;
+    }
+    insertEmbedding(rowid, embedding) {
+        if (!this.isConnected()) {
+            throw new Error('Database not connected');
+        }
+        const vec = embedding instanceof Float32Array ? embedding : Float32Array.from(embedding);
+        const buffer = Buffer.from(vec.buffer, vec.byteOffset, vec.byteLength);
+        const stmt = this.prepare(`
+      INSERT OR REPLACE INTO embeddings(rowid, embedding)
+      VALUES (?, ?)
+    `);
+        return stmt.run(rowid, buffer);
+    }
+    getLastInsertRowid() {
+        if (!this.isConnected()) {
+            throw new Error('Database not connected');
+        }
+        const result = this.prepare('SELECT last_insert_rowid() as rowid').get();
+        return result.rowid;
+    }
+    runMigrations(migrationsDir) {
+        if (!this.isConnected()) {
+            throw new Error('Database not connected');
+        }
+        const tables = this.prepare(`
+      SELECT name FROM sqlite_master
+      WHERE type='table' AND name='schema_version'
+    `).all();
+        let currentVersion = 0;
+        if (tables.length > 0) {
+            const version = this.prepare('SELECT MAX(version) as version FROM schema_version').get();
+            currentVersion = version?.version || 0;
+        }
+        (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Current schema version: ${currentVersion}`);
+        const migrationFiles = fs_1.default
+            .readdirSync(migrationsDir)
+            .filter((file) => file.endsWith('.sql'))
+            .sort();
+        for (const file of migrationFiles) {
+            const versionMatch = file.match(/^(\d+)-/);
+            if (!versionMatch) {
+                continue;
+            }
+            const version = parseInt(versionMatch[1], 10);
+            if (version <= currentVersion) {
+                continue;
+            }
+            const migrationPath = path_1.default.join(migrationsDir, file);
+            const migrationSQL = fs_1.default.readFileSync(migrationPath, 'utf8');
+            (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Applying migration: ${file}`);
+            try {
+                this.exec('BEGIN TRANSACTION');
+                this.exec(migrationSQL);
+                this.exec('COMMIT');
+                this.prepare('INSERT OR IGNORE INTO schema_version (version) VALUES (?)').run(version);
+                (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Migration ${file} applied successfully`);
+            }
+            catch (err) {
+                this.exec('ROLLBACK');
+                const message = err instanceof Error ? err.message : String(err);
+                if (message.includes('duplicate column')) {
+                    (0, debug_logger_js_1.warn)(`[node-sqlite-adapter] Migration ${file} skipped (duplicate column - already applied)`);
+                    this.prepare('INSERT OR IGNORE INTO schema_version (version) VALUES (?)').run(version);
+                    continue;
+                }
+                if (message.includes('no such table')) {
+                    const hasAlterTable = migrationSQL.toUpperCase().includes('ALTER TABLE');
+                    if (!hasAlterTable) {
+                        (0, debug_logger_js_1.error)(`[node-sqlite-adapter] Migration ${file} failed (missing required table):`, err);
+                        throw new Error(`Migration ${file} failed: ${message}`);
+                    }
+                    (0, debug_logger_js_1.warn)(`[node-sqlite-adapter] Migration ${file} skipped: ALTER TABLE on non-existent table (${message})`);
+                    this.prepare('INSERT OR IGNORE INTO schema_version (version) VALUES (?)').run(version);
+                    continue;
+                }
+                (0, debug_logger_js_1.error)(`[node-sqlite-adapter] Migration ${file} failed:`, err);
+                throw new Error(`Migration ${file} failed: ${message}`);
+            }
+        }
+        const embeddingsTables = this.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='embeddings'`).all();
+        if (embeddingsTables.length === 0) {
+            throw new Error('Embeddings table is missing after migrations. Add the required embeddings migration.');
+        }
+        this.migrateFromVssMemories();
+    }
+    migrateFromVssMemories() {
+        try {
+            const vssTables = this.prepare(`SELECT name FROM sqlite_master WHERE name='vss_memories'`).all();
+            if (vssTables.length === 0) {
+                return;
+            }
+            const rows = this.prepare('SELECT rowid, embedding FROM vss_memories').all();
+            if (rows.length > 0) {
+                const insertStmt = this.prepare('INSERT OR IGNORE INTO embeddings (rowid, embedding) VALUES (?, ?)');
+                let migrated = 0;
+                for (const row of rows) {
+                    const res = insertStmt.run(row.rowid, Buffer.from(row.embedding));
+                    if (res.changes > 0) {
+                        migrated++;
+                    }
+                }
+                (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Migrated ${migrated} embeddings from vss_memories to embeddings`);
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            (0, debug_logger_js_1.warn)(`[node-sqlite-adapter] Could not migrate from vss_memories (expected if sqlite-vec not installed): ${message}`);
+        }
+    }
+}
+exports.NodeSQLiteAdapter = NodeSQLiteAdapter;
+exports.default = NodeSQLiteAdapter;
+function bytesToVector(buffer) {
+    if (!buffer || buffer.byteLength % 4 !== 0) {
+        return null;
+    }
+    try {
+        const typedBuffer = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
+        const arrayBuffer = typedBuffer.buffer.slice(typedBuffer.byteOffset, typedBuffer.byteOffset + typedBuffer.byteLength);
+        return new Float32Array(arrayBuffer);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=node-sqlite-adapter.js.map

package/dist/db-adapter/node-sqlite-statement.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Node SQLite statement wrapper
+ *
+ * Wraps node:sqlite StatementSync to provide the existing Statement API.
+ */
+import { Statement, type RunResult } from './statement.js';
+interface NodeSQLiteStatementLike {
+    all: (...params: unknown[]) => unknown[];
+    get: (...params: unknown[]) => unknown;
+    run: (...params: unknown[]) => {
+        changes: number;
+        lastInsertRowid: number | bigint;
+    };
+}
+export declare class NodeSQLiteStatement extends Statement {
+    private stmt;
+    constructor(stmt: NodeSQLiteStatementLike);
+    all(...params: unknown[]): object[];
+    get(...params: unknown[]): object | undefined;
+    run(...params: unknown[]): RunResult;
+}
+export {};
+//# sourceMappingURL=node-sqlite-statement.d.ts.map

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

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * Node SQLite statement wrapper
+ *
+ * Wraps node:sqlite StatementSync to provide the existing Statement API.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeSQLiteStatement = void 0;
+const statement_js_1 = require("./statement.js");
+class NodeSQLiteStatement extends statement_js_1.Statement {
+    stmt;
+    constructor(stmt) {
+        super();
+        this.stmt = stmt;
+    }
+    all(...params) {
+        return this.stmt.all(...params);
+    }
+    get(...params) {
+        return this.stmt.get(...params);
+    }
+    run(...params) {
+        return this.stmt.run(...params);
+    }
+}
+exports.NodeSQLiteStatement = NodeSQLiteStatement;
+//# sourceMappingURL=node-sqlite-statement.js.map

package/dist/db-adapter/sqlite-adapter.d.ts

@@ -1,80 +1,15 @@
 /**
- * SQLite Database Adapter
+ * SQLite database adapter compatibility export.
  *
- * Implements DatabaseAdapter interface using better-sqlite3
- * Vector search uses pure TypeScript brute-force cosine similarity (no native extensions)
- *
- * @module sqlite-adapter
- */
-import Database from 'better-sqlite3';
-import { DatabaseAdapter, type VectorSearchResult, type RunResult } from './base-adapter.js';
-import { type Statement } from './statement.js';
-/**
- * Adapter configuration
+ * MAMA now standardizes on Node's built-in node:sqlite runtime. Keep the
+ * legacy SQLiteAdapter symbol so existing imports continue to work.
  */
+import { NodeSQLiteAdapter } from './node-sqlite-adapter.js';
 interface SQLiteAdapterConfig {
     dbPath?: string;
 }
-export declare class SQLiteAdapter extends DatabaseAdapter {
-    private config;
-    private db;
-    private _vectorSearchEnabled;
+export declare class SQLiteAdapter extends NodeSQLiteAdapter {
     constructor(config?: SQLiteAdapterConfig);
-    /**
-     * Check if vector search is enabled
-     */
-    get vectorSearchEnabled(): boolean;
-    /**
-     * Get database path with backward compatibility
-     */
-    getDbPath(): string;
-    /**
-     * Connect to SQLite database
-     */
-    connect(): Database.Database;
-    /**
-     * Disconnect from database
-     */
-    disconnect(): void;
-    /**
-     * Check if connected
-     */
-    isConnected(): boolean;
-    /**
-     * Prepare a SQL statement
-     */
-    prepare(sql: string): Statement;
-    /**
-     * Execute raw SQL
-     */
-    exec(sql: string): void;
-    /**
-     * Execute function in transaction
-     */
-    transaction<T>(fn: () => T): T;
-    /**
-     * Vector similarity search using brute-force cosine similarity
-     * Loads all embeddings from the embeddings table, computes similarity in JS,
-     * and returns top-N results sorted by similarity descending.
-     */
-    vectorSearch(embedding: Float32Array | number[], limit?: number): VectorSearchResult[] | null;
-    /**
-     * Insert vector embedding into the embeddings table (plain BLOB storage)
-     */
-    insertEmbedding(rowid: number, embedding: Float32Array | number[]): RunResult | null;
-    /**
-     * Get last inserted row ID
-     */
-    getLastInsertRowid(): number;
-    /**
-     * Run migrations
-     */
-    runMigrations(migrationsDir: string): void;
-    /**
-     * Attempt to migrate data from legacy vss_memories (sqlite-vec) to embeddings table.
-     * This is best-effort: if sqlite-vec is not loaded, the vss_memories table won't be readable.
-     */
-    private _migrateFromVssMemories;
 }
 export default SQLiteAdapter;
 //# sourceMappingURL=sqlite-adapter.d.ts.map

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

@@ -1,323 +1,18 @@
 "use strict";
 /**
- * SQLite Database Adapter
+ * SQLite database adapter compatibility export.
  *
- * Implements DatabaseAdapter interface using better-sqlite3
- * Vector search uses pure TypeScript brute-force cosine similarity (no native extensions)
- *
- * @module sqlite-adapter
+ * MAMA now standardizes on Node's built-in node:sqlite runtime. Keep the
+ * legacy SQLiteAdapter symbol so existing imports continue to work.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SQLiteAdapter = void 0;
-const path_1 = __importDefault(require("path"));
-const os_1 = __importDefault(require("os"));
-const fs_1 = __importDefault(require("fs"));
-const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
-const base_adapter_js_1 = require("./base-adapter.js");
-const statement_js_1 = require("./statement.js");
-const debug_logger_js_1 = require("../debug-logger.js");
-const embeddings_js_1 = require("../embeddings.js");
-// Database paths
-const LEGACY_DB_PATH = path_1.default.join(os_1.default.homedir(), '.spinelift', 'memories.db');
-// Default to ~/.claude/mama-memory.db for Claude Code/Desktop compatibility
-const DEFAULT_DB_PATH = path_1.default.join(os_1.default.homedir(), '.claude', 'mama-memory.db');
-class SQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
-    config;
-    db = null;
-    _vectorSearchEnabled = true; // Always true: pure TS cosine similarity
+const node_sqlite_adapter_js_1 = require("./node-sqlite-adapter.js");
+class SQLiteAdapter extends node_sqlite_adapter_js_1.NodeSQLiteAdapter {
     constructor(config = {}) {
-        super();
-        this.config = config;
-    }
-    /**
-     * Check if vector search is enabled
-     */
-    get vectorSearchEnabled() {
-        return this._vectorSearchEnabled;
-    }
-    /**
-     * Get database path with backward compatibility
-     */
-    getDbPath() {
-        // Support both MAMA_DB_PATH and MAMA_DATABASE_PATH for backward compatibility
-        const envPath = process.env.MAMA_DB_PATH || process.env.MAMA_DATABASE_PATH;
-        const configPath = this.config.dbPath;
-        // Expand ${HOME} or ~ in environment variable
-        let expandedEnvPath = envPath;
-        if (envPath) {
-            expandedEnvPath = envPath.replace(/\$\{HOME\}/g, os_1.default.homedir()).replace(/^~/, os_1.default.homedir());
-        }
-        // Priority: config > env > default
-        const targetPath = configPath || expandedEnvPath || DEFAULT_DB_PATH;
-        // Backward compatibility: Check legacy path if not explicitly set
-        if (!configPath && !envPath && fs_1.default.existsSync(LEGACY_DB_PATH)) {
-            (0, debug_logger_js_1.info)('[sqlite-adapter] Found legacy database at ~/.spinelift/memories.db, using it for backward compatibility');
-            return LEGACY_DB_PATH;
-        }
-        return targetPath;
-    }
-    /**
-     * Connect to SQLite database
-     */
-    connect() {
-        if (this.db) {
-            return this.db;
-        }
-        const dbPath = this.getDbPath();
-        const dbDir = path_1.default.dirname(dbPath);
-        // Ensure directory exists
-        if (!fs_1.default.existsSync(dbDir)) {
-            fs_1.default.mkdirSync(dbDir, { recursive: true });
-            (0, debug_logger_js_1.info)(`[sqlite-adapter] Created database directory: ${dbDir}`);
-        }
-        // Open database
-        this.db = new better_sqlite3_1.default(dbPath, { verbose: undefined });
-        (0, debug_logger_js_1.info)(`[sqlite-adapter] Opened database at: ${dbPath}`);
-        // Production configuration
-        this.db.pragma('journal_mode = WAL');
-        this.db.pragma('busy_timeout = 5000');
-        this.db.pragma('synchronous = NORMAL');
-        this.db.pragma('cache_size = -64000'); // 64MB cache
-        this.db.pragma('temp_store = MEMORY');
-        this.db.pragma('foreign_keys = ON');
-        (0, debug_logger_js_1.info)('[sqlite-adapter] Vector search: pure TS cosine similarity (no native extensions)');
-        return this.db;
-    }
-    /**
-     * Disconnect from database
-     */
-    disconnect() {
-        if (this.db) {
-            this.db.close();
-            this.db = null;
-            (0, debug_logger_js_1.info)('[sqlite-adapter] Disconnected from database');
-        }
-    }
-    /**
-     * Check if connected
-     */
-    isConnected() {
-        return this.db !== null && this.db.open;
-    }
-    /**
-     * Prepare a SQL statement
-     */
-    prepare(sql) {
-        if (!this.isConnected() || !this.db) {
-            throw new Error('Database not connected');
-        }
-        const stmt = this.db.prepare(sql);
-        return new statement_js_1.SQLiteStatement(stmt);
-    }
-    /**
-     * Execute raw SQL
-     */
-    exec(sql) {
-        if (!this.isConnected() || !this.db) {
-            throw new Error('Database not connected');
-        }
-        this.db.exec(sql);
-    }
-    /**
-     * Execute function in transaction
-     */
-    transaction(fn) {
-        if (!this.isConnected() || !this.db) {
-            throw new Error('Database not connected');
-        }
-        const txn = this.db.transaction(fn);
-        return txn();
-    }
-    /**
-     * Vector similarity search using brute-force cosine similarity
-     * Loads all embeddings from the embeddings table, computes similarity in JS,
-     * and returns top-N results sorted by similarity descending.
-     */
-    vectorSearch(embedding, limit = 5) {
-        if (!this.isConnected()) {
-            throw new Error('Database not connected');
-        }
-        const queryVector = embedding instanceof Float32Array ? embedding : Float32Array.from(embedding);
-        // Check if embeddings table exists
-        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 rows = this.prepare('SELECT rowid, embedding FROM embeddings').all();
-        const scored = [];
-        for (const row of rows) {
-            const candidate = bufferToVector(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})`);
-                continue;
-            }
-            const similarity = (0, embeddings_js_1.cosineSimilarity)(candidate, queryVector);
-            scored.push({
-                rowid: row.rowid,
-                similarity,
-                distance: 1 - similarity,
-            });
-        }
-        // Sort by similarity descending, return top-N
-        scored.sort((a, b) => (b.similarity ?? 0) - (a.similarity ?? 0));
-        return scored.slice(0, Math.max(limit, 1));
-    }
-    /**
-     * Insert vector embedding into the embeddings table (plain BLOB storage)
-     */
-    insertEmbedding(rowid, embedding) {
-        if (!this.isConnected()) {
-            throw new Error('Database not connected');
-        }
-        const vec = embedding instanceof Float32Array ? embedding : Float32Array.from(embedding);
-        const buffer = Buffer.from(vec.buffer, vec.byteOffset, vec.byteLength);
-        const stmt = this.prepare(`
-      INSERT OR REPLACE INTO embeddings(rowid, embedding)
-      VALUES (?, ?)
-    `);
-        return stmt.run(rowid, buffer);
-    }
-    /**
-     * Get last inserted row ID
-     */
-    getLastInsertRowid() {
-        if (!this.isConnected() || !this.db) {
-            throw new Error('Database not connected');
-        }
-        // better-sqlite3 provides this via Database instance
-        const result = this.db.prepare('SELECT last_insert_rowid() as rowid').get();
-        return result.rowid;
-    }
-    /**
-     * Run migrations
-     */
-    runMigrations(migrationsDir) {
-        if (!this.isConnected()) {
-            throw new Error('Database not connected');
-        }
-        // Check if schema_version table exists
-        const tables = this.prepare(`
-      SELECT name FROM sqlite_master
-      WHERE type='table' AND name='schema_version'
-    `).all();
-        let currentVersion = 0;
-        if (tables.length > 0) {
-            const version = this.prepare('SELECT MAX(version) as version FROM schema_version').get();
-            currentVersion = version?.version || 0;
-        }
-        (0, debug_logger_js_1.info)(`[sqlite-adapter] Current schema version: ${currentVersion}`);
-        // Get all migration files
-        const migrationFiles = fs_1.default
-            .readdirSync(migrationsDir)
-            .filter((file) => file.endsWith('.sql'))
-            .sort();
-        // Apply migrations
-        for (const file of migrationFiles) {
-            const versionMatch = file.match(/^(\d+)-/);
-            if (!versionMatch) {
-                continue;
-            }
-            const version = parseInt(versionMatch[1], 10);
-            if (version <= currentVersion) {
-                continue;
-            }
-            const migrationPath = path_1.default.join(migrationsDir, file);
-            const migrationSQL = fs_1.default.readFileSync(migrationPath, 'utf8');
-            (0, debug_logger_js_1.info)(`[sqlite-adapter] Applying migration: ${file}`);
-            try {
-                this.exec('BEGIN TRANSACTION');
-                this.exec(migrationSQL);
-                this.exec('COMMIT');
-                // Record migration in schema_version table (outside transaction for idempotency)
-                this.prepare('INSERT OR IGNORE INTO schema_version (version) VALUES (?)').run(version);
-                (0, debug_logger_js_1.info)(`[sqlite-adapter] Migration ${file} applied successfully`);
-            }
-            catch (err) {
-                this.exec('ROLLBACK');
-                const message = err instanceof Error ? err.message : String(err);
-                // Handle duplicate column errors as idempotent (migration 003)
-                if (message.includes('duplicate column')) {
-                    (0, debug_logger_js_1.warn)(`[sqlite-adapter] Migration ${file} skipped (duplicate column - already applied)`);
-                    // Record migration as applied
-                    this.prepare('INSERT OR IGNORE INTO schema_version (version) VALUES (?)').run(version);
-                    continue;
-                }
-                if (message.includes('no such table')) {
-                    // Only skip if this migration contains an ALTER TABLE (adding column to optional table)
-                    // Note: migrationSQL may contain comments, so check if ALTER TABLE exists anywhere
-                    const hasAlterTable = migrationSQL.toUpperCase().includes('ALTER TABLE');
-                    if (!hasAlterTable) {
-                        (0, debug_logger_js_1.error)(`[sqlite-adapter] Migration ${file} failed (missing required table):`, err);
-                        throw new Error(`Migration ${file} failed: ${message}`);
-                    }
-                    (0, debug_logger_js_1.warn)(`[sqlite-adapter] Migration ${file} skipped: ALTER TABLE on non-existent table (${message})`);
-                    this.prepare('INSERT OR IGNORE INTO schema_version (version) VALUES (?)').run(version);
-                    continue;
-                }
-                (0, debug_logger_js_1.error)(`[sqlite-adapter] Migration ${file} failed:`, err);
-                throw new Error(`Migration ${file} failed: ${message}`);
-            }
-        }
-        // Ensure embeddings table exists (plain table, no native extensions)
-        const embeddingsTables = this.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='embeddings'`).all();
-        if (embeddingsTables.length === 0) {
-            (0, debug_logger_js_1.info)('[sqlite-adapter] Creating embeddings table');
-            this.exec(`
-        CREATE TABLE embeddings (
-          rowid INTEGER PRIMARY KEY,
-          embedding BLOB NOT NULL
-        )
-      `);
-        }
-        // Always attempt migration — uses INSERT OR IGNORE so safe to run multiple times
-        this._migrateFromVssMemories();
-    }
-    /**
-     * Attempt to migrate data from legacy vss_memories (sqlite-vec) to embeddings table.
-     * This is best-effort: if sqlite-vec is not loaded, the vss_memories table won't be readable.
-     */
-    _migrateFromVssMemories() {
-        try {
-            const vssTables = this.prepare(`SELECT name FROM sqlite_master WHERE name='vss_memories'`).all();
-            if (vssTables.length === 0) {
-                return; // No legacy table
-            }
-            // Try to read from vss_memories — will fail if sqlite-vec extension isn't loaded
-            const rows = this.prepare('SELECT rowid, embedding FROM vss_memories').all();
-            if (rows.length > 0) {
-                const insertStmt = this.prepare('INSERT OR IGNORE INTO embeddings (rowid, embedding) VALUES (?, ?)');
-                let migrated = 0;
-                for (const row of rows) {
-                    const res = insertStmt.run(row.rowid, row.embedding);
-                    if (res.changes > 0)
-                        migrated++;
-                }
-                (0, debug_logger_js_1.info)(`[sqlite-adapter] Migrated ${migrated} embeddings from vss_memories to embeddings`);
-            }
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            (0, debug_logger_js_1.warn)(`[sqlite-adapter] Could not migrate from vss_memories (expected if sqlite-vec not installed): ${message}`);
-        }
+        super(config);
     }
 }
 exports.SQLiteAdapter = SQLiteAdapter;
 exports.default = SQLiteAdapter;
-function bufferToVector(buffer) {
-    if (!buffer || buffer.byteLength % 4 !== 0) {
-        return null;
-    }
-    try {
-        const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
-        return new Float32Array(arrayBuffer);
-    }
-    catch {
-        return null;
-    }
-}
 //# sourceMappingURL=sqlite-adapter.js.map

package/dist/db-adapter/statement.d.ts

@@ -81,6 +81,7 @@ export declare class SQLiteStatement extends Statement {
     run(...params: unknown[]): RunResult;
     finalize(): void;
 }
+export { NodeSQLiteStatement } from './node-sqlite-statement.js';
 /**
  * PostgreSQL statement wrapper (pg)
  *
@@ -115,5 +116,4 @@ export declare class PostgreSQLStatement extends Statement {
     runAsync(...params: unknown[]): Promise<RunResult>;
     finalize(): void;
 }
-export {};
 //# sourceMappingURL=statement.d.ts.map

package/dist/db-adapter/statement.js

@@ -8,7 +8,7 @@
  * @module statement
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostgreSQLStatement = exports.SQLiteStatement = exports.Statement = void 0;
+exports.PostgreSQLStatement = exports.NodeSQLiteStatement = exports.SQLiteStatement = exports.Statement = void 0;
 /**
  * Base statement interface
  * All statement wrappers must implement these methods
@@ -45,6 +45,8 @@ class SQLiteStatement extends Statement {
     }
 }
 exports.SQLiteStatement = SQLiteStatement;
+var node_sqlite_statement_js_1 = require("./node-sqlite-statement.js");
+Object.defineProperty(exports, "NodeSQLiteStatement", { enumerable: true, get: function () { return node_sqlite_statement_js_1.NodeSQLiteStatement; } });
 /**
  * PostgreSQL statement wrapper (pg)
  *

package/dist/embedding-server/mobile/auth.js

@@ -20,6 +20,7 @@ exports.isLocalhost = isLocalhost;
 exports.authenticate = authenticate;
 exports.authenticateWebSocket = authenticateWebSocket;
 exports.createAuthMiddleware = createAuthMiddleware;
+const node_crypto_1 = require("node:crypto");
 /**
  * Environment variable for auth token
  */
@@ -28,6 +29,24 @@ exports.AUTH_TOKEN = process.env.MAMA_AUTH_TOKEN;
  * Track if we've warned about missing auth token
  */
 let hasWarnedAboutToken = false;
+/**
+ * Track if we've warned about query parameter token usage
+ */
+let hasWarnedAboutQueryToken = false;
+/**
+ * HMAC key for timing-safe token comparison
+ */
+const hmacKey = (0, node_crypto_1.randomBytes)(32);
+/**
+ * Timing-safe string comparison using HMAC to prevent timing attacks.
+ * Both strings are hashed with HMAC-SHA256 before comparison,
+ * ensuring constant-time evaluation regardless of input.
+ */
+function safeTokenEqual(a, b) {
+    const hmacA = (0, node_crypto_1.createHmac)('sha256', hmacKey).update(a).digest();
+    const hmacB = (0, node_crypto_1.createHmac)('sha256', hmacKey).update(b).digest();
+    return (0, node_crypto_1.timingSafeEqual)(hmacA, hmacB);
+}
 /**
  * Check if request is from localhost
  * @param req - HTTP request
@@ -95,7 +114,7 @@ function authenticate(req) {
     const authHeader = req.headers['authorization'];
     if (authHeader?.startsWith('Bearer ')) {
         const token = authHeader.slice(7);
-        if (token === exports.AUTH_TOKEN) {
+        if (safeTokenEqual(token, exports.AUTH_TOKEN)) {
             console.error(`[Auth] External access granted via Bearer token from ${remoteAddress}`);
             return true;
         }
@@ -103,7 +122,13 @@ function authenticate(req) {
     // Check URL query parameter
     const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
     const queryToken = url.searchParams.get('token');
-    if (queryToken === exports.AUTH_TOKEN) {
+    if (queryToken && safeTokenEqual(queryToken, exports.AUTH_TOKEN)) {
+        if (!hasWarnedAboutQueryToken) {
+            console.warn('[Auth] DEPRECATION WARNING: Authentication via query parameter (?token=...) is deprecated. ' +
+                'Token in URL may leak through server logs, browser history, and Referer headers. ' +
+                'Please use the Authorization header instead: "Authorization: Bearer <token>"');
+            hasWarnedAboutQueryToken = true;
+        }
         console.error(`[Auth] External access granted via query token from ${remoteAddress}`);
         return true;
     }

package/dist/embedding-server/mobile/session-manager.d.ts

@@ -58,6 +58,9 @@ export declare class SessionManager {
     private sessions;
     private db;
     private initialized;
+    private cleanupPromise;
+    private cleanupHandlersRegistered;
+    private handleProcessExit;
     /**
      * Create a new SessionManager instance
      * @param dbPath - Path to SQLite database

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

@@ -53,6 +53,9 @@ class SessionManager {
     sessions;
     db;
     initialized;
+    cleanupPromise;
+    cleanupHandlersRegistered;
+    handleProcessExit;
     /**
      * Create a new SessionManager instance
      * @param dbPath - Path to SQLite database
@@ -62,6 +65,9 @@ class SessionManager {
         this.sessions = new Map();
         this.db = null;
         this.initialized = false;
+        this.cleanupPromise = null;
+        this.cleanupHandlersRegistered = false;
+        this.handleProcessExit = null;
     }
     /**
      * Initialize the SQLite database and create sessions table
@@ -71,10 +77,9 @@ class SessionManager {
             return;
         }
         try {
-            // Dynamically import better-sqlite3 to handle cases where it's not installed
             // eslint-disable-next-line @typescript-eslint/no-require-imports
-            const Database = require('better-sqlite3');
-            this.db = new Database(this.dbPath);
+            const { DatabaseSync } = require('node:sqlite');
+            this.db = new DatabaseSync(this.dbPath);
             // Create sessions table if not exists
             this.db.exec(exports.CREATE_SESSIONS_TABLE);
             this.db.exec(CREATE_STATUS_INDEX);
@@ -307,25 +312,50 @@ class SessionManager {
      * @private
      */
     _setupProcessCleanup() {
-        const cleanup = async () => {
+        if (this.cleanupHandlersRegistered) {
+            return;
+        }
+        const cleanup = () => {
+            if (this.cleanupPromise) {
+                return;
+            }
+            if (this.handleProcessExit) {
+                process.off('exit', this.handleProcessExit);
+            }
+            this.cleanupPromise = Promise.resolve();
             console.error('[SessionManager] Process exiting, cleaning up sessions...');
-            await this.terminateAll();
-            if (this.db) {
-                this.db.close();
+            if (this.db && this.initialized) {
+                for (const [sessionId, session] of this.sessions.entries()) {
+                    try {
+                        session.daemon.kill();
+                    }
+                    catch {
+                        // Best effort - process is already exiting.
+                    }
+                    this.sessions.delete(sessionId);
+                    const stmt = this.db.prepare(`
+            UPDATE sessions
+            SET status = 'terminated', last_active = datetime('now')
+            WHERE id = ?
+          `);
+                    stmt.run(sessionId);
+                }
             }
+            this.close();
         };
-        process.on('exit', () => void cleanup());
-        process.on('SIGINT', () => void cleanup());
-        process.on('SIGTERM', () => void cleanup());
+        this.handleProcessExit = cleanup;
+        process.on('exit', this.handleProcessExit);
+        this.cleanupHandlersRegistered = true;
     }
     /**
      * Close the database connection
      */
     close() {
         if (this.db) {
-            this.db.close();
+            const db = this.db;
             this.db = null;
             this.initialized = false;
+            db.close();
         }
     }
 }

package/dist/embeddings.d.ts

@@ -10,7 +10,7 @@
  * @date 2025-11-20
  */
 import { embeddingCache } from './embedding-cache.js';
-import { loadConfig, getModelName, getEmbeddingDim } from './config-loader.js';
+import { loadConfig, getModelName, getEmbeddingDim, getQuantized } from './config-loader.js';
 /**
  * Decision object for enhanced embedding generation
  */
@@ -71,5 +71,5 @@ export declare function cosineSimilarity(embA: Float32Array, embB: Float32Array)
 export { embeddingCache };
 export declare const EMBEDDING_DIM: number;
 export declare const MODEL_NAME: string;
-export { loadConfig, getModelName, getEmbeddingDim };
+export { loadConfig, getModelName, getEmbeddingDim, getQuantized };
 //# sourceMappingURL=embeddings.d.ts.map

package/dist/embeddings.js

@@ -14,7 +14,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEmbeddingDim = exports.getModelName = exports.loadConfig = exports.MODEL_NAME = exports.EMBEDDING_DIM = exports.embeddingCache = void 0;
+exports.getQuantized = exports.getEmbeddingDim = exports.getModelName = exports.loadConfig = exports.MODEL_NAME = exports.EMBEDDING_DIM = exports.embeddingCache = void 0;
 exports.generateEmbedding = generateEmbedding;
 exports.generateEnhancedEmbedding = generateEnhancedEmbedding;
 exports.generateBatchEmbeddings = generateBatchEmbeddings;
@@ -29,6 +29,7 @@ const config_loader_js_1 = require("./config-loader.js");
 Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return config_loader_js_1.loadConfig; } });
 Object.defineProperty(exports, "getModelName", { enumerable: true, get: function () { return config_loader_js_1.getModelName; } });
 Object.defineProperty(exports, "getEmbeddingDim", { enumerable: true, get: function () { return config_loader_js_1.getEmbeddingDim; } });
+Object.defineProperty(exports, "getQuantized", { enumerable: true, get: function () { return config_loader_js_1.getQuantized; } });
 // Shared cache directory (not in node_modules)
 const DEFAULT_CACHE_DIR = path_1.default.join(os_1.default.homedir(), '.cache', 'huggingface', 'transformers');
 // Singleton pattern for model loading
@@ -73,11 +74,14 @@ async function loadModel() {
             const cacheDir = process.env.HF_HOME || process.env.TRANSFORMERS_CACHE || DEFAULT_CACHE_DIR;
             env.cacheDir = cacheDir;
             (0, debug_logger_js_1.info)(`[MAMA] Model cache directory: ${cacheDir}`);
-            embeddingPipeline = (await pipeline('feature-extraction', modelName));
+            const quantized = (0, config_loader_js_1.getQuantized)();
+            embeddingPipeline = (await pipeline('feature-extraction', modelName, {
+                dtype: quantized ? 'q8' : 'fp32',
+            }));
             currentModelName = modelName;
             const loadTime = Date.now() - startTime;
             const config = (0, config_loader_js_1.loadConfig)();
-            (0, progress_indicator_js_1.logComplete)(`Embedding model ready (${loadTime}ms, ${config.embeddingDim}-dim)`);
+            (0, progress_indicator_js_1.logComplete)(`Embedding model ready (${loadTime}ms, ${config.embeddingDim}-dim, ${quantized ? 'q8' : 'fp32'})`);
         }
         catch (loadErr) {
             modelLoadFailed = true;

package/dist/tier-validator.d.ts

@@ -4,7 +4,7 @@
  * Centralized tier validation module for MAMA.
  * Validates system requirements and determines tier status (1 or 2).
  *
- * Tier 1: Full features (Node.js 18+, SQLite, Embeddings, Database)
+ * Tier 1: Full features (Node.js 22.13+, SQLite, Embeddings, Database)
  * Tier 2: Degraded mode (missing one or more requirements)
  *
  * @module tier-validator
@@ -25,7 +25,7 @@ export interface TierValidation {
  */
 export declare function checkNodeVersion(): CheckResult;
 /**
- * Validates SQLite (better-sqlite3) availability
+ * Validates SQLite availability (node:sqlite)
  */
 export declare function checkSQLite(): CheckResult;
 /**

package/dist/tier-validator.js

@@ -5,7 +5,7 @@
  * Centralized tier validation module for MAMA.
  * Validates system requirements and determines tier status (1 or 2).
  *
- * Tier 1: Full features (Node.js 18+, SQLite, Embeddings, Database)
+ * Tier 1: Full features (Node.js 22.13+, SQLite, Embeddings, Database)
  * Tier 2: Degraded mode (missing one or more requirements)
  *
  * @module tier-validator
@@ -30,8 +30,8 @@ const os_1 = __importDefault(require("os"));
 function checkNodeVersion() {
     try {
         const nodeVersion = process.versions.node;
-        const majorVersion = parseInt(nodeVersion.split('.')[0], 10);
-        if (majorVersion >= 18) {
+        const [majorVersion, minorVersion] = nodeVersion.split('.').map((part) => parseInt(part, 10));
+        if (majorVersion > 22 || (majorVersion === 22 && minorVersion >= 13)) {
             return {
                 status: 'pass',
                 details: `v${nodeVersion}`,
@@ -39,7 +39,7 @@ function checkNodeVersion() {
         }
         return {
             status: 'fail',
-            details: `v${nodeVersion} (requires 18+)`,
+            details: `v${nodeVersion} (requires 22.13+)`,
         };
     }
     catch (error) {
@@ -51,25 +51,24 @@ function checkNodeVersion() {
     }
 }
 /**
- * Validates SQLite (better-sqlite3) availability
+ * Validates SQLite availability (node:sqlite)
  */
 function checkSQLite() {
     try {
         // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const Database = require('better-sqlite3');
-        // Test instantiation with in-memory database
-        const testDb = new Database(':memory:');
+        const { DatabaseSync } = require('node:sqlite');
+        const testDb = new DatabaseSync(':memory:');
         testDb.close();
         return {
             status: 'pass',
-            details: 'better-sqlite3 native module ready',
+            details: 'node:sqlite built-in driver ready',
         };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         return {
             status: 'fail',
-            details: `better-sqlite3 not available: ${message}`,
+            details: `node:sqlite not available: ${message}`,
         };
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jungjaehoon/mama-core",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "description": "MAMA Core - Shared modules for Memory-Augmented MCP Assistant",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -59,15 +59,13 @@
     "access": "public"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=22.13.0"
   },
   "dependencies": {
     "@huggingface/transformers": "^3.8.1",
-    "better-sqlite3": "^11.0.0",
     "ws": "^8.19.0"
   },
   "devDependencies": {
-    "@types/better-sqlite3": "^7.6.0",
     "@types/node": "^22.0.0",
     "@types/ws": "^8.18.1",
     "typescript": "^5.4.0",