memorix 1.9.1 → 1.9.3

package/dist/index.js

@@ -452,70 +452,79 @@ function getDatabase(dataDir) {
   loadBetterSqlite3();
   fs.mkdirSync(dataDir, { recursive: true });
   const dbPath = path3.join(dataDir, "memorix.db");
-  const db2 = createDatabase(dbPath);
-  db2.pragma("journal_mode = WAL");
-  db2.pragma("busy_timeout = 5000");
-  db2.pragma("foreign_keys = ON");
-  db2.exec(CREATE_OBSERVATIONS_TABLE);
-  db2.exec(CREATE_MINI_SKILLS_TABLE);
-  db2.exec(CREATE_SESSIONS_TABLE);
-  db2.exec(CREATE_META_TABLE);
-  db2.exec(CREATE_TEAM_AGENTS_TABLE);
-  db2.exec(CREATE_TEAM_TASKS_TABLE);
-  db2.exec(CREATE_TEAM_TASK_DEPS_TABLE);
-  db2.exec(CREATE_TEAM_MESSAGES_TABLE);
-  db2.exec(CREATE_TEAM_LOCKS_TABLE);
-  db2.exec(CREATE_TEAM_ROLES_TABLE);
-  db2.exec(CREATE_GRAPH_ENTITIES_TABLE);
-  db2.exec(CREATE_GRAPH_RELATIONS_TABLE);
-  db2.exec(CREATE_CHAT_TRANSCRIPT_TABLE);
-  db2.exec(CREATE_CODE_FILES_TABLE);
-  db2.exec(CREATE_CODE_SYMBOLS_TABLE);
-  db2.exec(CREATE_CODE_EDGES_TABLE);
-  db2.exec(CREATE_OBSERVATION_CODE_REFS_TABLE);
-  db2.exec(CREATE_MAINTENANCE_JOBS_TABLE);
-  db2.exec(CREATE_MAINTENANCE_TARGETS_TABLE);
-  db2.exec(CREATE_COMPACTION_CHECKPOINTS_TABLE);
+  let db2;
   try {
-    db2.exec(`ALTER TABLE mini_skills ADD COLUMN sourceSnapshot TEXT NOT NULL DEFAULT ''`);
-  } catch {
-  }
-  try {
-    db2.exec(`ALTER TABLE mini_skills ADD COLUMN updatedAt TEXT`);
-  } catch {
-  }
-  try {
-    db2.exec(`ALTER TABLE observations ADD COLUMN createdByAgentId TEXT`);
-  } catch {
-  }
-  try {
-    db2.exec(`ALTER TABLE observations ADD COLUMN writeGeneration INTEGER DEFAULT 0`);
-  } catch {
-  }
-  try {
-    db2.exec(`ALTER TABLE team_tasks ADD COLUMN required_role TEXT`);
-  } catch {
-  }
-  try {
-    db2.exec(`ALTER TABLE team_tasks ADD COLUMN preferred_role TEXT`);
-  } catch {
-  }
-  try {
-    db2.exec(`ALTER TABLE team_messages ADD COLUMN to_role TEXT`);
-  } catch {
-  }
-  try {
-    db2.exec(`ALTER TABLE team_messages ADD COLUMN handoff_status TEXT`);
-  } catch {
+    db2 = createDatabase(dbPath);
+    db2.pragma("busy_timeout = 5000");
+    db2.pragma("journal_mode = WAL");
+    db2.pragma("foreign_keys = ON");
+    db2.exec(CREATE_OBSERVATIONS_TABLE);
+    db2.exec(CREATE_MINI_SKILLS_TABLE);
+    db2.exec(CREATE_SESSIONS_TABLE);
+    db2.exec(CREATE_META_TABLE);
+    db2.exec(CREATE_TEAM_AGENTS_TABLE);
+    db2.exec(CREATE_TEAM_TASKS_TABLE);
+    db2.exec(CREATE_TEAM_TASK_DEPS_TABLE);
+    db2.exec(CREATE_TEAM_MESSAGES_TABLE);
+    db2.exec(CREATE_TEAM_LOCKS_TABLE);
+    db2.exec(CREATE_TEAM_ROLES_TABLE);
+    db2.exec(CREATE_GRAPH_ENTITIES_TABLE);
+    db2.exec(CREATE_GRAPH_RELATIONS_TABLE);
+    db2.exec(CREATE_CHAT_TRANSCRIPT_TABLE);
+    db2.exec(CREATE_CODE_FILES_TABLE);
+    db2.exec(CREATE_CODE_SYMBOLS_TABLE);
+    db2.exec(CREATE_CODE_EDGES_TABLE);
+    db2.exec(CREATE_OBSERVATION_CODE_REFS_TABLE);
+    db2.exec(CREATE_MAINTENANCE_JOBS_TABLE);
+    db2.exec(CREATE_MAINTENANCE_TARGETS_TABLE);
+    db2.exec(CREATE_COMPACTION_CHECKPOINTS_TABLE);
+    try {
+      db2.exec(`ALTER TABLE mini_skills ADD COLUMN sourceSnapshot TEXT NOT NULL DEFAULT ''`);
+    } catch {
+    }
+    try {
+      db2.exec(`ALTER TABLE mini_skills ADD COLUMN updatedAt TEXT`);
+    } catch {
+    }
+    try {
+      db2.exec(`ALTER TABLE observations ADD COLUMN createdByAgentId TEXT`);
+    } catch {
+    }
+    try {
+      db2.exec(`ALTER TABLE observations ADD COLUMN writeGeneration INTEGER DEFAULT 0`);
+    } catch {
+    }
+    try {
+      db2.exec(`ALTER TABLE team_tasks ADD COLUMN required_role TEXT`);
+    } catch {
+    }
+    try {
+      db2.exec(`ALTER TABLE team_tasks ADD COLUMN preferred_role TEXT`);
+    } catch {
+    }
+    try {
+      db2.exec(`ALTER TABLE team_messages ADD COLUMN to_role TEXT`);
+    } catch {
+    }
+    try {
+      db2.exec(`ALTER TABLE team_messages ADD COLUMN handoff_status TEXT`);
+    } catch {
+    }
+    applySchemaMigrations(db2);
+    db2.exec(CREATE_INDEXES);
+    initializeObservationLexicalIndex(db2);
+    db2.prepare(`INSERT OR IGNORE INTO meta (key, value) VALUES ('storage_generation', '0')`).run();
+    db2.prepare(`INSERT OR IGNORE INTO meta (key, value) VALUES ('next_id', '1')`).run();
+    db2.prepare(`INSERT OR IGNORE INTO meta (key, value) VALUES ('mini_skills_generation', '0')`).run();
+    _dbCache.set(normalized, db2);
+    return db2;
+  } catch (error) {
+    try {
+      db2?.close();
+    } catch {
+    }
+    throw error;
   }
-  applySchemaMigrations(db2);
-  db2.exec(CREATE_INDEXES);
-  initializeObservationLexicalIndex(db2);
-  db2.prepare(`INSERT OR IGNORE INTO meta (key, value) VALUES ('storage_generation', '0')`).run();
-  db2.prepare(`INSERT OR IGNORE INTO meta (key, value) VALUES ('next_id', '1')`).run();
-  db2.prepare(`INSERT OR IGNORE INTO meta (key, value) VALUES ('mini_skills_generation', '0')`).run();
-  _dbCache.set(normalized, db2);
-  return db2;
 }
 function closeAllDatabases() {
   for (const [key, db2] of _dbCache) {
@@ -2329,6 +2338,74 @@ var init_types = __esm({
   }
 });
 
+// src/store/sqlite-reliability.ts
+function isTransientSqliteError(error) {
+  const code = error?.code;
+  if (typeof code === "string") {
+    return /^SQLITE_BUSY(?:_|$)/i.test(code);
+  }
+  return error instanceof Error && /\bdatabase is locked\b|\bdatabase is busy\b/i.test(error.message);
+}
+function isSqliteUnavailableError(error) {
+  return error instanceof SqliteUnavailableError || error instanceof Error && /SQLite is not available|better-sqlite3.*failed|node:sqlite.*failed|bun:sqlite.*failed/i.test(error.message);
+}
+function degradedReadError(storeName) {
+  return new Error(`[memorix] Cannot read ${storeName}: SQLite backend unavailable (memory is not loaded)`);
+}
+function degradedWriteError(storeName) {
+  return new Error(`[memorix] Cannot write ${storeName}: SQLite backend unavailable (degraded mode; read-only)`);
+}
+function formatSqliteFailure(error) {
+  return error instanceof Error && error.message ? error.message : String(error);
+}
+function delay(ms) {
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
+}
+async function retrySqliteBusy(operation, label) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (!isTransientSqliteError(error) || attempt >= SQLITE_BUSY_RETRY_DELAYS_MS.length) throw error;
+      const waitMs = SQLITE_BUSY_RETRY_DELAYS_MS[attempt];
+      console.error(
+        `[memorix] ${label} SQLite busy (attempt ${attempt + 1}/${SQLITE_BUSY_RETRY_DELAYS_MS.length + 1}), retrying in ${waitMs}ms`
+      );
+      await delay(waitMs);
+    }
+  }
+}
+async function initializeSqliteStore(factory, dataDir, label) {
+  try {
+    loadBetterSqlite3();
+  } catch (error) {
+    throw new SqliteUnavailableError(error);
+  }
+  return retrySqliteBusy(async () => {
+    const store = factory();
+    await store.init(dataDir);
+    return store;
+  }, label);
+}
+var SQLITE_BUSY_RETRY_DELAYS_MS, SqliteUnavailableError;
+var init_sqlite_reliability = __esm({
+  "src/store/sqlite-reliability.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sqlite_db();
+    SQLITE_BUSY_RETRY_DELAYS_MS = [50, 150, 400, 1e3, 2500];
+    SqliteUnavailableError = class extends Error {
+      code = "MEMORIX_SQLITE_UNAVAILABLE";
+      constructor(cause) {
+        super(
+          cause instanceof Error && cause.message ? cause.message : "[memorix] SQLite is unavailable (install a supported SQLite runtime)"
+        );
+        this.name = "SqliteUnavailableError";
+      }
+    };
+  }
+});
+
 // src/store/mini-skill-store.ts
 var mini_skill_store_exports = {};
 __export(mini_skill_store_exports, {
@@ -2400,16 +2477,18 @@ async function initMiniSkillStore(dataDir) {
   if (_store && _storeDataDir === dataDir) return _store;
   _store = null;
   _storeDataDir = null;
+  let degradedReason = "SQLite runtime unavailable";
   try {
-    const store2 = new MiniSkillSqliteStore();
-    await store2.init(dataDir);
+    const store2 = await initializeSqliteStore(() => new MiniSkillSqliteStore(), dataDir, "Mini-skill store");
     _store = store2;
     _storeDataDir = dataDir;
     return store2;
   } catch (err) {
-    console.error(`[memorix] MiniSkillSqliteStore unavailable, running in degraded read-only mode: ${err instanceof Error ? err.message : err}`);
+    if (!isSqliteUnavailableError(err)) throw err;
+    degradedReason = err instanceof Error ? err.message : String(err);
+    console.error(`[memorix] MiniSkillSqliteStore unavailable, running in degraded read-only mode: ${degradedReason}`);
   }
-  const store = new MiniSkillGracefulDegrade();
+  const store = new MiniSkillGracefulDegrade(degradedReason);
   await store.init(dataDir);
   _store = store;
   _storeDataDir = dataDir;
@@ -2421,6 +2500,7 @@ var init_mini_skill_store = __esm({
     "use strict";
     init_esm_shims();
     init_sqlite_db();
+    init_sqlite_reliability();
     MiniSkillSqliteStore = class {
       db = null;
       dataDir = "";
@@ -2529,7 +2609,7 @@ var init_mini_skill_store = __esm({
        * SQLite serializes write transactions, so concurrent calls are safely sequenced.
        */
       async atomicInsertWithId(skillWithoutId) {
-        const result = this.db.transaction(() => {
+        return retrySqliteBusy(async () => this.db.transaction(() => {
           const row = this.stmtGetMeta.get("mini_skills_next_id");
           const nextId2 = row ? parseInt(row.value, 10) : 1;
           const skill2 = { ...skillWithoutId, id: nextId2 };
@@ -2538,8 +2618,7 @@ var init_mini_skill_store = __esm({
           this.stmtBumpGeneration.run();
           this.knownGeneration = this.readGeneration();
           return skill2;
-        })();
-        return result;
+        })(), "Mini-skill promotion");
       }
       // ── Freshness ────────────────────────────────────────────────────
       async ensureFresh() {
@@ -2558,10 +2637,17 @@ var init_mini_skill_store = __esm({
       }
     };
     MiniSkillGracefulDegrade = class {
+      constructor(reason = "SQLite runtime unavailable") {
+        this.reason = reason;
+      }
+      reason;
       warned = false;
+      unavailableRead() {
+        return degradedReadError("mini-skills");
+      }
       warn() {
         if (!this.warned) {
-          console.error("[memorix] MiniSkillStore: SQLite unavailable \u2014 mini-skills are disabled (read-only empty). Install better-sqlite3 for full functionality.");
+          console.error("[memorix] MiniSkillStore: SQLite unavailable \u2014 mini-skills cannot be read or written. Install a supported SQLite runtime.");
           this.warned = true;
         }
       }
@@ -2569,28 +2655,33 @@ var init_mini_skill_store = __esm({
         this.warn();
       }
       async loadAll() {
-        return [];
+        throw this.unavailableRead();
       }
       async loadByProject(_projectId) {
-        return [];
+        throw this.unavailableRead();
       }
       async loadIdCounter() {
-        return 1;
+        throw this.unavailableRead();
       }
       async insert(_skill) {
         this.warn();
+        throw degradedWriteError("mini-skills");
       }
       async update(_skill) {
         this.warn();
+        throw degradedWriteError("mini-skills");
       }
       async remove(_id) {
         this.warn();
+        throw degradedWriteError("mini-skills");
       }
       async saveIdCounter(_nextId) {
+        this.warn();
+        throw degradedWriteError("mini-skills");
       }
       async atomicInsertWithId(skillWithoutId) {
         this.warn();
-        return { ...skillWithoutId, id: 0 };
+        throw degradedWriteError("mini-skills");
       }
       async ensureFresh() {
         return false;
@@ -2601,6 +2692,9 @@ var init_mini_skill_store = __esm({
       getBackendName() {
         return "degraded";
       }
+      getBackendReason() {
+        return this.reason;
+      }
     };
     _store = null;
     _storeDataDir = null;
@@ -4855,10 +4949,10 @@ async function fetchWithRetry(url, apiKey, body, options = {}, attempt = 0, nati
       );
     }
     if (options.retry !== false && (response.status === 429 || response.status >= 500) && attempt < MAX_RETRIES2) {
-      const delay2 = BASE_DELAY_MS * Math.pow(2, attempt);
+      const delay3 = BASE_DELAY_MS * Math.pow(2, attempt);
       const retryAfter = response.headers.get("retry-after");
       const parsedRetryAfter = retryAfter ? parseInt(retryAfter, 10) * 1e3 : NaN;
-      const waitMs = Number.isFinite(parsedRetryAfter) ? parsedRetryAfter : delay2;
+      const waitMs = Number.isFinite(parsedRetryAfter) ? parsedRetryAfter : delay3;
       console.error(`[memorix] Embedding API ${response.status}, retry ${attempt + 1}/${MAX_RETRIES2} in ${waitMs}ms`);
       await waitForRetry(waitMs, options.signal);
       return fetchWithRetry(url, apiKey, body, options, attempt + 1, nativeGemini);
@@ -6890,6 +6984,7 @@ var init_sqlite_store = __esm({
     "use strict";
     init_esm_shims();
     init_sqlite_db();
+    init_sqlite_reliability();
     init_sqlite_fts();
     SqliteBackend = class {
       db = null;
@@ -7167,7 +7262,9 @@ var init_sqlite_store = __esm({
       // ── Compound atomic operation ────────────────────────────────────
       async atomic(fn) {
         const run = this._atomicQueue.catch(() => void 0).then(async () => {
-          this.db.prepare("BEGIN IMMEDIATE").run();
+          await retrySqliteBusy(async () => {
+            this.db.prepare("BEGIN IMMEDIATE").run();
+          }, "Observation atomic write");
           try {
             const tx = {
               loadAll: async () => this.rawLoadAll(),
@@ -7266,15 +7363,15 @@ function resetObservationStore() {
 async function createObservationStore(dataDir) {
   try {
     const { SqliteBackend: SqliteBackend2 } = await Promise.resolve().then(() => (init_sqlite_store(), sqlite_store_exports));
-    const store2 = new SqliteBackend2();
-    await store2.init(dataDir);
-    return store2;
+    return await initializeSqliteStore(() => new SqliteBackend2(), dataDir, "Observation store");
   } catch (err) {
-    console.error(`[memorix] SQLite backend unavailable \u2014 degraded mode (read-only): ${err instanceof Error ? err.message : err}`);
+    if (!isSqliteUnavailableError(err)) throw err;
+    const reason = formatSqliteFailure(err);
+    console.error(`[memorix] SQLite module unavailable \u2014 degraded mode (reads/writes disabled): ${reason}`);
+    const degraded = new DegradedBackend(reason);
+    await degraded.init(dataDir);
+    return degraded;
   }
-  const store = new DegradedBackend();
-  await store.init(dataDir);
-  return store;
 }
 async function initObservationStore(dataDir) {
   if (_store2 && _storeDataDir2 === dataDir) {
@@ -7298,36 +7395,44 @@ var init_obs_store = __esm({
   "src/store/obs-store.ts"() {
     "use strict";
     init_esm_shims();
+    init_sqlite_reliability();
     _store2 = null;
     _storeDataDir2 = null;
     DegradedBackend = class {
+      constructor(reason = "SQLite runtime unavailable") {
+        this.reason = reason;
+      }
+      reason;
       dataDir = "";
+      unavailableRead() {
+        return degradedReadError("observations");
+      }
       async init(dataDir) {
         this.dataDir = dataDir;
       }
       async loadAll() {
-        return [];
+        throw this.unavailableRead();
       }
       async loadByProject(_projectId, _options) {
-        return [];
+        throw this.unavailableRead();
       }
       async countByProject(_projectId, _options) {
-        return 0;
+        throw this.unavailableRead();
       }
       async getById(_id) {
-        return void 0;
+        throw this.unavailableRead();
       }
       async loadIdCounter() {
-        return 1;
+        throw this.unavailableRead();
       }
       async countAll() {
-        return 0;
+        throw this.unavailableRead();
       }
       async listProjectIds() {
-        return [];
+        throw this.unavailableRead();
       }
       async searchLexical(_options) {
-        return [];
+        throw this.unavailableRead();
       }
       hasLexicalIndex() {
         return false;
@@ -7336,25 +7441,25 @@ var init_obs_store = __esm({
         return false;
       }
       async insert(_obs) {
-        throw new Error("[memorix] Cannot write observations: SQLite backend unavailable (degraded mode)");
+        throw degradedWriteError("observations");
       }
       async update(_obs) {
-        throw new Error("[memorix] Cannot write observations: SQLite backend unavailable (degraded mode)");
+        throw degradedWriteError("observations");
       }
       async remove(_id) {
-        throw new Error("[memorix] Cannot write observations: SQLite backend unavailable (degraded mode)");
+        throw degradedWriteError("observations");
       }
       async bulkReplace(_obs) {
-        throw new Error("[memorix] Cannot write observations: SQLite backend unavailable (degraded mode)");
+        throw degradedWriteError("observations");
       }
       async bulkRemoveByIds(_ids) {
-        throw new Error("[memorix] Cannot write observations: SQLite backend unavailable (degraded mode)");
+        throw degradedWriteError("observations");
       }
       async saveIdCounter(_nextId) {
-        throw new Error("[memorix] Cannot write observations: SQLite backend unavailable (degraded mode)");
+        throw degradedWriteError("observations");
       }
       async atomic(_fn) {
-        throw new Error("[memorix] Cannot write observations: SQLite backend unavailable (degraded mode)");
+        throw degradedWriteError("observations");
       }
       async ensureFresh() {
         return false;
@@ -7367,6 +7472,9 @@ var init_obs_store = __esm({
       getBackendName() {
         return "degraded";
       }
+      getBackendReason() {
+        return this.reason;
+      }
     };
   }
 });
@@ -10882,7 +10990,8 @@ function clampCursor(afterId) {
 }
 async function loadConsolidationPage(projectId, options) {
   const limit2 = clampBatchSize(options.limit);
-  const page = await getObservationStore().loadByProject(projectId, {
+  const store = options.store ?? getObservationStore();
+  const page = await store.loadByProject(projectId, {
     status: "active",
     afterId: clampCursor(options.afterId),
     limit: limit2 + 1
@@ -10942,7 +11051,7 @@ async function findConsolidationCandidates(_projectDir, projectId, opts) {
   return findClusters(page.observations, threshold);
 }
 async function executeConsolidation(_projectDir, projectId, opts) {
-  const store = getObservationStore();
+  const store = opts?.store ?? getObservationStore();
   const page = await loadConsolidationPage(projectId, opts ?? {});
   const clusters = findClusters(page.observations, opts?.threshold ?? DEFAULT_SIMILARITY_THRESHOLD);
   if (clusters.length === 0) {
@@ -56962,10 +57071,10 @@ var require_retry3 = __commonJS({
       if (!await shouldRetryFn(err)) {
         return { shouldRetry: false, config: err.config };
       }
-      const delay2 = getNextRetryDelay(config);
+      const delay3 = getNextRetryDelay(config);
       err.config.retryConfig.currentRetryAttempt += 1;
-      const backoff = config.retryBackoff ? config.retryBackoff(err, delay2) : new Promise((resolve5) => {
-        setTimeout(resolve5, delay2);
+      const backoff = config.retryBackoff ? config.retryBackoff(err, delay3) : new Promise((resolve5) => {
+        setTimeout(resolve5, delay3);
       });
       if (config.onRetryAttempt) {
         await config.onRetryAttempt(err);
@@ -98751,7 +98860,7 @@ async function retryBackoff(fn, strategy) {
         retryInterval = initialInterval * Math.pow(x2, exponent) + Math.random() * 1e3;
       }
       const d = Math.min(retryInterval, maxInterval);
-      await delay(d);
+      await delay2(d);
       x2++;
     }
   }
@@ -98772,8 +98881,8 @@ function retryIntervalFromResponse(res) {
   }
   return 0;
 }
-async function delay(delay2) {
-  return new Promise((resolve5) => setTimeout(resolve5, delay2));
+async function delay2(delay3) {
+  return new Promise((resolve5) => setTimeout(resolve5, delay3));
 }
 var defaultBackoff, PermanentError, TemporaryError, codeRangeRE2;
 var init_retries = __esm({
@@ -148882,7 +148991,7 @@ __export(lite_provider_exports, {
   refreshProjectLite: () => refreshProjectLite
 });
 import { createHash as createHash10 } from "crypto";
-import { readdirSync as readdirSync2, readFileSync as readFileSync8, statSync as statSync3 } from "fs";
+import { existsSync as existsSync12, readdirSync as readdirSync2, readFileSync as readFileSync8, statSync as statSync3 } from "fs";
 import { join as join4, relative as relative2 } from "path";
 function hashText2(text3) {
   return createHash10("sha256").update(text3).digest("hex");
@@ -148899,6 +149008,9 @@ function resolveMaxFileBytes(value) {
   if (!Number.isFinite(value)) return DEFAULT_CODEGRAPH_MAX_FILE_BYTES;
   return Math.max(1, Math.floor(value));
 }
+function isPythonVirtualenvDir(dir) {
+  return existsSync12(join4(dir, "pyvenv.cfg"));
+}
 function walk(root, exclude, maxFiles) {
   const out = [];
   const visit = (dir) => {
@@ -148916,6 +149028,7 @@ function walk(root, exclude, maxFiles) {
       if (entry.isDirectory()) {
         if (entry.name === ".git" || entry.name === ".worktrees" || entry.name === ".tmp" || entry.name === "node_modules") continue;
         if (rel === ".claude/worktrees" || rel.startsWith(".claude/worktrees/")) continue;
+        if (isPythonVirtualenvDir(abs)) continue;
         visit(abs);
         if (out.length >= maxFiles) return;
         continue;
@@ -152812,7 +152925,7 @@ __export(vector_backfill_runner_exports, {
 import { spawn as spawn4 } from "child_process";
 import {
   closeSync,
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   mkdirSync as mkdirSync2,
   openSync,
   readFileSync as readFileSync9,
@@ -152940,7 +153053,7 @@ function releaseVectorBackfillLock(lockPath = process.env.MEMORIX_VECTOR_BACKFIL
 }
 function launchDetachedVectorBackfill(request, options = {}) {
   const runnerPath = options.runnerPath ?? resolveVectorBackfillRunnerPath();
-  const exists = options.exists ?? existsSync12;
+  const exists = options.exists ?? existsSync13;
   if (!exists(runnerPath)) return false;
   const lock = acquireVectorBackfillLock(request.dataDir, request.projectId, options.lockPath);
   if (!lock) return false;
@@ -154225,16 +154338,18 @@ async function initSessionStore(dataDir) {
   if (_store3 && _storeDataDir3 === dataDir) return _store3;
   _store3 = null;
   _storeDataDir3 = null;
+  let degradedReason = "SQLite runtime unavailable";
   try {
-    const store2 = new SessionSqliteStore();
-    await store2.init(dataDir);
+    const store2 = await initializeSqliteStore(() => new SessionSqliteStore(), dataDir, "Session store");
     _store3 = store2;
     _storeDataDir3 = dataDir;
     return store2;
   } catch (err) {
-    console.error(`[memorix] SessionSqliteStore unavailable, running in degraded read-only mode: ${err instanceof Error ? err.message : err}`);
+    if (!isSqliteUnavailableError(err)) throw err;
+    degradedReason = formatSqliteFailure(err);
+    console.error(`[memorix] SessionSqliteStore unavailable, running in degraded read-only mode: ${degradedReason}`);
   }
-  const store = new SessionGracefulDegrade();
+  const store = new SessionGracefulDegrade(degradedReason);
   await store.init(dataDir);
   _store3 = store;
   _storeDataDir3 = dataDir;
@@ -154246,6 +154361,7 @@ var init_session_store = __esm({
     "use strict";
     init_esm_shims();
     init_sqlite_db();
+    init_sqlite_reliability();
     SessionSqliteStore = class {
       db = null;
       dataDir = "";
@@ -154334,7 +154450,7 @@ var init_session_store = __esm({
         }
         const stmtComplete = this._stmtCompleteActive;
         const stmtIns = this.stmtInsert;
-        const result = this.db.transaction(() => {
+        return retrySqliteBusy(async () => this.db.transaction(() => {
           let completedCount = 0;
           for (const pid of projectIds) {
             const info = stmtComplete.run({ pid, now: now3 });
@@ -154342,18 +154458,24 @@ var init_session_store = __esm({
           }
           stmtIns.run(sessionToRow(newSession));
           return completedCount;
-        })();
-        return result;
+        })(), "Session rollover");
       }
       getBackendName() {
         return "sqlite";
       }
     };
     SessionGracefulDegrade = class {
+      constructor(reason = "SQLite runtime unavailable") {
+        this.reason = reason;
+      }
+      reason;
       warned = false;
+      unavailableRead() {
+        return degradedReadError("sessions");
+      }
       warn() {
         if (!this.warned) {
-          console.error("[memorix] SessionStore: SQLite unavailable \u2014 sessions are disabled (read-only empty). Install better-sqlite3 for full functionality.");
+          console.error("[memorix] SessionStore: SQLite unavailable \u2014 sessions cannot be read or written. Install a supported SQLite runtime.");
           this.warned = true;
         }
       }
@@ -154361,33 +154483,39 @@ var init_session_store = __esm({
         this.warn();
       }
       async loadAll() {
-        return [];
+        throw this.unavailableRead();
       }
       async getById(_id) {
-        return void 0;
+        throw this.unavailableRead();
       }
       async loadByProject(_projectId) {
-        return [];
+        throw this.unavailableRead();
       }
       async loadActive(_projectId) {
-        return [];
+        throw this.unavailableRead();
       }
       async insert(_session) {
         this.warn();
+        throw degradedWriteError("sessions");
       }
       async update(_session) {
         this.warn();
+        throw degradedWriteError("sessions");
       }
       async bulkUpdate(_sessions) {
         this.warn();
+        throw degradedWriteError("sessions");
       }
       async atomicRolloverInsert(_newSession, _projectIds, _now) {
         this.warn();
-        return 0;
+        throw degradedWriteError("sessions");
       }
       getBackendName() {
         return "degraded";
       }
+      getBackendReason() {
+        return this.reason;
+      }
     };
     _store3 = null;
     _storeDataDir3 = null;
@@ -157861,7 +157989,7 @@ var init_sanitizer = __esm({
 });
 
 // src/workspace/applier.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync3, copyFileSync, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, renameSync } from "fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync3, copyFileSync, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, renameSync } from "fs";
 import { dirname } from "path";
 var WorkspaceSyncApplier;
 var init_applier = __esm({
@@ -157892,7 +158020,7 @@ var init_applier = __esm({
         for (const file of files) {
           try {
             const dir = dirname(file.filePath);
-            if (!existsSync13(dir)) {
+            if (!existsSync14(dir)) {
               mkdirSync3(dir, { recursive: true });
             }
           } catch (err) {
@@ -157901,7 +158029,7 @@ var init_applier = __esm({
           }
         }
         for (const file of files) {
-          if (existsSync13(file.filePath)) {
+          if (existsSync14(file.filePath)) {
             try {
               const backupPath = file.filePath + `.backup-${Date.now()}`;
               copyFileSync(file.filePath, backupPath);
@@ -157952,7 +158080,7 @@ var init_applier = __esm({
       cleanBackups(backups) {
         for (const backup of backups) {
           try {
-            if (existsSync13(backup.backupPath)) {
+            if (existsSync14(backup.backupPath)) {
               unlinkSync2(backup.backupPath);
             }
           } catch {
@@ -157964,7 +158092,7 @@ var init_applier = __esm({
 });
 
 // src/workspace/engine.ts
-import { readFileSync as readFileSync10, readdirSync as readdirSync3, existsSync as existsSync14, cpSync, mkdirSync as mkdirSync4 } from "fs";
+import { readFileSync as readFileSync10, readdirSync as readdirSync3, existsSync as existsSync15, cpSync, mkdirSync as mkdirSync4 } from "fs";
 import { join as join19 } from "path";
 import { homedir as homedir21 } from "os";
 var WorkspaceSyncEngine;
@@ -158044,7 +158172,7 @@ var init_engine4 = __esm({
           }
           const merged = /* @__PURE__ */ new Map();
           for (const path38 of pathsToCheck) {
-            if (existsSync14(path38)) {
+            if (existsSync15(path38)) {
               try {
                 const content = readFileSync10(path38, "utf-8");
                 const servers = adapter.parse(content);
@@ -158098,7 +158226,7 @@ var init_engine4 = __esm({
           const adapter = this.adapters.get(target);
           const configPath = adapter.getConfigPath(this.projectRoot);
           let configContent;
-          if (target === "antigravity" && existsSync14(configPath)) {
+          if (target === "antigravity" && existsSync15(configPath)) {
             try {
               const existing = JSON.parse(readFileSync10(configPath, "utf-8"));
               const generated = JSON.parse(adapter.generate(result.mcpServers.scanned));
@@ -158174,13 +158302,13 @@ var init_engine4 = __esm({
               join19(home, dir)
             ];
             for (const skillsRoot of paths) {
-              if (!existsSync14(skillsRoot)) continue;
+              if (!existsSync15(skillsRoot)) continue;
               try {
                 const entries = readdirSync3(skillsRoot, { withFileTypes: true });
                 for (const entry of entries) {
                   if (!entry.isDirectory()) continue;
                   const skillMd = join19(skillsRoot, entry.name, "SKILL.md");
-                  if (!existsSync14(skillMd)) continue;
+                  if (!existsSync15(skillMd)) continue;
                   let description = "";
                   try {
                     const content = readFileSync10(skillMd, "utf-8");
@@ -158229,7 +158357,7 @@ var init_engine4 = __esm({
         for (const skill2 of skills) {
           if (skill2.sourceAgent === target) continue;
           const dest = join19(targetDir, skill2.name);
-          if (existsSync14(dest)) {
+          if (existsSync15(dest)) {
             skipped.push(`${skill2.name} (already exists in ${target})`);
             continue;
           }
@@ -158245,7 +158373,7 @@ var init_engine4 = __esm({
       scanWorkflows() {
         const workflows = [];
         const wfDir = join19(this.projectRoot, ".windsurf", "workflows");
-        if (!existsSync14(wfDir)) return workflows;
+        if (!existsSync15(wfDir)) return workflows;
         try {
           const files = readdirSync3(wfDir).filter((f3) => f3.endsWith(".md"));
           for (const file of files) {
@@ -159643,7 +159771,7 @@ var init_request_context = __esm({
 function getMcpServerInfo() {
   return {
     name: "memorix",
-    version: true ? "1.9.1" : "1.0.1"
+    version: true ? "1.9.3" : "1.0.1"
   };
 }
 function createMcpDiscoverResult(capabilities, serverInfo) {
@@ -159711,7 +159839,7 @@ __export(behavior_exports, {
   getBehaviorConfig: () => getBehaviorConfig,
   resetBehaviorConfigCache: () => resetBehaviorConfigCache
 });
-import { existsSync as existsSync15, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync11 } from "fs";
 import { homedir as homedir22 } from "os";
 function isSessionInject(value) {
   return value === "full" || value === "minimal" || value === "silent";
@@ -159722,7 +159850,7 @@ function isFormationMode(value) {
 function legacyBehavior(homeDir) {
   const configPath = getLegacyConfigJsonPath(homeDir);
   try {
-    if (!existsSync15(configPath)) return {};
+    if (!existsSync16(configPath)) return {};
     const parsed = JSON.parse(readFileSync11(configPath, "utf-8"));
     return parsed.behavior && typeof parsed.behavior === "object" && !Array.isArray(parsed.behavior) ? parsed.behavior : {};
   } catch {
@@ -161076,11 +161204,11 @@ __export(current_facts_exports, {
   formatGitFact: () => formatGitFact
 });
 import { execFileSync } from "child_process";
-import { existsSync as existsSync16, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync12 } from "fs";
 import path29 from "path";
 function readTextIfExists(filePath) {
   try {
-    if (!existsSync16(filePath)) return null;
+    if (!existsSync17(filePath)) return null;
     return readFileSync12(filePath, "utf8");
   } catch {
     return null;
@@ -161371,7 +161499,7 @@ __export(external_provider_exports, {
   runExternalCodeGraphLifecycle: () => runExternalCodeGraphLifecycle
 });
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync17, readFileSync as readFileSync13 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync13 } from "fs";
 import { delimiter, dirname as dirname2, extname, isAbsolute as isAbsolute3, join as join20, relative as relative4, resolve as resolve3, sep } from "path";
 function boundedTimeout(value) {
   if (!Number.isFinite(value)) return DEFAULT_EXTERNAL_CODEGRAPH_TIMEOUT_MS;
@@ -161408,13 +161536,13 @@ function resolveCommandCandidates(command) {
 }
 function resolveLaunch(command) {
   for (const candidate of resolveCommandCandidates(command)) {
-    if (!existsSync17(candidate)) continue;
+    if (!existsSync18(candidate)) continue;
     const extension3 = extname(candidate).toLowerCase();
     if (extension3 === ".cmd") {
       const bundleRoot = resolve3(dirname2(candidate), "..");
       const node = join20(bundleRoot, "node.exe");
       const entry = join20(bundleRoot, "lib", "dist", "bin", "codegraph.js");
-      if (existsSync17(node) && existsSync17(entry)) {
+      if (existsSync18(node) && existsSync18(entry)) {
         return { executable: node, prefixArgs: ["--liftoff-only", entry] };
       }
       try {
@@ -161423,7 +161551,7 @@ function resolveLaunch(command) {
         if (match2?.[1]) {
           const base = dirname2(candidate).endsWith(sep) ? dirname2(candidate) : dirname2(candidate) + sep;
           const entry2 = resolve3(match2[1].replace(/%(?:~)?dp0%?/gi, base));
-          if (existsSync17(entry2)) return { executable: process.execPath, prefixArgs: [entry2] };
+          if (existsSync18(entry2)) return { executable: process.execPath, prefixArgs: [entry2] };
         }
       } catch {
       }
@@ -161571,7 +161699,7 @@ async function inspectExternalCodeGraph(input) {
     const health2 = { state: "disabled", reason: "External CodeGraph is disabled by configuration." };
     return { health: health2, quality: providerQuality({ mode, health: health2 }) };
   }
-  if (!existsSync17(join20(input.projectRoot, ".codegraph"))) {
+  if (!existsSync18(join20(input.projectRoot, ".codegraph"))) {
     const health2 = { state: "not-detected", reason: "No local .codegraph index is present for this project." };
     return { health: health2, quality: providerQuality({ mode, health: health2 }) };
   }
@@ -161607,7 +161735,7 @@ async function runExternalCodeGraphLifecycle(input) {
     };
   }
   const indexPath = join20(input.projectRoot, ".codegraph");
-  if (input.action === "sync" && !existsSync17(indexPath)) {
+  if (input.action === "sync" && !existsSync18(indexPath)) {
     const health = { state: "not-detected", reason: "No local .codegraph index is present for this project." };
     return {
       action: input.action,
@@ -161617,7 +161745,7 @@ async function runExternalCodeGraphLifecycle(input) {
       quality: providerQuality({ mode, health })
     };
   }
-  if (input.action === "init" && existsSync17(indexPath)) {
+  if (input.action === "init" && existsSync18(indexPath)) {
     const inspected2 = await inspectExternalCodeGraph(input);
     return {
       action: input.action,
@@ -162678,7 +162806,7 @@ __export(auto_context_exports, {
   formatAutoProjectContextSummary: () => formatAutoProjectContextSummary,
   formatLegacyAutoProjectContextPrompt: () => formatLegacyAutoProjectContextPrompt
 });
-import { existsSync as existsSync18, statSync as statSync5 } from "fs";
+import { existsSync as existsSync19, statSync as statSync5 } from "fs";
 import path30 from "path";
 function activeProjectObservations(observations2, projectId) {
   return observations2.filter((obs) => obs.projectId === projectId && (obs.status ?? "active") === "active");
@@ -163024,7 +163152,7 @@ function existingLensCandidates(rootPath, lens) {
   for (const candidate of lensPathCandidates(lens)) {
     const absolute = path30.join(rootPath, candidate);
     try {
-      if (!existsSync18(absolute)) continue;
+      if (!existsSync19(absolute)) continue;
       const stat5 = statSync5(absolute);
       if (stat5.isFile()) out.push(candidate);
       if (stat5.isDirectory()) out.push(candidate.replace(/\\/g, "/"));
@@ -163558,7 +163686,7 @@ var engine_exports2 = {};
 __export(engine_exports2, {
   SkillsEngine: () => SkillsEngine
 });
-import { existsSync as existsSync19, readFileSync as readFileSync14, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, readdirSync as readdirSync4 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync14, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, readdirSync as readdirSync4 } from "fs";
 import { join as join21 } from "path";
 import { homedir as homedir23 } from "os";
 var SKILLS_DIRS, SKILL_WORTHY_TYPES, MIN_OBS_FOR_SKILL, MIN_SCORE_FOR_SKILL, LOW_SIGNAL_TITLE_PATTERNS, LOW_SIGNAL_ENTITY_PATTERNS, COMMAND_TRACE_PATTERNS2, SkillsEngine;
@@ -163639,7 +163767,7 @@ var init_engine5 = __esm({
               paths.push(join21(home, dir));
             }
             for (const skillsRoot of paths) {
-              if (!existsSync19(skillsRoot)) continue;
+              if (!existsSync20(skillsRoot)) continue;
               try {
                 const entries = readdirSync4(skillsRoot, { withFileTypes: true });
                 for (const entry of entries) {
@@ -163647,7 +163775,7 @@ var init_engine5 = __esm({
                   const name = entry.name;
                   if (seen.has(name)) continue;
                   const skillMd = join21(skillsRoot, name, "SKILL.md");
-                  if (!existsSync19(skillMd)) continue;
+                  if (!existsSync20(skillMd)) continue;
                   try {
                     const content = readFileSync14(skillMd, "utf-8");
                     const description = this.parseDescription(content);
@@ -165448,7 +165576,8 @@ async function executeDeduplicate(context, payload, token) {
 async function previewConsolidate(context) {
   const clusters = await findConsolidationCandidates(
     context.projectRoot ?? context.dataDir,
-    context.projectId
+    context.projectId,
+    { store: context.store }
   );
   const payload = { clusterIds: normalizeClusters(clusters.map((cluster) => cluster.ids)) };
   return {
@@ -165471,11 +165600,19 @@ async function executeConsolidate(context, payload, token) {
   const clusterIds = record80.clusterIds.map((ids, index) => payloadIds(ids, `clusterIds[${index}]`));
   const normalized = { clusterIds: normalizeClusters(clusterIds) };
   verify("consolidate", context.projectId, normalized, token);
-  const current = await findConsolidationCandidates(context.projectRoot ?? context.dataDir, context.projectId);
+  const current = await findConsolidationCandidates(
+    context.projectRoot ?? context.dataDir,
+    context.projectId,
+    { store: context.store }
+  );
   if (JSON.stringify(normalized.clusterIds) !== JSON.stringify(normalizeClusters(current.map((cluster) => cluster.ids)))) {
     throw new DashboardMaintenanceError("Memory changed after the preview. Refresh before consolidating.", 409);
   }
-  const result = await executeConsolidation(context.projectRoot ?? context.dataDir, context.projectId);
+  const result = await executeConsolidation(
+    context.projectRoot ?? context.dataDir,
+    context.projectId,
+    { store: context.store }
+  );
   return { action: "consolidate", projectId: context.projectId, ...result };
 }
 async function retentionCandidates(context) {
@@ -166632,7 +166769,7 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
       }
       case "/config": {
         const os6 = await import("os");
-        const { existsSync: existsSync22 } = await import("fs");
+        const { existsSync: existsSync23 } = await import("fs");
         const { join: join26 } = await import("path");
         const configProjectRoot = effectiveProjectRoot;
         const resolved = getResolvedConfig({ projectRoot: configProjectRoot });
@@ -166660,7 +166797,7 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
             if (fpath === null) {
               files[key] = { exists: false, path: "unavailable", unavailable: true };
             } else {
-              files[key] = { exists: existsSync22(fpath), path: fpath };
+              files[key] = { exists: existsSync23(fpath), path: fpath };
             }
           }
         } catch {
@@ -167470,7 +167607,7 @@ var init_task_graph = __esm({
 
 // src/orchestrate/context-collector.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { readFileSync as readFileSync15, existsSync as existsSync20 } from "fs";
+import { readFileSync as readFileSync15, existsSync as existsSync21 } from "fs";
 import { join as join22 } from "path";
 function normalizeEntryLimit(value, fallback) {
   if (!Number.isSafeInteger(value) || value < 1) return fallback;
@@ -167547,7 +167684,7 @@ function collectFileTree(projectDir2, maxEntries) {
 function collectDependencies(projectDir2) {
   try {
     const pkgPath = join22(projectDir2, "package.json");
-    if (!existsSync20(pkgPath)) return "";
+    if (!existsSync21(pkgPath)) return "";
     const pkg = JSON.parse(readFileSync15(pkgPath, "utf-8"));
     const parts = [];
     if (pkg.dependencies && Object.keys(pkg.dependencies).length > 0) {
@@ -170048,11 +170185,11 @@ __export(hooks_path_exports, {
   resolveGitDir: () => resolveGitDir,
   resolveHooksDir: () => resolveHooksDir
 });
-import { existsSync as existsSync21, readFileSync as readFileSync16, statSync as statSync6, mkdirSync as mkdirSync6 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync16, statSync as statSync6, mkdirSync as mkdirSync6 } from "fs";
 import path35 from "path";
 function resolveGitDir(projectRoot) {
   const dotGit = path35.join(projectRoot, ".git");
-  if (!existsSync21(dotGit)) return null;
+  if (!existsSync22(dotGit)) return null;
   const stat5 = statSync6(dotGit);
   if (stat5.isDirectory()) {
     return dotGit;
@@ -170064,7 +170201,7 @@ function resolveGitDir(projectRoot) {
       if (match2) {
         const gitdir = match2[1].trim();
         const resolved = path35.isAbsolute(gitdir) ? gitdir : path35.resolve(projectRoot, gitdir);
-        if (existsSync21(resolved)) {
+        if (existsSync22(resolved)) {
           return resolved;
         }
       }
@@ -174659,10 +174796,10 @@ Preview: ${analysis.description.slice(0, 300)}${analysis.description.length > 30
         const { ensureHooksDir: ensureHooksDir2 } = await Promise.resolve().then(() => (init_hooks_path(), hooks_path_exports));
         const resolved = ensureHooksDir2(project.rootPath);
         if (resolved) {
-          const { existsSync: existsSync22, readFileSync: readFileSync17, writeFileSync: writeFileSync5, chmodSync } = await import("fs");
+          const { existsSync: existsSync23, readFileSync: readFileSync17, writeFileSync: writeFileSync5, chmodSync } = await import("fs");
           const { hookPath } = resolved;
           const HOOK_MARKER = "# [memorix-git-hook]";
-          const needsInstall = !existsSync22(hookPath) || !readFileSync17(hookPath, "utf-8").includes(HOOK_MARKER);
+          const needsInstall = !existsSync23(hookPath) || !readFileSync17(hookPath, "utf-8").includes(HOOK_MARKER);
           if (needsInstall) {
             const hookScript = `#!/bin/sh
 ${HOOK_MARKER}
@@ -174671,7 +174808,7 @@ if command -v memorix >/dev/null 2>&1; then
   memorix ingest commit --auto >/dev/null 2>&1 &
 fi
 `;
-            if (existsSync22(hookPath)) {
+            if (existsSync23(hookPath)) {
               const existing = readFileSync17(hookPath, "utf-8");
               writeFileSync5(hookPath, existing.trimEnd() + `
 
@@ -175343,7 +175480,7 @@ var init_serve_shared = __esm({
 
 // src/cli/version.ts
 function getCliVersion() {
-  return true ? "1.9.1" : pkg.version;
+  return true ? "1.9.3" : pkg.version;
 }
 var init_version3 = __esm({
   "src/cli/version.ts"() {