memorix 1.9.4 → 1.9.5

package/src/store/file-lock.ts

@@ -20,6 +20,22 @@ const RETRY_INTERVAL_MS = 50;
 const MAX_RETRIES = 60;
 const atomicWriteTails = new Map<string, Promise<void>>();
 
+function canReclaimStaleLock(raw: string): boolean {
+  try {
+    const parsed = JSON.parse(raw) as { pid?: unknown };
+    const pid = Number(parsed.pid);
+    if (!Number.isSafeInteger(pid) || pid < 1) return true;
+    try {
+      process.kill(pid, 0);
+      return false;
+    } catch (error) {
+      return (error as NodeJS.ErrnoException).code !== 'EPERM';
+    }
+  } catch {
+    return true;
+  }
+}
+
 /**
  * Acquire a lock file atomically.
  * Uses O_WRONLY | O_CREAT | O_EXCL — fails if file already exists.
@@ -39,8 +55,11 @@ export async function acquireLock(lockPath: string): Promise<void> {
         try {
           const stat = await fs.stat(lockPath);
           if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
-            await fs.unlink(lockPath).catch(() => {});
-            continue;
+            const raw = await fs.readFile(lockPath, 'utf8').catch(() => '');
+            if (canReclaimStaleLock(raw)) {
+              await fs.unlink(lockPath).catch(() => {});
+              continue;
+            }
           }
         } catch {
           continue; // Lock disappeared — retry immediately
@@ -51,7 +70,13 @@ export async function acquireLock(lockPath: string): Promise<void> {
       }
     }
   }
-  // Last resort: force-remove stale lock and try once more
+  // Last resort: reclaim only a stale lock whose recorded owner is no longer
+  // alive. Never delete a long-running live writer's lock just because the
+  // operation exceeded the retry window.
+  const raw = await fs.readFile(lockPath, 'utf8').catch(() => '');
+  if (!canReclaimStaleLock(raw)) {
+    throw new Error(`Failed to acquire lock: ${lockPath} (owner is still running)`);
+  }
   await fs.unlink(lockPath).catch(() => {});
   try {
     const fd = await fs.open(lockPath, 'wx');

package/src/store/graph-store.ts

@@ -11,8 +11,12 @@ import { loadGraphJsonl } from './persistence.js';
 import path from 'node:path';
 import fs from 'node:fs';
 
+export const DEFAULT_GRAPH_PROJECT_ID = '__default__';
+const LEGACY_GRAPH_PROJECT_ID = '__legacy__';
+const MAX_GRAPH_STORE_CACHE = 32;
+
 export interface GraphStore {
-  init(dataDir: string): Promise<void>;
+  init(dataDir: string, projectId?: string): Promise<void>;
   loadEntities(): Entity[];
   loadRelations(): Relation[];
   insertEntities(entities: Entity[]): void;
@@ -46,9 +50,61 @@ function entityToRow(entity: Entity): Record<string, unknown> {
   };
 }
 
+const 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)
+);`;
+
+const 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)
+);`;
+
+function ensureScopedGraphSchema(db: any): void {
+  const entityColumns = db.prepare('PRAGMA table_info(graph_entities)').all() as Array<{ name: string }>;
+  if (!entityColumns.some((column) => column.name === 'projectId')) {
+    const migrate = db.transaction(() => {
+      db.exec('ALTER TABLE graph_entities RENAME TO graph_entities_legacy_unscoped');
+      db.exec(CREATE_SCOPED_GRAPH_ENTITIES);
+      db.exec(`INSERT INTO graph_entities (projectId, name, entityType, observations)
+        SELECT '${LEGACY_GRAPH_PROJECT_ID}', name, entityType, observations
+        FROM graph_entities_legacy_unscoped`);
+      db.exec('DROP TABLE graph_entities_legacy_unscoped');
+    });
+    migrate();
+  } else {
+    db.exec(CREATE_SCOPED_GRAPH_ENTITIES);
+  }
+
+  const relationColumns = db.prepare('PRAGMA table_info(graph_relations)').all() as Array<{ name: string }>;
+  if (!relationColumns.some((column) => column.name === 'projectId')) {
+    const migrate = db.transaction(() => {
+      db.exec('ALTER TABLE graph_relations RENAME TO graph_relations_legacy_unscoped');
+      db.exec(CREATE_SCOPED_GRAPH_RELATIONS);
+      db.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`);
+      db.exec('DROP TABLE graph_relations_legacy_unscoped');
+    });
+    migrate();
+  } else {
+    db.exec(CREATE_SCOPED_GRAPH_RELATIONS);
+  }
+}
+
 export class GraphSqliteStore implements GraphStore {
   private db: any = null;
   private dataDir: string = '';
+  private projectId = DEFAULT_GRAPH_PROJECT_ID;
 
   private stmtInsertEntity: any = null;
   private stmtUpdateEntityObs: any = null;
@@ -61,40 +117,44 @@ export class GraphSqliteStore implements GraphStore {
   private stmtDeleteRelationsByEntity: any = null;
   private stmtSelectAllRelations: any = null;
 
-  async init(dataDir: string): Promise<void> {
+  async init(dataDir: string, projectId = DEFAULT_GRAPH_PROJECT_ID): Promise<void> {
     this.dataDir = dataDir;
+    this.projectId = projectId;
     this.db = getDatabase(dataDir);
+    ensureScopedGraphSchema(this.db);
 
     // Prepare entity statements
     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 = ?`);
 
     // Prepare relation statements
     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`);
 
     // One-time migration from graph.jsonl
     await this.migrateFromJsonlIfNeeded();
   }
 
   private async migrateFromJsonlIfNeeded(): Promise<void> {
-    const count = this.db.prepare(`SELECT COUNT(*) AS cnt FROM graph_entities`).get();
+    const count = 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 (count.cnt > 0) return;
+    if (totalCount.cnt > 0) return;
 
     const jsonlPath = path.join(this.dataDir, 'graph.jsonl');
     if (!fs.existsSync(jsonlPath)) return;
@@ -105,12 +165,65 @@ export class GraphSqliteStore implements GraphStore {
 
       console.error(`[memorix] Migrating graph from JSONL to SQLite (${data.entities.length} entities, ${data.relations.length} relations)...`);
 
+      const observations = this.db.prepare('SELECT id, projectId FROM observations').all() as Array<{ id: number; projectId: string }>;
+      const projectByObservationId = new Map(observations.map((row) => [row.id, row.projectId]));
+      const projectsByEntity = new Map<string, Set<string>>();
+      for (const entity of data.entities) {
+        const projects = new Set<string>();
+        for (const content of entity.observations ?? []) {
+          const match = /^\[#(\d+)\]/.exec(content);
+          const projectId = match ? projectByObservationId.get(Number(match[1])) : undefined;
+          if (projectId) projects.add(projectId);
+        }
+        projectsByEntity.set(entity.name, projects);
+      }
+
+      // Legacy graph.jsonl had no project column. Recover the ownership that
+      // can be proven from observation references, then propagate it through
+      // unambiguous relation endpoints. A relation crossing two projects is
+      // intentionally quarantined instead of leaking into both views.
+      let changed = true;
+      while (changed) {
+        changed = false;
+        for (const relation of data.relations) {
+          const from = projectsByEntity.get(relation.from) ?? new Set<string>();
+          const to = projectsByEntity.get(relation.to) ?? new Set<string>();
+          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) ?? new Set<string>();
+        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) ?? new Set<string>();
+        const to = projectsByEntity.get(relation.to) ?? new Set<string>();
+        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();
@@ -122,11 +235,11 @@ export class GraphSqliteStore implements GraphStore {
   }
 
   loadEntities(): Entity[] {
-    return this.stmtSelectAllEntities.all().map(rowToEntity);
+    return this.stmtSelectAllEntities.all(this.projectId).map(rowToEntity);
   }
 
   loadRelations(): Relation[] {
-    return this.stmtSelectAllRelations.all().map((row: any) => ({
+    return this.stmtSelectAllRelations.all(this.projectId).map((row: any) => ({
       from: row.from_entity,
       to: row.to_entity,
       relationType: row.relationType,
@@ -136,7 +249,7 @@ export class GraphSqliteStore implements GraphStore {
   insertEntities(entities: Entity[]): void {
     const insertAll = this.db.transaction(() => {
       for (const entity of entities) {
-        this.stmtInsertEntity.run(entityToRow(entity));
+        this.stmtInsertEntity.run({ ...entityToRow(entity), projectId: this.projectId });
       }
     });
     insertAll();
@@ -145,7 +258,7 @@ export class GraphSqliteStore implements GraphStore {
   insertRelations(relations: Relation[]): void {
     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();
@@ -154,8 +267,8 @@ export class GraphSqliteStore implements GraphStore {
   deleteEntities(names: string[]): void {
     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();
@@ -164,7 +277,7 @@ export class GraphSqliteStore implements GraphStore {
   deleteRelations(relations: Relation[]): void {
     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();
@@ -173,13 +286,13 @@ export class GraphSqliteStore implements GraphStore {
   addObservations(updates: { entityName: string; contents: string[] }[]): void {
     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: string[] = 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) });
         }
       }
     });
@@ -189,11 +302,11 @@ export class GraphSqliteStore implements GraphStore {
   deleteObservations(deletions: { entityName: string; observations: string[] }[]): void {
     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: string[] = 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();
@@ -205,13 +318,13 @@ export class GraphSqliteStore implements GraphStore {
    */
   replaceAll(entities: Entity[], relations: Relation[]): void {
     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();
@@ -224,26 +337,45 @@ export class GraphSqliteStore implements GraphStore {
 
 // ── Singleton ──────────────────────────────────────────────────────
 
-let _graphStore: GraphSqliteStore | null = null;
-let _graphDataDir: string | null = null;
+const _graphStores = new Map<string, GraphSqliteStore>();
+let _activeGraphKey: string | null = null;
+
+function graphStoreKey(dataDir: string, projectId: string): string {
+  return `${path.resolve(dataDir)}\0${projectId}`;
+}
 
-export async function initGraphStore(dataDir: string): Promise<GraphSqliteStore> {
-  if (_graphStore && _graphDataDir === dataDir) return _graphStore;
-  _graphStore = new GraphSqliteStore();
-  await _graphStore.init(dataDir);
-  _graphDataDir = dataDir;
-  return _graphStore;
+export async function initGraphStore(dataDir: string, projectId = DEFAULT_GRAPH_PROJECT_ID): Promise<GraphSqliteStore> {
+  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 as string | undefined;
+    if (!oldest) break;
+    _graphStores.delete(oldest);
+  }
+  _activeGraphKey = key;
+  return store;
 }
 
-export function getGraphStore(): GraphSqliteStore {
-  if (!_graphStore) throw new Error('[memorix] GraphStore not initialized — call initGraphStore() first');
-  return _graphStore;
+export function getGraphStore(dataDir?: string, projectId?: string): GraphSqliteStore {
+  const key = dataDir && projectId ? graphStoreKey(dataDir, projectId) : _activeGraphKey;
+  const store = key ? _graphStores.get(key) : undefined;
+  if (!store) throw new Error('[memorix] GraphStore not initialized — call initGraphStore() first');
+  return store;
 }
 
 export function resetGraphStore(): void {
-  if (_graphStore) {
-    try { _graphStore.close(); } catch { /* best-effort */ }
+  for (const store of _graphStores.values()) {
+    try { store.close(); } catch { /* best-effort */ }
   }
-  _graphStore = null;
-  _graphDataDir = null;
+  _graphStores.clear();
+  _activeGraphKey = null;
 }

package/src/store/persistence.ts

@@ -16,6 +16,7 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
+import { atomicWriteFile, withFileLock } from './file-lock.js';
 
 // ── Re-export JSON helpers for backward compat ────────────────────
 export {
@@ -105,6 +106,12 @@ export async function listProjectDirs(baseDir?: string): Promise<string[]> {
 export async function migrateSubdirsToFlat(baseDir?: string): Promise<boolean> {
   const base = baseDir ?? resolveDefaultDataDir();
   await fs.mkdir(base, { recursive: true });
+  return withFileLock(base, () => migrateSubdirsToFlatUnlocked(base));
+}
+
+async function migrateSubdirsToFlatUnlocked(baseDir?: string): Promise<boolean> {
+  const base = baseDir ?? resolveDefaultDataDir();
+  await fs.mkdir(base, { recursive: true });
 
   // Find all subdirectories that contain observations.json
   let entries: import('node:fs').Dirent[];
@@ -171,7 +178,9 @@ export async function migrateSubdirsToFlat(baseDir?: string): Promise<boolean> {
     for (const o of obs) {
       // Deduplicate by title+createdAt+projectId (same observation from migration overlap)
       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);
@@ -212,12 +221,8 @@ export async function migrateSubdirsToFlat(baseDir?: string): Promise<boolean> {
   }
 
   // Write merged data to base directory
-  await fs.writeFile(path.join(base, 'observations.json'), JSON.stringify(allObs, null, 2), 'utf-8');
-  await fs.writeFile(
-    path.join(base, 'counter.json'),
-    JSON.stringify({ nextId: allObs.length + 1 }),
-    'utf-8',
-  );
+  await atomicWriteFile(path.join(base, 'observations.json'), JSON.stringify(allObs, null, 2));
+  await atomicWriteFile(path.join(base, 'counter.json'), JSON.stringify({ nextId: allObs.length + 1 }));
 
   // Write merged graph
   const graphLines = [
@@ -225,7 +230,7 @@ export async function migrateSubdirsToFlat(baseDir?: string): Promise<boolean> {
     ...mergedRelations.map((r) => JSON.stringify({ type: 'relation', from: r.from, to: r.to, relationType: r.relationType })),
   ];
   if (graphLines.length > 0) {
-    await fs.writeFile(path.join(base, 'graph.jsonl'), graphLines.join('\n'), 'utf-8');
+    await atomicWriteFile(path.join(base, 'graph.jsonl'), graphLines.join('\n'));
   }
 
   // Also merge sessions if present
@@ -243,7 +248,7 @@ export async function migrateSubdirsToFlat(baseDir?: string): Promise<boolean> {
     } catch { /* no sessions */ }
   }
   if (allSessions.length > 0) {
-    await fs.writeFile(path.join(base, 'sessions.json'), JSON.stringify(allSessions, null, 2), 'utf-8');
+    await atomicWriteFile(path.join(base, 'sessions.json'), JSON.stringify(allSessions, null, 2));
   }
 
   // Move subdirectories to backup

package/src/store/sqlite-db.ts

@@ -217,19 +217,22 @@ CREATE TABLE IF NOT EXISTS chat_transcript (
 
 const 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)
 );
 `;
 
 const 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)
 );
 `;
 

package/src/store/sqlite-store.ts

@@ -28,6 +28,7 @@ import {
 import type { LexicalSearchHit } from './obs-store.js';
 import path from 'node:path';
 import fs from 'node:fs';
+import { withFileLock } from './file-lock.js';
 
 // ── Row ↔ Observation serialization ────────────────────────────────
 
@@ -294,49 +295,53 @@ export class SqliteBackend implements ObservationStore {
   // ── Migration ────────────────────────────────────────────────────
 
   private async migrateFromJsonIfNeeded(): Promise<void> {
-    // Only migrate if table is empty
-    const count = this.db.prepare(`SELECT COUNT(*) AS cnt FROM observations`).get();
-    if (count.cnt > 0) return;
-
     const jsonPath = path.join(this.dataDir, 'observations.json');
     if (!fs.existsSync(jsonPath)) return;
 
-    try {
-      const raw = fs.readFileSync(jsonPath, 'utf-8');
-      const observations: Observation[] = JSON.parse(raw);
+    await withFileLock(this.dataDir, async () => {
+      // Re-check under the cross-process lock. Another initializer may have
+      // completed the migration while this process was waiting.
+      const count = this.db.prepare(`SELECT COUNT(*) AS cnt FROM observations`).get();
+      if (count.cnt > 0) return;
 
+      const raw = fs.readFileSync(jsonPath, 'utf-8');
+      const parsed: unknown = JSON.parse(raw);
+      if (!Array.isArray(parsed)) {
+        throw new Error('[memorix] observations.json migration refused: expected a JSON array');
+      }
+      const observations = parsed as Observation[];
       if (observations.length === 0) return;
+      if (observations.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 ${observations.length} observations from JSON to SQLite...`);
 
+      // The SQLite transaction makes the migration all-or-nothing. The JSON
+      // source remains intact until an operator explicitly removes it.
       const insertMany = this.db.transaction((obsList: Observation[]) => {
         for (const obs of obsList) {
           this.stmtInsert.run(obsToRow(obs));
         }
-      });
-      insertMany(observations);
 
-      // Migrate counter
-      const counterPath = path.join(this.dataDir, 'counter.json');
-      if (fs.existsSync(counterPath)) {
-        try {
-          const counterData = JSON.parse(fs.readFileSync(counterPath, 'utf-8'));
-          const nextId = counterData.nextId ?? counterData.next_id ?? (Math.max(...observations.map(o => o.id)) + 1);
-          this.rawSaveIdCounter(nextId);
-        } catch {
-          // Fallback: derive from max observation ID
-          this.rawSaveIdCounter(Math.max(...observations.map(o => o.id)) + 1);
+        const counterPath = path.join(this.dataDir, 'counter.json');
+        let counterNextId: number | undefined;
+        if (fs.existsSync(counterPath)) {
+          const counterData = JSON.parse(fs.readFileSync(counterPath, 'utf-8')) as { nextId?: unknown; next_id?: unknown };
+          const candidate = counterData.nextId ?? counterData.next_id;
+          if (candidate !== undefined && (!Number.isSafeInteger(candidate) || Number(candidate) < 1)) {
+            throw new Error('[memorix] counter.json migration refused: nextId must be a positive integer');
+          }
+          counterNextId = candidate === undefined ? undefined : Number(candidate);
         }
-      } else {
-        this.rawSaveIdCounter(Math.max(...observations.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(observations);
 
       console.error(`[memorix] Migration complete. ${observations.length} observations now in SQLite.`);
-    } catch (err) {
-      console.error(`[memorix] JSON→SQLite migration failed (non-fatal, data preserved in JSON): ${err}`);
-    }
+    });
   }
 
   // ── Public read ──────────────────────────────────────────────────