memorix 1.9.4 → 1.9.6

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)
 );
 `;
 
@@ -818,6 +821,45 @@ CREATE TABLE IF NOT EXISTS memory_feedback_events (
 );
 `;
 
+const CREATE_TASK_CONTINUITY_EVENTS_TABLE = `
+CREATE TABLE IF NOT EXISTS task_continuity_events (
+  id              TEXT PRIMARY KEY,
+  project_id      TEXT NOT NULL,
+  task_id         TEXT NOT NULL,
+  task            TEXT NOT NULL,
+  kind            TEXT NOT NULL,
+  content         TEXT NOT NULL,
+  item_status     TEXT,
+  source_ref      TEXT,
+  evidence_json   TEXT NOT NULL DEFAULT '[]',
+  actor           TEXT,
+  created_at      TEXT NOT NULL,
+  event_key       TEXT,
+  item_key        TEXT,
+  supersedes_id   TEXT
+);
+`;
+
+const CREATE_AGENT_EFFECTS_TABLE = `
+CREATE TABLE IF NOT EXISTS agent_effects (
+  id                TEXT PRIMARY KEY,
+  pipeline_id       TEXT NOT NULL,
+  task_id           TEXT NOT NULL,
+  attempt           INTEGER NOT NULL,
+  effect_key        TEXT NOT NULL,
+  tool              TEXT NOT NULL,
+  risk_tier         TEXT NOT NULL,
+  replay_policy     TEXT NOT NULL,
+  status            TEXT NOT NULL,
+  call_id           TEXT,
+  idempotency_key   TEXT NOT NULL,
+  input_fingerprint TEXT,
+  detail            TEXT,
+  started_at        INTEGER NOT NULL,
+  finished_at       INTEGER
+);
+`;
+
 const CREATE_MCP_BINDINGS_TABLE = `
 CREATE TABLE IF NOT EXISTS mcp_bindings (
   handle_id    TEXT PRIMARY KEY,
@@ -896,7 +938,18 @@ CREATE INDEX IF NOT EXISTS idx_evidence_cards_candidate ON evidence_cards(projec
 CREATE INDEX IF NOT EXISTS idx_evidence_card_events_card ON evidence_card_events(card_id, created_at);
 CREATE INDEX IF NOT EXISTS idx_memory_feedback_states_project ON memory_feedback_states(project_id, candidate_kind, updated_at DESC);
 CREATE INDEX IF NOT EXISTS idx_memory_feedback_events_candidate ON memory_feedback_events(project_id, candidate_kind, candidate_id, observed_at DESC);
+CREATE INDEX IF NOT EXISTS idx_task_continuity_project_task ON task_continuity_events(project_id, task_id, created_at ASC);
+CREATE INDEX IF NOT EXISTS idx_task_continuity_project_recent ON task_continuity_events(project_id, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_task_continuity_item ON task_continuity_events(project_id, task_id, kind, item_key, created_at DESC);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_task_continuity_event_key
+  ON task_continuity_events(project_id, task_id, event_key)
+  WHERE event_key IS NOT NULL;
+CREATE UNIQUE INDEX IF NOT EXISTS idx_agent_effect_identity
+  ON agent_effects(pipeline_id, task_id, attempt, effect_key);
+CREATE INDEX IF NOT EXISTS idx_agent_effect_pipeline ON agent_effects(pipeline_id, started_at ASC);
 CREATE INDEX IF NOT EXISTS idx_mcp_bindings_project ON mcp_bindings(project_id, last_used_at DESC);
+CREATE INDEX IF NOT EXISTS idx_mcp_bindings_root ON mcp_bindings(project_root, last_used_at DESC);
+CREATE INDEX IF NOT EXISTS idx_mcp_bindings_expiry ON mcp_bindings(expires_at);
 CREATE UNIQUE INDEX IF NOT EXISTS idx_maintenance_jobs_active_dedupe
   ON maintenance_jobs(project_id, kind, dedupe_key)
   WHERE status IN ('pending', 'running', 'retry');
@@ -1075,6 +1128,8 @@ const SCHEMA_MIGRATIONS: SchemaMigration[] = [
       db.exec('CREATE INDEX IF NOT EXISTS idx_memory_feedback_states_project ON memory_feedback_states(project_id, candidate_kind, updated_at DESC)');
       db.exec('CREATE INDEX IF NOT EXISTS idx_memory_feedback_events_candidate ON memory_feedback_events(project_id, candidate_kind, candidate_id, observed_at DESC)');
       db.exec('CREATE INDEX IF NOT EXISTS idx_mcp_bindings_project ON mcp_bindings(project_id, last_used_at DESC)');
+      db.exec('CREATE INDEX IF NOT EXISTS idx_mcp_bindings_root ON mcp_bindings(project_root, last_used_at DESC)');
+      db.exec('CREATE INDEX IF NOT EXISTS idx_mcp_bindings_expiry ON mcp_bindings(expires_at)');
     },
   },
   {
@@ -1086,6 +1141,18 @@ const SCHEMA_MIGRATIONS: SchemaMigration[] = [
       addColumnIfMissing(db, 'code_edges', 'source', 'source TEXT');
     },
   },
+  {
+    id: '1.9-continuity-v2',
+    apply: (db) => {
+      addColumnIfMissing(db, 'task_continuity_events', 'event_key', 'event_key TEXT');
+      addColumnIfMissing(db, 'task_continuity_events', 'item_key', 'item_key TEXT');
+      addColumnIfMissing(db, 'task_continuity_events', 'supersedes_id', 'supersedes_id TEXT');
+      db.exec('CREATE INDEX IF NOT EXISTS idx_task_continuity_item ON task_continuity_events(project_id, task_id, kind, item_key, created_at DESC)');
+      db.exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_task_continuity_event_key
+        ON task_continuity_events(project_id, task_id, event_key)
+        WHERE event_key IS NOT NULL`);
+    },
+  },
 ];
 
 function applySchemaMigrations(db: any): void {
@@ -1107,6 +1174,28 @@ function applySchemaMigrations(db: any): void {
 // ── Singleton cache ─────────────────────────────────────────────────
 
 const _dbCache = new Map<string, any>();
+const _dbLeases = new Map<string, number>();
+
+export interface DatabaseLease {
+  dataDir: string;
+  db: any;
+  release: () => void;
+}
+
+export interface DatabaseStats {
+  cached: number;
+  leased: number;
+  leasedDataDirs: number;
+}
+
+function normalizeDataDir(dataDir: string): string {
+  return path.resolve(dataDir);
+}
+
+function touchDatabase(normalized: string, db: any): void {
+  _dbCache.delete(normalized);
+  _dbCache.set(normalized, db);
+}
 
 /**
  * Get or create a shared SQLite database handle for the given data directory.
@@ -1117,10 +1206,13 @@ const _dbCache = new Map<string, any>();
  * Callers must NOT close the returned handle directly — use closeDatabase().
  */
 export function getDatabase(dataDir: string): any {
-  const normalized = path.resolve(dataDir);
+  const normalized = normalizeDataDir(dataDir);
   assertNotHomeDataDir(normalized);
   const existing = _dbCache.get(normalized);
-  if (existing) return existing;
+  if (existing) {
+    touchDatabase(normalized, existing);
+    return existing;
+  }
 
   loadBetterSqlite3();
   fs.mkdirSync(dataDir, { recursive: true });
@@ -1158,6 +1250,8 @@ export function getDatabase(dataDir: string): any {
   db.exec(CREATE_MAINTENANCE_JOBS_TABLE);
   db.exec(CREATE_MAINTENANCE_TARGETS_TABLE);
   db.exec(CREATE_COMPACTION_CHECKPOINTS_TABLE);
+  db.exec(CREATE_TASK_CONTINUITY_EVENTS_TABLE);
+  db.exec(CREATE_AGENT_EFFECTS_TABLE);
 
   // Phase 3a migration: add sourceSnapshot + updatedAt to mini_skills
   // Idempotent — ALTER TABLE ADD COLUMN throws if column already exists
@@ -1191,7 +1285,7 @@ export function getDatabase(dataDir: string): any {
   db.prepare(`INSERT OR IGNORE INTO meta (key, value) VALUES ('next_id', '1')`).run();
   db.prepare(`INSERT OR IGNORE INTO meta (key, value) VALUES ('mini_skills_generation', '0')`).run();
 
-    _dbCache.set(normalized, db);
+    touchDatabase(normalized, db);
     return db;
   } catch (error) {
     // A schema/migration/FTS failure must not leave an uncached connection
@@ -1201,12 +1295,60 @@ export function getDatabase(dataDir: string): any {
   }
 }
 
+/**
+ * Hold a database handle across an HTTP/session lifetime. Idle eviction only
+ * closes handles with no active leases, so cache pressure cannot invalidate a
+ * store that is still serving a request.
+ */
+export function acquireDatabase(dataDir: string): DatabaseLease {
+  const normalized = normalizeDataDir(dataDir);
+  const db = getDatabase(normalized);
+  _dbLeases.set(normalized, (_dbLeases.get(normalized) ?? 0) + 1);
+  let released = false;
+  return {
+    dataDir: normalized,
+    db,
+    release: () => {
+      if (released) return;
+      released = true;
+      const count = (_dbLeases.get(normalized) ?? 0) - 1;
+      if (count > 0) _dbLeases.set(normalized, count);
+      else _dbLeases.delete(normalized);
+    },
+  };
+}
+
+/** Return bounded resource information for health and diagnostics. */
+export function getDatabaseStats(): DatabaseStats {
+  let leased = 0;
+  for (const count of _dbLeases.values()) leased += count;
+  return { cached: _dbCache.size, leased, leasedDataDirs: _dbLeases.size };
+}
+
+/**
+ * Evict least-recently-used unleased handles until the cache is within its
+ * target. Stores that need a handle across awaits must hold a lease first.
+ */
+export function evictIdleDatabases(maxCached: number): number {
+  const target = Math.max(0, Math.floor(maxCached));
+  let evicted = 0;
+  for (const [normalized, db] of [..._dbCache]) {
+    if (_dbCache.size <= target) break;
+    if ((_dbLeases.get(normalized) ?? 0) > 0) continue;
+    try { db.close(); } catch { /* best-effort */ }
+    _dbCache.delete(normalized);
+    evicted++;
+  }
+  return evicted;
+}
+
 /**
  * Close and remove a cached database handle for the given data directory.
  * Safe to call even if no handle exists.
  */
 export function closeDatabase(dataDir: string): void {
-  const normalized = path.resolve(dataDir);
+  const normalized = normalizeDataDir(dataDir);
+  if ((_dbLeases.get(normalized) ?? 0) > 0) return;
   const db = _dbCache.get(normalized);
   if (db) {
     try { db.close(); } catch { /* best-effort */ }
@@ -1222,6 +1364,7 @@ export function closeAllDatabases(): void {
     try { db.close(); } catch { /* best-effort */ }
     _dbCache.delete(key);
   }
+  _dbLeases.clear();
 }
 
 /**