monomind 1.14.7 → 1.15.0

package/packages/@monomind/cli/dist/src/memory/memory-migrations.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Memory Migrations
+ * Schema column migration and legacy database detection.
+ * Extracted from memory-initializer.ts (ARCH-4)
+ *
+ * @module v1/cli/memory-migrations
+ */
+/**
+ * Ensure memory_entries table has all required columns
+ * Adds missing columns for older databases (e.g., 'content' column)
+ */
+export declare function ensureSchemaColumns(dbPath: string): Promise<{
+    success: boolean;
+    columnsAdded: string[];
+    error?: string;
+}>;
+/**
+ * Check for legacy database installations and migrate if needed
+ */
+export declare function checkAndMigrateLegacy(options: {
+    dbPath: string;
+    verbose?: boolean;
+}): Promise<{
+    needsMigration: boolean;
+    legacyVersion?: string;
+    legacyEntries?: number;
+    migrated?: boolean;
+    migratedCount?: number;
+}>;
+//# sourceMappingURL=memory-migrations.d.ts.map

package/packages/@monomind/cli/dist/src/memory/memory-migrations.js

@@ -0,0 +1,134 @@
+/**
+ * Memory Migrations
+ * Schema column migration and legacy database detection.
+ * Extracted from memory-initializer.ts (ARCH-4)
+ *
+ * @module v1/cli/memory-migrations
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+/** Maximum SQLite database file size accepted before read (256 MB). */
+const MAX_DB_FILE_BYTES = 256 * 1024 * 1024;
+/**
+ * Ensure memory_entries table has all required columns
+ * Adds missing columns for older databases (e.g., 'content' column)
+ */
+export async function ensureSchemaColumns(dbPath) {
+    const columnsAdded = [];
+    try {
+        if (!fs.existsSync(dbPath)) {
+            return { success: true, columnsAdded: [] };
+        }
+        const initSqlJs = (await import('sql.js')).default;
+        const SQL = await initSqlJs();
+        // Guard against excessively large DB files to prevent OOM.
+        const ensureStat = fs.statSync(dbPath);
+        if (ensureStat.size > MAX_DB_FILE_BYTES) {
+            return { success: false, columnsAdded, error: `Database file too large: ${ensureStat.size} bytes` };
+        }
+        const fileBuffer = fs.readFileSync(dbPath);
+        const db = new SQL.Database(fileBuffer);
+        // Get current columns in memory_entries
+        const tableInfo = db.exec("PRAGMA table_info(memory_entries)");
+        const existingColumns = new Set(tableInfo[0]?.values?.map(row => row[1]) || []);
+        // Required columns that may be missing in older schemas
+        // Issue #977: 'type' column was missing from this list, causing store failures on older DBs
+        const requiredColumns = [
+            { name: 'content', definition: "content TEXT DEFAULT ''" },
+            { name: 'type', definition: "type TEXT DEFAULT 'semantic'" },
+            { name: 'embedding', definition: 'embedding TEXT' },
+            { name: 'embedding_model', definition: "embedding_model TEXT DEFAULT 'local'" },
+            { name: 'embedding_dimensions', definition: 'embedding_dimensions INTEGER' },
+            { name: 'tags', definition: 'tags TEXT' },
+            { name: 'metadata', definition: 'metadata TEXT' },
+            { name: 'owner_id', definition: 'owner_id TEXT' },
+            { name: 'expires_at', definition: 'expires_at INTEGER' },
+            { name: 'last_accessed_at', definition: 'last_accessed_at INTEGER' },
+            { name: 'access_count', definition: 'access_count INTEGER DEFAULT 0' },
+            { name: 'status', definition: "status TEXT DEFAULT 'active'" }
+        ];
+        let modified = false;
+        for (const col of requiredColumns) {
+            if (!existingColumns.has(col.name)) {
+                try {
+                    db.run(`ALTER TABLE memory_entries ADD COLUMN ${col.definition}`);
+                    columnsAdded.push(col.name);
+                    modified = true;
+                }
+                catch (e) {
+                    // Column might already exist or other error - continue
+                }
+            }
+        }
+        if (modified) {
+            // Save updated database (atomic to avoid corruption on crash)
+            const data = db.export();
+            const tmp = dbPath + '.tmp';
+            fs.writeFileSync(tmp, Buffer.from(data));
+            fs.renameSync(tmp, dbPath);
+        }
+        db.close();
+        return { success: true, columnsAdded };
+    }
+    catch (error) {
+        return {
+            success: false,
+            columnsAdded,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+/**
+ * Check for legacy database installations and migrate if needed
+ */
+export async function checkAndMigrateLegacy(options) {
+    const { dbPath, verbose = false } = options;
+    // Check for legacy locations
+    const legacyPaths = [
+        path.join(process.cwd(), 'memory.db'),
+        path.join(process.cwd(), '.claude/memory.db'),
+        path.join(process.cwd(), 'data/memory.db'),
+        path.join(process.cwd(), '.monomind/memory.db')
+    ];
+    for (const legacyPath of legacyPaths) {
+        if (fs.existsSync(legacyPath) && legacyPath !== dbPath) {
+            try {
+                const initSqlJs = (await import('sql.js')).default;
+                const SQL = await initSqlJs();
+                // Guard against excessively large legacy DB files to prevent OOM.
+                const legacyStat = fs.statSync(legacyPath);
+                if (legacyStat.size > MAX_DB_FILE_BYTES) {
+                    if (verbose) {
+                        console.warn(`[memory] Skipping legacy DB at ${legacyPath}: file too large (${legacyStat.size} bytes)`);
+                    }
+                    continue;
+                }
+                const legacyBuffer = fs.readFileSync(legacyPath);
+                const legacyDb = new SQL.Database(legacyBuffer);
+                // Check if it has data
+                const countResult = legacyDb.exec('SELECT COUNT(*) FROM memory_entries');
+                const count = countResult[0]?.values[0]?.[0] || 0;
+                // Get version if available
+                let version = 'unknown';
+                try {
+                    const versionResult = legacyDb.exec("SELECT value FROM metadata WHERE key='schema_version'");
+                    version = versionResult[0]?.values[0]?.[0] || 'unknown';
+                }
+                catch { /* no metadata table */ }
+                legacyDb.close();
+                if (count > 0) {
+                    return {
+                        needsMigration: true,
+                        legacyVersion: version,
+                        legacyEntries: count
+                    };
+                }
+            }
+            catch {
+                // Not a valid SQLite database, skip
+            }
+        }
+    }
+    return { needsMigration: false };
+}
+//# sourceMappingURL=memory-migrations.js.map

package/packages/@monomind/cli/dist/src/memory/memory-read.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Memory Read Operations
+ * Search, list, and get entries from the memory database.
+ * Split from memory-crud.ts (ARCH-4b).
+ *
+ * @module v1/cli/memory-read
+ */
+/**
+ * Search entries using sql.js with vector similarity
+ * Uses HNSW index for 150x faster search when available
+ */
+export declare function searchEntries(options: {
+    query: string;
+    namespace?: string;
+    limit?: number;
+    threshold?: number;
+    dbPath?: string;
+}): Promise<{
+    success: boolean;
+    results: {
+        id: string;
+        key: string;
+        content: string;
+        score: number;
+        namespace: string;
+    }[];
+    searchTime: number;
+    error?: string;
+}>;
+/**
+ * List all entries from the memory database
+ */
+export declare function listEntries(options: {
+    namespace?: string;
+    limit?: number;
+    offset?: number;
+    dbPath?: string;
+}): Promise<{
+    success: boolean;
+    entries: {
+        id: string;
+        key: string;
+        namespace: string;
+        size: number;
+        accessCount: number;
+        createdAt: string;
+        updatedAt: string;
+        hasEmbedding: boolean;
+    }[];
+    total: number;
+    error?: string;
+}>;
+/**
+ * Get a specific entry from the memory database
+ */
+export declare function getEntry(options: {
+    key: string;
+    namespace?: string;
+    dbPath?: string;
+    /** Agent ID for collaborative memory promotion tracking */
+    agentId?: string;
+}): Promise<{
+    success: boolean;
+    found: boolean;
+    entry?: {
+        id: string;
+        key: string;
+        namespace: string;
+        content: string;
+        accessCount: number;
+        createdAt: string;
+        updatedAt: string;
+        hasEmbedding: boolean;
+        tags: string[];
+    };
+    error?: string;
+}>;
+//# sourceMappingURL=memory-read.d.ts.map

package/packages/@monomind/cli/dist/src/memory/memory-read.js

@@ -0,0 +1,331 @@
+/**
+ * Memory Read Operations
+ * Search, list, and get entries from the memory database.
+ * Split from memory-crud.ts (ARCH-4b).
+ *
+ * @module v1/cli/memory-read
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { safeParseEmbedding } from './memory-bridge.js';
+import { ensureSchemaColumns } from './memory-migrations.js';
+import { generateEmbedding } from './embedding-operations.js';
+import { searchHNSWIndex } from './hnsw-operations.js';
+/** Maximum SQLite database file size accepted before read (256 MB). */
+const MAX_DB_FILE_BYTES = 256 * 1024 * 1024;
+// ADR-053: Lazy import of AgentDB v1 bridge
+let _bridge;
+async function getBridge() {
+    if (_bridge === null)
+        return null;
+    if (_bridge)
+        return _bridge;
+    try {
+        _bridge = await import('./memory-bridge.js');
+        return _bridge;
+    }
+    catch {
+        _bridge = null;
+        return null;
+    }
+}
+/**
+ * Optimized cosine similarity
+ * V8 JIT-friendly - avoids manual unrolling which can hurt performance
+ * ~0.5μs per 384-dim vector comparison
+ */
+function cosineSim(a, b) {
+    if (!a || !b || a.length === 0 || b.length === 0)
+        return 0;
+    const len = Math.min(a.length, b.length);
+    let dot = 0, normA = 0, normB = 0;
+    for (let i = 0; i < len; i++) {
+        const ai = a[i], bi = b[i];
+        dot += ai * bi;
+        normA += ai * ai;
+        normB += bi * bi;
+    }
+    const mag = Math.sqrt(normA * normB);
+    return mag === 0 ? 0 : dot / mag;
+}
+/**
+ * Search entries using sql.js with vector similarity
+ * Uses HNSW index for 150x faster search when available
+ */
+export async function searchEntries(options) {
+    // ADR-053: Try AgentDB v1 bridge first
+    const bridge = await getBridge();
+    if (bridge) {
+        const bridgeResult = await bridge.bridgeSearchEntries(options);
+        if (bridgeResult)
+            return bridgeResult;
+    }
+    // Fallback: raw sql.js
+    const { query, namespace, limit = 10, threshold = 0.3, dbPath: customPath } = options;
+    const effectiveNamespace = namespace || 'all';
+    const swarmDir = path.resolve(process.cwd(), '.swarm');
+    const dbPath = customPath ? path.resolve(customPath) : path.join(swarmDir, 'memory.db');
+    const startTime = Date.now();
+    try {
+        if (!fs.existsSync(dbPath)) {
+            return { success: false, results: [], searchTime: 0, error: 'Database not found' };
+        }
+        await ensureSchemaColumns(dbPath);
+        const searchStat = fs.statSync(dbPath);
+        if (searchStat.size > MAX_DB_FILE_BYTES) {
+            return { success: false, results: [], searchTime: 0, error: `Database file too large: ${searchStat.size} bytes` };
+        }
+        const queryEmb = await generateEmbedding(query);
+        const queryEmbedding = queryEmb.embedding;
+        // Try HNSW search first (150x faster)
+        const hnswResults = await searchHNSWIndex(queryEmbedding, { k: limit, namespace: effectiveNamespace });
+        if (hnswResults && hnswResults.length > 0) {
+            const filtered = hnswResults.filter(r => r.score >= threshold);
+            return {
+                success: true,
+                results: filtered,
+                searchTime: Date.now() - startTime
+            };
+        }
+        // Fall back to brute-force SQLite search
+        const initSqlJs = (await import('sql.js')).default;
+        const SQL = await initSqlJs();
+        const searchFbStat = fs.statSync(dbPath);
+        if (searchFbStat.size > MAX_DB_FILE_BYTES) {
+            return { success: false, results: [], searchTime: Date.now() - startTime, error: `Database file too large: ${searchFbStat.size} bytes` };
+        }
+        const fileBuffer = fs.readFileSync(dbPath);
+        const db = new SQL.Database(fileBuffer);
+        const searchStmt = db.prepare(effectiveNamespace !== 'all'
+            ? `SELECT id, key, namespace, content, embedding FROM memory_entries WHERE status = 'active' AND namespace = ? LIMIT 1000`
+            : `SELECT id, key, namespace, content, embedding FROM memory_entries WHERE status = 'active' LIMIT 1000`);
+        if (effectiveNamespace !== 'all') {
+            searchStmt.bind([effectiveNamespace]);
+        }
+        const searchRows = [];
+        while (searchStmt.step()) {
+            searchRows.push(searchStmt.get());
+        }
+        searchStmt.free();
+        const entries = searchRows.length > 0 ? [{ values: searchRows }] : [];
+        const results = [];
+        if (entries[0]?.values) {
+            for (const row of entries[0].values) {
+                const [id, key, ns, content, embeddingJson] = row;
+                let score = 0;
+                if (embeddingJson) {
+                    const embedding = safeParseEmbedding(embeddingJson);
+                    if (embedding && embedding.length === queryEmbedding.length) {
+                        score = cosineSim(queryEmbedding, embedding);
+                    }
+                }
+                if (score < threshold) {
+                    const lowerContent = (content || '').toLowerCase();
+                    const lowerQuery = query.toLowerCase();
+                    const words = lowerQuery.split(/\s+/).filter(w => w.length > 0);
+                    if (words.length > 0) {
+                        const matchCount = words.filter(w => lowerContent.includes(w)).length;
+                        const keywordScore = matchCount / words.length * 0.5;
+                        score = Math.max(score, keywordScore);
+                    }
+                }
+                if (score >= threshold) {
+                    results.push({
+                        id: id.substring(0, 12),
+                        key: key || id.substring(0, 15),
+                        content: (content || '').substring(0, 60) + ((content || '').length > 60 ? '...' : ''),
+                        score,
+                        namespace: ns || 'default'
+                    });
+                }
+            }
+        }
+        db.close();
+        results.sort((a, b) => b.score - a.score);
+        return {
+            success: true,
+            results: results.slice(0, limit),
+            searchTime: Date.now() - startTime
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            results: [],
+            searchTime: Date.now() - startTime,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+/**
+ * List all entries from the memory database
+ */
+export async function listEntries(options) {
+    // ADR-053: Try AgentDB v1 bridge first
+    const bridge = await getBridge();
+    if (bridge) {
+        const bridgeResult = await bridge.bridgeListEntries(options);
+        if (bridgeResult)
+            return bridgeResult;
+    }
+    // Fallback: raw sql.js
+    const { namespace, limit = 20, offset = 0, dbPath: customPath } = options;
+    const swarmDir = path.join(process.cwd(), '.swarm');
+    const dbPath = customPath || path.join(swarmDir, 'memory.db');
+    try {
+        if (!fs.existsSync(dbPath)) {
+            return { success: false, entries: [], total: 0, error: 'Database not found' };
+        }
+        await ensureSchemaColumns(dbPath);
+        const initSqlJs = (await import('sql.js')).default;
+        const SQL = await initSqlJs();
+        const listStat = fs.statSync(dbPath);
+        if (listStat.size > MAX_DB_FILE_BYTES) {
+            return { success: false, entries: [], total: 0, error: `Database file too large: ${listStat.size} bytes` };
+        }
+        const fileBuffer = fs.readFileSync(dbPath);
+        const db = new SQL.Database(fileBuffer);
+        const countStmt = namespace
+            ? db.prepare(`SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active' AND namespace = ?`)
+            : db.prepare(`SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active'`);
+        if (namespace) {
+            countStmt.bind([namespace]);
+        }
+        const countRows = [];
+        while (countStmt.step()) {
+            countRows.push(countStmt.get());
+        }
+        countStmt.free();
+        const countResult = countRows.length > 0 ? [{ values: countRows }] : [];
+        const total = countResult[0]?.values?.[0]?.[0] || 0;
+        const MAX_LIST_LIMIT = 10_000;
+        const rawLimit = parseInt(String(limit), 10);
+        const safeLimit = Number.isFinite(rawLimit) && rawLimit > 0 ? Math.min(rawLimit, MAX_LIST_LIMIT) : 100;
+        const rawOffset = parseInt(String(offset), 10);
+        const safeOffset = Number.isFinite(rawOffset) && rawOffset >= 0 ? rawOffset : 0;
+        const listStmt = namespace
+            ? db.prepare(`SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at FROM memory_entries WHERE status = 'active' AND namespace = ? ORDER BY updated_at DESC LIMIT ? OFFSET ?`)
+            : db.prepare(`SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at FROM memory_entries WHERE status = 'active' ORDER BY updated_at DESC LIMIT ? OFFSET ?`);
+        if (namespace) {
+            listStmt.bind([namespace, safeLimit, safeOffset]);
+        }
+        else {
+            listStmt.bind([safeLimit, safeOffset]);
+        }
+        const listRows = [];
+        while (listStmt.step()) {
+            listRows.push(listStmt.get());
+        }
+        listStmt.free();
+        const result = listRows.length > 0 ? [{ values: listRows }] : [];
+        const entries = [];
+        if (result[0]?.values) {
+            for (const row of result[0].values) {
+                const [id, key, ns, content, embedding, accessCount, createdAt, updatedAt] = row;
+                entries.push({
+                    id: String(id).substring(0, 20),
+                    key: key || String(id).substring(0, 15),
+                    namespace: ns || 'default',
+                    size: (content || '').length,
+                    accessCount: accessCount || 0,
+                    createdAt: createdAt || new Date().toISOString(),
+                    updatedAt: updatedAt || new Date().toISOString(),
+                    hasEmbedding: !!embedding && embedding.length > 10
+                });
+            }
+        }
+        db.close();
+        return { success: true, entries, total };
+    }
+    catch (error) {
+        return {
+            success: false,
+            entries: [],
+            total: 0,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+/**
+ * Get a specific entry from the memory database
+ */
+export async function getEntry(options) {
+    // ADR-053: Try AgentDB v1 bridge first
+    const bridge = await getBridge();
+    if (bridge) {
+        const bridgeResult = await bridge.bridgeGetEntry(options);
+        if (bridgeResult)
+            return bridgeResult;
+    }
+    // Fallback: raw sql.js
+    const { key, namespace = 'default', dbPath: customPath } = options;
+    const swarmDir = path.join(process.cwd(), '.swarm');
+    const dbPath = customPath || path.join(swarmDir, 'memory.db');
+    try {
+        if (!fs.existsSync(dbPath)) {
+            return { success: false, found: false, error: 'Database not found' };
+        }
+        await ensureSchemaColumns(dbPath);
+        const initSqlJs = (await import('sql.js')).default;
+        const SQL = await initSqlJs();
+        const getStat = fs.statSync(dbPath);
+        if (getStat.size > MAX_DB_FILE_BYTES) {
+            return { success: false, found: false, error: `Database file too large: ${getStat.size} bytes` };
+        }
+        const fileBuffer = fs.readFileSync(dbPath);
+        const db = new SQL.Database(fileBuffer);
+        const getStmt = db.prepare(`
+      SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at, tags
+      FROM memory_entries
+      WHERE status = 'active'
+        AND key = ?
+        AND namespace = ?
+      LIMIT 1
+    `);
+        getStmt.bind([key, namespace]);
+        const getRows = [];
+        while (getStmt.step()) {
+            getRows.push(getStmt.get());
+        }
+        getStmt.free();
+        const result = getRows.length > 0 ? [{ values: getRows }] : [];
+        if (!result[0]?.values?.[0]) {
+            db.close();
+            return { success: true, found: false };
+        }
+        const [id, entryKey, ns, content, embedding, accessCount, createdAt, updatedAt, tagsJson] = result[0].values[0];
+        db.close();
+        let tags = [];
+        if (tagsJson) {
+            try {
+                tags = JSON.parse(tagsJson);
+            }
+            catch {
+                // Invalid JSON
+            }
+        }
+        return {
+            success: true,
+            found: true,
+            entry: {
+                id: String(id),
+                key: entryKey || String(id),
+                namespace: ns || 'default',
+                content: content || '',
+                accessCount: (accessCount || 0) + 1,
+                createdAt: createdAt || new Date().toISOString(),
+                updatedAt: updatedAt || new Date().toISOString(),
+                hasEmbedding: !!embedding && embedding.length > 10,
+                tags
+            }
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            found: false,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+//# sourceMappingURL=memory-read.js.map

package/packages/@monomind/cli/dist/src/memory/memory-schema.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Memory Schema
+ * SQL schema for the Monomind memory database.
+ * Extracted from memory-initializer.ts (ARCH-4)
+ *
+ * @module v1/cli/memory-schema
+ */
+/**
+ * Enhanced schema with pattern confidence, temporal decay, versioning
+ * Vector embeddings enabled for semantic search
+ */
+export declare const MEMORY_SCHEMA = "\n-- Monomind Memory Database\n-- Version: 3.0.0\n-- Features: Pattern learning, vector embeddings, temporal decay, migration tracking\n\nPRAGMA journal_mode = WAL;\nPRAGMA synchronous = NORMAL;\nPRAGMA foreign_keys = ON;\n\n-- ============================================\n-- CORE MEMORY TABLES\n-- ============================================\n\n-- Memory entries (main storage)\nCREATE TABLE IF NOT EXISTS memory_entries (\n  id TEXT PRIMARY KEY,\n  key TEXT NOT NULL,\n  namespace TEXT NOT NULL DEFAULT 'default',\n  content TEXT NOT NULL DEFAULT '',\n  type TEXT NOT NULL DEFAULT 'semantic',\n  embedding TEXT,\n  embedding_model TEXT DEFAULT 'local',\n  embedding_dimensions INTEGER,\n  confidence REAL DEFAULT 1.0,\n  decay_rate REAL DEFAULT 0.01,\n  importance_score REAL DEFAULT 0.5,\n  access_count INTEGER DEFAULT 0,\n  last_accessed_at INTEGER,\n  expires_at INTEGER,\n  tags TEXT,\n  metadata TEXT,\n  owner_id TEXT,\n  agent_id TEXT,\n  session_id TEXT,\n  status TEXT DEFAULT 'active',\n  created_at INTEGER DEFAULT (strftime('%s', 'now') * 1000),\n  updated_at INTEGER DEFAULT (strftime('%s', 'now') * 1000)\n);\n\nCREATE INDEX IF NOT EXISTS idx_memory_namespace ON memory_entries(namespace);\nCREATE INDEX IF NOT EXISTS idx_memory_key ON memory_entries(key);\nCREATE INDEX IF NOT EXISTS idx_memory_type ON memory_entries(type);\nCREATE INDEX IF NOT EXISTS idx_memory_status ON memory_entries(status);\nCREATE INDEX IF NOT EXISTS idx_memory_created ON memory_entries(created_at);\nCREATE INDEX IF NOT EXISTS idx_memory_accessed ON memory_entries(last_accessed_at);\nCREATE INDEX IF NOT EXISTS idx_memory_owner ON memory_entries(owner_id);\n\n-- Pattern learning tables\nCREATE TABLE IF NOT EXISTS patterns (\n  id TEXT PRIMARY KEY,\n  name TEXT NOT NULL,\n  pattern_type TEXT NOT NULL DEFAULT 'task-routing',\n  condition TEXT NOT NULL,\n  action TEXT NOT NULL,\n  confidence REAL DEFAULT 0.5,\n  success_count INTEGER DEFAULT 0,\n  failure_count INTEGER DEFAULT 0,\n  decay_rate REAL DEFAULT 0.05,\n  last_matched_at INTEGER,\n  status TEXT DEFAULT 'active',\n  metadata TEXT,\n  created_at INTEGER DEFAULT (strftime('%s', 'now') * 1000),\n  updated_at INTEGER DEFAULT (strftime('%s', 'now') * 1000)\n);\n\nCREATE INDEX IF NOT EXISTS idx_patterns_type ON patterns(pattern_type);\nCREATE INDEX IF NOT EXISTS idx_patterns_confidence ON patterns(confidence);\nCREATE INDEX IF NOT EXISTS idx_patterns_status ON patterns(status);\nCREATE INDEX IF NOT EXISTS idx_patterns_last_matched ON patterns(last_matched_at);\n\n-- Pattern history for temporal analysis\nCREATE TABLE IF NOT EXISTS pattern_history (\n  id TEXT PRIMARY KEY,\n  pattern_id TEXT NOT NULL REFERENCES patterns(id) ON DELETE CASCADE,\n  event_type TEXT NOT NULL,\n  confidence_before REAL,\n  confidence_after REAL,\n  metadata TEXT,\n  created_at INTEGER DEFAULT (strftime('%s', 'now') * 1000)\n);\n\nCREATE INDEX IF NOT EXISTS idx_pattern_history_pattern ON pattern_history(pattern_id);\n\n-- Trajectory recording for learning\nCREATE TABLE IF NOT EXISTS trajectories (\n  id TEXT PRIMARY KEY,\n  task_description TEXT NOT NULL,\n  agent_type TEXT,\n  success BOOLEAN DEFAULT FALSE,\n  total_steps INTEGER DEFAULT 0,\n  duration_ms INTEGER,\n  metadata TEXT,\n  created_at INTEGER DEFAULT (strftime('%s', 'now') * 1000),\n  completed_at INTEGER\n);\n\n-- Trajectory steps\nCREATE TABLE IF NOT EXISTS trajectory_steps (\n  id TEXT PRIMARY KEY,\n  trajectory_id TEXT NOT NULL REFERENCES trajectories(id) ON DELETE CASCADE,\n  step_number INTEGER NOT NULL,\n  action TEXT NOT NULL,\n  result TEXT,\n  success BOOLEAN,\n  duration_ms INTEGER,\n  metadata TEXT,\n  created_at INTEGER DEFAULT (strftime('%s', 'now') * 1000)\n);\n\nCREATE INDEX IF NOT EXISTS idx_steps_trajectory ON trajectory_steps(trajectory_id);\n\n-- Migration state tracking\nCREATE TABLE IF NOT EXISTS migration_state (\n  id TEXT PRIMARY KEY,\n  migration_type TEXT NOT NULL,\n  source_path TEXT,\n  target_path TEXT,\n  status TEXT DEFAULT 'pending',\n  entries_migrated INTEGER DEFAULT 0,\n  errors INTEGER DEFAULT 0,\n  started_at INTEGER,\n  completed_at INTEGER,\n  metadata TEXT,\n  created_at INTEGER DEFAULT (strftime('%s', 'now') * 1000)\n);\n\n-- Session management\nCREATE TABLE IF NOT EXISTS sessions (\n  id TEXT PRIMARY KEY,\n  agent_id TEXT,\n  metadata TEXT,\n  status TEXT DEFAULT 'active',\n  started_at INTEGER DEFAULT (strftime('%s', 'now') * 1000),\n  ended_at INTEGER,\n  summary TEXT\n);\n\n-- Vector index configuration\nCREATE TABLE IF NOT EXISTS vector_indexes (\n  id TEXT PRIMARY KEY,\n  name TEXT NOT NULL,\n  dimensions INTEGER NOT NULL DEFAULT 384,\n  hnsw_m INTEGER DEFAULT 16,\n  hnsw_ef_construction INTEGER DEFAULT 200,\n  entry_count INTEGER DEFAULT 0,\n  created_at INTEGER DEFAULT (strftime('%s', 'now') * 1000),\n  updated_at INTEGER DEFAULT (strftime('%s', 'now') * 1000)\n);\n\nCREATE TABLE IF NOT EXISTS metadata (\n  key TEXT PRIMARY KEY,\n  value TEXT NOT NULL,\n  updated_at INTEGER DEFAULT (strftime('%s', 'now') * 1000)\n);\n";
+//# sourceMappingURL=memory-schema.d.ts.map