memorix 1.9.1 → 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.1" : 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;
+      }
     };
   }
 });
@@ -27498,7 +27606,8 @@ function clampCursor(afterId) {
 }
 async function loadConsolidationPage(projectId, options) {
   const limit2 = clampBatchSize(options.limit);
-  const page = await getObservationStore().loadByProject(projectId, {
+  const store2 = options.store ?? getObservationStore();
+  const page = await store2.loadByProject(projectId, {
     status: "active",
     afterId: clampCursor(options.afterId),
     limit: limit2 + 1
@@ -27558,7 +27667,7 @@ async function findConsolidationCandidates(_projectDir, projectId, opts) {
   return findClusters(page.observations, threshold);
 }
 async function executeConsolidation(_projectDir, projectId, opts) {
-  const store2 = getObservationStore();
+  const store2 = opts?.store ?? getObservationStore();
   const page = await loadConsolidationPage(projectId, opts ?? {});
   const clusters = findClusters(page.observations, opts?.threshold ?? DEFAULT_SIMILARITY_THRESHOLD);
   if (clusters.length === 0) {
@@ -73578,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);
@@ -127106,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++;
     }
   }
@@ -127127,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({
@@ -181365,7 +181474,7 @@ __export(lite_provider_exports, {
   refreshProjectLite: () => refreshProjectLite
 });
 import { createHash as createHash10 } from "crypto";
-import { readdirSync as readdirSync2, readFileSync as readFileSync9, statSync as statSync4 } from "fs";
+import { existsSync as existsSync14, readdirSync as readdirSync2, readFileSync as readFileSync9, statSync as statSync4 } from "fs";
 import { join as join5, relative as relative2 } from "path";
 function hashText2(text3) {
   return createHash10("sha256").update(text3).digest("hex");
@@ -181382,6 +181491,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 existsSync14(join5(dir, "pyvenv.cfg"));
+}
 function walk(root, exclude, maxFiles) {
   const out = [];
   const visit = (dir) => {
@@ -181399,6 +181511,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;
@@ -185295,7 +185408,7 @@ __export(vector_backfill_runner_exports, {
 import { spawn as spawn4 } from "child_process";
 import {
   closeSync,
-  existsSync as existsSync14,
+  existsSync as existsSync15,
   mkdirSync as mkdirSync2,
   openSync,
   readFileSync as readFileSync10,
@@ -185423,7 +185536,7 @@ function releaseVectorBackfillLock(lockPath = process.env.MEMORIX_VECTOR_BACKFIL
 }
 function launchDetachedVectorBackfill(request, options = {}) {
   const runnerPath = options.runnerPath ?? resolveVectorBackfillRunnerPath();
-  const exists3 = options.exists ?? existsSync14;
+  const exists3 = options.exists ?? existsSync15;
   if (!exists3(runnerPath)) return false;
   const lock = acquireVectorBackfillLock(request.dataDir, request.projectId, options.lockPath);
   if (!lock) return false;
@@ -191547,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;
@@ -191568,6 +191683,7 @@ var init_session_store = __esm({
     "use strict";
     init_esm_shims();
     init_sqlite_db();
+    init_sqlite_reliability();
     SessionSqliteStore = class {
       db = null;
       dataDir = "";
@@ -191656,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 });
@@ -191664,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;
         }
       }
@@ -191683,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;
@@ -192262,7 +192390,8 @@ var init_memory3 = __esm({
             case "deduplicate": {
               const query = asStringArg(args.query);
               const dryRun = !!args.dryRun || !!args["dry-run"];
-              const { isLLMEnabled: isLLMEnabled2 } = await Promise.resolve().then(() => (init_provider2(), provider_exports2));
+              const { initLLM: initLLM2, isLLMEnabled: isLLMEnabled2 } = await Promise.resolve().then(() => (init_provider2(), provider_exports2));
+              initLLM2({ scope: "memory", projectRoot: project.rootPath });
               if (!isLLMEnabled2()) {
                 emitResult(
                   { project, available: false, usedLLM: false },
@@ -192615,7 +192744,7 @@ __export(init_exports, {
   buildInitTomlConfig: () => buildInitTomlConfig,
   default: () => init_default5
 });
-import { existsSync as existsSync15, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir8 } from "os";
 import path29 from "path";
 function buildInitTomlConfig(options) {
@@ -192764,7 +192893,7 @@ var init_init = __esm({
         const targetPath = path29.join(targetDir, isGlobal ? getInitConfigFilename() : getInitProjectConfigFilename());
         const envPath = path29.join(targetDir, ".env");
         v3.info(getInitScopeDescription(scope));
-        if (existsSync15(targetPath)) {
+        if (existsSync16(targetPath)) {
           const overwrite = await me({
             message: `${targetPath} already exists. Overwrite it?`,
             initialValue: false
@@ -192872,10 +193001,10 @@ var init_init = __esm({
         v3.success(`Created ${targetPath}`);
         if (shouldOfferDotenv(scope)) {
           const envExamplePath = getEnvTemplateTarget(targetDir, {
-            hasDotenvExample: existsSync15(path29.join(targetDir, ".env.example"))
+            hasDotenvExample: existsSync16(path29.join(targetDir, ".env.example"))
           });
           const envContent = envLines.join("\n");
-          if (existsSync15(envExamplePath)) {
+          if (existsSync16(envExamplePath)) {
             const overwriteEnvTemplate = await me({
               message: `${envExamplePath} already exists. Overwrite it?`,
               initialValue: false
@@ -192887,7 +193016,7 @@ var init_init = __esm({
           }
           writeFileSync3(envExamplePath, envContent, "utf-8");
           v3.success(`Created ${envExamplePath}`);
-          const createEnv = !existsSync15(envPath) ? await me({
+          const createEnv = !existsSync16(envPath) ? await me({
             message: `Create .env from ${path29.basename(envExamplePath)} now? (you can fill in keys later)`,
             initialValue: true
           }) : false;
@@ -196057,7 +196186,7 @@ __export(setup_exports, {
   tryInstallCodexPlugin: () => tryInstallCodexPlugin
 });
 import { spawnSync } from "child_process";
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 import { copyFile as copyFile2, mkdir as mkdir6, readFile as readFile6, readdir as readdir3, rm as rm2, writeFile as writeFile7 } from "fs/promises";
 import { homedir as homedir27 } from "os";
 import path32 from "path";
@@ -196102,7 +196231,7 @@ function buildSetupPlan(options) {
 function findPackageRoot(start = path32.dirname(fileURLToPath7(import.meta.url))) {
   let dir = start;
   for (let i4 = 0; i4 < 8; i4++) {
-    if (existsSync16(path32.join(dir, "package.json")) && existsSync16(path32.join(dir, "plugins"))) {
+    if (existsSync17(path32.join(dir, "package.json")) && existsSync17(path32.join(dir, "plugins"))) {
       return dir;
     }
     const parent = path32.dirname(dir);
@@ -196388,8 +196517,8 @@ function isOwnedLegacyCodexHooks(content) {
 async function removeOwnedLegacyCodexPluginFolder(homeDir) {
   const canonicalPath2 = path32.join(homeDir, "plugins", "memorix");
   const legacyPath = path32.join(homeDir, ".codex", "plugins", "memorix");
-  if (!existsSync16(legacyPath)) return "missing";
-  if (!existsSync16(canonicalPath2)) return "preserved";
+  if (!existsSync17(legacyPath)) return "missing";
+  if (!existsSync17(canonicalPath2)) return "preserved";
   try {
     const manifest = JSON.parse(await readFile6(path32.join(legacyPath, ".codex-plugin", "plugin.json"), "utf-8"));
     const repository = String(manifest.repository ?? "");
@@ -196605,7 +196734,7 @@ async function installCodeBuddyPluginPackage(options = {}) {
   const home = options.homeDir ?? homedir27();
   const packageRoot = findPackageRoot();
   const source = path32.join(packageRoot, "plugins", "codebuddy", "memorix");
-  if (!existsSync16(source)) throw new Error(`CodeBuddy plugin template not found: ${source}`);
+  if (!existsSync17(source)) throw new Error(`CodeBuddy plugin template not found: ${source}`);
   const marketplaceRoot = path32.join(home, ".codebuddy", "memorix-local");
   const marketplacePath = path32.join(marketplaceRoot, ".codebuddy-plugin", "marketplace.json");
   const pluginPath = path32.join(marketplaceRoot, "plugins", "memorix");
@@ -196626,7 +196755,7 @@ async function installPluginPackage(options) {
   const packageRoot = findPackageRoot();
   const source = path32.join(packageRoot, "plugins", options.agent, "memorix");
   const includeHooks = options.includeHooks ?? true;
-  if (!existsSync16(source)) {
+  if (!existsSync17(source)) {
     throw new Error(`Plugin package template not found: ${source}`);
   }
   if (options.agent === "codex") {
@@ -196674,7 +196803,7 @@ async function installGeminiExtensionPackage(options = {}) {
   const home = options.homeDir ?? homedir27();
   const packageRoot = findPackageRoot();
   const source = path32.join(packageRoot, "plugins", "gemini", "memorix");
-  if (!existsSync16(source)) {
+  if (!existsSync17(source)) {
     throw new Error(`Gemini extension template not found: ${source}`);
   }
   const extensionPath = path32.join(home, ".gemini", "extensions", "memorix");
@@ -196688,7 +196817,7 @@ async function installGeminiExtensionPackage(options = {}) {
 async function installAntigravityPluginPackage(options = {}) {
   const packageRoot = findPackageRoot();
   const source = path32.join(packageRoot, "plugins", "antigravity", "memorix");
-  if (!existsSync16(source)) {
+  if (!existsSync17(source)) {
     throw new Error(`Antigravity plugin template not found: ${source}`);
   }
   const pluginPath = options.global === false ? path32.join(options.projectRoot ?? process.cwd(), ".agents", "plugins", "memorix") : path32.join(options.homeDir ?? homedir27(), ".gemini", "config", "plugins", "memorix");
@@ -196706,7 +196835,7 @@ async function installAntigravityPluginPackage(options = {}) {
 async function installPiPackage(options = {}) {
   const packageRoot = findPackageRoot();
   const source = path32.join(packageRoot, "plugins", "pi", "memorix");
-  if (!existsSync16(source)) {
+  if (!existsSync17(source)) {
     throw new Error(`Pi package template not found: ${source}`);
   }
   const defaultRoot = options.global ? path32.join(options.homeDir ?? homedir27(), ".pi", "agent", "packages") : path32.join(process.cwd(), ".pi", "packages");
@@ -196724,7 +196853,7 @@ async function installOpenClawBundlePackage(options = {}) {
   const home = options.homeDir ?? homedir27();
   const packageRoot = findPackageRoot();
   const source = path32.join(packageRoot, "plugins", "openclaw", "memorix");
-  if (!existsSync16(source)) {
+  if (!existsSync17(source)) {
     throw new Error(`OpenClaw bundle template not found: ${source}`);
   }
   const bundlePath = path32.join(home, ".openclaw", "extensions", "memorix");
@@ -196740,7 +196869,7 @@ async function installOpenClawBundlePackage(options = {}) {
 async function installHermesPluginPackage(options = {}) {
   const packageRoot = findPackageRoot();
   const source = path32.join(packageRoot, "plugins", "hermes", "memorix");
-  if (!existsSync16(source)) {
+  if (!existsSync17(source)) {
     throw new Error(`Hermes plugin template not found: ${source}`);
   }
   const hermesHome = resolveHermesHome(options.homeDir);
@@ -196767,7 +196896,7 @@ async function installHermesPluginPackage(options = {}) {
 async function installOmpPackage(options = {}) {
   const packageRoot = findPackageRoot();
   const source = path32.join(packageRoot, "plugins", "omp", "memorix");
-  if (!existsSync16(source)) {
+  if (!existsSync17(source)) {
     throw new Error(`Oh-my-Pi package template not found: ${source}`);
   }
   const defaultRoot = options.global ? path32.join(options.homeDir ?? homedir27(), ".omp", "agent", "packages") : path32.join(process.cwd(), ".omp", "packages");
@@ -196994,7 +197123,7 @@ ${hook.stdout || ""}`.toLowerCase();
 function resolveHermesCommand(hermesHome) {
   if (process.platform === "win32") {
     const localHermes = path32.join(hermesHome, "hermes-agent", "venv", "Scripts", "hermes.exe");
-    if (existsSync16(localHermes)) return localHermes;
+    if (existsSync17(localHermes)) return localHermes;
   }
   return "hermes";
 }
@@ -198610,11 +198739,11 @@ __export(current_facts_exports, {
   formatGitFact: () => formatGitFact
 });
 import { execFileSync } from "child_process";
-import { existsSync as existsSync17, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync11 } from "fs";
 import path33 from "path";
 function readTextIfExists(filePath) {
   try {
-    if (!existsSync17(filePath)) return null;
+    if (!existsSync18(filePath)) return null;
     return readFileSync11(filePath, "utf8");
   } catch {
     return null;
@@ -198905,7 +199034,7 @@ __export(external_provider_exports, {
   runExternalCodeGraphLifecycle: () => runExternalCodeGraphLifecycle
 });
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync18, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync19, readFileSync as readFileSync12 } from "fs";
 import { delimiter, dirname as dirname5, extname, isAbsolute as isAbsolute4, join as join24, relative as relative4, resolve as resolve6, sep as sep2 } from "path";
 function boundedTimeout(value) {
   if (!Number.isFinite(value)) return DEFAULT_EXTERNAL_CODEGRAPH_TIMEOUT_MS;
@@ -198942,13 +199071,13 @@ function resolveCommandCandidates(command) {
 }
 function resolveLaunch(command) {
   for (const candidate2 of resolveCommandCandidates(command)) {
-    if (!existsSync18(candidate2)) continue;
+    if (!existsSync19(candidate2)) continue;
     const extension3 = extname(candidate2).toLowerCase();
     if (extension3 === ".cmd") {
       const bundleRoot = resolve6(dirname5(candidate2), "..");
       const node = join24(bundleRoot, "node.exe");
       const entry = join24(bundleRoot, "lib", "dist", "bin", "codegraph.js");
-      if (existsSync18(node) && existsSync18(entry)) {
+      if (existsSync19(node) && existsSync19(entry)) {
         return { executable: node, prefixArgs: ["--liftoff-only", entry] };
       }
       try {
@@ -198957,7 +199086,7 @@ function resolveLaunch(command) {
         if (match2?.[1]) {
           const base = dirname5(candidate2).endsWith(sep2) ? dirname5(candidate2) : dirname5(candidate2) + sep2;
           const entry2 = resolve6(match2[1].replace(/%(?:~)?dp0%?/gi, base));
-          if (existsSync18(entry2)) return { executable: process.execPath, prefixArgs: [entry2] };
+          if (existsSync19(entry2)) return { executable: process.execPath, prefixArgs: [entry2] };
         }
       } catch {
       }
@@ -199105,7 +199234,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 (!existsSync18(join24(input.projectRoot, ".codegraph"))) {
+  if (!existsSync19(join24(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 }) };
   }
@@ -199141,7 +199270,7 @@ async function runExternalCodeGraphLifecycle(input) {
     };
   }
   const indexPath = join24(input.projectRoot, ".codegraph");
-  if (input.action === "sync" && !existsSync18(indexPath)) {
+  if (input.action === "sync" && !existsSync19(indexPath)) {
     const health = { state: "not-detected", reason: "No local .codegraph index is present for this project." };
     return {
       action: input.action,
@@ -199151,7 +199280,7 @@ async function runExternalCodeGraphLifecycle(input) {
       quality: providerQuality({ mode, health })
     };
   }
-  if (input.action === "init" && existsSync18(indexPath)) {
+  if (input.action === "init" && existsSync19(indexPath)) {
     const inspected2 = await inspectExternalCodeGraph(input);
     return {
       action: input.action,
@@ -201120,7 +201249,7 @@ __export(auto_context_exports, {
   formatAutoProjectContextSummary: () => formatAutoProjectContextSummary,
   formatLegacyAutoProjectContextPrompt: () => formatLegacyAutoProjectContextPrompt
 });
-import { existsSync as existsSync19, statSync as statSync6 } from "fs";
+import { existsSync as existsSync20, statSync as statSync6 } from "fs";
 import path35 from "path";
 function activeProjectObservations(observations2, projectId) {
   return observations2.filter((obs) => obs.projectId === projectId && (obs.status ?? "active") === "active");
@@ -201466,7 +201595,7 @@ function existingLensCandidates(rootPath, lens) {
   for (const candidate2 of lensPathCandidates(lens)) {
     const absolute = path35.join(rootPath, candidate2);
     try {
-      if (!existsSync19(absolute)) continue;
+      if (!existsSync20(absolute)) continue;
       const stat6 = statSync6(absolute);
       if (stat6.isFile()) out.push(candidate2);
       if (stat6.isDirectory()) out.push(candidate2.replace(/\\/g, "/"));
@@ -205105,7 +205234,7 @@ var engine_exports2 = {};
 __export(engine_exports2, {
   SkillsEngine: () => SkillsEngine
 });
-import { existsSync as existsSync20, readFileSync as readFileSync13, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, readdirSync as readdirSync3 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync13, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, readdirSync as readdirSync3 } from "fs";
 import { join as join25 } from "path";
 import { homedir as homedir31 } 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;
@@ -205186,7 +205315,7 @@ var init_engine4 = __esm({
               paths.push(join25(home, dir));
             }
             for (const skillsRoot of paths) {
-              if (!existsSync20(skillsRoot)) continue;
+              if (!existsSync21(skillsRoot)) continue;
               try {
                 const entries = readdirSync3(skillsRoot, { withFileTypes: true });
                 for (const entry of entries) {
@@ -205194,7 +205323,7 @@ var init_engine4 = __esm({
                   const name = entry.name;
                   if (seen.has(name)) continue;
                   const skillMd = join25(skillsRoot, name, "SKILL.md");
-                  if (!existsSync20(skillMd)) continue;
+                  if (!existsSync21(skillMd)) continue;
                   try {
                     const content = readFileSync13(skillMd, "utf-8");
                     const description = this.parseDescription(content);
@@ -206416,7 +206545,7 @@ var init_task_graph = __esm({
 
 // src/orchestrate/context-collector.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { readFileSync as readFileSync14, existsSync as existsSync21 } from "fs";
+import { readFileSync as readFileSync14, existsSync as existsSync22 } from "fs";
 import { join as join26 } from "path";
 function normalizeEntryLimit(value, fallback) {
   if (!Number.isSafeInteger(value) || value < 1) return fallback;
@@ -206493,7 +206622,7 @@ function collectFileTree(projectDir2, maxEntries) {
 function collectDependencies(projectDir2) {
   try {
     const pkgPath = join26(projectDir2, "package.json");
-    if (!existsSync21(pkgPath)) return "";
+    if (!existsSync22(pkgPath)) return "";
     const pkg = JSON.parse(readFileSync14(pkgPath, "utf-8"));
     const parts = [];
     if (pkg.dependencies && Object.keys(pkg.dependencies).length > 0) {
@@ -207543,7 +207672,7 @@ __export(receipt_service_exports, {
   formatHandoffReceipt: () => formatHandoffReceipt
 });
 import { createHash as createHash18 } from "crypto";
-import { existsSync as existsSync22, readFileSync as readFileSync15 } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync15 } from "fs";
 import path37 from "path";
 function sha256(value) {
   return `sha256:${createHash18("sha256").update(value).digest("hex")}`;
@@ -207574,7 +207703,7 @@ function safeJsonArray(value) {
 }
 async function loadReceiptObservations(dataDir, projectId) {
   const dbPath = path37.join(dataDir, "memorix.db");
-  if (existsSync22(dbPath)) {
+  if (existsSync23(dbPath)) {
     try {
       const DB = loadBetterSqlite3();
       const db2 = new DB(dbPath, { readonly: true, fileMustExist: true });
@@ -207591,7 +207720,7 @@ async function loadReceiptObservations(dataDir, projectId) {
     }
   }
   const jsonPath = path37.join(dataDir, "observations.json");
-  if (!existsSync22(jsonPath)) return [];
+  if (!existsSync23(jsonPath)) return [];
   try {
     const parsed = JSON.parse(readFileSync15(jsonPath, "utf-8"));
     if (!Array.isArray(parsed)) return [];
@@ -207829,7 +207958,7 @@ var init_tool_profile = __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) {
@@ -221527,7 +221656,7 @@ var init_sanitizer = __esm({
 });
 
 // src/workspace/applier.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync6, copyFileSync, writeFileSync as writeFileSync6, unlinkSync as unlinkSync2, renameSync } from "fs";
+import { existsSync as existsSync24, mkdirSync as mkdirSync6, copyFileSync, writeFileSync as writeFileSync6, unlinkSync as unlinkSync2, renameSync } from "fs";
 import { dirname as dirname6 } from "path";
 var WorkspaceSyncApplier;
 var init_applier = __esm({
@@ -221558,7 +221687,7 @@ var init_applier = __esm({
         for (const file2 of files) {
           try {
             const dir = dirname6(file2.filePath);
-            if (!existsSync23(dir)) {
+            if (!existsSync24(dir)) {
               mkdirSync6(dir, { recursive: true });
             }
           } catch (err) {
@@ -221567,7 +221696,7 @@ var init_applier = __esm({
           }
         }
         for (const file2 of files) {
-          if (existsSync23(file2.filePath)) {
+          if (existsSync24(file2.filePath)) {
             try {
               const backupPath = file2.filePath + `.backup-${Date.now()}`;
               copyFileSync(file2.filePath, backupPath);
@@ -221618,7 +221747,7 @@ var init_applier = __esm({
       cleanBackups(backups) {
         for (const backup of backups) {
           try {
-            if (existsSync23(backup.backupPath)) {
+            if (existsSync24(backup.backupPath)) {
               unlinkSync2(backup.backupPath);
             }
           } catch {
@@ -221634,7 +221763,7 @@ var engine_exports3 = {};
 __export(engine_exports3, {
   WorkspaceSyncEngine: () => WorkspaceSyncEngine
 });
-import { readFileSync as readFileSync16, readdirSync as readdirSync4, existsSync as existsSync24, cpSync, mkdirSync as mkdirSync7 } from "fs";
+import { readFileSync as readFileSync16, readdirSync as readdirSync4, existsSync as existsSync25, cpSync, mkdirSync as mkdirSync7 } from "fs";
 import { join as join28 } from "path";
 import { homedir as homedir32 } from "os";
 var WorkspaceSyncEngine;
@@ -221714,7 +221843,7 @@ var init_engine5 = __esm({
           }
           const merged = /* @__PURE__ */ new Map();
           for (const path50 of pathsToCheck) {
-            if (existsSync24(path50)) {
+            if (existsSync25(path50)) {
               try {
                 const content = readFileSync16(path50, "utf-8");
                 const servers = adapter.parse(content);
@@ -221768,7 +221897,7 @@ var init_engine5 = __esm({
           const adapter = this.adapters.get(target);
           const configPath = adapter.getConfigPath(this.projectRoot);
           let configContent;
-          if (target === "antigravity" && existsSync24(configPath)) {
+          if (target === "antigravity" && existsSync25(configPath)) {
             try {
               const existing = JSON.parse(readFileSync16(configPath, "utf-8"));
               const generated = JSON.parse(adapter.generate(result.mcpServers.scanned));
@@ -221844,13 +221973,13 @@ var init_engine5 = __esm({
               join28(home, dir)
             ];
             for (const skillsRoot of paths) {
-              if (!existsSync24(skillsRoot)) continue;
+              if (!existsSync25(skillsRoot)) continue;
               try {
                 const entries = readdirSync4(skillsRoot, { withFileTypes: true });
                 for (const entry of entries) {
                   if (!entry.isDirectory()) continue;
                   const skillMd = join28(skillsRoot, entry.name, "SKILL.md");
-                  if (!existsSync24(skillMd)) continue;
+                  if (!existsSync25(skillMd)) continue;
                   let description = "";
                   try {
                     const content = readFileSync16(skillMd, "utf-8");
@@ -221899,7 +222028,7 @@ var init_engine5 = __esm({
         for (const skill2 of skills) {
           if (skill2.sourceAgent === target) continue;
           const dest = join28(targetDir, skill2.name);
-          if (existsSync24(dest)) {
+          if (existsSync25(dest)) {
             skipped.push(`${skill2.name} (already exists in ${target})`);
             continue;
           }
@@ -221915,7 +222044,7 @@ var init_engine5 = __esm({
       scanWorkflows() {
         const workflows = [];
         const wfDir = join28(this.projectRoot, ".windsurf", "workflows");
-        if (!existsSync24(wfDir)) return workflows;
+        if (!existsSync25(wfDir)) return workflows;
         try {
           const files = readdirSync4(wfDir).filter((f7) => f7.endsWith(".md"));
           for (const file2 of files) {
@@ -222194,7 +222323,7 @@ __export(behavior_exports, {
   getBehaviorConfig: () => getBehaviorConfig,
   resetBehaviorConfigCache: () => resetBehaviorConfigCache
 });
-import { existsSync as existsSync25, readFileSync as readFileSync17 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync17 } from "fs";
 import { homedir as homedir33 } from "os";
 function isSessionInject(value) {
   return value === "full" || value === "minimal" || value === "silent";
@@ -222205,7 +222334,7 @@ function isFormationMode(value) {
 function legacyBehavior(homeDir) {
   const configPath = getLegacyConfigJsonPath(homeDir);
   try {
-    if (!existsSync25(configPath)) return {};
+    if (!existsSync26(configPath)) return {};
     const parsed = JSON.parse(readFileSync17(configPath, "utf-8"));
     return parsed.behavior && typeof parsed.behavior === "object" && !Array.isArray(parsed.behavior) ? parsed.behavior : {};
   } catch {
@@ -222519,7 +222648,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 {
@@ -222542,11 +222672,19 @@ async function executeConsolidate(context, payload, token) {
   const clusterIds = record2.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) {
@@ -223703,7 +223841,7 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
       }
       case "/config": {
         const os10 = await import("os");
-        const { existsSync: existsSync35 } = await import("fs");
+        const { existsSync: existsSync36 } = await import("fs");
         const { join: join35 } = await import("path");
         const configProjectRoot = effectiveProjectRoot;
         const resolved = getResolvedConfig({ projectRoot: configProjectRoot });
@@ -223731,7 +223869,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: existsSync35(fpath), path: fpath };
+              files[key] = { exists: existsSync36(fpath), path: fpath };
             }
           }
         } catch {
@@ -264200,11 +264338,11 @@ __export(hooks_path_exports, {
   resolveGitDir: () => resolveGitDir,
   resolveHooksDir: () => resolveHooksDir
 });
-import { existsSync as existsSync26, readFileSync as readFileSync18, statSync as statSync7, mkdirSync as mkdirSync8 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync18, statSync as statSync7, mkdirSync as mkdirSync8 } from "fs";
 import path42 from "path";
 function resolveGitDir(projectRoot) {
   const dotGit = path42.join(projectRoot, ".git");
-  if (!existsSync26(dotGit)) return null;
+  if (!existsSync27(dotGit)) return null;
   const stat6 = statSync7(dotGit);
   if (stat6.isDirectory()) {
     return dotGit;
@@ -264216,7 +264354,7 @@ function resolveGitDir(projectRoot) {
       if (match2) {
         const gitdir = match2[1].trim();
         const resolved = path42.isAbsolute(gitdir) ? gitdir : path42.resolve(projectRoot, gitdir);
-        if (existsSync26(resolved)) {
+        if (existsSync27(resolved)) {
           return resolved;
         }
       }
@@ -268809,10 +268947,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: existsSync35, readFileSync: readFileSync25, writeFileSync: writeFileSync13, chmodSync: chmodSync2 } = await import("fs");
+          const { existsSync: existsSync36, readFileSync: readFileSync25, writeFileSync: writeFileSync13, chmodSync: chmodSync2 } = await import("fs");
           const { hookPath } = resolved;
           const HOOK_MARKER3 = "# [memorix-git-hook]";
-          const needsInstall = !existsSync35(hookPath) || !readFileSync25(hookPath, "utf-8").includes(HOOK_MARKER3);
+          const needsInstall = !existsSync36(hookPath) || !readFileSync25(hookPath, "utf-8").includes(HOOK_MARKER3);
           if (needsInstall) {
             const hookScript = `#!/bin/sh
 ${HOOK_MARKER3}
@@ -268821,7 +268959,7 @@ if command -v memorix >/dev/null 2>&1; then
   memorix ingest commit --auto >/dev/null 2>&1 &
 fi
 `;
-            if (existsSync35(hookPath)) {
+            if (existsSync36(hookPath)) {
               const existing = readFileSync25(hookPath, "utf-8");
               writeFileSync13(hookPath, existing.trimEnd() + `
 
@@ -272883,7 +273021,7 @@ var init_serve_http = __esm({
             if (apiPath === "/config") {
               const { projectId: configProjectId } = await resolveRequestProject(url2);
               const os10 = await import("os");
-              const { existsSync: existsSync35 } = await import("fs");
+              const { existsSync: existsSync36 } = await import("fs");
               const { join: join35 } = await import("path");
               const { loadYamlConfig: loadYamlConfig2 } = await Promise.resolve().then(() => (init_yaml_loader(), yaml_loader_exports));
               const { loadFileConfig: loadFileConfig2, loadDotenv: loadDotenv2, getLoadedEnvFiles: getLoadedEnvFiles2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -272905,7 +273043,7 @@ var init_serve_http = __esm({
                   "legacy config.json": join35(home, ".memorix", "config.json")
                 };
                 for (const [key, fpath] of Object.entries(paths)) {
-                  files[key] = { exists: existsSync35(fpath), path: fpath };
+                  files[key] = { exists: existsSync36(fpath), path: fpath };
                 }
               } else {
                 files["project memorix.yml"] = { exists: false, path: "unavailable", unavailable: true };
@@ -272916,7 +273054,7 @@ var init_serve_http = __esm({
                   "legacy config.json": join35(home, ".memorix", "config.json")
                 };
                 for (const [key, fpath] of Object.entries(userPaths)) {
-                  files[key] = { exists: existsSync35(fpath), path: fpath };
+                  files[key] = { exists: existsSync36(fpath), path: fpath };
                 }
               }
               const values = [];
@@ -273452,7 +273590,7 @@ var init_status = __esm({
         const { getProjectDataDir: getProjectDataDir2 } = await Promise.resolve().then(() => (init_persistence(), persistence_exports));
         const { getEmbeddingProvider: getEmbeddingProvider2 } = await Promise.resolve().then(() => (init_provider(), provider_exports));
         const { getResolvedConfig: getResolvedConfig2, getResolvedAgentLane: getResolvedAgentLane2 } = await Promise.resolve().then(() => (init_resolved_config(), resolved_config_exports));
-        const { existsSync: existsSync35, readFileSync: readFileSync25 } = await import("fs");
+        const { existsSync: existsSync36, readFileSync: readFileSync25 } = await import("fs");
         const project = detectProject2();
         if (!project) {
           const message = "Memorix requires a git repo to establish project identity. Run `git init` in this workspace first.";
@@ -273535,7 +273673,7 @@ var init_status = __esm({
           try {
             const { resolveHooksDir: resolveHooksDir2 } = await Promise.resolve().then(() => (init_hooks_path(), hooks_path_exports));
             const resolved2 = resolveHooksDir2(project.rootPath);
-            if (resolved2 && existsSync35(resolved2.hookPath)) {
+            if (resolved2 && existsSync36(resolved2.hookPath)) {
               const hookContent = readFileSync25(resolved2.hookPath, "utf-8");
               if (hookContent.includes("# [memorix-git-hook]")) {
                 diagLines.push(`  Git hook:      installed [OK]`);
@@ -279510,7 +279648,7 @@ var git_hook_install_exports = {};
 __export(git_hook_install_exports, {
   default: () => git_hook_install_default
 });
-import { existsSync as existsSync27, readFileSync as readFileSync19, writeFileSync as writeFileSync7, chmodSync } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync19, writeFileSync as writeFileSync7, chmodSync } from "fs";
 function generateHookScript() {
   return `${HOOK_MARKER}
 # Memorix: Auto-ingest git commits as memories
@@ -279557,7 +279695,7 @@ var init_git_hook_install = __esm({
           return;
         }
         const { hookPath } = resolved;
-        if (existsSync27(hookPath)) {
+        if (existsSync28(hookPath)) {
           const existing = readFileSync19(hookPath, "utf-8");
           if (existing.includes(HOOK_MARKER)) {
             v3.warn("Memorix git hook is already installed.");
@@ -279607,7 +279745,7 @@ var git_hook_uninstall_exports = {};
 __export(git_hook_uninstall_exports, {
   default: () => git_hook_uninstall_default
 });
-import { existsSync as existsSync28, readFileSync as readFileSync20, writeFileSync as writeFileSync8, unlinkSync as unlinkSync3 } from "fs";
+import { existsSync as existsSync29, readFileSync as readFileSync20, writeFileSync as writeFileSync8, unlinkSync as unlinkSync3 } from "fs";
 var HOOK_MARKER2, git_hook_uninstall_default;
 var init_git_hook_uninstall = __esm({
   "src/cli/commands/git-hook-uninstall.ts"() {
@@ -279639,7 +279777,7 @@ var init_git_hook_uninstall = __esm({
           return;
         }
         const { hookPath } = resolved;
-        if (!existsSync28(hookPath)) {
+        if (!existsSync29(hookPath)) {
           v3.warn("No post-commit hook found.");
           fe2("Nothing to uninstall.");
           return;
@@ -280486,7 +280624,7 @@ __export(agent_integrations_exports, {
   repairAgentIntegrations: () => repairAgentIntegrations
 });
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync30, realpathSync as realpathSync2 } from "fs";
+import { existsSync as existsSync31, realpathSync as realpathSync2 } from "fs";
 import { mkdir as mkdir9, readFile as readFile10, writeFile as writeFile10 } from "fs/promises";
 import { basename as basename5, dirname as dirname8, resolve as resolve7 } from "path";
 import { homedir as homedir35 } from "os";
@@ -280608,7 +280746,7 @@ async function inspectCodexPluginBundle() {
   const manifestPath = `${pluginPath}/.codex-plugin/plugin.json`;
   const hooksPath = `${pluginPath}/hooks/hooks.json`;
   const mcpPath = codexPluginMcpPath();
-  if (!existsSync30(pluginPath)) {
+  if (!existsSync31(pluginPath)) {
     return {
       scope: "global",
       kind: "bundle",
@@ -280618,7 +280756,7 @@ async function inspectCodexPluginBundle() {
       issues: ["codex-plugin-bundle-missing"]
     };
   }
-  if (!existsSync30(manifestPath)) {
+  if (!existsSync31(manifestPath)) {
     return {
       scope: "global",
       kind: "bundle",
@@ -280655,7 +280793,7 @@ async function inspectCodexPluginBundle() {
   const issues = [];
   if (version2 !== getCliVersion()) issues.push("codex-plugin-version-mismatch");
   if (manifest.hooks !== "./hooks/hooks.json") issues.push("codex-hook-manifest-missing");
-  if (!existsSync30(mcpPath)) {
+  if (!existsSync31(mcpPath)) {
     issues.push("codex-plugin-mcp-manifest-missing");
   } else {
     try {
@@ -280669,7 +280807,7 @@ async function inspectCodexPluginBundle() {
     }
   }
   let declared = [];
-  if (!existsSync30(hooksPath)) {
+  if (!existsSync31(hooksPath)) {
     issues.push("codex-hook-manifest-missing");
   } else {
     try {
@@ -280696,7 +280834,7 @@ async function inspectCodexPluginBundle() {
 }
 async function inspectCodexMarketplace() {
   const marketplacePath = codexMarketplacePath();
-  if (!existsSync30(marketplacePath)) {
+  if (!existsSync31(marketplacePath)) {
     return {
       scope: "global",
       kind: "marketplace",
@@ -280786,7 +280924,7 @@ function inspectCodexPluginRuntime() {
 }
 async function inspectCodexHookTrust() {
   const configPath = codexConfigPath();
-  if (!existsSync30(configPath)) {
+  if (!existsSync31(configPath)) {
     return {
       scope: "global",
       kind: "hook-trust",
@@ -280887,7 +281025,7 @@ function defaultClaudeProjectKey(projectRoot) {
 }
 function canonicalProjectPath(projectRoot) {
   const resolved = resolve7(projectRoot);
-  const canonical = existsSync30(resolved) ? realpathSync2(resolved) : resolved;
+  const canonical = existsSync31(resolved) ? realpathSync2(resolved) : resolved;
   return canonical.replace(/\\/g, "/");
 }
 function getClaudeLocalConfigPath() {
@@ -280919,7 +281057,7 @@ function findClaudeLocalProject(config2, projectRoot) {
 }
 async function inspectClaudeLocalMcp(projectRoot) {
   const configPath = getClaudeLocalConfigPath();
-  if (!existsSync30(configPath)) {
+  if (!existsSync31(configPath)) {
     return {
       scope: "local",
       path: configPath,
@@ -281007,7 +281145,7 @@ async function inspectCodexPluginMcp() {
   const runtime = inspectCodexPluginRuntime();
   if (!runtime.runtime?.installed || !runtime.runtime.enabled) return null;
   const mcpPath = codexPluginMcpPath();
-  if (!existsSync30(mcpPath)) {
+  if (!existsSync31(mcpPath)) {
     return {
       scope: "global",
       path: mcpPath,
@@ -281075,7 +281213,7 @@ async function inspectMcp(agent, projectRoot, scope) {
     if (targetScope === "global" && configPath === adapter.getConfigPath(projectRoot) && scope === "all") {
       continue;
     }
-    if (!existsSync30(configPath)) {
+    if (!existsSync31(configPath)) {
       checks.push({
         scope: targetScope,
         path: configPath,
@@ -281152,7 +281290,7 @@ async function inspectGuidance(agent, projectRoot, scope) {
   for (const targetScope of requestedGuidanceScopes(scope)) {
     const root = targetScope === "project" ? projectRoot : homedir35();
     const rulesPath = getAgentRulesPath(agent, root, targetScope === "global");
-    if (!existsSync30(rulesPath)) {
+    if (!existsSync31(rulesPath)) {
       checks.push({
         scope: targetScope,
         path: rulesPath,
@@ -281430,7 +281568,7 @@ var init_doctor = __esm({
           }
           return;
         }
-        const { existsSync: existsSync35, readFileSync: readFileSync25 } = await import("fs");
+        const { existsSync: existsSync36, readFileSync: readFileSync25 } = await import("fs");
         const { join: join35, basename: basename7 } = await import("path");
         const { homedir: homedir37 } = await import("os");
         const { execSync: execSync5 } = await import("child_process");
@@ -281501,7 +281639,7 @@ var init_doctor = __esm({
         let bgPid = 0;
         let backgroundHealthy = false;
         try {
-          if (existsSync35(bgStatePath)) {
+          if (existsSync36(bgStatePath)) {
             const bgState = JSON.parse(readFileSync25(bgStatePath, "utf-8"));
             bgPid = bgState.pid;
             bgPort = bgState.port;
@@ -281616,7 +281754,7 @@ var init_doctor = __esm({
             }
             try {
               const cachePath = join35(memorixDir, "embedding-cache.json");
-              if (existsSync35(cachePath)) {
+              if (existsSync36(cachePath)) {
                 const cache5 = JSON.parse(readFileSync25(cachePath, "utf-8"));
                 const cacheCount = Object.keys(cache5).length;
                 lines.push(info2(`Cached embeddings: ${cacheCount}`));
@@ -281631,27 +281769,44 @@ var init_doctor = __esm({
         }
         lines.push("");
         lines.push("\u250C\u2500 Data Status \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-        if (dataDir && existsSync35(dataDir)) {
+        if (dataDir && existsSync36(dataDir)) {
           let obsCount = 0;
           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);
@@ -281661,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"));
@@ -281819,7 +282008,7 @@ var init_doctor = __esm({
         let conflictsFound = false;
         if (dataDir) {
           const lockFile = join35(dataDir, ".memorix.lock");
-          if (existsSync35(lockFile)) {
+          if (existsSync36(lockFile)) {
             try {
               const lockData = JSON.parse(readFileSync25(lockFile, "utf-8"));
               const lockAge = Date.now() - lockData.time;
@@ -281931,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;
+        }
       }
     });
   }
@@ -284026,7 +284218,7 @@ var init_pipeline_trace = __esm({
 
 // src/orchestrate/worktree.ts
 import { execFileSync as execFileSync5 } from "child_process";
-import { existsSync as existsSync32, rmSync as rmSync2 } from "fs";
+import { existsSync as existsSync33, rmSync as rmSync2 } from "fs";
 import { join as join33, basename as basename6 } from "path";
 function runGit4(cwd, args, timeout = 5e3) {
   return String(execFileSync5("git", args, {
@@ -284072,7 +284264,7 @@ function createWorktree(projectDir2, taskId, pipelineId) {
     const suffix = attempt === 1 ? "" : `-${attempt}`;
     const worktreePath = `${worktreeBase}${suffix}`;
     const branch = `${branchBase}${suffix}`;
-    if (existsSync32(worktreePath)) continue;
+    if (existsSync33(worktreePath)) continue;
     if (!isBranchAvailable(projectDir2, branch)) continue;
     runGit4(projectDir2, ["worktree", "add", "-b", branch, worktreePath], 3e4);
     return { worktreePath, branch };
@@ -284123,7 +284315,7 @@ function removeWorktree(projectDir2, worktreePath, branch) {
   try {
     runGit4(projectDir2, ["worktree", "remove", worktreePath, "--force"], 1e4);
   } catch {
-    if (existsSync32(worktreePath)) {
+    if (existsSync33(worktreePath)) {
       try {
         rmSync2(worktreePath, { recursive: true, force: true });
       } catch {
@@ -284378,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
     };
@@ -290064,10 +290256,10 @@ function WorkbenchApp({ version: version2, onExitForInteractive }) {
           }
           try {
             const { resolveHooksDir: resolveHooksDir2 } = await Promise.resolve().then(() => (init_hooks_path(), hooks_path_exports));
-            const { existsSync: existsSync35, readFileSync: readFileSync25, writeFileSync: writeFileSync13, unlinkSync: unlinkSync5 } = await import("fs");
+            const { existsSync: existsSync36, readFileSync: readFileSync25, writeFileSync: writeFileSync13, unlinkSync: unlinkSync5 } = await import("fs");
             const resolved = resolveHooksDir2(proj.rootPath);
             const hookMarker = "# [memorix-git-hook]";
-            if (!resolved || !existsSync35(resolved.hookPath)) {
+            if (!resolved || !existsSync36(resolved.hookPath)) {
               setActionStatus("No post-commit hook found.");
               return;
             }
@@ -290222,7 +290414,7 @@ function WorkbenchApp({ version: version2, onExitForInteractive }) {
           break;
         }
         case "3": {
-          const { existsSync: existsSync35, readFileSync: readFileSync25, writeFileSync: writeFileSync13, chmodSync: chmodSync2 } = await import("fs");
+          const { existsSync: existsSync36, readFileSync: readFileSync25, writeFileSync: writeFileSync13, chmodSync: chmodSync2 } = await import("fs");
           const { ensureHooksDir: ensureHooksDir2 } = await Promise.resolve().then(() => (init_hooks_path(), hooks_path_exports));
           const hookMarker = "# [memorix-git-hook]";
           const resolved = ensureHooksDir2(cwd);
@@ -290236,7 +290428,7 @@ if command -v memorix >/dev/null 2>&1; then
   memorix ingest commit --auto >/dev/null 2>&1 &
 fi
 `;
-          if (existsSync35(resolved.hookPath)) {
+          if (existsSync36(resolved.hookPath)) {
             if (readFileSync25(resolved.hookPath, "utf-8").includes(hookMarker)) {
               setActionStatus("Post-commit hook already installed.");
               break;
@@ -290256,11 +290448,11 @@ ${hookScript}`, "utf-8");
           break;
         }
         case "4": {
-          const { existsSync: existsSync35, readFileSync: readFileSync25, writeFileSync: writeFileSync13, unlinkSync: unlinkSync5 } = await import("fs");
+          const { existsSync: existsSync36, readFileSync: readFileSync25, writeFileSync: writeFileSync13, unlinkSync: unlinkSync5 } = await import("fs");
           const { resolveHooksDir: resolveHooksDir2 } = await Promise.resolve().then(() => (init_hooks_path(), hooks_path_exports));
           const hookMarker = "# [memorix-git-hook]";
           const resolved = resolveHooksDir2(cwd);
-          if (!resolved || !existsSync35(resolved.hookPath)) {
+          if (!resolved || !existsSync36(resolved.hookPath)) {
             setActionStatus("No post-commit hook found.");
             break;
           }
@@ -291072,6 +291264,14 @@ function printCliGuideForHelp(argv2 = process.argv.slice(2)) {
   return true;
 }
 
+// src/cli/default-mode.ts
+init_esm_shims();
+function shouldDefaultToMcp(options = {}) {
+  const stdinIsTTY = options.stdinIsTTY ?? process.stdin.isTTY;
+  const stdoutIsTTY = options.stdoutIsTTY ?? process.stdout.isTTY;
+  return stdinIsTTY !== true || stdoutIsTTY !== true;
+}
+
 // src/cli/index.ts
 installCliPipeErrorGuard();
 var NO_GIT_MSG = "Memorix requires a git repo to establish project identity. Run `git init` in this workspace first.";
@@ -291382,6 +291582,11 @@ var main2 = defineCommand({
     ];
     if (firstArg && knownSubs.includes(firstArg)) return;
     if (!firstArg) {
+      if (shouldDefaultToMcp()) {
+        const serve = await Promise.resolve().then(() => (init_serve(), serve_exports));
+        await serve.default.run?.({ args: {}, rawArgs: [], cmd: serve.default });
+        return;
+      }
       try {
         const { runCli } = await importBundledMemcode();
         await runCli(process.argv.slice(2));