memorix 1.9.6 → 1.9.7

package/dist/vector-backfill-runner.js

@@ -419,6 +419,74 @@ var init_launch_root = __esm({
   }
 });
 
+// src/store/sqlite-reliability.ts
+function isTransientSqliteError(error) {
+  const code = error?.code;
+  if (typeof code === "string") {
+    return /^SQLITE_BUSY(?:_|$)/i.test(code);
+  }
+  return error instanceof Error && /\bdatabase is locked\b|\bdatabase is busy\b/i.test(error.message);
+}
+function isSqliteUnavailableError(error) {
+  return error instanceof SqliteUnavailableError || error instanceof Error && /SQLite is not available|better-sqlite3.*failed|node:sqlite.*failed|bun:sqlite.*failed/i.test(error.message);
+}
+function degradedReadError(storeName) {
+  return new Error(`[memorix] Cannot read ${storeName}: SQLite backend unavailable (memory is not loaded)`);
+}
+function degradedWriteError(storeName) {
+  return new Error(`[memorix] Cannot write ${storeName}: SQLite backend unavailable (degraded mode; read-only)`);
+}
+function formatSqliteFailure(error) {
+  return error instanceof Error && error.message ? error.message : String(error);
+}
+function delay(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function retrySqliteBusy(operation, label) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (!isTransientSqliteError(error) || attempt >= SQLITE_BUSY_RETRY_DELAYS_MS.length) throw error;
+      const waitMs = SQLITE_BUSY_RETRY_DELAYS_MS[attempt];
+      console.error(
+        `[memorix] ${label} SQLite busy (attempt ${attempt + 1}/${SQLITE_BUSY_RETRY_DELAYS_MS.length + 1}), retrying in ${waitMs}ms`
+      );
+      await delay(waitMs);
+    }
+  }
+}
+async function initializeSqliteStore(factory, dataDir, label) {
+  try {
+    loadBetterSqlite3();
+  } catch (error) {
+    throw new SqliteUnavailableError(error);
+  }
+  return retrySqliteBusy(async () => {
+    const store = factory();
+    await store.init(dataDir);
+    return store;
+  }, label);
+}
+var SQLITE_BUSY_RETRY_DELAYS_MS, SqliteUnavailableError;
+var init_sqlite_reliability = __esm({
+  "src/store/sqlite-reliability.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sqlite_db();
+    SQLITE_BUSY_RETRY_DELAYS_MS = [50, 150, 400, 1e3, 2500];
+    SqliteUnavailableError = class extends Error {
+      code = "MEMORIX_SQLITE_UNAVAILABLE";
+      constructor(cause) {
+        super(
+          cause instanceof Error && cause.message ? cause.message : "[memorix] SQLite is unavailable (install a supported SQLite runtime)"
+        );
+        this.name = "SqliteUnavailableError";
+      }
+    };
+  }
+});
+
 // src/store/sqlite-fts.ts
 function normalizeFtsToken(token) {
   return token.replace(/"/g, '""');
@@ -432,22 +500,27 @@ function buildFtsQuery(query) {
 function initializeObservationLexicalIndex(db2) {
   const known = ftsAvailability.get(db2);
   if (known !== void 0) return known;
-  try {
-    db2.exec(CREATE_OBSERVATION_FTS);
-    const observationCount = Number(db2.prepare("SELECT COUNT(*) AS count FROM observations").get()?.count ?? 0);
-    const indexedCount = Number(db2.prepare(`SELECT COUNT(*) AS count FROM ${FTS_TABLE}`).get()?.count ?? 0);
-    if (observationCount !== indexedCount) {
-      db2.exec(`INSERT INTO ${FTS_TABLE}(${FTS_TABLE}) VALUES ('rebuild')`);
+  let lastError;
+  for (let attempt = 1; attempt <= FTS_INIT_MAX_ATTEMPTS; attempt++) {
+    try {
+      db2.exec(CREATE_OBSERVATION_FTS);
+      const observationCount = Number(db2.prepare("SELECT COUNT(*) AS count FROM observations").get()?.count ?? 0);
+      const indexedCount = Number(db2.prepare(`SELECT COUNT(*) AS count FROM ${FTS_TABLE}`).get()?.count ?? 0);
+      if (observationCount !== indexedCount) {
+        db2.exec(`INSERT INTO ${FTS_TABLE}(${FTS_TABLE}) VALUES ('rebuild')`);
+      }
+      ftsAvailability.set(db2, true);
+      return true;
+    } catch (error) {
+      lastError = error;
+      if (!isTransientSqliteError(error) || attempt === FTS_INIT_MAX_ATTEMPTS) break;
     }
-    ftsAvailability.set(db2, true);
-    return true;
-  } catch (error) {
-    ftsAvailability.set(db2, false);
-    console.warn(
-      `[memorix] SQLite FTS5 unavailable; using the existing search fallback: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return false;
   }
+  ftsAvailability.set(db2, false);
+  console.warn(
+    `[memorix] SQLite FTS5 unavailable; using the existing search fallback: ${lastError instanceof Error ? lastError.message : String(lastError)}`
+  );
+  return false;
 }
 function isObservationLexicalIndexEnabled(db2) {
   return ftsAvailability.get(db2) === true;
@@ -501,11 +574,12 @@ function searchObservationLexically(db2, options) {
     score: Math.max(0, Number(row.lexical_score ?? 0))
   }));
 }
-var ftsAvailability, FTS_TABLE, CREATE_OBSERVATION_FTS;
+var ftsAvailability, FTS_TABLE, CREATE_OBSERVATION_FTS, FTS_INIT_MAX_ATTEMPTS;
 var init_sqlite_fts = __esm({
   "src/store/sqlite-fts.ts"() {
     "use strict";
     init_esm_shims();
+    init_sqlite_reliability();
     ftsAvailability = /* @__PURE__ */ new WeakMap();
     FTS_TABLE = "observations_fts";
     CREATE_OBSERVATION_FTS = `
@@ -539,6 +613,7 @@ CREATE TRIGGER IF NOT EXISTS observations_fts_au AFTER UPDATE ON observations BE
   VALUES (new.id, new.entityName, new.title, new.narrative, new.facts, new.filesModified, new.concepts, new.attachments);
 END;
 `;
+    FTS_INIT_MAX_ATTEMPTS = 3;
   }
 });
 
@@ -1726,74 +1801,6 @@ CREATE UNIQUE INDEX IF NOT EXISTS idx_maintenance_jobs_active_dedupe
   }
 });
 
-// src/store/sqlite-reliability.ts
-function isTransientSqliteError(error) {
-  const code = error?.code;
-  if (typeof code === "string") {
-    return /^SQLITE_BUSY(?:_|$)/i.test(code);
-  }
-  return error instanceof Error && /\bdatabase is locked\b|\bdatabase is busy\b/i.test(error.message);
-}
-function isSqliteUnavailableError(error) {
-  return error instanceof SqliteUnavailableError || error instanceof Error && /SQLite is not available|better-sqlite3.*failed|node:sqlite.*failed|bun:sqlite.*failed/i.test(error.message);
-}
-function degradedReadError(storeName) {
-  return new Error(`[memorix] Cannot read ${storeName}: SQLite backend unavailable (memory is not loaded)`);
-}
-function degradedWriteError(storeName) {
-  return new Error(`[memorix] Cannot write ${storeName}: SQLite backend unavailable (degraded mode; read-only)`);
-}
-function formatSqliteFailure(error) {
-  return error instanceof Error && error.message ? error.message : String(error);
-}
-function delay(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-async function retrySqliteBusy(operation, label) {
-  for (let attempt = 0; ; attempt++) {
-    try {
-      return await operation();
-    } catch (error) {
-      if (!isTransientSqliteError(error) || attempt >= SQLITE_BUSY_RETRY_DELAYS_MS.length) throw error;
-      const waitMs = SQLITE_BUSY_RETRY_DELAYS_MS[attempt];
-      console.error(
-        `[memorix] ${label} SQLite busy (attempt ${attempt + 1}/${SQLITE_BUSY_RETRY_DELAYS_MS.length + 1}), retrying in ${waitMs}ms`
-      );
-      await delay(waitMs);
-    }
-  }
-}
-async function initializeSqliteStore(factory, dataDir, label) {
-  try {
-    loadBetterSqlite3();
-  } catch (error) {
-    throw new SqliteUnavailableError(error);
-  }
-  return retrySqliteBusy(async () => {
-    const store = factory();
-    await store.init(dataDir);
-    return store;
-  }, label);
-}
-var SQLITE_BUSY_RETRY_DELAYS_MS, SqliteUnavailableError;
-var init_sqlite_reliability = __esm({
-  "src/store/sqlite-reliability.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_sqlite_db();
-    SQLITE_BUSY_RETRY_DELAYS_MS = [50, 150, 400, 1e3, 2500];
-    SqliteUnavailableError = class extends Error {
-      code = "MEMORIX_SQLITE_UNAVAILABLE";
-      constructor(cause) {
-        super(
-          cause instanceof Error && cause.message ? cause.message : "[memorix] SQLite is unavailable (install a supported SQLite runtime)"
-        );
-        this.name = "SqliteUnavailableError";
-      }
-    };
-  }
-});
-
 // src/store/file-lock.ts
 import { promises as fs2 } from "fs";
 import { randomUUID } from "crypto";
@@ -7686,6 +7693,7 @@ async function searchObservations(options) {
   };
   let queryVector = null;
   let embeddingProviderForSearch = null;
+  let embeddingUnavailable = false;
   if (quality !== "fast" && embeddingEnabled && hasQuery && tier !== "fast") {
     try {
       const provider2 = await getEmbeddingProvider();
@@ -7693,6 +7701,7 @@ async function searchObservations(options) {
         embeddingProviderForSearch = provider2;
         const activeVectorDimensions = getVectorDimensions();
         if (activeVectorDimensions !== null && provider2.dimensions !== activeVectorDimensions) {
+          embeddingUnavailable = true;
           rememberSearchMode(
             modeKey,
             `fulltext (embedding dimension mismatch: provider ${provider2.dimensions}d vs index ${activeVectorDimensions}d)`
@@ -7732,8 +7741,11 @@ async function searchObservations(options) {
             hybridWeights: isCJKHeavy ? { text: 0.2, vector: 0.8 } : { text: 0.6, vector: 0.4 }
           };
         }
+      } else {
+        embeddingUnavailable = true;
       }
     } catch (error) {
+      embeddingUnavailable = true;
       rememberSearchMode(modeKey, "fulltext (embedding unavailable)");
       console.error("[memorix] Embedding failed or timed out, falling back to fulltext search");
     }
@@ -7741,7 +7753,7 @@ async function searchObservations(options) {
   mark("preSearch");
   let results;
   const persistentCorpusEligible = await shouldUsePersistentSearch(projectIds, options.projectId);
-  const canUsePersistentLexical = persistentCorpusEligible && Boolean(hasQuery) && !queryVector && (quality === "fast" || tier === "fast" || !embeddingEnabled);
+  const canUsePersistentLexical = persistentCorpusEligible && Boolean(hasQuery) && !queryVector && (quality === "fast" || tier === "fast" || !embeddingEnabled || embeddingUnavailable);
   let persistent = persistentCorpusEligible && queryVector && embeddingProviderForSearch ? await searchPersistentSemantically(options, projectIds, requestLimit, queryVector, embeddingProviderForSearch) : canUsePersistentLexical ? await searchPersistentLexically(options, projectIds, requestLimit) : null;
   const durableStore = getOptionalObservationStore();
   if (!persistent && queryVector && durableStore?.hasLexicalIndex?.() && count(database) === 0) {

package/docs/DEVELOPMENT.md

@@ -13,7 +13,7 @@ Memorix is a TypeScript project built around:
 
 ## Current Development Baseline
 
-The current release line is **1.9.6** and package metadata is kept synchronized
+The current release line is **1.9.7** and package metadata is kept synchronized
 with the root package and MCP Registry manifest.
 
 Contributors should assume the following areas are part of the current release line:

package/docs/KNOWN_ISSUES_AND_ROADMAP.md

@@ -1,6 +1,6 @@
 # Memorix 已知边界与路线图
 
-> 最后审阅：2026-09-22（对照 v1.9.6 发布内容）
+> 最后审阅：2026-09-28（对照 v1.9.7 发布内容）
 
 这份文档说明仍然成立的产品边界、风险和方向；它不是发布流水账。
 

package/docs/README.md

@@ -126,7 +126,7 @@ Historical/deep-reference documents may describe older designs. If they conflict
 
 ## Current Product Line
 
-The current product line is **1.9.6**. Multi-device store sync is opt-in and
+The current product line is **1.9.7**. Multi-device store sync is opt-in and
 keeps local SQLite canonical; existing users do not upload anything until they
 configure a relay provider explicitly.
 The authoritative acceptance contract for the current implementation is

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "memorix",
   "mcpName": "io.github.AVIDS2/memorix",
-  "version": "1.9.6",
+  "version": "1.9.7",
   "description": "Local-first shared memory layer for AI coding agents across MCP clients, Git history, reasoning context, and project sessions.",
   "type": "module",
   "sideEffects": false,

package/plugins/antigravity/memorix/plugin.json

@@ -1,4 +1,4 @@
 {
   "name": "memorix",
-  "version": "1.9.6"
+  "version": "1.9.7"
 }

package/plugins/claude/memorix/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "memorix",
-  "version": "1.9.6",
+  "version": "1.9.7",
   "description": "Shared workspace memory for Claude Code and other AI coding agents.",
   "author": {
     "name": "AVIDS2",

package/plugins/codebuddy/memorix/.codebuddy-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.9.6",
+  "version": "1.9.7",
   "description": "Local-first project memory for CodeBuddy Code and other coding agents.",
   "author": {
     "name": "AVIDS2",

package/plugins/codex/memorix/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.9.6",
+  "version": "1.9.7",
   "description": "Shared workspace memory for Codex and other AI coding agents.",
   "author": {
     "name": "AVIDS2",

package/plugins/copilot/memorix/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.9.6",
+  "version": "1.9.7",
   "description": "Shared local workspace memory for GitHub Copilot CLI and other AI coding agents.",
   "author": {
     "name": "AVIDS2",

package/plugins/gemini/memorix/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.9.6",
+  "version": "1.9.7",
   "mcpServers": {
     "memorix": {
       "command": "memorix",

package/plugins/hermes/memorix/plugin.yaml

@@ -1,5 +1,5 @@
 name: memorix
-version: "1.9.6"
+version: "1.9.7"
 description: Shared workspace memory bridge for Hermes Agent.
 author: AVIDS2
 license: Apache-2.0

package/plugins/omp/memorix/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix-omp-package",
-  "version": "1.9.6",
+  "version": "1.9.7",
   "description": "Memorix shared workspace memory package for Oh-my-Pi.",
   "license": "Apache-2.0",
   "keywords": [

package/plugins/openclaw/memorix/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.9.6",
+  "version": "1.9.7",
   "description": "Shared workspace memory for OpenClaw and other AI coding agents.",
   "author": {
     "name": "AVIDS2",

package/plugins/pi/memorix/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix-pi-package",
-  "version": "1.9.6",
+  "version": "1.9.7",
   "description": "Memorix shared workspace memory package for Pi coding agent.",
   "license": "Apache-2.0",
   "keywords": [

package/server.json

@@ -7,7 +7,7 @@
     "url": "https://github.com/AVIDS2/memorix",
     "source": "github"
   },
-  "version": "1.9.6",
+  "version": "1.9.7",
   "websiteUrl": "https://mem.rglens.com",
   "icons": [
     {
@@ -22,7 +22,7 @@
     {
       "registryType": "npm",
       "identifier": "memorix",
-      "version": "1.9.6",
+      "version": "1.9.7",
       "runtimeHint": "npx",
       "packageArguments": [
         {

package/src/store/orama-store.ts

@@ -909,6 +909,11 @@ export async function searchObservations(options: SearchOptions): Promise<IndexE
   // Fast-tier queries skip embedding entirely (fulltext is sufficient)
   let queryVector: number[] | null = null;
   let embeddingProviderForSearch: EmbeddingProvider | null = null;
+  // Distinct from `embeddingEnabled` (static config): this tracks whether the
+  // current query can use embeddings (provider unavailable, incompatible
+  // dimensions, TLS, network, or timeout). `canUsePersistentLexical` below
+  // must fall back whenever this is true.
+  let embeddingUnavailable = false;
   if (quality !== 'fast' && embeddingEnabled && hasQuery && tier !== 'fast') {
     try {
       const provider = await getEmbeddingProvider();
@@ -916,6 +921,7 @@ export async function searchObservations(options: SearchOptions): Promise<IndexE
         embeddingProviderForSearch = provider;
         const activeVectorDimensions = getVectorDimensions();
         if (activeVectorDimensions !== null && provider.dimensions !== activeVectorDimensions) {
+          embeddingUnavailable = true;
           rememberSearchMode(
             modeKey,
             `fulltext (embedding dimension mismatch: provider ${provider.dimensions}d vs index ${activeVectorDimensions}d)`,
@@ -961,9 +967,12 @@ export async function searchObservations(options: SearchOptions): Promise<IndexE
               : { text: 0.6, vector: 0.4 },
           };
         }
+      } else {
+        embeddingUnavailable = true;
       }
     } catch (error) {
       // Fallback to fulltext if embedding fails or times out
+      embeddingUnavailable = true;
       rememberSearchMode(modeKey, 'fulltext (embedding unavailable)');
       console.error('[memorix] Embedding failed or timed out, falling back to fulltext search');
     }
@@ -972,8 +981,14 @@ export async function searchObservations(options: SearchOptions): Promise<IndexE
   mark('preSearch');
   let results: SearchResultLike | Awaited<ReturnType<typeof search>>;
   const persistentCorpusEligible = await shouldUsePersistentSearch(projectIds, options.projectId);
+  // `embeddingEnabled` alone misses the common case: embedding is configured
+  // (enabled) but the current provider is unavailable, has incompatible
+  // dimensions, or failed at runtime. Without this per-query state, those
+  // failures leave queryVector null AND canUsePersistentLexical false, so
+  // neither the semantic nor lexical persistent path runs — a silent,
+  // deterministic empty result despite the FTS5 index having real matches.
   const canUsePersistentLexical = persistentCorpusEligible && Boolean(hasQuery) && !queryVector &&
-    (quality === 'fast' || tier === 'fast' || !embeddingEnabled);
+    (quality === 'fast' || tier === 'fast' || !embeddingEnabled || embeddingUnavailable);
   let persistent = persistentCorpusEligible && queryVector && embeddingProviderForSearch
     ? await searchPersistentSemantically(options, projectIds, requestLimit, queryVector, embeddingProviderForSearch)
     : canUsePersistentLexical

package/src/store/sqlite-fts.ts

@@ -1,4 +1,5 @@
 import type { Observation } from '../types.js';
+import { isTransientSqliteError } from './sqlite-reliability.js';
 
 /** Rows returned by the derived FTS5 index before normal Observation parsing. */
 export interface SqliteLexicalHit {
@@ -56,31 +57,52 @@ export function buildFtsQuery(query: string): string | null {
   return unique.map((token) => `"${normalizeFtsToken(token)}"`).join(' OR ');
 }
 
+/**
+ * initializeObservationLexicalIndex runs exactly once per db handle (called
+ * from getDatabase's synchronous setup), so a transient cross-process BUSY
+ * here would otherwise be cached as a permanent "unavailable" for that
+ * handle's entire lifetime, with no other call site ever re-checking it.
+ */
+const FTS_INIT_MAX_ATTEMPTS = 3;
+
 /**
  * Create and reconcile the external-content FTS5 index for one SQLite handle.
- * FTS5 is an optional SQLite capability, so an unavailable extension is a
- * normal fallback rather than a reason to make the durable store unusable.
+ * FTS5 is an optional SQLite capability, so a genuinely unavailable extension
+ * is a normal fallback rather than a reason to make the durable store
+ * unusable. Cross-process lock contention (SQLITE_BUSY) is not that case —
+ * it is retried a few times, mirroring the retry already applied to the
+ * write paths in sqlite-store.ts / session-store.ts / mini-skill-store.ts,
+ * since the caller here is synchronous and cannot await retrySqliteBusy.
  */
 export function initializeObservationLexicalIndex(db: any): boolean {
   const known = ftsAvailability.get(db);
   if (known !== undefined) return known;
 
-  try {
-    db.exec(CREATE_OBSERVATION_FTS);
-    const observationCount = Number(db.prepare('SELECT COUNT(*) AS count FROM observations').get()?.count ?? 0);
-    const indexedCount = Number(db.prepare(`SELECT COUNT(*) AS count FROM ${FTS_TABLE}`).get()?.count ?? 0);
-    if (observationCount !== indexedCount) {
-      db.exec(`INSERT INTO ${FTS_TABLE}(${FTS_TABLE}) VALUES ('rebuild')`);
+  let lastError: unknown;
+  for (let attempt = 1; attempt <= FTS_INIT_MAX_ATTEMPTS; attempt++) {
+    try {
+      db.exec(CREATE_OBSERVATION_FTS);
+      const observationCount = Number(db.prepare('SELECT COUNT(*) AS count FROM observations').get()?.count ?? 0);
+      const indexedCount = Number(db.prepare(`SELECT COUNT(*) AS count FROM ${FTS_TABLE}`).get()?.count ?? 0);
+      if (observationCount !== indexedCount) {
+        db.exec(`INSERT INTO ${FTS_TABLE}(${FTS_TABLE}) VALUES ('rebuild')`);
+      }
+      ftsAvailability.set(db, true);
+      return true;
+    } catch (error) {
+      lastError = error;
+      if (!isTransientSqliteError(error) || attempt === FTS_INIT_MAX_ATTEMPTS) break;
+      // better-sqlite3 is synchronous, so there is no await-able delay here;
+      // re-entering db.exec/prepare re-enters SQLite's own busy_timeout wait
+      // (already configured in sqlite-db.ts), which is the retry itself.
     }
-    ftsAvailability.set(db, true);
-    return true;
-  } catch (error) {
-    ftsAvailability.set(db, false);
-    console.warn(
-      `[memorix] SQLite FTS5 unavailable; using the existing search fallback: ${error instanceof Error ? error.message : String(error)}`,
-    );
-    return false;
   }
+
+  ftsAvailability.set(db, false);
+  console.warn(
+    `[memorix] SQLite FTS5 unavailable; using the existing search fallback: ${lastError instanceof Error ? lastError.message : String(lastError)}`,
+  );
+  return false;
 }
 
 export function isObservationLexicalIndexEnabled(db: any): boolean {