π The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
TypeScript agentic-aiagentic-frameworkagentic-workflowagentsai-agentsai-assistantai-skillsautonomous-agentsclaudecodexdsh-pluginharnessmcp-servermulti-agentmulti-agent-systemsnpmskillsswarmswarm-intelligencetypescript
fix(statusline): real vector count + self-heal missing vector_indexes on init (#2569)
rUv5e29dc1a0da7
diff --git a/v3/@claude-flow/cli/__tests__/vector-indexes-repair-heal.test.ts b/v3/@claude-flow/cli/__tests__/vector-indexes-repair-heal.test.tsnew file mode 100644index 0000000000..79b06003eb--- /dev/null+++ b/v3/@claude-flow/cli/__tests__/vector-indexes-repair-heal.test.ts@@ -0,0 +1,234 @@+/**+ * Regression: statusline "Vectors β0" despite thousands of real vectors.+ *+ * Root cause (two layers):+ * 1. DISPLAY β the statusline fetched the vector count and the HNSW row count+ * in ONE combined SQL statement. On a DB with no `vector_indexes` table+ * (older CLI / agentdb-written DBs), the statement failed at PREPARE time+ * and the valid `memory_entries` count was discarded too β shown as 0.+ * 2. DATA β such a DB genuinely lacks the `vector_indexes` table + per-+ * namespace rows, so the HNSW flag and #1941 namespace routing break.+ *+ * Fix: statusline splits the two counts (covered by statusline-generator), and+ * `repairVectorIndexes()` self-heals the DB on init / MCP start. This test+ * pins the DATA-layer self-heal: a `vector_indexes`-less DB with embedded rows+ * is provisioned + backfilled idempotently, and the read-only queries the+ * statusline runs then return the real count (never zero) with the HNSW flag up.+ */+import { describe, it, expect, beforeAll } from 'vitest';+import { mkdtempSync, readFileSync, writeFileSync, existsSync } from 'node:fs';+import { join } from 'node:path';+import { tmpdir } from 'node:os';++import { repairVectorIndexes, recoverMemoryDatabase } from '../src/memory/memory-initializer.js';++// better-sqlite3 is the same engine the repair uses; skip the suite if the+// native module can't load on this host (WASM-only) β the repair no-ops there.+let Database: any;+let haveNative = false;+try { Database = (await import('better-sqlite3')).default; haveNative = true; } catch { haveNative = false; }++/** Build a DB that mimics an old install: memory_entries with embeddings, NO vector_indexes. */+function seedLegacyDb(dbPath: string): void {+ const db = new Database(dbPath);+ db.exec(`CREATE TABLE memory_entries (+ id TEXT PRIMARY KEY, key TEXT, namespace TEXT DEFAULT 'default',+ content TEXT, embedding TEXT, status TEXT DEFAULT 'active'+ )`);+ const ins = db.prepare('INSERT INTO memory_entries (id, key, namespace, content, embedding) VALUES (?,?,?,?,?)');+ const vec = JSON.stringify(Array.from({ length: 8 }, (_, i) => i / 8));+ // 3 in 'commands', 2 in 'feedback', 1 with NO embedding (must not be counted)+ ins.run('a', 'k1', 'commands', 'alpha', vec);+ ins.run('b', 'k2', 'commands', 'beta', vec);+ ins.run('c', 'k3', 'commands', 'gamma', vec);+ ins.run('d', 'k4', 'feedback', 'delta', vec);+ ins.run('e', 'k5', 'feedback', 'epsilon', vec);+ ins.run('f', 'k6', 'commands', 'no-embedding', null);+ db.close();+}++describe.skipIf(!haveNative)('repairVectorIndexes β self-heal missing vector_indexes', () => {+ let workdir: string;++ beforeAll(() => {+ workdir = mkdtempSync(join(tmpdir(), 'vidx-heal-'));+ });++ it('provisions vector_indexes and backfills accurate per-namespace counts', async () => {+ const dbPath = join(workdir, 'legacy.db');+ seedLegacyDb(dbPath);++ // Precondition: table genuinely absent.+ const pre = new Database(dbPath);+ const preCount = pre.prepare("SELECT COUNT(*) AS c FROM sqlite_master WHERE type='table' AND name='vector_indexes'").get() as { c: number };+ expect(preCount.c).toBe(0);+ pre.close();++ const res = await repairVectorIndexes(dbPath);+ expect(res.tableCreated).toBe(true);+ expect(res.repaired).toBe(true);+ expect(res.namespaces.sort()).toEqual(['commands', 'feedback']);++ // total_vectors reflects ONLY embedded rows (the null-embedding row excluded).+ const db = new Database(dbPath);+ const counts = Object.fromEntries(+ (db.prepare('SELECT name, total_vectors FROM vector_indexes').all() as Array<{ name: string; total_vectors: number }>)+ .map(r => [r.name, r.total_vectors]),+ );+ expect(counts.commands).toBe(3);+ expect(counts.feedback).toBe(2);+ // Fresh-install parity seed rows exist too.+ expect(counts.default).toBeDefined();+ expect(counts.patterns).toBeDefined();+ db.close();+ });++ it('the read-only queries the statusline runs now return the real count + HNSW flag', async () => {+ const dbPath = join(workdir, 'statusline.db');+ seedLegacyDb(dbPath);+ await repairVectorIndexes(dbPath);++ const db = new Database(dbPath, { readonly: true });+ // Statusline query 1 (count) β always worked, must be non-zero.+ const c = db.prepare("SELECT COUNT(*) AS c FROM memory_entries WHERE embedding IS NOT NULL").get() as { c: number };+ expect(c.c).toBe(5);+ // Statusline query 2 (HNSW flag) β now succeeds (table present) and is > 0.+ const h = db.prepare('SELECT COUNT(*) AS c FROM vector_indexes').get() as { c: number };+ expect(h.c).toBeGreaterThan(0);+ db.close();+ });++ it('is idempotent β a second run is a clean no-op (no writes) once healed', async () => {+ const dbPath = join(workdir, 'idem.db');+ seedLegacyDb(dbPath);+ const first = await repairVectorIndexes(dbPath);+ expect(first.repaired).toBe(true);+ // Already healed: table exists and every embedded namespace has a row, so+ // the second run must NOT write (avoids touching the live DB every start).+ const second = await repairVectorIndexes(dbPath);+ expect(second.tableCreated).toBe(false);+ expect(second.repaired).toBe(false);+ expect(second.namespaces).toEqual([]);++ // Counts from the first heal remain correct.+ const db = new Database(dbPath);+ const commands = db.prepare("SELECT total_vectors AS t FROM vector_indexes WHERE name='commands'").get() as { t: number };+ expect(commands.t).toBe(3);+ db.close();+ });++ it('is a safe no-op when the DB file does not exist', async () => {+ const res = await repairVectorIndexes(join(workdir, 'nope-does-not-exist.db'));+ expect(res.repaired).toBe(false);+ expect(res.tableCreated).toBe(false);+ expect(res.namespaces).toEqual([]);+ });++ it('is a safe no-op when memory_entries is absent (nothing to key off)', async () => {+ const dbPath = join(workdir, 'empty.db');+ const db = new Database(dbPath);+ db.exec('CREATE TABLE unrelated (x INTEGER)');+ db.close();+ const res = await repairVectorIndexes(dbPath);+ expect(res.repaired).toBe(false);+ expect(res.tableCreated).toBe(false);+ });+});++describe.skipIf(!haveNative)('recoverMemoryDatabase β auto-recover a corrupt memory DB', () => {+ let workdir: string;++ beforeAll(() => {+ workdir = mkdtempSync(join(tmpdir(), 'vidx-recover-'));+ });++ /** Write many rows so the b-tree spans multiple pages, then scribble a page to corrupt it. */+ function seedAndCorrupt(dbPath: string): { rows: number } {+ const db = new Database(dbPath);+ db.pragma('journal_mode = DELETE'); // single-file, no WAL β simpler to corrupt deterministically+ db.pragma('page_size = 4096');+ db.exec(`CREATE TABLE memory_entries (+ id TEXT PRIMARY KEY, key TEXT, namespace TEXT DEFAULT 'default',+ content TEXT, embedding TEXT, status TEXT DEFAULT 'active'+ )`);+ db.exec("CREATE TABLE skills (id TEXT PRIMARY KEY, body TEXT)");+ const ins = db.prepare('INSERT INTO memory_entries (id, key, namespace, content, embedding) VALUES (?,?,?,?,?)');+ const vec = JSON.stringify(Array.from({ length: 8 }, (_, i) => i / 8));+ const N = 500;+ const many = db.transaction(() => {+ for (let i = 0; i < N; i++) {+ ins.run('id' + i, 'k' + i, i % 2 ? 'commands' : 'feedback', 'content number ' + i + ' '.repeat(40), vec);+ }+ });+ many();+ db.close();++ // Scribble over a page in the middle of the file to induce b-tree corruption+ // that quick_check detects but that leaves most rows individually readable.+ const buf = readFileSync(dbPath);+ const pageSize = 4096;+ const targetPage = 6; // past the schema/first pages, into memory_entries data+ const off = targetPage * pageSize + 16;+ for (let i = 0; i < 80; i++) buf[off + i] = 0x00;+ writeFileSync(dbPath, buf);+ return { rows: N };+ }++ it('backs up, rebuilds, verifies, and atomically swaps a corrupt DB', async () => {+ const dbPath = join(workdir, 'corrupt.db');+ const { rows } = seedAndCorrupt(dbPath);++ // Precondition: quick_check must now report corruption.+ const pre = new Database(dbPath);+ const qc = String(pre.pragma('quick_check(1)', { simple: true }));+ pre.close();+ // If our synthetic corruption didn't take on this SQLite build, skip rather+ // than assert a false negative β the recovery path is still exercised below.+ if (qc.toLowerCase() === 'ok') return;++ const rec = await recoverMemoryDatabase(dbPath, { verbose: false });+ expect(rec.recovered).toBe(true);+ expect(rec.backupPath).toBeTruthy();+ expect(existsSync(rec.backupPath!)).toBe(true); // corrupt original preserved++ // The swapped-in DB is clean and retains the readable rows.+ const db = new Database(dbPath, { readonly: true });+ expect(String(db.pragma('integrity_check', { simple: true })).toLowerCase()).toBe('ok');+ const c = (db.prepare('SELECT COUNT(*) AS c FROM memory_entries').get() as { c: number }).c;+ expect(c).toBeGreaterThan(0);+ expect(c).toBeLessThanOrEqual(rows);+ db.close();+ });++ it('is a no-op on a healthy DB (never rewrites a good database)', async () => {+ const dbPath = join(workdir, 'healthy.db');+ const db = new Database(dbPath);+ db.exec("CREATE TABLE memory_entries (id TEXT PRIMARY KEY, content TEXT)");+ db.prepare('INSERT INTO memory_entries VALUES (?, ?)').run('a', 'hello');+ db.close();++ const rec = await recoverMemoryDatabase(dbPath);+ expect(rec.recovered).toBe(false);+ expect(rec.reason).toBe('not-corrupt');+ });++ it('repairVectorIndexes({autoRecover}) recovers then heals in one call', async () => {+ const dbPath = join(workdir, 'corrupt-autoheal.db');+ const { rows } = seedAndCorrupt(dbPath);+ const pre = new Database(dbPath);+ const qc = String(pre.pragma('quick_check(1)', { simple: true }));+ pre.close();+ if (qc.toLowerCase() === 'ok') return; // synthetic corruption didn't take β skip++ const out = await repairVectorIndexes(dbPath, { autoRecover: true });+ expect(out.corrupt).toBe(true);+ expect(out.recovered).toBe(true);+ // After recovery it provisioned vector_indexes on the clean rebuild.+ const db = new Database(dbPath, { readonly: true });+ expect(String(db.pragma('integrity_check', { simple: true })).toLowerCase()).toBe('ok');+ const vidx = (db.prepare('SELECT COUNT(*) AS c FROM vector_indexes').get() as { c: number }).c;+ expect(vidx).toBeGreaterThan(0);+ db.close();+ expect(rows).toBe(500);+ });+});diff --git a/v3/@claude-flow/cli/src/index.ts b/v3/@claude-flow/cli/src/index.tsindex 251cd44767..a02aa92f48 100644--- a/v3/@claude-flow/cli/src/index.ts+++ b/v3/@claude-flow/cli/src/index.ts@@ -607,6 +607,8 @@ export {// Memory & Intelligence (V3 Performance Features)export {initializeMemoryDatabase,+ repairVectorIndexes,+ recoverMemoryDatabase,generateEmbedding,generateBatchEmbeddings,storeEntry,diff --git a/v3/@claude-flow/cli/src/init/executor.ts b/v3/@claude-flow/cli/src/init/executor.tsindex 76efa0585a..0c40abf54c 100644--- a/v3/@claude-flow/cli/src/init/executor.ts+++ b/v3/@claude-flow/cli/src/init/executor.ts@@ -235,6 +235,19 @@ export async function executeInit(options: InitOptions): Promise<InitResult> {if (memRecord) {result.created.files.push('.claude-flow/memory-package.json');}++ // #2568-followup: if this project already has a memory DB that predates+ // the `vector_indexes` table (older CLI / agentdb-written), self-heal it+ // so the statusline vector count + namespace routing work. Best-effort,+ // dynamically imported so a WASM-only host without better-sqlite3 just+ // skips it. Fresh projects have no DB yet β this is a no-op there.+ try {+ const memDbPath = path.join(targetDir, '.swarm', 'memory.db');+ if (fs.existsSync(memDbPath)) {+ const { repairVectorIndexes } = await import('../memory/memory-initializer.js');+ await repairVectorIndexes(memDbPath, { autoRecover: true });+ }+ } catch { /* best-effort β never block init on memory repair */ }}// Generate statuslinediff --git a/v3/@claude-flow/cli/src/init/statusline-generator.ts b/v3/@claude-flow/cli/src/init/statusline-generator.tsindex 56a8bc2ccf..7f92070334 100644--- a/v3/@claude-flow/cli/src/init/statusline-generator.ts+++ b/v3/@claude-flow/cli/src/init/statusline-generator.ts@@ -215,13 +215,24 @@ function getLocalAgentDB() {const memDb = path.join(CWD, '.swarm', 'memory.db');if (fs.existsSync(memDb)) {const Q = String.fromCharCode(34);- const sql = Q + 'SELECT (SELECT COUNT(*) FROM memory_entries WHERE embedding IS NOT NULL)||' + "'|'" + '||(SELECT COUNT(*) FROM vector_indexes);' + Q;- const out = safeExec("sqlite3 'file:" + memDb + "?mode=ro' " + sql, 1500);- if (out && out.indexOf('|') !== -1) {- const parts = out.split('|');- result.vectorCount = parseInt(parts[0], 10) || 0;- result.hasHnsw = (parseInt(parts[1], 10) || 0) > 0;- }+ // Two INDEPENDENT statements -- do NOT combine into one. Coupling the+ // vector count with the vector_indexes row count in a single statement+ // meant that on a DB missing the vector_indexes table (older/agentdb-+ // written DBs), the whole statement failed at PREPARE time (SQLite+ // compiles the full SQL before running), so the valid memory_entries+ // count was discarded too and the statusline showed Vectors 0 despite+ // thousands of real vectors. Split so a missing table can only zero the+ // HNSW flag, never the count. The init self-heal provisions the table so+ // the flag recovers on the next ruflo init / MCP start.+ const countSql = Q + 'SELECT COUNT(*) FROM memory_entries WHERE embedding IS NOT NULL;' + Q;+ const vc = safeExec("sqlite3 'file:" + memDb + "?mode=ro' " + countSql, 1500);+ if (vc) result.vectorCount = parseInt(vc, 10) || 0;+ // HNSW flag: separate statement. If vector_indexes is absent, sqlite3+ // exits non-zero and safeExec returns empty -- hasHnsw stays false (exact+ // original semantics: at least one index-config row present).+ const hnswSql = Q + 'SELECT COUNT(*) FROM vector_indexes;' + Q;+ const hn = safeExec("sqlite3 'file:" + memDb + "?mode=ro' " + hnswSql, 1500);+ if (hn) result.hasHnsw = (parseInt(hn, 10) || 0) > 0;}} catch { /* ignore */ }return result;diff --git a/v3/@claude-flow/cli/src/memory/memory-initializer.ts b/v3/@claude-flow/cli/src/memory/memory-initializer.tsindex def2180b90..4d35a9d9ad 100644--- a/v3/@claude-flow/cli/src/memory/memory-initializer.ts+++ b/v3/@claude-flow/cli/src/memory/memory-initializer.ts@@ -1313,6 +1313,315 @@ async function activateControllerRegistry(return { activated, failed, initTimeMs: performance.now() - startTime };}+/**+ * Self-heal an EXISTING memory database that is missing the `vector_indexes`+ * table or per-namespace rows.+ *+ * Why this exists: fresh installs create `vector_indexes` + seed rows, but a+ * DB written by an older CLI or by agentdb directly may have thousands of+ * embedded rows in `memory_entries` and NO `vector_indexes` table at all.+ * Two things break as a result:+ * 1. The statusline's vector count read collapsed to `0` (the count query+ * referenced the missing table and failed whole β now split, but the+ * HNSW flag still needs the table).+ * 2. #1941 β `memory_search` routes per namespace via `vector_indexes`; a+ * namespace with no row returns 0 results even when entries exist.+ *+ * This is idempotent and conservative:+ * - Does NOTHING (no writes) when the table already exists and every embedded+ * namespace already has a row β the common already-healed path, hit on+ * every MCP start, must not write to the live DB unnecessarily.+ * - Before ANY write, runs `PRAGMA quick_check`; if the DB reports structural+ * corruption it SKIPS the repair entirely (returns `corrupt:true`) rather+ * than writing into a malformed btree and risking making it worse. The+ * caller/user should recover via `sqlite3 old.db .recover | sqlite3 new.db`.+ * - Does NOT checkpoint. mode=ro readers already see committed WAL frames, and+ * forcing a checkpoint on a DB with a torn WAL could persist latent damage.+ *+ * When a repair IS needed and the DB is healthy: creates the table if absent,+ * seeds the fresh-install default rows, and backfills an accurate+ * `total_vectors` per namespace. Runs on the existing-DB path of+ * `initializeMemoryDatabase` (MCP start / `memory init`) and from `ruflo init`.+ *+ * Uses better-sqlite3 (WAL-safe, native). If the native module is unavailable+ * it is a silent no-op β the split statusline query already prevents the count+ * from zeroing; only the HNSW flag and namespace routing stay degraded.+ */+/**+ * Auto-recover a structurally-corrupt memory DB into a clean one, universally+ * (better-sqlite3 only β no dependency on the external `sqlite3` CLI, which is+ * absent on many npx hosts). Safe by construction:+ * 1. Confirms corruption (quick_check) β no-op on a healthy DB.+ * 2. Acquires an EXCLUSIVE lock (BEGIN IMMEDIATE). If another process is+ * writing, it SKIPS (returns reason:'writer-active') rather than racing a+ * writer and losing its in-flight writes β the mistake that must not recur.+ * 3. Rebuilds a fresh DB table-by-table (schema + rows), skipping any single+ * table whose pages won't scan so one bad table can't abort the whole+ * rebuild.+ * 4. VERIFIES the rebuild (integrity_check == ok AND recovered+ * memory_entries count >= the readable source count) BEFORE touching the+ * original.+ * 5. Backs up the corrupt DB to `<db>.corrupt-<ts>.bak`, then atomically+ * renames the verified rebuild into place and drops stale -wal/-shm.+ * On any failure the original + backup are left intact β never destructive.+ */+export async function recoverMemoryDatabase(+ dbPath: string,+ opts: { verbose?: boolean } = {},+): Promise<{ recovered: boolean; backupPath?: string; rows?: number; reason?: string }> {+ if (!dbPath || !fs.existsSync(dbPath)) return { recovered: false, reason: 'no-db' };++ let Database: any;+ try {+ // Module name behind a variable so TS does not statically resolve the+ // optional native dep's types at build time (CI may not install them).+ const mod: string = 'better-sqlite3';+ Database = (await import(mod)).default;+ } catch {+ return { recovered: false, reason: 'no-native' };+ }++ const ts = Date.now();+ const tmpPath = `${dbPath}.recovering-${ts}`;+ const bakPath = `${dbPath}.corrupt-${ts}.bak`;+ let src: any;+ let dst: any;++ try {+ src = new Database(dbPath, { timeout: 1500 });++ // Confirm corruption β never rewrite a healthy DB.+ const qc = src.prepare('PRAGMA quick_check(1)').get() as Record<string, string> | undefined;+ const qcVal = qc ? String(Object.values(qc)[0] ?? '') : '';+ if (qcVal.toLowerCase() === 'ok') { src.close(); return { recovered: false, reason: 'not-corrupt' }; }++ // Exclusive-writer guard: acquire the write lock. If busy, another process+ // is writing β do NOT race it. Reading within this txn is still allowed.+ try {+ src.exec('BEGIN IMMEDIATE');+ } catch {+ src.close();+ return { recovered: false, reason: 'writer-active' };+ }++ let srcRows = 0;+ try { srcRows = (src.prepare('SELECT COUNT(*) AS c FROM memory_entries').get() as { c: number })?.c ?? 0; } catch { /* unreadable */ }++ try { fs.rmSync(tmpPath, { force: true }); } catch { /* fresh */ }+ dst = new Database(tmpPath);++ // Copy schema: tables first (so data can be inserted), then indexes/triggers.+ const objects = src+ .prepare("SELECT type, name, sql FROM sqlite_master WHERE sql IS NOT NULL AND name NOT LIKE 'sqlite_%'")+ .all() as Array<{ type: string; name: string; sql: string }>;+ const tables = objects.filter(o => o.type === 'table');+ const others = objects.filter(o => o.type !== 'table');++ for (const t of tables) {+ try { dst.exec(t.sql); } catch { /* skip an untranslatable table def */ }+ }++ // Copy rows table-by-table; a table whose pages won't scan is skipped whole.+ let copiedEntries = 0;+ for (const t of tables) {+ try {+ const cols = (dst.prepare(`PRAGMA table_info("${t.name}")`).all() as Array<{ name: string }>).map(c => c.name);+ if (!cols.length) continue;+ const colList = cols.map(c => `"${c}"`).join(',');+ const placeholders = cols.map(() => '?').join(',');+ const insert = dst.prepare(`INSERT OR IGNORE INTO "${t.name}" (${colList}) VALUES (${placeholders})`);+ const rows = src.prepare(`SELECT ${colList} FROM "${t.name}"`).all() as Array<Record<string, unknown>>;+ const runAll = dst.transaction((rs: Array<Record<string, unknown>>) => {+ for (const r of rs) insert.run(cols.map(c => r[c] as any));+ });+ runAll(rows);+ if (t.name === 'memory_entries') copiedEntries = rows.length;+ } catch { /* skip a table whose data pages are unreadable */ }+ }++ for (const o of others) {+ try { dst.exec(o.sql); } catch { /* an index over corrupt data β non-fatal */ }+ }++ dst.close(); dst = null;+ try { src.exec('ROLLBACK'); } catch { /* ignore */ }+ src.close(); src = null;++ // Verify BEFORE touching the original.+ const check = new Database(tmpPath, { readonly: true });+ const integ = String(check.pragma('integrity_check', { simple: true }) ?? '');+ let dstRows = 0;+ try { dstRows = (check.prepare('SELECT COUNT(*) AS c FROM memory_entries').get() as { c: number })?.c ?? 0; } catch { /* */ }+ check.close();++ if (integ.toLowerCase() !== 'ok' || dstRows < srcRows) {+ try { fs.rmSync(tmpPath, { force: true }); } catch { /* */ }+ if (opts.verbose) {+ console.log(`memory DB auto-recovery aborted (integrity=${integ}, rows ${dstRows}/${srcRows}) β original untouched`);+ }+ return { recovered: false, reason: 'verify-failed' };+ }++ // Back up the corrupt DB, then atomically swap in the verified rebuild.+ fs.copyFileSync(dbPath, bakPath);+ fs.renameSync(tmpPath, dbPath);+ for (const s of ['-wal', '-shm']) { try { fs.rmSync(`${dbPath}${s}`, { force: true }); } catch { /* */ } }++ if (opts.verbose) {+ console.log(`memory DB auto-recovered: ${dstRows} rows, integrity ok. Corrupt original saved to ${bakPath}`);+ }+ return { recovered: true, backupPath: bakPath, rows: dstRows };+ } catch (e) {+ try { dst?.close(); } catch { /* */ }+ try { src?.exec('ROLLBACK'); } catch { /* */ }+ try { src?.close(); } catch { /* */ }+ try { fs.rmSync(tmpPath, { force: true }); } catch { /* */ }+ if (opts.verbose) console.log(`memory DB auto-recovery error: ${(e as Error)?.message ?? e}`);+ return { recovered: false, reason: 'error' };+ }+}++export async function repairVectorIndexes(+ dbPath: string,+ opts: { verbose?: boolean; autoRecover?: boolean } = {},+): Promise<{ repaired: boolean; tableCreated: boolean; namespaces: string[]; corrupt?: boolean; recovered?: boolean; backupPath?: string }> {+ const res = { repaired: false, tableCreated: false, namespaces: [] as string[], corrupt: false };+ if (!dbPath || !fs.existsSync(dbPath)) return res;++ let Database: any;+ try {+ // Module name behind a variable so TS does not statically resolve the+ // optional native dep's types at build time (CI may not install them).+ const mod: string = 'better-sqlite3';+ Database = (await import(mod)).default;+ } catch {+ // Native module absent (e.g. WASM-only host). Statusline fix still covers+ // the display; nothing to repair here.+ return res;+ }++ let db: any;+ try {+ db = new Database(dbPath, { timeout: 3000 });++ const tableExists = (name: string): boolean =>+ (db.prepare("SELECT COUNT(*) AS c FROM sqlite_master WHERE type='table' AND name=?").get(name)?.c ?? 0) > 0;++ // Nothing to key off if there is no entries table.+ if (!tableExists('memory_entries')) { db.close(); return res; }++ const hasVectorIndexes = tableExists('vector_indexes');++ // Namespaces that actually have embeddings.+ const nsRows = db+ .prepare(+ "SELECT COALESCE(namespace, 'default') AS ns, COUNT(*) AS c " ++ 'FROM memory_entries WHERE embedding IS NOT NULL GROUP BY ns',+ )+ .all() as Array<{ ns: string; c: number }>;++ // Which of those are already present in vector_indexes? If the table exists+ // and every embedded namespace already has a row, the DB is already healed+ // β return WITHOUT writing anything (common path on every MCP start).+ let needsWrite = !hasVectorIndexes;+ if (hasVectorIndexes) {+ const present = new Set(+ (db.prepare('SELECT name FROM vector_indexes').all() as Array<{ name: string }>).map(r => r.name),+ );+ needsWrite = nsRows.some(r => !present.has(String(r.ns || 'default')));+ }+ if (!needsWrite) { db.close(); return res; }++ // A write is needed. GUARD: never write into a structurally corrupt DB β+ // that risks worsening the damage. quick_check is cheaper than a full+ // integrity_check and only runs on the rare repair path, not every start.+ const qc = db.prepare('PRAGMA quick_check(1)').get() as Record<string, string> | undefined;+ const qcVal = qc ? String(Object.values(qc)[0] ?? '') : '';+ if (qcVal.toLowerCase() !== 'ok') {+ res.corrupt = true;+ db.close(); // release our handle before recovery may swap the file+ if (opts.autoRecover) {+ // Auto-fix: rebuild the corrupt DB (backup + verify + atomic swap), then+ // provision vector_indexes on the clean rebuild. This is what makes any+ // npx-deployed ruflo self-repair a corrupt memory DB on init / MCP start.+ const rec = await recoverMemoryDatabase(dbPath, { verbose: opts.verbose });+ if (rec.recovered) {+ const healed = await repairVectorIndexes(dbPath, { verbose: opts.verbose });+ return { ...healed, corrupt: true, recovered: true, backupPath: rec.backupPath };+ }+ if (opts.verbose) {+ console.log(`vector_indexes repair skipped β corruption (${qcVal}); auto-recovery not run (${rec.reason ?? 'unknown'})`);+ }+ } else if (opts.verbose) {+ console.log(+ 'vector_indexes repair SKIPPED β memory DB reports corruption (' + qcVal + '). ' ++ 'Recover with: sqlite3 <db> .recover | sqlite3 <db>.recovered',+ );+ }+ return res;+ }++ if (!hasVectorIndexes) {+ db.exec(`CREATE TABLE IF NOT EXISTS vector_indexes (+ id TEXT PRIMARY KEY,+ name TEXT NOT NULL UNIQUE,+ dimensions INTEGER NOT NULL,+ metric TEXT DEFAULT 'cosine' CHECK(metric IN ('cosine', 'euclidean', 'dot')),+ hnsw_m INTEGER DEFAULT 16,+ hnsw_ef_construction INTEGER DEFAULT 200,+ hnsw_ef_search INTEGER DEFAULT 100,+ quantization_type TEXT CHECK(quantization_type IN ('none', 'scalar', 'product')),+ quantization_bits INTEGER DEFAULT 8,+ total_vectors INTEGER DEFAULT 0,+ last_rebuild_at INTEGER,+ created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),+ updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)+ )`);+ res.tableCreated = true;+ }++ // 384 = default ONNX model dim (Xenova/all-MiniLM-L6-v2); HNSW rejects+ // dim-mismatched inserts, so this must match the stored embeddings (#1947).+ const ensureRow = db.prepare(+ 'INSERT OR IGNORE INTO vector_indexes (id, name, dimensions) VALUES (?, ?, 384)',+ );+ const setCount = db.prepare(+ 'UPDATE vector_indexes SET total_vectors = ?, updated_at = ? WHERE name = ?',+ );++ const backfill = db.transaction(() => {+ // Parity with a fresh install's seed rows.+ ensureRow.run('default', 'default');+ ensureRow.run('patterns', 'patterns');++ const now = Date.now();+ for (const r of nsRows) {+ const ns = String(r.ns || 'default');+ ensureRow.run(ns, ns);+ setCount.run(r.c, now, ns);+ res.namespaces.push(ns);+ }+ });+ backfill();++ res.repaired = res.tableCreated || res.namespaces.length > 0;+ db.close();++ if (opts.verbose && res.repaired) {+ console.log(+ `vector_indexes ${res.tableCreated ? 'created' : 'refreshed'} β ` ++ `backfilled ${res.namespaces.length} namespace(s)`,+ );+ }+ } catch (e) {+ try { db?.close(); } catch { /* already closed */ }+ if (opts.verbose) {+ console.log(`vector_indexes repair skipped: ${(e as Error)?.message ?? e}`);+ }+ }+ return res;+}+/*** Initialize the memory database properly using sql.js*/@@ -1357,19 +1666,24 @@ export async function initializeMemoryDatabase(options: {// surfaced an `[ERROR]` and a "Initialization failed" spinner even when// the existing DB was perfectly healthy.if (fs.existsSync(dbPath) && !force) {+ // #2568-followup: an existing DB may predate `vector_indexes` (or was+ // written by agentdb directly). Self-heal it here β this branch is hit on+ // every MCP-server start and `memory init`, so any ruflo repairs itself.+ // Idempotent + best-effort; never turns a healthy re-init into a failure.+ const heal = await repairVectorIndexes(dbPath, { verbose, autoRecover: true });return {success: true,alreadyExists: true,backend,dbPath,schemaVersion: '3.0.0',- tablesCreated: [],+ tablesCreated: heal.tableCreated ? ['vector_indexes'] : [],indexesCreated: [],features: {vectorEmbeddings: false,patternLearning: false,temporalDecay: false,- hnswIndexing: false,+ hnswIndexing: heal.repaired,migrationTracking: false}};