memorix 1.9.4 → 1.9.5

package/dist/index.js

@@ -707,18 +707,21 @@ CREATE TABLE IF NOT EXISTS chat_transcript (
 `;
     CREATE_GRAPH_ENTITIES_TABLE = `
 CREATE TABLE IF NOT EXISTS graph_entities (
-  name            TEXT PRIMARY KEY,
+  projectId       TEXT NOT NULL,
+  name            TEXT NOT NULL,
   entityType      TEXT NOT NULL DEFAULT '',
-  observations    TEXT NOT NULL DEFAULT '[]'
+  observations    TEXT NOT NULL DEFAULT '[]',
+  PRIMARY KEY (projectId, name)
 );
 `;
     CREATE_GRAPH_RELATIONS_TABLE = `
 CREATE TABLE IF NOT EXISTS graph_relations (
   id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  projectId       TEXT NOT NULL,
   from_entity     TEXT NOT NULL,
   to_entity       TEXT NOT NULL,
   relationType    TEXT NOT NULL DEFAULT '',
-  UNIQUE(from_entity, to_entity, relationType)
+  UNIQUE(projectId, from_entity, to_entity, relationType)
 );
 `;
     CREATE_CODE_FILES_TABLE = `
@@ -1518,6 +1521,21 @@ CREATE UNIQUE INDEX IF NOT EXISTS idx_maintenance_jobs_active_dedupe
 import { promises as fs2 } from "fs";
 import { randomUUID } from "crypto";
 import path4 from "path";
+function canReclaimStaleLock(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    const pid = Number(parsed.pid);
+    if (!Number.isSafeInteger(pid) || pid < 1) return true;
+    try {
+      process.kill(pid, 0);
+      return false;
+    } catch (error) {
+      return error.code !== "EPERM";
+    }
+  } catch {
+    return true;
+  }
+}
 async function acquireLock(lockPath) {
   for (let i2 = 0; i2 < MAX_RETRIES; i2++) {
     try {
@@ -1531,9 +1549,12 @@ async function acquireLock(lockPath) {
         try {
           const stat5 = await fs2.stat(lockPath);
           if (Date.now() - stat5.mtimeMs > LOCK_STALE_MS) {
-            await fs2.unlink(lockPath).catch(() => {
-            });
-            continue;
+            const raw2 = await fs2.readFile(lockPath, "utf8").catch(() => "");
+            if (canReclaimStaleLock(raw2)) {
+              await fs2.unlink(lockPath).catch(() => {
+              });
+              continue;
+            }
           }
         } catch {
           continue;
@@ -1544,6 +1565,10 @@ async function acquireLock(lockPath) {
       }
     }
   }
+  const raw = await fs2.readFile(lockPath, "utf8").catch(() => "");
+  if (!canReclaimStaleLock(raw)) {
+    throw new Error(`Failed to acquire lock: ${lockPath} (owner is still running)`);
+  }
   await fs2.unlink(lockPath).catch(() => {
   });
   try {
@@ -1782,6 +1807,11 @@ async function listProjectDirs(baseDir) {
   }
 }
 async function migrateSubdirsToFlat(baseDir) {
+  const base = baseDir ?? resolveDefaultDataDir();
+  await fs4.mkdir(base, { recursive: true });
+  return withFileLock(base, () => migrateSubdirsToFlatUnlocked(base));
+}
+async function migrateSubdirsToFlatUnlocked(baseDir) {
   const base = baseDir ?? resolveDefaultDataDir();
   await fs4.mkdir(base, { recursive: true });
   let entries;
@@ -1838,7 +1868,7 @@ async function migrateSubdirsToFlat(baseDir) {
   for (const { obs } of subdirData) {
     for (const o of obs) {
       const isDuplicate = allObs.some(
-        (existing) => existing.title === o.title && existing.createdAt === o.createdAt
+        (existing) => existing.title === o.title && existing.createdAt === o.createdAt && existing.projectId === o.projectId
       );
       if (!isDuplicate) {
         allObs.push(o);
@@ -1871,18 +1901,14 @@ async function migrateSubdirsToFlat(baseDir) {
       mergedRelations.push(rel);
     }
   }
-  await fs4.writeFile(path6.join(base, "observations.json"), JSON.stringify(allObs, null, 2), "utf-8");
-  await fs4.writeFile(
-    path6.join(base, "counter.json"),
-    JSON.stringify({ nextId: allObs.length + 1 }),
-    "utf-8"
-  );
+  await atomicWriteFile(path6.join(base, "observations.json"), JSON.stringify(allObs, null, 2));
+  await atomicWriteFile(path6.join(base, "counter.json"), JSON.stringify({ nextId: allObs.length + 1 }));
   const graphLines = [
     ...[...entityMap.values()].map((e2) => JSON.stringify({ type: "entity", name: e2.name, entityType: e2.entityType, observations: e2.observations })),
     ...mergedRelations.map((r2) => JSON.stringify({ type: "relation", from: r2.from, to: r2.to, relationType: r2.relationType }))
   ];
   if (graphLines.length > 0) {
-    await fs4.writeFile(path6.join(base, "graph.jsonl"), graphLines.join("\n"), "utf-8");
+    await atomicWriteFile(path6.join(base, "graph.jsonl"), graphLines.join("\n"));
   }
   let allSessions = [];
   try {
@@ -1900,7 +1926,7 @@ async function migrateSubdirsToFlat(baseDir) {
     }
   }
   if (allSessions.length > 0) {
-    await fs4.writeFile(path6.join(base, "sessions.json"), JSON.stringify(allSessions, null, 2), "utf-8");
+    await atomicWriteFile(path6.join(base, "sessions.json"), JSON.stringify(allSessions, null, 2));
   }
   const backupDir = path6.join(base, ".migrated-subdirs");
   await fs4.mkdir(backupDir, { recursive: true });
@@ -1936,6 +1962,7 @@ var init_persistence = __esm({
   "src/store/persistence.ts"() {
     "use strict";
     init_esm_shims();
+    init_file_lock();
     init_persistence_json();
   }
 });
@@ -1943,6 +1970,7 @@ var init_persistence = __esm({
 // src/store/graph-store.ts
 var graph_store_exports = {};
 __export(graph_store_exports, {
+  DEFAULT_GRAPH_PROJECT_ID: () => DEFAULT_GRAPH_PROJECT_ID,
   GraphSqliteStore: () => GraphSqliteStore,
   getGraphStore: () => getGraphStore,
   initGraphStore: () => initGraphStore,
@@ -1972,37 +2000,106 @@ function entityToRow(entity) {
     observations: JSON.stringify(entity.observations ?? [])
   };
 }
-async function initGraphStore(dataDir) {
-  if (_graphStore && _graphDataDir === dataDir) return _graphStore;
-  _graphStore = new GraphSqliteStore();
-  await _graphStore.init(dataDir);
-  _graphDataDir = dataDir;
-  return _graphStore;
+function ensureScopedGraphSchema(db2) {
+  const entityColumns = db2.prepare("PRAGMA table_info(graph_entities)").all();
+  if (!entityColumns.some((column) => column.name === "projectId")) {
+    const migrate = db2.transaction(() => {
+      db2.exec("ALTER TABLE graph_entities RENAME TO graph_entities_legacy_unscoped");
+      db2.exec(CREATE_SCOPED_GRAPH_ENTITIES);
+      db2.exec(`INSERT INTO graph_entities (projectId, name, entityType, observations)
+        SELECT '${LEGACY_GRAPH_PROJECT_ID}', name, entityType, observations
+        FROM graph_entities_legacy_unscoped`);
+      db2.exec("DROP TABLE graph_entities_legacy_unscoped");
+    });
+    migrate();
+  } else {
+    db2.exec(CREATE_SCOPED_GRAPH_ENTITIES);
+  }
+  const relationColumns = db2.prepare("PRAGMA table_info(graph_relations)").all();
+  if (!relationColumns.some((column) => column.name === "projectId")) {
+    const migrate = db2.transaction(() => {
+      db2.exec("ALTER TABLE graph_relations RENAME TO graph_relations_legacy_unscoped");
+      db2.exec(CREATE_SCOPED_GRAPH_RELATIONS);
+      db2.exec(`INSERT INTO graph_relations (projectId, from_entity, to_entity, relationType)
+        SELECT '${LEGACY_GRAPH_PROJECT_ID}', from_entity, to_entity, relationType
+        FROM graph_relations_legacy_unscoped`);
+      db2.exec("DROP TABLE graph_relations_legacy_unscoped");
+    });
+    migrate();
+  } else {
+    db2.exec(CREATE_SCOPED_GRAPH_RELATIONS);
+  }
+}
+function graphStoreKey(dataDir, projectId) {
+  return `${path7.resolve(dataDir)}\0${projectId}`;
 }
-function getGraphStore() {
-  if (!_graphStore) throw new Error("[memorix] GraphStore not initialized \u2014 call initGraphStore() first");
-  return _graphStore;
+async function initGraphStore(dataDir, projectId = DEFAULT_GRAPH_PROJECT_ID) {
+  const key = graphStoreKey(dataDir, projectId);
+  const existing = _graphStores.get(key);
+  if (existing) {
+    _graphStores.delete(key);
+    _graphStores.set(key, existing);
+    _activeGraphKey = key;
+    return existing;
+  }
+  const store = new GraphSqliteStore();
+  await store.init(dataDir, projectId);
+  _graphStores.set(key, store);
+  while (_graphStores.size > MAX_GRAPH_STORE_CACHE) {
+    const oldest = _graphStores.keys().next().value;
+    if (!oldest) break;
+    _graphStores.delete(oldest);
+  }
+  _activeGraphKey = key;
+  return store;
+}
+function getGraphStore(dataDir, projectId) {
+  const key = dataDir && projectId ? graphStoreKey(dataDir, projectId) : _activeGraphKey;
+  const store = key ? _graphStores.get(key) : void 0;
+  if (!store) throw new Error("[memorix] GraphStore not initialized \u2014 call initGraphStore() first");
+  return store;
 }
 function resetGraphStore() {
-  if (_graphStore) {
+  for (const store of _graphStores.values()) {
     try {
-      _graphStore.close();
+      store.close();
     } catch {
     }
   }
-  _graphStore = null;
-  _graphDataDir = null;
+  _graphStores.clear();
+  _activeGraphKey = null;
 }
-var GraphSqliteStore, _graphStore, _graphDataDir;
+var DEFAULT_GRAPH_PROJECT_ID, LEGACY_GRAPH_PROJECT_ID, MAX_GRAPH_STORE_CACHE, CREATE_SCOPED_GRAPH_ENTITIES, CREATE_SCOPED_GRAPH_RELATIONS, GraphSqliteStore, _graphStores, _activeGraphKey;
 var init_graph_store = __esm({
   "src/store/graph-store.ts"() {
     "use strict";
     init_esm_shims();
     init_sqlite_db();
     init_persistence();
+    DEFAULT_GRAPH_PROJECT_ID = "__default__";
+    LEGACY_GRAPH_PROJECT_ID = "__legacy__";
+    MAX_GRAPH_STORE_CACHE = 32;
+    CREATE_SCOPED_GRAPH_ENTITIES = `
+CREATE TABLE IF NOT EXISTS graph_entities (
+  projectId       TEXT NOT NULL,
+  name            TEXT NOT NULL,
+  entityType      TEXT NOT NULL DEFAULT '',
+  observations    TEXT NOT NULL DEFAULT '[]',
+  PRIMARY KEY (projectId, name)
+);`;
+    CREATE_SCOPED_GRAPH_RELATIONS = `
+CREATE TABLE IF NOT EXISTS graph_relations (
+  id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  projectId       TEXT NOT NULL,
+  from_entity     TEXT NOT NULL,
+  to_entity       TEXT NOT NULL,
+  relationType    TEXT NOT NULL DEFAULT '',
+  UNIQUE(projectId, from_entity, to_entity, relationType)
+);`;
     GraphSqliteStore = class {
       db = null;
       dataDir = "";
+      projectId = DEFAULT_GRAPH_PROJECT_ID;
       stmtInsertEntity = null;
       stmtUpdateEntityObs = null;
       stmtDeleteEntity = null;
@@ -2012,45 +2109,89 @@ var init_graph_store = __esm({
       stmtDeleteRelation = null;
       stmtDeleteRelationsByEntity = null;
       stmtSelectAllRelations = null;
-      async init(dataDir) {
+      async init(dataDir, projectId = DEFAULT_GRAPH_PROJECT_ID) {
         this.dataDir = dataDir;
+        this.projectId = projectId;
         this.db = getDatabase(dataDir);
+        ensureScopedGraphSchema(this.db);
         this.stmtInsertEntity = this.db.prepare(
-          `INSERT OR REPLACE INTO graph_entities (name, entityType, observations) VALUES (@name, @entityType, @observations)`
+          `INSERT OR REPLACE INTO graph_entities (projectId, name, entityType, observations) VALUES (@projectId, @name, @entityType, @observations)`
         );
         this.stmtUpdateEntityObs = this.db.prepare(
-          `UPDATE graph_entities SET observations = @observations WHERE name = @name`
+          `UPDATE graph_entities SET observations = @observations WHERE projectId = @projectId AND name = @name`
         );
-        this.stmtDeleteEntity = this.db.prepare(`DELETE FROM graph_entities WHERE name = ?`);
-        this.stmtSelectAllEntities = this.db.prepare(`SELECT * FROM graph_entities`);
-        this.stmtSelectEntityByName = this.db.prepare(`SELECT * FROM graph_entities WHERE name = ?`);
+        this.stmtDeleteEntity = this.db.prepare(`DELETE FROM graph_entities WHERE projectId = ? AND name = ?`);
+        this.stmtSelectAllEntities = this.db.prepare(`SELECT * FROM graph_entities WHERE projectId = ? ORDER BY name`);
+        this.stmtSelectEntityByName = this.db.prepare(`SELECT * FROM graph_entities WHERE projectId = ? AND name = ?`);
         this.stmtInsertRelation = this.db.prepare(
-          `INSERT OR IGNORE INTO graph_relations (from_entity, to_entity, relationType) VALUES (@from, @to, @relationType)`
+          `INSERT OR IGNORE INTO graph_relations (projectId, from_entity, to_entity, relationType) VALUES (@projectId, @from, @to, @relationType)`
         );
         this.stmtDeleteRelation = this.db.prepare(
-          `DELETE FROM graph_relations WHERE from_entity = ? AND to_entity = ? AND relationType = ?`
+          `DELETE FROM graph_relations WHERE projectId = ? AND from_entity = ? AND to_entity = ? AND relationType = ?`
         );
         this.stmtDeleteRelationsByEntity = this.db.prepare(
-          `DELETE FROM graph_relations WHERE from_entity = ? OR to_entity = ?`
+          `DELETE FROM graph_relations WHERE projectId = ? AND (from_entity = ? OR to_entity = ?)`
         );
-        this.stmtSelectAllRelations = this.db.prepare(`SELECT * FROM graph_relations`);
+        this.stmtSelectAllRelations = this.db.prepare(`SELECT * FROM graph_relations WHERE projectId = ? ORDER BY id`);
         await this.migrateFromJsonlIfNeeded();
       }
       async migrateFromJsonlIfNeeded() {
-        const count2 = this.db.prepare(`SELECT COUNT(*) AS cnt FROM graph_entities`).get();
+        const count2 = this.db.prepare(`SELECT COUNT(*) AS cnt FROM graph_entities WHERE projectId = ?`).get(this.projectId);
+        const totalCount = this.db.prepare(`SELECT COUNT(*) AS cnt FROM graph_entities`).get();
         if (count2.cnt > 0) return;
+        if (totalCount.cnt > 0) return;
         const jsonlPath = path7.join(this.dataDir, "graph.jsonl");
         if (!fs5.existsSync(jsonlPath)) return;
         try {
           const data = await loadGraphJsonl(this.dataDir);
           if (data.entities.length === 0 && data.relations.length === 0) return;
           console.error(`[memorix] Migrating graph from JSONL to SQLite (${data.entities.length} entities, ${data.relations.length} relations)...`);
+          const observations2 = this.db.prepare("SELECT id, projectId FROM observations").all();
+          const projectByObservationId = new Map(observations2.map((row) => [row.id, row.projectId]));
+          const projectsByEntity = /* @__PURE__ */ new Map();
+          for (const entity of data.entities) {
+            const projects = /* @__PURE__ */ new Set();
+            for (const content of entity.observations ?? []) {
+              const match2 = /^\[#(\d+)\]/.exec(content);
+              const projectId = match2 ? projectByObservationId.get(Number(match2[1])) : void 0;
+              if (projectId) projects.add(projectId);
+            }
+            projectsByEntity.set(entity.name, projects);
+          }
+          let changed = true;
+          while (changed) {
+            changed = false;
+            for (const relation of data.relations) {
+              const from = projectsByEntity.get(relation.from) ?? /* @__PURE__ */ new Set();
+              const to = projectsByEntity.get(relation.to) ?? /* @__PURE__ */ new Set();
+              if (from.size > 0 && to.size === 0) {
+                projectsByEntity.set(relation.to, new Set(from));
+                changed = true;
+              } else if (to.size > 0 && from.size === 0) {
+                projectsByEntity.set(relation.from, new Set(to));
+                changed = true;
+              }
+            }
+          }
+          const entityRows = data.entities.flatMap((entity) => {
+            const projects = projectsByEntity.get(entity.name) ?? /* @__PURE__ */ new Set();
+            const owners = projects.size > 0 ? [...projects] : [this.projectId];
+            return owners.map((projectId) => ({ ...entityToRow(entity), projectId }));
+          });
+          const projectSet = new Set(entityRows.map((row) => String(row.projectId)));
+          const relationRows = data.relations.flatMap((relation) => {
+            const from = projectsByEntity.get(relation.from) ?? /* @__PURE__ */ new Set();
+            const to = projectsByEntity.get(relation.to) ?? /* @__PURE__ */ new Set();
+            const shared = [...from].filter((projectId) => to.has(projectId));
+            const owners = shared.length > 0 ? shared : from.size === 0 && to.size === 0 ? [this.projectId] : [];
+            return owners.filter((projectId) => projectSet.has(projectId)).map((projectId) => ({ projectId, from: relation.from, to: relation.to, relationType: relation.relationType }));
+          });
           const insertAll = this.db.transaction(() => {
-            for (const entity of data.entities) {
-              this.stmtInsertEntity.run(entityToRow(entity));
+            for (const entity of entityRows) {
+              this.stmtInsertEntity.run(entity);
             }
-            for (const rel of data.relations) {
-              this.stmtInsertRelation.run({ from: rel.from, to: rel.to, relationType: rel.relationType });
+            for (const relation of relationRows) {
+              this.stmtInsertRelation.run(relation);
             }
           });
           insertAll();
@@ -2060,10 +2201,10 @@ var init_graph_store = __esm({
         }
       }
       loadEntities() {
-        return this.stmtSelectAllEntities.all().map(rowToEntity);
+        return this.stmtSelectAllEntities.all(this.projectId).map(rowToEntity);
       }
       loadRelations() {
-        return this.stmtSelectAllRelations.all().map((row) => ({
+        return this.stmtSelectAllRelations.all(this.projectId).map((row) => ({
           from: row.from_entity,
           to: row.to_entity,
           relationType: row.relationType
@@ -2072,7 +2213,7 @@ var init_graph_store = __esm({
       insertEntities(entities) {
         const insertAll = this.db.transaction(() => {
           for (const entity of entities) {
-            this.stmtInsertEntity.run(entityToRow(entity));
+            this.stmtInsertEntity.run({ ...entityToRow(entity), projectId: this.projectId });
           }
         });
         insertAll();
@@ -2080,7 +2221,7 @@ var init_graph_store = __esm({
       insertRelations(relations) {
         const insertAll = this.db.transaction(() => {
           for (const rel of relations) {
-            this.stmtInsertRelation.run({ from: rel.from, to: rel.to, relationType: rel.relationType });
+            this.stmtInsertRelation.run({ projectId: this.projectId, from: rel.from, to: rel.to, relationType: rel.relationType });
           }
         });
         insertAll();
@@ -2088,8 +2229,8 @@ var init_graph_store = __esm({
       deleteEntities(names) {
         const deleteAll = this.db.transaction(() => {
           for (const name of names) {
-            this.stmtDeleteRelationsByEntity.run(name, name);
-            this.stmtDeleteEntity.run(name);
+            this.stmtDeleteRelationsByEntity.run(this.projectId, name, name);
+            this.stmtDeleteEntity.run(this.projectId, name);
           }
         });
         deleteAll();
@@ -2097,7 +2238,7 @@ var init_graph_store = __esm({
       deleteRelations(relations) {
         const deleteAll = this.db.transaction(() => {
           for (const rel of relations) {
-            this.stmtDeleteRelation.run(rel.from, rel.to, rel.relationType);
+            this.stmtDeleteRelation.run(this.projectId, rel.from, rel.to, rel.relationType);
           }
         });
         deleteAll();
@@ -2105,13 +2246,13 @@ var init_graph_store = __esm({
       addObservations(updates) {
         const updateAll = this.db.transaction(() => {
           for (const u of updates) {
-            const row = this.stmtSelectEntityByName.get(u.entityName);
+            const row = this.stmtSelectEntityByName.get(this.projectId, u.entityName);
             if (!row) continue;
             const existing = safeJsonParse(row.observations, []);
             const newObs = u.contents.filter((c) => !existing.includes(c));
             if (newObs.length > 0) {
               existing.push(...newObs);
-              this.stmtUpdateEntityObs.run({ name: u.entityName, observations: JSON.stringify(existing) });
+              this.stmtUpdateEntityObs.run({ projectId: this.projectId, name: u.entityName, observations: JSON.stringify(existing) });
             }
           }
         });
@@ -2120,11 +2261,11 @@ var init_graph_store = __esm({
       deleteObservations(deletions) {
         const deleteAll = this.db.transaction(() => {
           for (const d of deletions) {
-            const row = this.stmtSelectEntityByName.get(d.entityName);
+            const row = this.stmtSelectEntityByName.get(this.projectId, d.entityName);
             if (!row) continue;
             const existing = safeJsonParse(row.observations, []);
             const filtered = existing.filter((o) => !d.observations.includes(o));
-            this.stmtUpdateEntityObs.run({ name: d.entityName, observations: JSON.stringify(filtered) });
+            this.stmtUpdateEntityObs.run({ projectId: this.projectId, name: d.entityName, observations: JSON.stringify(filtered) });
           }
         });
         deleteAll();
@@ -2135,13 +2276,13 @@ var init_graph_store = __esm({
        */
       replaceAll(entities, relations) {
         const replaceAll = this.db.transaction(() => {
-          this.db.prepare("DELETE FROM graph_relations").run();
-          this.db.prepare("DELETE FROM graph_entities").run();
+          this.db.prepare("DELETE FROM graph_relations WHERE projectId = ?").run(this.projectId);
+          this.db.prepare("DELETE FROM graph_entities WHERE projectId = ?").run(this.projectId);
           for (const entity of entities) {
-            this.stmtInsertEntity.run(entityToRow(entity));
+            this.stmtInsertEntity.run({ ...entityToRow(entity), projectId: this.projectId });
           }
           for (const rel of relations) {
-            this.stmtInsertRelation.run({ from: rel.from, to: rel.to, relationType: rel.relationType });
+            this.stmtInsertRelation.run({ projectId: this.projectId, from: rel.from, to: rel.to, relationType: rel.relationType });
           }
         });
         replaceAll();
@@ -2149,8 +2290,8 @@ var init_graph_store = __esm({
       close() {
       }
     };
-    _graphStore = null;
-    _graphDataDir = null;
+    _graphStores = /* @__PURE__ */ new Map();
+    _activeGraphKey = null;
   }
 });
 
@@ -2165,11 +2306,14 @@ var init_graph = __esm({
       entities = [];
       relations = [];
       projectDir;
+      projectId;
+      store = null;
       initialized = false;
       /** Index: lowercase entity name → Entity for O(1) lookups */
       entityIndex = /* @__PURE__ */ new Map();
-      constructor(projectDir2) {
+      constructor(projectDir2, projectId = "__default__") {
         this.projectDir = projectDir2;
+        this.projectId = projectId;
       }
       /** Rebuild the entity name index */
       rebuildIndex() {
@@ -2181,10 +2325,9 @@ var init_graph = __esm({
       /** Load graph from SQLite on first access */
       async init() {
         if (this.initialized) return;
-        await initGraphStore(this.projectDir);
-        const store = getGraphStore();
-        this.entities = store.loadEntities();
-        this.relations = store.loadRelations();
+        this.store = await initGraphStore(this.projectDir, this.projectId);
+        this.entities = this.store.loadEntities();
+        this.relations = this.store.loadRelations();
         this.rebuildIndex();
         this.initialized = true;
       }
@@ -2198,8 +2341,8 @@ var init_graph = __esm({
       }
       /** Persist current state to SQLite */
       async save() {
-        const store = getGraphStore();
-        store.replaceAll(this.entities, this.relations);
+        if (!this.store) throw new Error("[memorix] KnowledgeGraphManager not initialized");
+        this.store.replaceAll(this.entities, this.relations);
       }
       /** Create new entities (skip duplicates by name) */
       async createEntities(entities) {
@@ -6986,6 +7129,7 @@ var init_sqlite_store = __esm({
     init_sqlite_db();
     init_sqlite_reliability();
     init_sqlite_fts();
+    init_file_lock();
     SqliteBackend = class {
       db = null;
       dataDir = "";
@@ -7149,38 +7293,43 @@ var init_sqlite_store = __esm({
       }
       // ── Migration ────────────────────────────────────────────────────
       async migrateFromJsonIfNeeded() {
-        const count2 = this.db.prepare(`SELECT COUNT(*) AS cnt FROM observations`).get();
-        if (count2.cnt > 0) return;
         const jsonPath = path10.join(this.dataDir, "observations.json");
         if (!fs7.existsSync(jsonPath)) return;
-        try {
+        await withFileLock(this.dataDir, async () => {
+          const count2 = this.db.prepare(`SELECT COUNT(*) AS cnt FROM observations`).get();
+          if (count2.cnt > 0) return;
           const raw = fs7.readFileSync(jsonPath, "utf-8");
-          const observations2 = JSON.parse(raw);
+          const parsed = JSON.parse(raw);
+          if (!Array.isArray(parsed)) {
+            throw new Error("[memorix] observations.json migration refused: expected a JSON array");
+          }
+          const observations2 = parsed;
           if (observations2.length === 0) return;
+          if (observations2.some((obs) => !obs || !Number.isSafeInteger(obs.id) || obs.id < 1 || typeof obs.projectId !== "string")) {
+            throw new Error("[memorix] observations.json migration refused: invalid observation record");
+          }
           console.error(`[memorix] Migrating ${observations2.length} observations from JSON to SQLite...`);
           const insertMany = this.db.transaction((obsList) => {
             for (const obs of obsList) {
               this.stmtInsert.run(obsToRow(obs));
             }
-          });
-          insertMany(observations2);
-          const counterPath = path10.join(this.dataDir, "counter.json");
-          if (fs7.existsSync(counterPath)) {
-            try {
+            const counterPath = path10.join(this.dataDir, "counter.json");
+            let counterNextId;
+            if (fs7.existsSync(counterPath)) {
               const counterData = JSON.parse(fs7.readFileSync(counterPath, "utf-8"));
-              const nextId2 = counterData.nextId ?? counterData.next_id ?? Math.max(...observations2.map((o) => o.id)) + 1;
-              this.rawSaveIdCounter(nextId2);
-            } catch {
-              this.rawSaveIdCounter(Math.max(...observations2.map((o) => o.id)) + 1);
+              const candidate = counterData.nextId ?? counterData.next_id;
+              if (candidate !== void 0 && (!Number.isSafeInteger(candidate) || Number(candidate) < 1)) {
+                throw new Error("[memorix] counter.json migration refused: nextId must be a positive integer");
+              }
+              counterNextId = candidate === void 0 ? void 0 : Number(candidate);
             }
-          } else {
-            this.rawSaveIdCounter(Math.max(...observations2.map((o) => o.id)) + 1);
-          }
-          this.bumpGeneration();
+            const maxId = Math.max(...obsList.map((obs) => obs.id));
+            this.rawSaveIdCounter(Math.max(counterNextId ?? 1, maxId + 1));
+            this.bumpGeneration();
+          });
+          insertMany(observations2);
           console.error(`[memorix] Migration complete. ${observations2.length} observations now in SQLite.`);
-        } catch (err) {
-          console.error(`[memorix] JSON\u2192SQLite migration failed (non-fatal, data preserved in JSON): ${err}`);
-        }
+        });
       }
       // ── Public read ──────────────────────────────────────────────────
       async loadAll() {
@@ -159802,7 +159951,7 @@ var init_request_context = __esm({
 function getMcpServerInfo() {
   return {
     name: "memorix",
-    version: true ? "1.9.4" : "1.0.1"
+    version: true ? "1.9.5" : "1.0.1"
   };
 }
 function createMcpDiscoverResult(capabilities, serverInfo) {
@@ -160197,7 +160346,7 @@ async function getSessionContext(projectDir2, projectId, limit2 = 3, reader2) {
     let graphNeighbors = [];
     if (!reader2 && activeEntities.length > 0) {
       try {
-        const graphMgr = new KnowledgeGraphManager(projectDir2);
+        const graphMgr = new KnowledgeGraphManager(projectDir2, projectId);
         await graphMgr.init();
         const { relations } = await graphMgr.readGraph();
         const activeSet = new Set(activeEntities.map((n) => n.toLowerCase()));
@@ -166539,8 +166688,7 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
         break;
       }
       case "/graph": {
-        await initGraphStore(effectiveDataDir);
-        const gStore = getGraphStore();
+        const gStore = await initGraphStore(effectiveDataDir, effectiveProjectId);
         const graph = { entities: gStore.loadEntities(), relations: gStore.loadRelations() };
         const graphObs = filterDashboardObservations(
           await getObservationStore().loadByProject(effectiveProjectId, { status: "active" }),
@@ -166584,8 +166732,8 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
         break;
       }
       case "/stats": {
-        await initGraphStore(effectiveDataDir);
-        const graph = { entities: getGraphStore().loadEntities(), relations: getGraphStore().loadRelations() };
+        const gStore = await initGraphStore(effectiveDataDir, effectiveProjectId);
+        const graph = { entities: gStore.loadEntities(), relations: gStore.loadRelations() };
         const observations2 = filterDashboardObservations(
           await getObservationStore().loadByProject(effectiveProjectId, { status: "active" }),
           effectiveProjectId
@@ -166778,15 +166926,15 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
       case "/knowledge-graph": {
         const { generateKnowledgeGraph: generateKnowledgeGraph2 } = await Promise.resolve().then(() => (init_knowledge_graph(), knowledge_graph_exports));
         const { initMiniSkillStore: initMiniSkillStore2, getMiniSkillStore: getMiniSkillStore2 } = await Promise.resolve().then(() => (init_mini_skill_store(), mini_skill_store_exports));
-        const { initGraphStore: initGraphStore2, getGraphStore: getGraphStore2 } = await Promise.resolve().then(() => (init_graph_store(), graph_store_exports));
+        const { initGraphStore: initGraphStore2 } = await Promise.resolve().then(() => (init_graph_store(), graph_store_exports));
         await initMiniSkillStore2(effectiveDataDir);
-        await initGraphStore2(effectiveDataDir);
+        const gStore = await initGraphStore2(effectiveDataDir, effectiveProjectId);
         const allObs = filterDashboardObservations(
           await getObservationStore().loadByProject(effectiveProjectId, { status: "active" }),
           effectiveProjectId
         );
         const skills = await getMiniSkillStore2().loadByProject(effectiveProjectId);
-        const fullGraph = { entities: getGraphStore2().loadEntities(), relations: getGraphStore2().loadRelations() };
+        const fullGraph = { entities: gStore.loadEntities(), relations: gStore.loadRelations() };
         const scoped = scopeKnowledgeGraphToProject(fullGraph, allObs);
         const graph = generateKnowledgeGraph2({
           projectId: effectiveProjectId,
@@ -166983,8 +167131,7 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
           } else {
             await obsStore.remove(obsId);
             try {
-              await initGraphStore(effectiveDataDir);
-              const gStore = getGraphStore();
+              const gStore = await initGraphStore(effectiveDataDir, effectiveProjectId);
               const prefix = `[#${obsId}] `;
               const deletions = [];
               for (const entity of gStore.loadEntities()) {
@@ -166999,8 +167146,8 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
           break;
         }
         if (apiPath === "/export") {
-          await initGraphStore(effectiveDataDir);
-          const fullGraph = { entities: getGraphStore().loadEntities(), relations: getGraphStore().loadRelations() };
+          const gStore = await initGraphStore(effectiveDataDir, effectiveProjectId);
+          const fullGraph = { entities: gStore.loadEntities(), relations: gStore.loadRelations() };
           const observations2 = filterDashboardObservations(
             await getObservationStore().loadByProject(effectiveProjectId, { status: "active" }),
             effectiveProjectId
@@ -170445,7 +170592,7 @@ async function createMemorixServer(cwd, existingServer, sharedTeam, options = {}
     const store = getObservationStore();
     console.error(`[memorix] ObservationStore backend: ${store.getBackendName()}, generation: ${store.getGeneration()}`);
   }
-  let graphManager = new KnowledgeGraphManager(projectDir2);
+  let graphManager = new KnowledgeGraphManager(projectDir2, project.id);
   if (!deferProjectRuntimeInit) {
     await graphManager.init();
     await initObservations(projectDir2);
@@ -170457,7 +170604,7 @@ async function createMemorixServer(cwd, existingServer, sharedTeam, options = {}
     await initObservationStore(projectDir2);
     await initMiniSkillStore(projectDir2);
     await initSessionStore(projectDir2);
-    graphManager = new KnowledgeGraphManager(projectDir2);
+    graphManager = new KnowledgeGraphManager(projectDir2, project.id);
     await graphManager.init();
     await initObservations(projectDir2);
     const indexed = await prepareSearchIndex();
@@ -175513,7 +175660,7 @@ var init_serve_shared = __esm({
 
 // src/cli/version.ts
 function getCliVersion() {
-  return true ? "1.9.4" : pkg.version;
+  return true ? "1.9.5" : pkg.version;
 }
 var init_version3 = __esm({
   "src/cli/version.ts"() {