memorix 1.9.2 → 1.9.3

package/dist/cli/index.js

@@ -3232,7 +3232,7 @@ ${import_picocolors.default.gray(m3)}  ${s4}
 
 // src/cli/version.ts
 function getCliVersion() {
-  return true ? "1.9.2" : pkg.version;
+  return true ? "1.9.3" : pkg.version;
 }
 var init_version = __esm({
   "src/cli/version.ts"() {
@@ -9515,70 +9515,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 (error40) {
+    try {
+      db2?.close();
+    } catch {
+    }
+    throw error40;
   }
-  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) {
@@ -10568,6 +10577,74 @@ CREATE UNIQUE INDEX IF NOT EXISTS idx_maintenance_jobs_active_dedupe
   }
 });
 
+// src/store/sqlite-reliability.ts
+function isTransientSqliteError(error40) {
+  const code = error40?.code;
+  if (typeof code === "string") {
+    return /^SQLITE_BUSY(?:_|$)/i.test(code);
+  }
+  return error40 instanceof Error && /\bdatabase is locked\b|\bdatabase is busy\b/i.test(error40.message);
+}
+function isSqliteUnavailableError(error40) {
+  return error40 instanceof SqliteUnavailableError || error40 instanceof Error && /SQLite is not available|better-sqlite3.*failed|node:sqlite.*failed|bun:sqlite.*failed/i.test(error40.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(error40) {
+  return error40 instanceof Error && error40.message ? error40.message : String(error40);
+}
+function delay(ms2) {
+  return new Promise((resolve9) => setTimeout(resolve9, ms2));
+}
+async function retrySqliteBusy(operation, label) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await operation();
+    } catch (error40) {
+      if (!isTransientSqliteError(error40) || attempt >= SQLITE_BUSY_RETRY_DELAYS_MS.length) throw error40;
+      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 (error40) {
+    throw new SqliteUnavailableError(error40);
+  }
+  return retrySqliteBusy(async () => {
+    const store2 = factory();
+    await store2.init(dataDir);
+    return store2;
+  }, 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/file-lock.ts
 import { promises as fs2 } from "fs";
 import { randomUUID } from "crypto";
@@ -11065,16 +11142,18 @@ async function initMiniSkillStore(dataDir) {
   if (_store && _storeDataDir === dataDir) return _store;
   _store = null;
   _storeDataDir = null;
+  let degradedReason = "SQLite runtime unavailable";
   try {
-    const store3 = new MiniSkillSqliteStore();
-    await store3.init(dataDir);
+    const store3 = await initializeSqliteStore(() => new MiniSkillSqliteStore(), dataDir, "Mini-skill store");
     _store = store3;
     _storeDataDir = dataDir;
     return store3;
   } 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 store2 = new MiniSkillGracefulDegrade();
+  const store2 = new MiniSkillGracefulDegrade(degradedReason);
   await store2.init(dataDir);
   _store = store2;
   _storeDataDir = dataDir;
@@ -11086,6 +11165,7 @@ var init_mini_skill_store = __esm({
     "use strict";
     init_esm_shims();
     init_sqlite_db();
+    init_sqlite_reliability();
     MiniSkillSqliteStore = class {
       db = null;
       dataDir = "";
@@ -11194,7 +11274,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 };
@@ -11203,8 +11283,7 @@ var init_mini_skill_store = __esm({
           this.stmtBumpGeneration.run();
           this.knownGeneration = this.readGeneration();
           return skill2;
-        })();
-        return result;
+        })(), "Mini-skill promotion");
       }
       // ── Freshness ────────────────────────────────────────────────────
       async ensureFresh() {
@@ -11223,10 +11302,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;
         }
       }
@@ -11234,28 +11320,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;
@@ -11266,6 +11357,9 @@ var init_mini_skill_store = __esm({
       getBackendName() {
         return "degraded";
       }
+      getBackendReason() {
+        return this.reason;
+      }
     };
     _store = null;
     _storeDataDir = null;
@@ -23207,10 +23301,10 @@ async function fetchWithRetry(url2, apiKey, body, options = {}, attempt = 0, nat
       );
     }
     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(url2, apiKey, body, options, attempt + 1, nativeGemini);
@@ -25242,6 +25336,7 @@ var init_sqlite_store = __esm({
     "use strict";
     init_esm_shims();
     init_sqlite_db();
+    init_sqlite_reliability();
     init_sqlite_fts();
     SqliteBackend = class {
       db = null;
@@ -25519,7 +25614,9 @@ var init_sqlite_store = __esm({
       // ── Compound atomic operation ────────────────────────────────────
       async atomic(fn2) {
         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(),
@@ -25618,15 +25715,15 @@ function resetObservationStore() {
 async function createObservationStore(dataDir) {
   try {
     const { SqliteBackend: SqliteBackend2 } = await Promise.resolve().then(() => (init_sqlite_store(), sqlite_store_exports));
-    const store3 = new SqliteBackend2();
-    await store3.init(dataDir);
-    return store3;
+    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 store2 = new DegradedBackend();
-  await store2.init(dataDir);
-  return store2;
 }
 async function initObservationStore(dataDir) {
   if (_store2 && _storeDataDir2 === dataDir) {
@@ -25650,36 +25747,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;
@@ -25688,25 +25793,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;
@@ -25719,6 +25824,9 @@ var init_obs_store = __esm({
       getBackendName() {
         return "degraded";
       }
+      getBackendReason() {
+        return this.reason;
+      }
     };
   }
 });
@@ -73579,10 +73687,10 @@ var require_retry3 = __commonJS({
       if (!await shouldRetryFn(err)) {
         return { shouldRetry: false, config: err.config };
       }
-      const delay2 = getNextRetryDelay(config2);
+      const delay3 = getNextRetryDelay(config2);
       err.config.retryConfig.currentRetryAttempt += 1;
-      const backoff = config2.retryBackoff ? config2.retryBackoff(err, delay2) : new Promise((resolve9) => {
-        setTimeout(resolve9, delay2);
+      const backoff = config2.retryBackoff ? config2.retryBackoff(err, delay3) : new Promise((resolve9) => {
+        setTimeout(resolve9, delay3);
       });
       if (config2.onRetryAttempt) {
         await config2.onRetryAttempt(err);
@@ -127107,7 +127215,7 @@ async function retryBackoff(fn2, strategy) {
         retryInterval = initialInterval * Math.pow(x5, exponent) + Math.random() * 1e3;
       }
       const d4 = Math.min(retryInterval, maxInterval);
-      await delay(d4);
+      await delay2(d4);
       x5++;
     }
   }
@@ -127128,8 +127236,8 @@ function retryIntervalFromResponse(res) {
   }
   return 0;
 }
-async function delay(delay2) {
-  return new Promise((resolve9) => setTimeout(resolve9, delay2));
+async function delay2(delay3) {
+  return new Promise((resolve9) => setTimeout(resolve9, delay3));
 }
 var defaultBackoff, PermanentError, TemporaryError, codeRangeRE2;
 var init_retries = __esm({
@@ -191552,16 +191660,18 @@ async function initSessionStore(dataDir) {
   if (_store3 && _storeDataDir3 === dataDir) return _store3;
   _store3 = null;
   _storeDataDir3 = null;
+  let degradedReason = "SQLite runtime unavailable";
   try {
-    const store3 = new SessionSqliteStore();
-    await store3.init(dataDir);
+    const store3 = await initializeSqliteStore(() => new SessionSqliteStore(), dataDir, "Session store");
     _store3 = store3;
     _storeDataDir3 = dataDir;
     return store3;
   } 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 store2 = new SessionGracefulDegrade();
+  const store2 = new SessionGracefulDegrade(degradedReason);
   await store2.init(dataDir);
   _store3 = store2;
   _storeDataDir3 = dataDir;
@@ -191573,6 +191683,7 @@ var init_session_store = __esm({
     "use strict";
     init_esm_shims();
     init_sqlite_db();
+    init_sqlite_reliability();
     SessionSqliteStore = class {
       db = null;
       dataDir = "";
@@ -191661,7 +191772,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 info2 = stmtComplete.run({ pid, now: now3 });
@@ -191669,18 +191780,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;
         }
       }
@@ -191688,33 +191805,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;
@@ -207835,7 +207958,7 @@ var init_tool_profile = __esm({
 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) {
@@ -281651,22 +281774,39 @@ var init_doctor = __esm({
           let activeCount = 0;
           let ranCount = 0;
           let backendName = "unknown";
+          let backendReason;
+          let observationFailure;
           try {
             const { initObservationStore: initObservationStore2, getObservationStore: getObservationStore2 } = await Promise.resolve().then(() => (init_obs_store(), obs_store_exports));
             await initObservationStore2(dataDir);
             const store2 = getObservationStore2();
             backendName = store2.getBackendName();
+            backendReason = store2.getBackendReason?.();
             const { filterReadableObservations: filterReadableObservations2 } = await Promise.resolve().then(() => (init_visibility(), visibility_exports));
             projectObservations = projectId ? filterReadableObservations2(await store2.loadAll(), { projectId }) : [];
             obsCount = projectObservations.length;
             activeCount = projectObservations.filter((o4) => (o4.status ?? "active") === "active").length;
             ranCount = projectObservations.filter((o4) => /^Ran:\s/i.test(o4.title ?? "")).length;
-          } catch {
-          }
-          if (backendName === "degraded") {
-            lines.push(warn2("Observations: SQLite unavailable \u2014 degraded (read-only, no data)"));
-            issues.push("SQLite backend unavailable \u2014 observations cannot be read or written.");
+          } catch (error40) {
+            observationFailure = error40 instanceof Error ? error40.message : String(error40);
+          }
+          if (observationFailure) {
+            lines.push(fail2(`Observations: storage unavailable \u2014 ${observationFailure}`));
+            issues.push(`Observation store could not be opened: ${observationFailure}`);
+            report.data = {
+              backend: "unavailable",
+              observations: null,
+              active: null,
+              commandLogs: null,
+              error: observationFailure
+            };
+          } else if (backendName === "degraded") {
+            lines.push(fail2(`Backend: degraded (read-only; writes disabled${backendReason ? `; ${backendReason}` : ""})`));
+            lines.push(fail2("Observations: unavailable \u2014 count not reported"));
+            issues.push("SQLite backend unavailable \u2014 observation storage is in degraded read-only mode; observations are not being persisted.");
+            report.data = { backend: "degraded", ...backendReason ? { backendReason } : {}, observations: null, active: null, commandLogs: null };
           } else {
+            lines.push(ok("Backend: sqlite (read-write)"));
             lines.push(ok(`Observations: ${obsCount} total, ${activeCount} active`));
             if (ranCount > 0) {
               const pct = Math.round(ranCount / obsCount * 100);
@@ -281676,29 +281816,63 @@ var init_doctor = __esm({
               }
             }
           }
-          report.data = { observations: obsCount, active: activeCount, commandLogs: ranCount };
+          if (!report.data) {
+            report.data = { backend: backendName, observations: obsCount, active: activeCount, commandLogs: ranCount };
+          } else if (!report.data.backend) {
+            report.data.backend = backendName;
+          }
+          let sessionBackend = "unknown";
+          let sessionReason;
           try {
             const { initSessionStore: initSessionStore2, getSessionStore: getSessionStore2 } = await Promise.resolve().then(() => (init_session_store(), session_store_exports));
             await initSessionStore2(dataDir);
             const sessStore = getSessionStore2();
-            const sess = await sessStore.loadAll();
-            const sessCount = sess.length;
-            const activeSess = sess.filter((s4) => s4.status === "active").length;
-            lines.push(ok(`Sessions: ${sessCount} total, ${activeSess} active`));
-            report.data.sessions = sessCount;
-          } catch {
+            sessionBackend = sessStore.getBackendName();
+            sessionReason = sessStore.getBackendReason?.();
+            if (sessionBackend === "degraded") {
+              lines.push(fail2(`Sessions: unavailable \u2014 read-only degraded backend${sessionReason ? `; ${sessionReason}` : ""}`));
+              issues.push("Session storage is in degraded read-only mode.");
+              report.data.sessions = null;
+              if (sessionReason) report.data.sessionBackendReason = sessionReason;
+            } else {
+              const sess = await sessStore.loadAll();
+              const sessCount = sess.length;
+              const activeSess = sess.filter((s4) => s4.status === "active").length;
+              lines.push(ok(`Sessions: ${sessCount} total, ${activeSess} active`));
+              report.data.sessions = sessCount;
+            }
+          } catch (error40) {
+            const message = error40 instanceof Error ? error40.message : String(error40);
+            lines.push(fail2(`Sessions: unavailable (${message})`));
+            issues.push(`Session storage is unavailable: ${message}`);
+            report.data.sessions = null;
           }
+          let skillBackend = "unknown";
+          let skillReason;
           try {
             const { initMiniSkillStore: initMiniSkillStore2, getMiniSkillStore: getMiniSkillStore2 } = await Promise.resolve().then(() => (init_mini_skill_store(), mini_skill_store_exports));
             await initMiniSkillStore2(dataDir);
             const skillStore = getMiniSkillStore2();
-            const skills = await skillStore.loadAll();
-            const skillCount = skills.length;
-            if (skillCount > 0) {
-              lines.push(ok(`Mini-skills: ${skillCount}`));
-              report.data.miniSkills = skillCount;
+            skillBackend = skillStore.getBackendName();
+            skillReason = skillStore.getBackendReason?.();
+            if (skillBackend === "degraded") {
+              lines.push(fail2(`Mini-skills: unavailable \u2014 read-only degraded backend${skillReason ? `; ${skillReason}` : ""}`));
+              issues.push("Mini-skill storage is in degraded read-only mode.");
+              report.data.miniSkills = null;
+              if (skillReason) report.data.miniSkillBackendReason = skillReason;
+            } else {
+              const skills = await skillStore.loadAll();
+              const skillCount = skills.length;
+              if (skillCount > 0) {
+                lines.push(ok(`Mini-skills: ${skillCount}`));
+                report.data.miniSkills = skillCount;
+              }
             }
-          } catch {
+          } catch (error40) {
+            const message = error40 instanceof Error ? error40.message : String(error40);
+            lines.push(fail2(`Mini-skills: unavailable (${message})`));
+            issues.push(`Mini-skill storage is unavailable: ${message}`);
+            report.data.miniSkills = null;
           }
         } else {
           lines.push(warn2("No data directory found for current project"));
@@ -281946,6 +282120,9 @@ var init_doctor = __esm({
         } else {
           console.log(lines.join("\n"));
         }
+        if (issues.some((issue2) => /^(Observation store could not be opened|Observation storage |Session storage |Mini-skill storage |SQLite backend unavailable)/.test(issue2))) {
+          process.exitCode = 1;
+        }
       }
     });
   }
@@ -284393,12 +284570,12 @@ function classifyError(ctx, taskId) {
     if (taskId) backoffState.set(taskId, attempt);
     const baseDelay = 2e3;
     const maxDelay = 3e4;
-    const delay2 = Math.min(baseDelay * Math.pow(2, attempt - 1), maxDelay);
-    const jitter = delay2 * 0.25 * (Math.random() * 2 - 1);
+    const delay3 = Math.min(baseDelay * Math.pow(2, attempt - 1), maxDelay);
+    const jitter = delay3 * 0.25 * (Math.random() * 2 - 1);
     return {
       category: "transient",
       strategy: "backoff_and_retry",
-      delayMs: Math.round(delay2 + jitter),
+      delayMs: Math.round(delay3 + jitter),
       reason: `Transient error detected (attempt ${attempt})`,
       backoffAttempt: attempt
     };