memorix 1.9.4 → 1.9.5

package/dist/maintenance-runner.js

@@ -643,18 +643,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 = `
@@ -3041,13 +3044,120 @@ var init_sqlite_reliability = __esm({
   }
 });
 
+// src/store/file-lock.ts
+import { promises as fs2 } from "fs";
+import { randomUUID } from "crypto";
+import path5 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 {
+      const fd = await fs2.open(lockPath, "wx");
+      await fd.writeFile(JSON.stringify({ pid: process.pid, time: Date.now() }));
+      await fd.close();
+      return;
+    } catch (err) {
+      const code = err instanceof Error && "code" in err ? err.code : void 0;
+      if (code === "EEXIST" || code === "EPERM") {
+        try {
+          const stat5 = await fs2.stat(lockPath);
+          if (Date.now() - stat5.mtimeMs > LOCK_STALE_MS) {
+            const raw2 = await fs2.readFile(lockPath, "utf8").catch(() => "");
+            if (canReclaimStaleLock(raw2)) {
+              await fs2.unlink(lockPath).catch(() => {
+              });
+              continue;
+            }
+          }
+        } catch {
+          continue;
+        }
+        await new Promise((r2) => setTimeout(r2, RETRY_INTERVAL_MS));
+      } else {
+        throw err;
+      }
+    }
+  }
+  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 {
+    const fd = await fs2.open(lockPath, "wx");
+    await fd.writeFile(JSON.stringify({ pid: process.pid, time: Date.now() }));
+    await fd.close();
+    return;
+  } catch {
+    throw new Error(`Failed to acquire lock: ${lockPath} (timeout after ${MAX_RETRIES * RETRY_INTERVAL_MS}ms)`);
+  }
+}
+async function releaseLock(lockPath) {
+  await fs2.unlink(lockPath).catch(() => {
+  });
+}
+async function withFileLock(projectDir2, fn) {
+  const lockPath = path5.join(projectDir2, ".memorix.lock");
+  await acquireLock(lockPath);
+  try {
+    return await fn();
+  } finally {
+    await releaseLock(lockPath);
+  }
+}
+async function atomicWriteFileOnce(filePath, data) {
+  const tmpPath = filePath + `.tmp.${process.pid}.${randomUUID()}`;
+  try {
+    await fs2.writeFile(tmpPath, data, "utf-8");
+    await fs2.rename(tmpPath, filePath);
+  } catch (error) {
+    await fs2.unlink(tmpPath).catch(() => {
+    });
+    throw error;
+  }
+}
+function atomicWriteFile(filePath, data) {
+  const previous = atomicWriteTails.get(filePath) ?? Promise.resolve();
+  const next = previous.catch(() => void 0).then(() => atomicWriteFileOnce(filePath, data));
+  atomicWriteTails.set(filePath, next);
+  return next.finally(() => {
+    if (atomicWriteTails.get(filePath) === next) atomicWriteTails.delete(filePath);
+  });
+}
+var LOCK_STALE_MS, RETRY_INTERVAL_MS, MAX_RETRIES, atomicWriteTails;
+var init_file_lock = __esm({
+  "src/store/file-lock.ts"() {
+    "use strict";
+    init_esm_shims();
+    LOCK_STALE_MS = 1e4;
+    RETRY_INTERVAL_MS = 50;
+    MAX_RETRIES = 60;
+    atomicWriteTails = /* @__PURE__ */ new Map();
+  }
+});
+
 // src/store/sqlite-store.ts
 var sqlite_store_exports = {};
 __export(sqlite_store_exports, {
   SqliteBackend: () => SqliteBackend
 });
-import path5 from "path";
-import fs2 from "fs";
+import path6 from "path";
+import fs3 from "fs";
 function obsToRow(obs) {
   return {
     id: obs.id,
@@ -3134,6 +3244,7 @@ var init_sqlite_store = __esm({
     init_sqlite_db();
     init_sqlite_reliability();
     init_sqlite_fts();
+    init_file_lock();
     SqliteBackend = class {
       db = null;
       dataDir = "";
@@ -3297,38 +3408,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 = path5.join(this.dataDir, "observations.json");
-        if (!fs2.existsSync(jsonPath)) return;
-        try {
-          const raw = fs2.readFileSync(jsonPath, "utf-8");
-          const observations2 = JSON.parse(raw);
+        const jsonPath = path6.join(this.dataDir, "observations.json");
+        if (!fs3.existsSync(jsonPath)) return;
+        await withFileLock(this.dataDir, async () => {
+          const count2 = this.db.prepare(`SELECT COUNT(*) AS cnt FROM observations`).get();
+          if (count2.cnt > 0) return;
+          const raw = fs3.readFileSync(jsonPath, "utf-8");
+          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));
             }
+            const counterPath = path6.join(this.dataDir, "counter.json");
+            let counterNextId;
+            if (fs3.existsSync(counterPath)) {
+              const counterData = JSON.parse(fs3.readFileSync(counterPath, "utf-8"));
+              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);
+            }
+            const maxId = Math.max(...obsList.map((obs) => obs.id));
+            this.rawSaveIdCounter(Math.max(counterNextId ?? 1, maxId + 1));
+            this.bumpGeneration();
           });
           insertMany(observations2);
-          const counterPath = path5.join(this.dataDir, "counter.json");
-          if (fs2.existsSync(counterPath)) {
-            try {
-              const counterData = JSON.parse(fs2.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);
-            }
-          } else {
-            this.rawSaveIdCounter(Math.max(...observations2.map((o) => o.id)) + 1);
-          }
-          this.bumpGeneration();
           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() {
@@ -3657,91 +3773,6 @@ var init_types = __esm({
   }
 });
 
-// src/store/file-lock.ts
-import { promises as fs3 } from "fs";
-import { randomUUID } from "crypto";
-import path6 from "path";
-async function acquireLock(lockPath) {
-  for (let i2 = 0; i2 < MAX_RETRIES; i2++) {
-    try {
-      const fd = await fs3.open(lockPath, "wx");
-      await fd.writeFile(JSON.stringify({ pid: process.pid, time: Date.now() }));
-      await fd.close();
-      return;
-    } catch (err) {
-      const code = err instanceof Error && "code" in err ? err.code : void 0;
-      if (code === "EEXIST" || code === "EPERM") {
-        try {
-          const stat5 = await fs3.stat(lockPath);
-          if (Date.now() - stat5.mtimeMs > LOCK_STALE_MS) {
-            await fs3.unlink(lockPath).catch(() => {
-            });
-            continue;
-          }
-        } catch {
-          continue;
-        }
-        await new Promise((r2) => setTimeout(r2, RETRY_INTERVAL_MS));
-      } else {
-        throw err;
-      }
-    }
-  }
-  await fs3.unlink(lockPath).catch(() => {
-  });
-  try {
-    const fd = await fs3.open(lockPath, "wx");
-    await fd.writeFile(JSON.stringify({ pid: process.pid, time: Date.now() }));
-    await fd.close();
-    return;
-  } catch {
-    throw new Error(`Failed to acquire lock: ${lockPath} (timeout after ${MAX_RETRIES * RETRY_INTERVAL_MS}ms)`);
-  }
-}
-async function releaseLock(lockPath) {
-  await fs3.unlink(lockPath).catch(() => {
-  });
-}
-async function withFileLock(projectDir2, fn) {
-  const lockPath = path6.join(projectDir2, ".memorix.lock");
-  await acquireLock(lockPath);
-  try {
-    return await fn();
-  } finally {
-    await releaseLock(lockPath);
-  }
-}
-async function atomicWriteFileOnce(filePath, data) {
-  const tmpPath = filePath + `.tmp.${process.pid}.${randomUUID()}`;
-  try {
-    await fs3.writeFile(tmpPath, data, "utf-8");
-    await fs3.rename(tmpPath, filePath);
-  } catch (error) {
-    await fs3.unlink(tmpPath).catch(() => {
-    });
-    throw error;
-  }
-}
-function atomicWriteFile(filePath, data) {
-  const previous = atomicWriteTails.get(filePath) ?? Promise.resolve();
-  const next = previous.catch(() => void 0).then(() => atomicWriteFileOnce(filePath, data));
-  atomicWriteTails.set(filePath, next);
-  return next.finally(() => {
-    if (atomicWriteTails.get(filePath) === next) atomicWriteTails.delete(filePath);
-  });
-}
-var LOCK_STALE_MS, RETRY_INTERVAL_MS, MAX_RETRIES, atomicWriteTails;
-var init_file_lock = __esm({
-  "src/store/file-lock.ts"() {
-    "use strict";
-    init_esm_shims();
-    LOCK_STALE_MS = 1e4;
-    RETRY_INTERVAL_MS = 50;
-    MAX_RETRIES = 60;
-    atomicWriteTails = /* @__PURE__ */ new Map();
-  }
-});
-
 // src/store/mini-skill-store.ts
 import path7 from "path";
 import fs4 from "fs";

package/dist/media-audio-runner.js

@@ -805,18 +805,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 = `
@@ -2697,6 +2700,21 @@ var init_sqlite_reliability = __esm({
 import { promises as fs2 } from "fs";
 import { randomUUID as randomUUID3 } 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 {
@@ -2710,9 +2728,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;
@@ -2723,6 +2744,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 {
@@ -6653,6 +6678,7 @@ var init_sqlite_store = __esm({
     init_sqlite_db();
     init_sqlite_reliability();
     init_sqlite_fts();
+    init_file_lock();
     SqliteBackend = class {
       db = null;
       dataDir = "";
@@ -6816,38 +6842,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 = path7.join(this.dataDir, "observations.json");
         if (!fs4.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 = fs4.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 = path7.join(this.dataDir, "counter.json");
-          if (fs4.existsSync(counterPath)) {
-            try {
+            const counterPath = path7.join(this.dataDir, "counter.json");
+            let counterNextId;
+            if (fs4.existsSync(counterPath)) {
               const counterData = JSON.parse(fs4.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() {

package/dist/media-video-runner.js

@@ -835,18 +835,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 = `
@@ -1714,6 +1717,21 @@ var init_sqlite_reliability = __esm({
 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 {
@@ -1727,9 +1745,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;
@@ -1740,6 +1761,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 {
@@ -5670,6 +5695,7 @@ var init_sqlite_store = __esm({
     init_sqlite_db();
     init_sqlite_reliability();
     init_sqlite_fts();
+    init_file_lock();
     SqliteBackend = class {
       db = null;
       dataDir = "";
@@ -5833,38 +5859,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 = path7.join(this.dataDir, "observations.json");
         if (!fs4.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 = fs4.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 = path7.join(this.dataDir, "counter.json");
-          if (fs4.existsSync(counterPath)) {
-            try {
+            const counterPath = path7.join(this.dataDir, "counter.json");
+            let counterNextId;
+            if (fs4.existsSync(counterPath)) {
               const counterData = JSON.parse(fs4.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() {

package/dist/memcode-runtime/CHANGELOG.md

@@ -2,7 +2,39 @@
 
 All notable changes to this project will be documented in this file.
 
-## [Unreleased]
+## [1.9.5] - 2026-09-20
+
+### Added
+- **Setup HTTP MCP** -- `memorix setup --mcp http` honors Grok (writes a
+  `[mcp_servers.memorix]` URL in Grok `config.toml`) and rewrites installed
+  plugin/extension bundled MCP manifests from `memorix serve` to
+  `http://localhost:3211/mcp`. Default Grok MCP stays host-owned. Docs include
+  generic systemd user unit and LaunchAgent KeepAlive examples for
+  `memorix serve-http`.
+- **User-global store sync** -- `memorix sync store push|pull|status --scope user`
+  replicates every local project's eligible observations through the existing
+  opt-in relay. Default `--scope project` is unchanged. Privacy filters still
+  drop personal, agent-targeted, candidate, and ephemeral rows. The live
+  SQLite file is never copied.
+
+### Fixed
+- **HTTP control-plane safety** -- JSON request bodies are bounded, non-loopback
+  binds require an explicit Bearer token or unsafe opt-in, listen failures are
+  reported synchronously, background startup removes unverified state, and
+  shutdown waits for HTTP and SQLite resources to close.
+- **Project-scoped graph storage** -- graph entities and relations now carry a
+  project key, legacy JSONL migration recovers ownership from observation
+  references, and Dashboard/MCP graph access no longer crosses projects.
+- **Migration and lifecycle reliability** -- legacy observation/subdirectory
+  migrations use locks and atomic writes, malformed observation JSON fails
+  closed, stale file locks cannot evict a live writer, stateless MCP bindings
+  expire and are cleaned up, and SDK clients share resources safely.
+- **User-scope sync correctness** -- imported observation IDs are remapped on
+  collision, tombstones validate their source project, and user namespaces
+  must be explicit per-user values.
+- **Release contract** -- publish workflow validates tag/version/commit
+  identity, waits for npm visibility before MCP Registry publication, and
+  keeps prepublish checks non-mutating.
 
 ## [1.9.4] - 2026-09-18
 

package/dist/sdk.d.ts

@@ -120,6 +120,7 @@ declare class MemoryClient {
     private _oramaStore;
     private _obsStore;
     private _freshness;
+    private _sdkRefRegistered;
     /** @internal — use createMemoryClient() instead */
     constructor(projectId: string, projectRoot: string, dataDir: string);
     /** The canonical project ID (derived from Git remote or local path) */