memorix 1.9.2 → 1.9.3

package/dist/sdk.js

@@ -468,70 +468,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 closeDatabase(dataDir) {
   const normalized = path3.resolve(dataDir);
@@ -2369,6 +2378,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, {
@@ -2440,16 +2517,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;
@@ -2461,6 +2540,7 @@ var init_mini_skill_store = __esm({
     "use strict";
     init_esm_shims();
     init_sqlite_db();
+    init_sqlite_reliability();
     MiniSkillSqliteStore = class {
       db = null;
       dataDir = "";
@@ -2569,7 +2649,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 };
@@ -2578,8 +2658,7 @@ var init_mini_skill_store = __esm({
           this.stmtBumpGeneration.run();
           this.knownGeneration = this.readGeneration();
           return skill2;
-        })();
-        return result;
+        })(), "Mini-skill promotion");
       }
       // ── Freshness ────────────────────────────────────────────────────
       async ensureFresh() {
@@ -2598,10 +2677,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;
         }
       }
@@ -2609,28 +2695,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;
@@ -2641,6 +2732,9 @@ var init_mini_skill_store = __esm({
       getBackendName() {
         return "degraded";
       }
+      getBackendReason() {
+        return this.reason;
+      }
     };
     _store = null;
     _storeDataDir = null;
@@ -4843,10 +4937,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);
@@ -6878,6 +6972,7 @@ var init_sqlite_store = __esm({
     "use strict";
     init_esm_shims();
     init_sqlite_db();
+    init_sqlite_reliability();
     init_sqlite_fts();
     SqliteBackend = class {
       db = null;
@@ -7155,7 +7250,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(),
@@ -7254,15 +7351,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) {
@@ -7286,36 +7383,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;
@@ -7324,25 +7429,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;
@@ -7355,6 +7460,9 @@ var init_obs_store = __esm({
       getBackendName() {
         return "degraded";
       }
+      getBackendReason() {
+        return this.reason;
+      }
     };
   }
 });
@@ -57009,10 +57117,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);
@@ -98798,7 +98906,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++;
     }
   }
@@ -98819,8 +98927,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({
@@ -154276,16 +154384,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;
@@ -154297,6 +154407,7 @@ var init_session_store = __esm({
     "use strict";
     init_esm_shims();
     init_sqlite_db();
+    init_sqlite_reliability();
     SessionSqliteStore = class {
       db = null;
       dataDir = "";
@@ -154385,7 +154496,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 });
@@ -154393,18 +154504,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;
         }
       }
@@ -154412,33 +154529,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;
@@ -169896,7 +170019,7 @@ var MCP_SERVER_INFO_META_KEY = "io.modelcontextprotocol/serverInfo";
 function getMcpServerInfo() {
   return {
     name: "memorix",
-    version: true ? "1.9.2" : "1.0.1"
+    version: true ? "1.9.3" : "1.0.1"
   };
 }
 function createMcpDiscoverResult(capabilities, serverInfo) {