memorix 1.9.4 → 1.9.6

package/dist/index.js

@@ -444,11 +444,21 @@ function applySchemaMigrations(db2) {
     apply();
   }
 }
+function normalizeDataDir(dataDir) {
+  return path3.resolve(dataDir);
+}
+function touchDatabase(normalized, db2) {
+  _dbCache.delete(normalized);
+  _dbCache.set(normalized, db2);
+}
 function getDatabase(dataDir) {
-  const normalized = path3.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 });
   const dbPath = path3.join(dataDir, "memorix.db");
@@ -478,6 +488,8 @@ function getDatabase(dataDir) {
     db2.exec(CREATE_MAINTENANCE_JOBS_TABLE);
     db2.exec(CREATE_MAINTENANCE_TARGETS_TABLE);
     db2.exec(CREATE_COMPACTION_CHECKPOINTS_TABLE);
+    db2.exec(CREATE_TASK_CONTINUITY_EVENTS_TABLE);
+    db2.exec(CREATE_AGENT_EFFECTS_TABLE);
     try {
       db2.exec(`ALTER TABLE mini_skills ADD COLUMN sourceSnapshot TEXT NOT NULL DEFAULT ''`);
     } catch {
@@ -516,7 +528,7 @@ function getDatabase(dataDir) {
     db2.prepare(`INSERT OR IGNORE INTO meta (key, value) VALUES ('storage_generation', '0')`).run();
     db2.prepare(`INSERT OR IGNORE INTO meta (key, value) VALUES ('next_id', '1')`).run();
     db2.prepare(`INSERT OR IGNORE INTO meta (key, value) VALUES ('mini_skills_generation', '0')`).run();
-    _dbCache.set(normalized, db2);
+    touchDatabase(normalized, db2);
     return db2;
   } catch (error) {
     try {
@@ -534,8 +546,9 @@ function closeAllDatabases() {
     }
     _dbCache.delete(key);
   }
+  _dbLeases.clear();
 }
-var BetterSqlite3, CREATE_OBSERVATIONS_TABLE, CREATE_MINI_SKILLS_TABLE, CREATE_SESSIONS_TABLE, CREATE_META_TABLE, CREATE_TEAM_AGENTS_TABLE, CREATE_TEAM_MESSAGES_TABLE, CREATE_TEAM_TASKS_TABLE, CREATE_TEAM_TASK_DEPS_TABLE, CREATE_TEAM_LOCKS_TABLE, CREATE_TEAM_ROLES_TABLE, CREATE_CHAT_TRANSCRIPT_TABLE, CREATE_GRAPH_ENTITIES_TABLE, CREATE_GRAPH_RELATIONS_TABLE, CREATE_CODE_FILES_TABLE, CREATE_CODE_SYMBOLS_TABLE, CREATE_CODE_EDGES_TABLE, CREATE_OBSERVATION_CODE_REFS_TABLE, CREATE_SCHEMA_MIGRATIONS_TABLE, CREATE_CODE_STATE_SNAPSHOTS_TABLE, CREATE_CODE_STATE_SNAPSHOT_FILES_TABLE, CREATE_KNOWLEDGE_CLAIMS_TABLE, CREATE_KNOWLEDGE_CLAIM_EVIDENCE_TABLE, CREATE_KNOWLEDGE_CLAIM_EVENTS_TABLE, CREATE_KNOWLEDGE_WORKSPACES_TABLE, CREATE_KNOWLEDGE_PAGES_TABLE, CREATE_KNOWLEDGE_PAGE_CLAIMS_TABLE, CREATE_KNOWLEDGE_PAGE_LINKS_TABLE, CREATE_KNOWLEDGE_PROPOSALS_TABLE, CREATE_KNOWLEDGE_WORKFLOWS_TABLE, CREATE_KNOWLEDGE_WORKFLOW_RUNS_TABLE, CREATE_LONG_TERM_MEMORIES_TABLE, CREATE_LONG_TERM_MEMORY_EVIDENCE_TABLE, CREATE_LONG_TERM_MEMORY_EVENTS_TABLE, CREATE_MEMORY_OUTCOME_SIGNALS_TABLE, CREATE_MEDIA_ASSETS_TABLE, CREATE_MEDIA_ASSET_LINKS_TABLE, CREATE_MEDIA_DERIVATIONS_TABLE, CREATE_MEDIA_EMBEDDING_PROFILES_TABLE, CREATE_MEDIA_EMBEDDINGS_TABLE, CREATE_MEDIA_JOBS_TABLE, CREATE_MAINTENANCE_JOBS_TABLE, CREATE_MAINTENANCE_TARGETS_TABLE, CREATE_COMPACTION_CHECKPOINTS_TABLE, CREATE_EVIDENCE_CARDS_TABLE, CREATE_EVIDENCE_CARD_EVENTS_TABLE, CREATE_MEMORY_FEEDBACK_STATES_TABLE, CREATE_MEMORY_FEEDBACK_EVENTS_TABLE, CREATE_MCP_BINDINGS_TABLE, CREATE_INDEXES, SCHEMA_MIGRATIONS, _dbCache;
+var BetterSqlite3, CREATE_OBSERVATIONS_TABLE, CREATE_MINI_SKILLS_TABLE, CREATE_SESSIONS_TABLE, CREATE_META_TABLE, CREATE_TEAM_AGENTS_TABLE, CREATE_TEAM_MESSAGES_TABLE, CREATE_TEAM_TASKS_TABLE, CREATE_TEAM_TASK_DEPS_TABLE, CREATE_TEAM_LOCKS_TABLE, CREATE_TEAM_ROLES_TABLE, CREATE_CHAT_TRANSCRIPT_TABLE, CREATE_GRAPH_ENTITIES_TABLE, CREATE_GRAPH_RELATIONS_TABLE, CREATE_CODE_FILES_TABLE, CREATE_CODE_SYMBOLS_TABLE, CREATE_CODE_EDGES_TABLE, CREATE_OBSERVATION_CODE_REFS_TABLE, CREATE_SCHEMA_MIGRATIONS_TABLE, CREATE_CODE_STATE_SNAPSHOTS_TABLE, CREATE_CODE_STATE_SNAPSHOT_FILES_TABLE, CREATE_KNOWLEDGE_CLAIMS_TABLE, CREATE_KNOWLEDGE_CLAIM_EVIDENCE_TABLE, CREATE_KNOWLEDGE_CLAIM_EVENTS_TABLE, CREATE_KNOWLEDGE_WORKSPACES_TABLE, CREATE_KNOWLEDGE_PAGES_TABLE, CREATE_KNOWLEDGE_PAGE_CLAIMS_TABLE, CREATE_KNOWLEDGE_PAGE_LINKS_TABLE, CREATE_KNOWLEDGE_PROPOSALS_TABLE, CREATE_KNOWLEDGE_WORKFLOWS_TABLE, CREATE_KNOWLEDGE_WORKFLOW_RUNS_TABLE, CREATE_LONG_TERM_MEMORIES_TABLE, CREATE_LONG_TERM_MEMORY_EVIDENCE_TABLE, CREATE_LONG_TERM_MEMORY_EVENTS_TABLE, CREATE_MEMORY_OUTCOME_SIGNALS_TABLE, CREATE_MEDIA_ASSETS_TABLE, CREATE_MEDIA_ASSET_LINKS_TABLE, CREATE_MEDIA_DERIVATIONS_TABLE, CREATE_MEDIA_EMBEDDING_PROFILES_TABLE, CREATE_MEDIA_EMBEDDINGS_TABLE, CREATE_MEDIA_JOBS_TABLE, CREATE_MAINTENANCE_JOBS_TABLE, CREATE_MAINTENANCE_TARGETS_TABLE, CREATE_COMPACTION_CHECKPOINTS_TABLE, CREATE_EVIDENCE_CARDS_TABLE, CREATE_EVIDENCE_CARD_EVENTS_TABLE, CREATE_MEMORY_FEEDBACK_STATES_TABLE, CREATE_MEMORY_FEEDBACK_EVENTS_TABLE, CREATE_TASK_CONTINUITY_EVENTS_TABLE, CREATE_AGENT_EFFECTS_TABLE, CREATE_MCP_BINDINGS_TABLE, CREATE_INDEXES, SCHEMA_MIGRATIONS, _dbCache, _dbLeases;
 var init_sqlite_db = __esm({
   "src/store/sqlite-db.ts"() {
     "use strict";
@@ -707,18 +720,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 = `
@@ -1249,6 +1265,43 @@ CREATE TABLE IF NOT EXISTS memory_feedback_events (
   delta           REAL NOT NULL DEFAULT 0,
   observed_at     TEXT NOT NULL
 );
+`;
+    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
+);
+`;
+    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
+);
 `;
     CREATE_MCP_BINDINGS_TABLE = `
 CREATE TABLE IF NOT EXISTS mcp_bindings (
@@ -1327,7 +1380,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');
@@ -1498,6 +1562,8 @@ CREATE UNIQUE INDEX IF NOT EXISTS idx_maintenance_jobs_active_dedupe
           db2.exec("CREATE INDEX IF NOT EXISTS idx_memory_feedback_states_project ON memory_feedback_states(project_id, candidate_kind, updated_at DESC)");
           db2.exec("CREATE INDEX IF NOT EXISTS idx_memory_feedback_events_candidate ON memory_feedback_events(project_id, candidate_kind, candidate_id, observed_at DESC)");
           db2.exec("CREATE INDEX IF NOT EXISTS idx_mcp_bindings_project ON mcp_bindings(project_id, last_used_at DESC)");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_mcp_bindings_root ON mcp_bindings(project_root, last_used_at DESC)");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_mcp_bindings_expiry ON mcp_bindings(expires_at)");
         }
       },
       {
@@ -1508,9 +1574,22 @@ CREATE UNIQUE INDEX IF NOT EXISTS idx_maintenance_jobs_active_dedupe
           addColumnIfMissing(db2, "code_symbols", "source", "source TEXT");
           addColumnIfMissing(db2, "code_edges", "source", "source TEXT");
         }
+      },
+      {
+        id: "1.9-continuity-v2",
+        apply: (db2) => {
+          addColumnIfMissing(db2, "task_continuity_events", "event_key", "event_key TEXT");
+          addColumnIfMissing(db2, "task_continuity_events", "item_key", "item_key TEXT");
+          addColumnIfMissing(db2, "task_continuity_events", "supersedes_id", "supersedes_id TEXT");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_task_continuity_item ON task_continuity_events(project_id, task_id, kind, item_key, created_at DESC)");
+          db2.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`);
+        }
       }
     ];
     _dbCache = /* @__PURE__ */ new Map();
+    _dbLeases = /* @__PURE__ */ new Map();
   }
 });
 
@@ -1518,6 +1597,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 +1625,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 +1641,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 +1883,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 +1944,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 +1977,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 +2002,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 +2038,7 @@ var init_persistence = __esm({
   "src/store/persistence.ts"() {
     "use strict";
     init_esm_shims();
+    init_file_lock();
     init_persistence_json();
   }
 });
@@ -1943,6 +2046,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 +2076,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 getGraphStore() {
-  if (!_graphStore) throw new Error("[memorix] GraphStore not initialized \u2014 call initGraphStore() first");
-  return _graphStore;
+function graphStoreKey(dataDir, projectId) {
+  return `${path7.resolve(dataDir)}\0${projectId}`;
+}
+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 +2185,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 +2277,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 +2289,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 +2297,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 +2305,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 +2314,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 +2322,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 +2337,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 +2352,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 +2366,8 @@ var init_graph_store = __esm({
       close() {
       }
     };
-    _graphStore = null;
-    _graphDataDir = null;
+    _graphStores = /* @__PURE__ */ new Map();
+    _activeGraphKey = null;
   }
 });
 
@@ -2165,11 +2382,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 +2401,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 +2417,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) {
@@ -3085,18 +3304,23 @@ __export(yaml_loader_exports, {
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { homedir } from "os";
 import { parse as parseYamlDocument } from "yaml";
+function cacheKey(homeDir, projectRoot) {
+  return `${homeDir}\0${projectRoot ?? ""}`;
+}
 function initProjectRoot(root) {
   globalProjectRoot = root;
-  configCache.delete(root);
+  configCache.delete(cacheKey(homedir(), root));
 }
 function clearProjectRoot() {
   globalProjectRoot = null;
 }
-function loadYamlConfig(projectRoot) {
+function loadYamlConfig(projectRoot, options = {}) {
+  const homeDir = options.homeDir ?? homedir();
   const resolvedRoot = projectRoot === null ? null : projectRoot ?? globalProjectRoot ?? null;
-  const cached = configCache.get(resolvedRoot ?? null);
+  const key = cacheKey(homeDir, resolvedRoot);
+  const cached = configCache.get(key);
   if (cached) return cached;
-  const userYaml = getGlobalYamlPath(homedir());
+  const userYaml = getGlobalYamlPath(homeDir);
   const projectYaml = resolvedRoot ? getProjectYamlPath(resolvedRoot) : null;
   let userConfig = {};
   let projectConfig = {};
@@ -3128,12 +3352,12 @@ function loadYamlConfig(projectRoot) {
     server: { ...userConfig.server, ...projectConfig.server },
     team: { ...userConfig.team, ...projectConfig.team }
   };
-  configCache.set(resolvedRoot ?? null, merged);
+  configCache.set(key, merged);
   return merged;
 }
-function resetYamlConfigCache(projectRoot) {
+function resetYamlConfigCache(projectRoot, homeDir = homedir()) {
   if (projectRoot !== void 0) {
-    configCache.delete(projectRoot ?? null);
+    configCache.delete(cacheKey(homeDir, projectRoot ?? null));
   } else {
     configCache.clear();
   }
@@ -3343,9 +3567,9 @@ var init_detector = __esm({
 // src/config/legacy-loader.ts
 import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
 import { homedir as homedir2 } from "os";
-function loadFileConfig() {
+function loadFileConfig(homeDir = homedir2()) {
   if (cachedConfig !== null) return cachedConfig;
-  const configPath = getLegacyConfigJsonPath(homedir2());
+  const configPath = getLegacyConfigJsonPath(homeDir);
   try {
     if (existsSync4(configPath)) {
       cachedConfig = JSON.parse(readFileSync4(configPath, "utf-8"));
@@ -3375,15 +3599,15 @@ import { homedir as homedir3 } from "os";
 function loadTomlConfig(options = {}) {
   const homeDir = options.homeDir ?? homedir3();
   const projectRoot = options.projectRoot ?? null;
-  const cacheKey = `${homeDir}\0${projectRoot ?? ""}`;
-  const cached = configCache2.get(cacheKey);
+  const cacheKey3 = `${homeDir}\0${projectRoot ?? ""}`;
+  const cached = configCache2.get(cacheKey3);
   if (cached) return cached;
   const userToml = getGlobalConfigTomlPath(homeDir);
   const projectToml = projectRoot ? getProjectConfigTomlPath(projectRoot) : null;
   const userConfig = existsSync5(userToml) ? parseTomlConfig(readFileSync5(userToml, "utf8"), userToml) : {};
   const projectConfig = projectToml && existsSync5(projectToml) ? parseTomlConfig(readFileSync5(projectToml, "utf8"), projectToml) : {};
   const merged = mergeTomlConfig(userConfig, projectConfig);
-  configCache2.set(cacheKey, merged);
+  configCache2.set(cacheKey3, merged);
   return merged;
 }
 function mergeTomlConfig(base, override) {
@@ -3583,8 +3807,8 @@ function getResolvedConfig(options = {}) {
   const projectRoot = options.projectRoot === void 0 ? detectProject()?.rootPath ?? null : options.projectRoot;
   loadDotenv(projectRoot === null ? void 0 : projectRoot ?? void 0, { userHomeDir: homeDir });
   const toml = loadTomlConfig({ projectRoot: projectRoot ?? null, homeDir });
-  const yaml = loadYamlConfig(projectRoot ?? null);
-  const legacy = loadFileConfig();
+  const yaml = loadYamlConfig(projectRoot ?? null, { homeDir });
+  const legacy = loadFileConfig(homeDir);
   const embeddingBaseUrl = first(process.env.MEMORIX_EMBEDDING_BASE_URL, toml.embedding?.base_url, yaml.embedding?.baseUrl, legacy.embeddingApi?.baseUrl);
   const openRouterEmbeddingApiKey = isOpenRouterUrl(embeddingBaseUrl) ? process.env.OPENROUTER_API_KEY : void 0;
   const memoryLlmProvider = first(
@@ -3606,15 +3830,17 @@ function getResolvedConfig(options = {}) {
     legacy.llm?.baseUrl
   );
   const openRouterMemoryLlmApiKey = isOpenRouterMemoryLane(memoryLlmProvider, memoryLlmBaseUrl) ? process.env.OPENROUTER_API_KEY : void 0;
+  const isAtlasCloud = memoryLlmProvider === "atlascloud";
   const memoryLlmApiKey = first(
     process.env.MEMORIX_LLM_API_KEY,
     process.env.MEMORIX_API_KEY,
     toml.memory?.llm?.api_key,
     yaml.llm?.apiKey,
     legacy.llm?.apiKey,
-    process.env.OPENAI_API_KEY,
-    process.env.ANTHROPIC_API_KEY,
-    openRouterMemoryLlmApiKey
+    // Never borrow another provider's credentials for the Atlas Cloud preset.
+    isAtlasCloud ? process.env.ATLASCLOUD_API_KEY : process.env.OPENAI_API_KEY,
+    isAtlasCloud ? void 0 : process.env.ANTHROPIC_API_KEY,
+    isAtlasCloud ? void 0 : openRouterMemoryLlmApiKey
   );
   const resolved = {
     agent: {
@@ -3793,7 +4019,8 @@ function getEnvSourceNames() {
     "MEMORIX_CODEGRAPH_EXTERNAL_CONTEXT",
     "MEMORIX_CODEGRAPH_EXTERNAL_COMMAND",
     "MEMORIX_CODEGRAPH_EXTERNAL_TIMEOUT_MS",
-    "OPENROUTER_API_KEY"
+    "OPENROUTER_API_KEY",
+    "ATLASCLOUD_API_KEY"
   ].filter((name) => process.env[name]);
 }
 function isOpenRouterUrl(value) {
@@ -4012,12 +4239,45 @@ function textHash(text3) {
 async function loadDiskCache() {
   try {
     const raw = await readFile(CACHE_FILE, "utf-8");
+    if (Buffer.byteLength(raw, "utf8") > MAX_CACHE_FILE_BYTES) {
+      console.error("[memorix] FastEmbed cache exceeds the disk load limit; starting with an empty cache");
+      return;
+    }
     const entries = JSON.parse(raw);
-    for (const [k, v] of entries) cache.set(k, v);
-    console.error(`[memorix] Loaded ${entries.length} cached embeddings from disk`);
+    if (!Array.isArray(entries)) return;
+    for (const entry of entries) {
+      if (!Array.isArray(entry) || typeof entry[0] !== "string" || !isVector(entry[1])) continue;
+      cacheSet(entry[0], entry[1], false);
+    }
+    console.error(`[memorix] Loaded ${cache.size} cached embeddings from disk`);
   } catch {
   }
 }
+function isVector(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "number");
+}
+function maxCachePayloadBytes() {
+  const raw = Number.parseInt(process.env.MEMORIX_EMBEDDING_CACHE_MAX_BYTES ?? "", 10);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_CACHE_PAYLOAD_BYTES;
+}
+function cacheSet(hash4, value, markDirty = true) {
+  const incomingBytes = value.length * 8;
+  if (incomingBytes > maxCachePayloadBytes()) return;
+  const existing = cache.get(hash4);
+  if (existing) cachePayloadBytes -= existing.length * 8;
+  else {
+    while (cache.size >= MAX_CACHE_SIZE || cachePayloadBytes + incomingBytes > maxCachePayloadBytes()) {
+      const firstKey = cache.keys().next().value;
+      if (firstKey === void 0) break;
+      const old = cache.get(firstKey);
+      cache.delete(firstKey);
+      if (old) cachePayloadBytes -= old.length * 8;
+    }
+  }
+  cache.set(hash4, value);
+  cachePayloadBytes += incomingBytes;
+  if (markDirty) diskCacheDirty = true;
+}
 async function saveDiskCache() {
   if (!diskCacheDirty) return;
   try {
@@ -4028,7 +4288,7 @@ async function saveDiskCache() {
   } catch {
   }
 }
-var CACHE_DIR, CACHE_FILE, cache, MAX_CACHE_SIZE, diskCacheDirty, FastEmbedProvider;
+var CACHE_DIR, CACHE_FILE, cache, MAX_CACHE_SIZE, DEFAULT_CACHE_PAYLOAD_BYTES, MAX_CACHE_FILE_BYTES, cachePayloadBytes, diskCacheDirty, FastEmbedProvider;
 var init_fastembed_provider = __esm({
   "src/embedding/fastembed-provider.ts"() {
     "use strict";
@@ -4038,6 +4298,9 @@ var init_fastembed_provider = __esm({
     CACHE_FILE = join2(CACHE_DIR, ".embedding-cache.json");
     cache = /* @__PURE__ */ new Map();
     MAX_CACHE_SIZE = 5e3;
+    DEFAULT_CACHE_PAYLOAD_BYTES = 64 * 1024 * 1024;
+    MAX_CACHE_FILE_BYTES = 128 * 1024 * 1024;
+    cachePayloadBytes = 0;
     diskCacheDirty = false;
     FastEmbedProvider = class _FastEmbedProvider {
       name = "fastembed-bge-small";
@@ -4079,7 +4342,7 @@ var init_fastembed_provider = __esm({
         if (result.length !== this.dimensions) {
           throw new Error(`Expected ${this.dimensions}d embedding, got ${result.length}d`);
         }
-        this.cacheSet(hash4, result);
+        cacheSet(hash4, result);
         return result;
       }
       async embedBatch(texts) {
@@ -4104,7 +4367,7 @@ var init_fastembed_provider = __esm({
               const originalIdx = uncachedIndices[batchIdx];
               const plain = Array.from(vec);
               results[originalIdx] = plain;
-              this.cacheSet(textHash(uncachedTexts[batchIdx]), plain);
+              cacheSet(textHash(uncachedTexts[batchIdx]), plain);
               batchIdx++;
             }
           }
@@ -4112,14 +4375,6 @@ var init_fastembed_provider = __esm({
         }
         return results;
       }
-      cacheSet(hash4, value) {
-        if (cache.size >= MAX_CACHE_SIZE) {
-          const firstKey = cache.keys().next().value;
-          if (firstKey !== void 0) cache.delete(firstKey);
-        }
-        cache.set(hash4, value);
-        diskCacheDirty = true;
-      }
     };
   }
 });
@@ -4129,7 +4384,15 @@ var transformers_provider_exports = {};
 __export(transformers_provider_exports, {
   TransformersProvider: () => TransformersProvider
 });
-var cache2, MAX_CACHE_SIZE2, TransformersProvider;
+import { createHash as createHash2 } from "crypto";
+function cacheKey2(text3) {
+  return createHash2("sha256").update(text3).digest("hex");
+}
+function maxCachePayloadBytes2() {
+  const raw = Number.parseInt(process.env.MEMORIX_EMBEDDING_CACHE_MAX_BYTES ?? "", 10);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_CACHE_PAYLOAD_BYTES2;
+}
+var cache2, MAX_CACHE_SIZE2, DEFAULT_CACHE_PAYLOAD_BYTES2, cachePayloadBytes2, TransformersProvider;
 var init_transformers_provider = __esm({
   "src/embedding/transformers-provider.ts"() {
     "use strict";
@@ -4137,6 +4400,8 @@ var init_transformers_provider = __esm({
     init_provider();
     cache2 = /* @__PURE__ */ new Map();
     MAX_CACHE_SIZE2 = 5e3;
+    DEFAULT_CACHE_PAYLOAD_BYTES2 = 64 * 1024 * 1024;
+    cachePayloadBytes2 = 0;
     TransformersProvider = class _TransformersProvider {
       name = "transformers-minilm";
       dimensions = 384;
@@ -4171,7 +4436,7 @@ var init_transformers_provider = __esm({
         return Promise.all(inputs.map((input) => this.embedInput(input, options)));
       }
       async embed(text3) {
-        const cached = cache2.get(text3);
+        const cached = cache2.get(cacheKey2(text3));
         if (cached) return cached;
         const output = await this.extractor(text3, {
           pooling: "mean",
@@ -4181,7 +4446,7 @@ var init_transformers_provider = __esm({
         if (result.length !== this.dimensions) {
           throw new Error(`Expected ${this.dimensions}d embedding, got ${result.length}d`);
         }
-        this.cacheSet(text3, result);
+        this.cacheSet(cacheKey2(text3), result);
         return result;
       }
       async embedBatch(texts) {
@@ -4189,7 +4454,7 @@ var init_transformers_provider = __esm({
         const uncachedIndices = [];
         const uncachedTexts = [];
         for (let i2 = 0; i2 < texts.length; i2++) {
-          const cached = cache2.get(texts[i2]);
+          const cached = cache2.get(cacheKey2(texts[i2]));
           if (cached) {
             results[i2] = cached;
           } else {
@@ -4207,17 +4472,27 @@ var init_transformers_provider = __esm({
             const vec = Array.from(allVecs[i2]);
             const originalIdx = uncachedIndices[i2];
             results[originalIdx] = vec;
-            this.cacheSet(uncachedTexts[i2], vec);
+            this.cacheSet(cacheKey2(uncachedTexts[i2]), vec);
           }
         }
         return results;
       }
       cacheSet(key, value) {
-        if (cache2.size >= MAX_CACHE_SIZE2) {
-          const firstKey = cache2.keys().next().value;
-          if (firstKey !== void 0) cache2.delete(firstKey);
+        const incomingBytes = value.length * 8;
+        if (incomingBytes > maxCachePayloadBytes2()) return;
+        const existing = cache2.get(key);
+        if (existing) cachePayloadBytes2 -= existing.length * 8;
+        else {
+          while (cache2.size >= MAX_CACHE_SIZE2 || cachePayloadBytes2 + incomingBytes > maxCachePayloadBytes2()) {
+            const firstKey = cache2.keys().next().value;
+            if (firstKey === void 0) break;
+            const old = cache2.get(firstKey);
+            cache2.delete(firstKey);
+            if (old) cachePayloadBytes2 -= old.length * 8;
+          }
         }
         cache2.set(key, value);
+        cachePayloadBytes2 += incomingBytes;
       }
     };
   }
@@ -4239,7 +4514,7 @@ __export(api_provider_exports, {
   saveDiskCacheNow: () => saveDiskCacheNow,
   seedApiEmbeddingCacheForTests: () => seedApiEmbeddingCacheForTests
 });
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import { createReadStream, createWriteStream, constants as fsConstants } from "fs";
 import { access, readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, rename, stat, unlink } from "fs/promises";
 import { join as join3 } from "path";
@@ -4266,7 +4541,7 @@ function cacheStatFile() {
 function payloadBytes(vector) {
   return vector.length * BYTES_PER_DIM;
 }
-function maxCachePayloadBytes() {
+function maxCachePayloadBytes3() {
   const raw = process.env.MEMORIX_EMBEDDING_CACHE_MAX_BYTES;
   if (raw) {
     const parsed = Number.parseInt(raw, 10);
@@ -4276,7 +4551,7 @@ function maxCachePayloadBytes() {
 }
 function maxEntriesForDimensions(dimensions) {
   const dim = Math.max(1, Math.floor(dimensions));
-  const byBytes = Math.floor(maxCachePayloadBytes() / (dim * BYTES_PER_DIM));
+  const byBytes = Math.floor(maxCachePayloadBytes3() / (dim * BYTES_PER_DIM));
   return Math.max(1, Math.min(MAX_CACHE_ENTRIES, byBytes));
 }
 function rememberDimensions(vector) {
@@ -4289,13 +4564,15 @@ function evictOldest() {
   if (firstKey === void 0) return;
   const old = cache3.get(firstKey);
   cache3.delete(firstKey);
-  if (old) cachePayloadBytes -= payloadBytes(old);
+  if (old) cachePayloadBytes3 -= payloadBytes(old);
 }
 function evictToFit(incomingBytes, incomingDims) {
+  if (incomingBytes > maxCachePayloadBytes3()) return false;
   const limit2 = maxEntriesForDimensions(incomingDims);
-  while (cache3.size > 0 && (cache3.size >= limit2 || cachePayloadBytes + incomingBytes > maxCachePayloadBytes())) {
+  while (cache3.size > 0 && (cache3.size >= limit2 || cachePayloadBytes3 + incomingBytes > maxCachePayloadBytes3())) {
     evictOldest();
   }
+  return true;
 }
 function isNumberArray(value) {
   return Array.isArray(value) && value.every((entry) => typeof entry === "number");
@@ -4322,12 +4599,12 @@ function cacheInsert(hash4, value, dirty) {
   const incoming = payloadBytes(value);
   const existing = cache3.get(hash4);
   if (existing) {
-    cachePayloadBytes -= payloadBytes(existing);
+    cachePayloadBytes3 -= payloadBytes(existing);
     cache3.delete(hash4);
   }
-  evictToFit(incoming, value.length || cacheDimensions || DEFAULT_ASSUMED_DIMENSIONS);
+  if (!evictToFit(incoming, value.length || cacheDimensions || DEFAULT_ASSUMED_DIMENSIONS)) return;
   cache3.set(hash4, value);
-  cachePayloadBytes += incoming;
+  cachePayloadBytes3 += incoming;
   if (dirty) diskCacheDirty2 = true;
 }
 async function readCacheStat() {
@@ -4363,7 +4640,7 @@ function cacheNamespace(config) {
   ].join("|");
 }
 function textHash2(text3, namespace) {
-  return createHash2("sha256").update(`${namespace}\0${text3}`).digest("hex").slice(0, 16);
+  return createHash3("sha256").update(`${namespace}\0${text3}`).digest("hex").slice(0, 16);
 }
 function inputIdentity(input, options = {}) {
   return JSON.stringify({
@@ -4705,7 +4982,7 @@ function getApiEmbeddingDiskCacheLoadCountForTests() {
 }
 function resetApiEmbeddingCacheForTests() {
   cache3.clear();
-  cachePayloadBytes = 0;
+  cachePayloadBytes3 = 0;
   cacheDimensions = null;
   diskCacheEntryCount = 0;
   diskCacheLoaded = false;
@@ -4716,14 +4993,14 @@ function resetApiEmbeddingCacheForTests() {
 }
 function seedApiEmbeddingCacheForTests(entries) {
   cache3.clear();
-  cachePayloadBytes = 0;
+  cachePayloadBytes3 = 0;
   cacheDimensions = null;
   for (const [key, value] of entries) cacheInsert(key, value, true);
   diskCacheLoaded = true;
   diskCacheDirty2 = true;
 }
 function getApiEmbeddingCachePayloadBytesForTests() {
-  return cachePayloadBytes;
+  return cachePayloadBytes3;
 }
 function getApiEmbeddingJsonlLineCountCallsForTests() {
   return jsonlLineCountCalls;
@@ -4897,7 +5174,7 @@ function scheduleDiskSave() {
     diskSaveTimer = null;
   }, DISK_SAVE_DEBOUNCE_MS);
 }
-function cacheSet(hash4, value) {
+function cacheSet2(hash4, value) {
   cacheInsert(hash4, value, true);
 }
 function resolveEnvEmbeddingApiKey() {
@@ -5017,7 +5294,7 @@ async function waitForRetry(waitMs, signal) {
     abortSignal.addEventListener("abort", onAbort, { once: true });
   });
 }
-var cache3, MAX_CACHE_ENTRIES, MAX_CACHE_PAYLOAD_BYTES, BYTES_PER_DIM, DEFAULT_ASSUMED_DIMENSIONS, MAX_MIGRATION_VALUE_BYTES, cachePayloadBytes, cacheDimensions, diskCacheEntryCount, diskCacheDirty2, diskSaveTimer, diskCacheLoaded, diskCacheLoadPromise, diskCacheLoadCount, jsonlLineCountCalls, MAX_INPUT_CHARS, MAX_CONCURRENCY, DISK_SAVE_DEBOUNCE_MS, DEFAULT_MAX_BATCH_SIZE, DASHSCOPE_MAX_BATCH_SIZE, MAX_RETRIES2, BASE_DELAY_MS, EmbeddingAPIError, APIEmbeddingProvider;
+var cache3, MAX_CACHE_ENTRIES, MAX_CACHE_PAYLOAD_BYTES, BYTES_PER_DIM, DEFAULT_ASSUMED_DIMENSIONS, MAX_MIGRATION_VALUE_BYTES, cachePayloadBytes3, cacheDimensions, diskCacheEntryCount, diskCacheDirty2, diskSaveTimer, diskCacheLoaded, diskCacheLoadPromise, diskCacheLoadCount, jsonlLineCountCalls, MAX_INPUT_CHARS, MAX_CONCURRENCY, DISK_SAVE_DEBOUNCE_MS, DEFAULT_MAX_BATCH_SIZE, DASHSCOPE_MAX_BATCH_SIZE, MAX_RETRIES2, BASE_DELAY_MS, EmbeddingAPIError, APIEmbeddingProvider;
 var init_api_provider = __esm({
   "src/embedding/api-provider.ts"() {
     "use strict";
@@ -5029,7 +5306,7 @@ var init_api_provider = __esm({
     BYTES_PER_DIM = 8;
     DEFAULT_ASSUMED_DIMENSIONS = 4096;
     MAX_MIGRATION_VALUE_BYTES = 16 * 1024 * 1024;
-    cachePayloadBytes = 0;
+    cachePayloadBytes3 = 0;
     cacheDimensions = null;
     diskCacheEntryCount = 0;
     diskCacheDirty2 = false;
@@ -5214,7 +5491,7 @@ var init_api_provider = __esm({
         } else {
           embedding = await apiCall();
         }
-        cacheSet(hash4, embedding);
+        cacheSet2(hash4, embedding);
         scheduleDiskSave();
         return embedding;
       }
@@ -5262,7 +5539,7 @@ var init_api_provider = __esm({
             for (const item of response.data) {
               const originalIdx = chunkIndices[item.index];
               results[originalIdx] = item.embedding;
-              cacheSet(textHash2(normalizedTexts[originalIdx], this.cacheKeyNamespace), item.embedding);
+              cacheSet2(textHash2(normalizedTexts[originalIdx], this.cacheKeyNamespace), item.embedding);
             }
           } catch (error) {
             const providerLimit = parseBatchLimit(error);
@@ -5340,7 +5617,7 @@ var init_api_provider = __esm({
           throw new Error(`Expected ${this.dimensions}d, got ${embedding.length}d; dimension mismatch`);
         }
         this.trackUsage(response);
-        cacheSet(hash4, embedding);
+        cacheSet2(hash4, embedding);
         scheduleDiskSave();
         return embedding;
       }
@@ -6723,6 +7000,7 @@ var init_provider2 = __esm({
       openai: { baseUrl: "https://api.openai.com/v1", model: "gpt-4.1-nano" },
       anthropic: { baseUrl: "https://api.anthropic.com/v1", model: "claude-3-5-haiku-latest" },
       openrouter: { baseUrl: "https://openrouter.ai/api/v1", model: "openai/gpt-4.1-nano" },
+      atlascloud: { baseUrl: "https://api.atlascloud.ai/v1", model: "deepseek-ai/deepseek-v3.2" },
       custom: { baseUrl: "http://localhost:11434/v1", model: "llama3" }
     };
     currentConfig = null;
@@ -6986,6 +7264,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 +7428,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() {
@@ -7480,7 +7764,7 @@ var init_obs_store = __esm({
 });
 
 // src/search/semantic-index.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import { createRequire as createRequire3 } from "module";
 import path11 from "path";
 function createSemanticIndexProfile(provider2) {
@@ -7494,7 +7778,7 @@ function stateKey(dataDir, profile) {
   return `${path11.resolve(dataDir)}::${profile.key}`;
 }
 function tableName(profile) {
-  const digest2 = createHash3("sha256").update(profile.key).digest("hex").slice(0, 20);
+  const digest2 = createHash4("sha256").update(profile.key).digest("hex").slice(0, 20);
   return `${TABLE_PREFIX}${digest2}`;
 }
 function indexRoot(dataDir) {
@@ -9537,6 +9821,7 @@ var init_secret_filter = __esm({
 // src/runtime/maintenance-jobs.ts
 var maintenance_jobs_exports = {};
 __export(maintenance_jobs_exports, {
+  DEFAULT_FAILED_HISTORY_RETENTION_MS: () => DEFAULT_FAILED_HISTORY_RETENTION_MS,
   MAINTENANCE_JOB_KINDS: () => MAINTENANCE_JOB_KINDS,
   MaintenanceJobStore: () => MaintenanceJobStore,
   MaintenanceJobWorker: () => MaintenanceJobWorker,
@@ -9586,7 +9871,7 @@ function normalizedKinds(kinds) {
 function getMaintenanceRetryDelayMs(attempts) {
   return Math.min(6e4, 1e3 * 2 ** Math.max(0, attempts - 1));
 }
-var MAINTENANCE_JOB_KINDS, DEFAULT_MAX_ATTEMPTS, DEFAULT_LEASE_MS, DEFAULT_POLL_INTERVAL_MS, MAX_ERROR_LENGTH, DEFAULT_COMPLETED_HISTORY_RETENTION_MS, MaintenanceJobStore, MaintenanceJobWorker;
+var MAINTENANCE_JOB_KINDS, DEFAULT_MAX_ATTEMPTS, DEFAULT_LEASE_MS, DEFAULT_POLL_INTERVAL_MS, MAX_ERROR_LENGTH, DEFAULT_COMPLETED_HISTORY_RETENTION_MS, DEFAULT_FAILED_HISTORY_RETENTION_MS, MaintenanceJobStore, MaintenanceJobWorker;
 var init_maintenance_jobs = __esm({
   "src/runtime/maintenance-jobs.ts"() {
     "use strict";
@@ -9613,6 +9898,7 @@ var init_maintenance_jobs = __esm({
     DEFAULT_POLL_INTERVAL_MS = 2e3;
     MAX_ERROR_LENGTH = 1e3;
     DEFAULT_COMPLETED_HISTORY_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
+    DEFAULT_FAILED_HISTORY_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
     MaintenanceJobStore = class {
       db;
       constructor(dataDir) {
@@ -9739,18 +10025,21 @@ var init_maintenance_jobs = __esm({
       }
       /**
        * Completed jobs are useful recent operator history, not permanent data.
-       * Failed jobs stay available for diagnosis until an operator explicitly
-       * resolves them or clears the database.
+       * Failed diagnostics are retained longer, but are still bounded so a
+       * permanently failing job kind cannot grow the database forever.
        */
       pruneCompletedHistory(options = {}) {
         const now3 = options.now ?? Date.now();
         const maxAgeMs = Number.isFinite(options.maxAgeMs) ? Math.max(0, Math.floor(options.maxAgeMs)) : DEFAULT_COMPLETED_HISTORY_RETENTION_MS;
+        const failedMaxAgeMs = Number.isFinite(options.failedMaxAgeMs) ? Math.max(0, Math.floor(options.failedMaxAgeMs)) : DEFAULT_FAILED_HISTORY_RETENTION_MS;
         const result = this.db.prepare(`
       DELETE FROM maintenance_jobs
-      WHERE status = 'completed'
+      WHERE (status = 'completed'
         AND completed_at IS NOT NULL
-        AND completed_at < ?
-    `).run(now3 - maxAgeMs);
+        AND completed_at < ?)
+        OR (status = 'failed'
+        AND updated_at < ?)
+    `).run(now3 - maxAgeMs, now3 - failedMaxAgeMs);
         return Number(result.changes ?? 0);
       }
       claimNext(options) {
@@ -10104,7 +10393,7 @@ var init_lifecycle = __esm({
 });
 
 // src/store/evidence-store.ts
-import { createHash as createHash4, randomUUID as randomUUID3 } from "crypto";
+import { createHash as createHash5, randomUUID as randomUUID3 } from "crypto";
 function safeJson(value, fallback) {
   if (typeof value !== "string" || value.length === 0) return fallback;
   try {
@@ -10138,7 +10427,7 @@ function rowToCard(row) {
   };
 }
 function observationHash(observation) {
-  return createHash4("sha256").update(JSON.stringify({
+  return createHash5("sha256").update(JSON.stringify({
     projectId: observation.projectId,
     id: observation.id,
     title: observation.title,
@@ -10732,13 +11021,13 @@ __export(workspace_exports, {
   loadKnowledgeWorkspace: () => loadKnowledgeWorkspace,
   resolveKnowledgeWorkspaceFile: () => resolveKnowledgeWorkspaceFile
 });
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import { execFile } from "child_process";
 import { promises as fs9 } from "fs";
 import path14 from "path";
 import { promisify } from "util";
 function hash(value) {
-  return createHash5("sha256").update(value).digest("hex");
+  return createHash6("sha256").update(value).digest("hex");
 }
 function workspaceId(projectId, mode) {
   return "workspace:" + hash(projectId + ":" + mode).slice(0, 24);
@@ -11891,14 +12180,14 @@ __export(asset_store_exports, {
   readMediaAsset: () => readMediaAsset,
   removeMediaAsset: () => removeMediaAsset
 });
-import { createHash as createHash6, randomUUID as randomUUID6 } from "crypto";
+import { createHash as createHash7, randomUUID as randomUUID6 } from "crypto";
 import { copyFile, lstat, mkdir as mkdir3, open, readFile as readFile3, readdir, rename as rename2, rm, stat as stat2, writeFile as writeFile3 } from "fs/promises";
 import path15 from "path";
 function mediaRoot(dataDir) {
   return path15.resolve(dataDir, "media");
 }
 function projectStorageKey(projectId) {
-  return createHash6("sha256").update(projectId).digest("hex").slice(0, 16);
+  return createHash7("sha256").update(projectId).digest("hex").slice(0, 16);
 }
 function validateUnderRoot(root, candidate) {
   const resolved = path15.resolve(candidate);
@@ -11958,7 +12247,7 @@ async function readHeader(filePath, bytes = 32) {
 }
 async function sha256File(filePath) {
   const bytes = await readFile3(filePath);
-  return createHash6("sha256").update(bytes).digest("hex");
+  return createHash7("sha256").update(bytes).digest("hex");
 }
 function destinationFor(root, projectId, sha256, extension3) {
   const relative5 = path15.join("assets", projectStorageKey(projectId), sha256.slice(0, 2), `${sha256}${extension3}`);
@@ -12064,7 +12353,7 @@ async function importMediaBuffer(input) {
   if (input.bytes.length === 0) throw new Error("Media import rejects empty payloads");
   if (input.bytes.length > maxBytes) throw new Error(`Media payload is too large (${input.bytes.length} bytes; limit ${maxBytes})`);
   const detected = detectMedia(input.bytes.subarray(0, 32));
-  const sha256 = createHash6("sha256").update(input.bytes).digest("hex");
+  const sha256 = createHash7("sha256").update(input.bytes).digest("hex");
   return importKnownMedia({
     dataDir: input.dataDir,
     projectId: input.projectId,
@@ -12082,7 +12371,7 @@ async function readMediaAsset(dataDir, asset, maxBytes = DEFAULT_MAX_MEDIA_BYTES
   if (asset.byteSize > maxBytes) throw new Error(`Media asset exceeds read limit (${asset.byteSize} bytes; limit ${maxBytes})`);
   const bytes = await readFile3(getMediaAssetPath(dataDir, asset));
   if (bytes.length !== asset.byteSize) throw new Error(`Media asset size no longer matches metadata: ${asset.id}`);
-  const sha256 = createHash6("sha256").update(bytes).digest("hex");
+  const sha256 = createHash7("sha256").update(bytes).digest("hex");
   if (sha256 !== asset.sha256) throw new Error(`Media asset hash no longer matches metadata: ${asset.id}`);
   return bytes;
 }
@@ -64952,7 +65241,7 @@ var require_gaxios = __commonJS({
     var retry_js_1 = require_retry3();
     var stream_1 = __require("stream");
     var interceptor_js_1 = require_interceptor();
-    var randomUUID19 = async () => globalThis.crypto?.randomUUID() || (await import("crypto")).randomUUID();
+    var randomUUID20 = async () => globalThis.crypto?.randomUUID() || (await import("crypto")).randomUUID();
     var HTTP_STATUS_NO_CONTENT = 204;
     var Gaxios = class {
       agentCache = /* @__PURE__ */ new Map();
@@ -65225,7 +65514,7 @@ var require_gaxios = __commonJS({
          */
         ["Blob", "File", "FormData"].includes(opts.data?.constructor?.name || "");
         if (opts.multipart?.length) {
-          const boundary = await randomUUID19();
+          const boundary = await randomUUID20();
           preparedHeaders.set("content-type", `multipart/related; boundary=${boundary}`);
           opts.body = stream_1.Readable.from(this.getMultipartRequest(opts.multipart, boundary));
         } else if (shouldDirectlyPassData) {
@@ -70897,16 +71186,16 @@ var require_jwtaccess = __commonJS({
        * @returns A string that returns the cached key.
        */
       getCachedKey(url, scopes) {
-        let cacheKey = url;
+        let cacheKey3 = url;
         if (scopes && Array.isArray(scopes) && scopes.length) {
-          cacheKey = url ? `${url}_${scopes.join("_")}` : `${scopes.join("_")}`;
+          cacheKey3 = url ? `${url}_${scopes.join("_")}` : `${scopes.join("_")}`;
         } else if (typeof scopes === "string") {
-          cacheKey = url ? `${url}_${scopes}` : scopes;
+          cacheKey3 = url ? `${url}_${scopes}` : scopes;
         }
-        if (!cacheKey) {
+        if (!cacheKey3) {
           throw Error("Scopes or url must be provided");
         }
-        return cacheKey;
+        return cacheKey3;
       }
       /**
        * Get a non-expired access token, after refreshing if necessary.
@@ -77452,7 +77741,7 @@ var require_websocket = __commonJS({
     var http3 = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes2, createHash: createHash19 } = __require("crypto");
+    var { randomBytes: randomBytes2, createHash: createHash20 } = __require("crypto");
     var { Duplex, Readable: Readable2 } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -78120,7 +78409,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest2 = createHash19("sha1").update(key + GUID).digest("base64");
+        const digest2 = createHash20("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest2) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -78492,7 +78781,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter2 = __require("events");
     var http3 = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash19 } = __require("crypto");
+    var { createHash: createHash20 } = __require("crypto");
     var extension3 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -78799,7 +79088,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest2 = createHash19("sha1").update(key + GUID).digest("base64");
+        const digest2 = createHash20("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -142858,9 +143147,9 @@ var init_union_priority_sort = __esm({
 // node_modules/typebox/build/value/clean/from_union.mjs
 function FromUnion9(context, type, value) {
   for (const schema of UnionPrioritySort(type.anyOf)) {
-    const clean = FromType19(context, schema, Clone2(value));
-    if (Check2(context, schema, clean))
-      return clean;
+    const clean2 = FromType19(context, schema, Clone2(value));
+    if (Check2(context, schema, clean2))
+      return clean2;
   }
   return value;
 }
@@ -147498,9 +147787,9 @@ var init_long_term = __esm({
 });
 
 // src/codegraph/ids.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 function digest(input) {
-  return createHash7("sha256").update(input).digest("hex").slice(0, 16);
+  return createHash8("sha256").update(input).digest("hex").slice(0, 16);
 }
 function normalizeCodePath(path38) {
   return path38.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/");
@@ -148548,7 +148837,7 @@ var init_store = __esm({
 
 // src/codegraph/code-state.ts
 import { execFile as execFile2 } from "child_process";
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 import { promisify as promisify3 } from "util";
 async function runGit(rootPath, args) {
   try {
@@ -148577,7 +148866,7 @@ function changedPathCount(status) {
   return count2;
 }
 function fingerprint(baseRevision, status) {
-  return createHash8("sha256").update(baseRevision ?? "").update("\0").update(status).digest("hex");
+  return createHash9("sha256").update(baseRevision ?? "").update("\0").update(status).digest("hex");
 }
 async function collectCodeStateSnapshot(input) {
   const [revision, status] = await Promise.all([
@@ -148671,12 +148960,12 @@ var init_exclude3 = __esm({
 });
 
 // src/codegraph/semantic-provider.ts
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 import "fs";
 import { resolve } from "path";
 import ts from "typescript";
 function hashText(value) {
-  return createHash9("sha256").update(value).digest("hex");
+  return createHash10("sha256").update(value).digest("hex");
 }
 function canonicalPath(value) {
   const normalized = resolve(value).replace(/\\/g, "/");
@@ -149021,11 +149310,11 @@ __export(lite_provider_exports, {
   indexProjectLite: () => indexProjectLite,
   refreshProjectLite: () => refreshProjectLite
 });
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 import { existsSync as existsSync12, readdirSync as readdirSync2, readFileSync as readFileSync8, statSync as statSync3 } from "fs";
 import { join as join4, relative as relative2 } from "path";
 function hashText2(text3) {
-  return createHash10("sha256").update(text3).digest("hex");
+  return createHash11("sha256").update(text3).digest("hex");
 }
 function extension2(path38) {
   const index = path38.lastIndexOf(".");
@@ -149658,7 +149947,7 @@ var claim_store_exports = {};
 __export(claim_store_exports, {
   ClaimStore: () => ClaimStore
 });
-import { createHash as createHash11, randomUUID as randomUUID12 } from "crypto";
+import { createHash as createHash12, randomUUID as randomUUID12 } from "crypto";
 function optionalText3(value) {
   return typeof value === "string" && value ? value : void 0;
 }
@@ -149711,7 +150000,7 @@ function rowToEvent3(row) {
   };
 }
 function evidenceKey(input) {
-  return createHash11("sha256").update(JSON.stringify([
+  return createHash12("sha256").update(JSON.stringify([
     input.evidenceKind,
     input.evidenceId,
     input.relation,
@@ -149909,7 +150198,7 @@ __export(claims_exports, {
   supersedeClaim: () => supersedeClaim,
   writeClaim: () => writeClaim
 });
-import { createHash as createHash12, randomUUID as randomUUID13 } from "crypto";
+import { createHash as createHash13, randomUUID as randomUUID13 } from "crypto";
 function compactText2(value, field) {
   if (typeof value !== "string") throw new Error("Claim " + field + " must be text");
   const sanitized = sanitizeCredentials(value).trim().replace(/\s+/g, " ");
@@ -149921,7 +150210,7 @@ function normalizedTerm(value) {
   return compactText2(value, "identity").toLocaleLowerCase("en-US");
 }
 function hashIdentity(parts) {
-  return createHash12("sha256").update(parts.join(String.fromCharCode(31))).digest("hex");
+  return createHash13("sha256").update(parts.join(String.fromCharCode(31))).digest("hex");
 }
 function buildClaimIdentity(input) {
   const subject = normalizedTerm(input.subject);
@@ -150162,7 +150451,7 @@ function supersedeClaim(store, input) {
   });
 }
 function hashObservation(observation) {
-  return createHash12("sha256").update(JSON.stringify([
+  return createHash13("sha256").update(JSON.stringify([
     observation.title,
     observation.narrative,
     observation.facts,
@@ -150406,11 +150695,11 @@ var init_frontmatter = __esm({
 });
 
 // src/knowledge/markdown.ts
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash14 } from "crypto";
 import { promises as fs13 } from "fs";
 import path22 from "path";
 function hashContent(content) {
-  return createHash13("sha256").update(content).digest("hex");
+  return createHash14("sha256").update(content).digest("hex");
 }
 function stringField(data, key) {
   const value = data[key];
@@ -150536,11 +150825,11 @@ __export(wiki_exports, {
   lintKnowledgeWorkspace: () => lintKnowledgeWorkspace,
   readKnowledgePage: () => readKnowledgePage
 });
-import { createHash as createHash14 } from "crypto";
+import { createHash as createHash15 } from "crypto";
 import { promises as fs14 } from "fs";
 import path23 from "path";
 function hash2(value) {
-  return createHash14("sha256").update(value).digest("hex");
+  return createHash15("sha256").update(value).digest("hex");
 }
 function now() {
   return (/* @__PURE__ */ new Date()).toISOString();
@@ -151759,11 +152048,11 @@ __export(workflows_exports, {
   syncCanonicalWorkflows: () => syncCanonicalWorkflows,
   writeCanonicalWorkflow: () => writeCanonicalWorkflow
 });
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 import { promises as fs15 } from "fs";
 import path24 from "path";
 function hash3(value) {
-  return createHash15("sha256").update(value).digest("hex");
+  return createHash16("sha256").update(value).digest("hex");
 }
 function now2() {
   return (/* @__PURE__ */ new Date()).toISOString();
@@ -156124,9 +156413,9 @@ var init_graph_context = __esm({
 });
 
 // src/rules/utils.ts
-import { createHash as createHash16 } from "crypto";
+import { createHash as createHash17 } from "crypto";
 function hashContent2(content) {
-  return createHash16("sha256").update(content.trim()).digest("hex").substring(0, 16);
+  return createHash17("sha256").update(content.trim()).digest("hex").substring(0, 16);
 }
 function generateRuleId(source, filePath) {
   const sanitized = filePath.replace(/[\/\\]/g, "-").replace(/^\./, "");
@@ -158569,6 +158858,7 @@ var init_tool_profile = __esm({
       // keep the default micro profile at its nine-tool token budget.
       memorix_evidence: ["lite", "team", "full"],
       memorix_feedback: ["lite", "team", "full"],
+      memorix_continuity: ["lite", "team", "full"],
       // ── lite: extended solo memory surface ────────────────────────────
       memorix_graph_context: ["lite", "team", "full"],
       memorix_timeline: ["lite", "team", "full"],
@@ -159802,7 +160092,7 @@ var init_request_context = __esm({
 function getMcpServerInfo() {
   return {
     name: "memorix",
-    version: true ? "1.9.4" : "1.0.1"
+    version: true ? "1.9.6" : "1.0.1"
   };
 }
 function createMcpDiscoverResult(capabilities, serverInfo) {
@@ -159891,8 +160181,8 @@ function legacyBehavior(homeDir) {
 function getBehaviorConfig(options = {}) {
   const homeDir = options.homeDir ?? homedir22();
   const projectRoot = options.projectRoot === void 0 ? detectProject()?.rootPath ?? null : options.projectRoot;
-  const cacheKey = `${homeDir}\0${projectRoot ?? ""}`;
-  const cached = cache4.get(cacheKey);
+  const cacheKey3 = `${homeDir}\0${projectRoot ?? ""}`;
+  const cached = cache4.get(cacheKey3);
   if (cached) return cached;
   const legacy = legacyBehavior(homeDir);
   let resolved = {};
@@ -159906,7 +160196,7 @@ function getBehaviorConfig(options = {}) {
     autoCleanup: typeof resolved.autoCleanup === "boolean" ? resolved.autoCleanup : typeof legacy.autoCleanup === "boolean" ? legacy.autoCleanup : DEFAULTS.autoCleanup,
     formationMode: isFormationMode(resolved.formation) ? resolved.formation : isFormationMode(legacy.formationMode) ? legacy.formationMode : DEFAULTS.formationMode
   };
-  cache4.set(cacheKey, config);
+  cache4.set(cacheKey3, config);
   return config;
 }
 function resetBehaviorConfigCache() {
@@ -160197,7 +160487,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()));
@@ -160511,6 +160801,7 @@ function freshnessForMemory(status) {
   return "unknown";
 }
 function receiptOmissionKind(raw) {
+  if (raw.includes("continuity")) return "continuity";
   if (raw.includes("continuation")) return "continuation";
   if (raw.includes("task")) return "task";
   if (raw.includes("fact")) return "current-fact";
@@ -160621,6 +160912,77 @@ function renderTaskWorksetPrompt(input) {
     trust: "source-backed"
   });
   appendLine(lines, "Task lens: " + input.lens, maxTokens, omitted, "lens");
+  if (input.continuity) {
+    const continuity = input.continuity;
+    appendLine(lines, "", maxTokens, omitted, "continuity-heading");
+    appendLine(lines, "Task continuity", maxTokens, omitted, "continuity-heading", selected, {
+      kind: "continuity",
+      id: "continuity:" + continuity.taskId,
+      reason: "explicit task continuity ledger",
+      trust: "source-backed"
+    });
+    appendLine(
+      lines,
+      "- Status: " + continuity.status + " | " + short(continuity.task, 30),
+      maxTokens,
+      omitted,
+      "continuity-task"
+    );
+    appendLine(
+      lines,
+      "- Outcome: " + continuity.outcome.state,
+      maxTokens,
+      omitted,
+      "continuity-outcome",
+      selected,
+      {
+        kind: "continuity",
+        id: "continuity:" + continuity.taskId,
+        reason: "deterministic task outcome projection",
+        trust: "derived"
+      }
+    );
+    for (const requirement of continuity.requirements.slice(0, 3)) {
+      appendLine(lines, "- Requirement: " + short(requirement, 24), maxTokens, omitted, "continuity-requirement", selected, {
+        kind: "continuity",
+        id: "continuity:" + continuity.taskId,
+        reason: "explicit task requirement",
+        trust: "source-backed"
+      });
+    }
+    for (const decision of continuity.decisions.slice(0, 2)) {
+      appendLine(lines, "- Decision: " + short(decision, 24), maxTokens, omitted, "continuity-decision", selected, {
+        kind: "continuity",
+        id: "continuity:" + continuity.taskId,
+        reason: "explicit task decision",
+        trust: "source-backed"
+      });
+    }
+    for (const verification of continuity.verification.slice(-3)) {
+      appendLine(
+        lines,
+        "- Verify [" + verification.status + "]: " + short(verification.content, 22),
+        maxTokens,
+        omitted,
+        "continuity-verification",
+        selected,
+        {
+          kind: "continuity",
+          id: "continuity:" + continuity.taskId,
+          reason: "task verification state",
+          trust: "source-backed"
+        }
+      );
+    }
+    for (const risk of continuity.risks.slice(0, 2)) {
+      appendLine(lines, "- Risk: " + short(risk, 22), maxTokens, omitted, "continuity-risk", selected, {
+        kind: "continuity",
+        id: "continuity:" + continuity.taskId,
+        reason: "open task risk",
+        trust: "source-backed"
+      });
+    }
+  }
   if (input.alwaysOn) {
     const hasAlwaysOn = input.alwaysOn.profile.length > 0 || Boolean(input.alwaysOn.state) || input.alwaysOn.durable.length > 0;
     if (hasAlwaysOn) {
@@ -161144,6 +161506,7 @@ async function buildTaskWorkset(input) {
     version: "1.3",
     task,
     lens: input.lens,
+    ...input.continuity ? { continuity: input.continuity } : {},
     ...input.alwaysOn && (input.alwaysOn.profile.length > 0 || input.alwaysOn.state || input.alwaysOn.durable.length > 0) ? { alwaysOn: input.alwaysOn } : {},
     currentFacts: input.currentFacts?.map((fact) => fact.startsWith("Historical note:") ? short(fact, 48) : short(fact, 28)).slice(0, 4) ?? [],
     ...continuation ? { continuation } : {},
@@ -162528,7 +162891,7 @@ var compaction_checkpoint_store_exports = {};
 __export(compaction_checkpoint_store_exports, {
   CompactionCheckpointStore: () => CompactionCheckpointStore
 });
-import { createHash as createHash17, randomUUID as randomUUID16 } from "crypto";
+import { createHash as createHash18, randomUUID as randomUUID16 } from "crypto";
 function optionalText7(value) {
   return typeof value === "string" && value ? value : void 0;
 }
@@ -162570,7 +162933,7 @@ function sourceKeyFor(input, summary) {
     input.tokensBefore ?? "",
     input.firstKeptEntryId ?? ""
   ].join("\0");
-  return `derived:${createHash17("sha256").update(material).digest("hex").slice(0, 32)}`;
+  return `derived:${createHash18("sha256").update(material).digest("hex").slice(0, 32)}`;
 }
 function rowToCheckpoint(row) {
   return {
@@ -162828,6 +163191,305 @@ var init_compaction_checkpoint_store = __esm({
   }
 });
 
+// src/knowledge/task-continuity.ts
+var task_continuity_exports = {};
+__export(task_continuity_exports, {
+  TASK_CONTINUITY_EVENT_KINDS: () => TASK_CONTINUITY_EVENT_KINDS,
+  TaskContinuityStore: () => TaskContinuityStore,
+  evaluateTaskContinuity: () => evaluateTaskContinuity
+});
+import { randomUUID as randomUUID17 } from "crypto";
+function clean(value, maxLength = MAX_TEXT_LENGTH2) {
+  return sanitizeCredentials(value).replace(/\s+/g, " ").trim().slice(0, maxLength);
+}
+function cleanList(values, maxLength = MAX_TEXT_LENGTH2) {
+  return [...new Set((values ?? []).map((value) => clean(value, maxLength)).filter(Boolean))].slice(0, MAX_LIST_ITEMS2);
+}
+function parseRefs(value) {
+  if (typeof value !== "string") return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? cleanList(parsed.filter((item) => typeof item === "string"), 500).slice(0, MAX_EVIDENCE_REFS) : [];
+  } catch {
+    return [];
+  }
+}
+function evaluateTaskContinuity(ledger) {
+  const verification = {
+    passed: ledger.verification.filter((item) => item.status === "passed").length,
+    failed: ledger.verification.filter((item) => item.status === "failed").length,
+    pending: ledger.verification.filter((item) => item.status === "pending").length,
+    skipped: ledger.verification.filter((item) => item.status === "skipped").length
+  };
+  const reasons = [];
+  if (verification.failed > 0) reasons.push("verification-failed");
+  if (verification.pending > 0) reasons.push("verification-pending");
+  if (ledger.risks.length > 0) reasons.push("open-risks");
+  if (ledger.status === "blocked") reasons.push("task-blocked");
+  if (ledger.status === "abandoned") reasons.push("task-abandoned");
+  if (ledger.status === "blocked" || ledger.status === "abandoned" || verification.failed > 0) {
+    return {
+      state: "at-risk",
+      score: verification.passed > verification.failed ? 0.55 : 0.2,
+      verification,
+      reasons
+    };
+  }
+  if (ledger.status === "completed") {
+    if (verification.passed > 0 && verification.pending === 0 && verification.skipped === 0) {
+      return {
+        state: ledger.risks.length > 0 ? "validated-with-risks" : "validated",
+        score: ledger.risks.length > 0 ? 0.8 : 1,
+        verification,
+        reasons: reasons.length > 0 ? reasons : ["verification-passed"]
+      };
+    }
+    return {
+      state: "unverified",
+      score: 0.4,
+      verification,
+      reasons: reasons.length > 0 ? reasons : ["no-passing-verification"]
+    };
+  }
+  return {
+    state: "in-progress",
+    score: verification.passed > 0 && verification.pending === 0 ? 0.75 : 0.5,
+    verification,
+    reasons: reasons.length > 0 ? reasons : ["task-open"]
+  };
+}
+function rowToEvent4(row) {
+  const status = row.item_status ? String(row.item_status) : void 0;
+  return {
+    id: String(row.id),
+    projectId: String(row.project_id),
+    taskId: String(row.task_id),
+    task: clean(String(row.task), MAX_TASK_LENGTH),
+    kind: row.kind,
+    content: clean(String(row.content)),
+    ...status ? { status } : {},
+    ...row.source_ref ? { sourceRef: clean(String(row.source_ref), 500) } : {},
+    evidenceRefs: parseRefs(row.evidence_json),
+    ...row.actor ? { actor: clean(String(row.actor), 200) } : {},
+    at: String(row.created_at),
+    ...row.event_key ? { eventKey: clean(String(row.event_key), 200) } : {},
+    ...row.item_key ? { itemKey: clean(String(row.item_key), 120) } : {},
+    ...row.supersedes_id ? { supersedesId: clean(String(row.supersedes_id), 120) } : {}
+  };
+}
+function aggregate(events) {
+  const first2 = events.find((event) => event.kind === "task") ?? events[0];
+  const latestOutcome = [...events].reverse().find((event) => event.kind === "outcome");
+  const verificationByKey = /* @__PURE__ */ new Map();
+  for (const event of events.filter((event2) => event2.kind === "verification")) {
+    verificationByKey.set(event.itemKey ?? `event:${event.id}`, event);
+  }
+  const ledger = {
+    taskId: first2.taskId,
+    projectId: first2.projectId,
+    task: first2.task,
+    status: latestOutcome?.status ?? "open",
+    requirements: events.filter((event) => event.kind === "requirement").map((event) => event.content),
+    decisions: events.filter((event) => event.kind === "decision").map((event) => event.content),
+    verification: [...verificationByKey.values()].map((event) => ({
+      id: event.itemKey ?? event.id,
+      content: event.content,
+      status: event.status ?? "pending",
+      ...event.sourceRef ? { sourceRef: event.sourceRef } : {},
+      evidenceRefs: event.evidenceRefs
+    })),
+    risks: events.filter((event) => event.kind === "risk").map((event) => event.content),
+    outcomes: events.filter((event) => event.kind === "outcome").map((event) => event.content),
+    updatedAt: events[events.length - 1].at,
+    events
+  };
+  return { ...ledger, outcome: evaluateTaskContinuity(ledger) };
+}
+var TASK_CONTINUITY_EVENT_KINDS, MAX_TEXT_LENGTH2, MAX_TASK_LENGTH, MAX_LIST_ITEMS2, MAX_EVIDENCE_REFS, MAX_EVENTS_PER_TASK, TaskContinuityStore;
+var init_task_continuity = __esm({
+  "src/knowledge/task-continuity.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_secret_filter();
+    init_sqlite_db();
+    TASK_CONTINUITY_EVENT_KINDS = [
+      "task",
+      "requirement",
+      "decision",
+      "verification",
+      "risk",
+      "outcome"
+    ];
+    MAX_TEXT_LENGTH2 = 2e3;
+    MAX_TASK_LENGTH = 1e3;
+    MAX_LIST_ITEMS2 = 8;
+    MAX_EVIDENCE_REFS = 8;
+    MAX_EVENTS_PER_TASK = 200;
+    TaskContinuityStore = class {
+      db = null;
+      async init(dataDir) {
+        this.db = getDatabase(dataDir);
+      }
+      requireDb() {
+        if (!this.db) throw new Error("TaskContinuityStore is not initialized.");
+        return this.db;
+      }
+      insert(input) {
+        const db2 = this.requireDb();
+        const projectId = clean(input.projectId, 500);
+        const taskId = clean(input.taskId, 120);
+        const eventKey = input.eventKey ? clean(input.eventKey, 200) : void 0;
+        if (eventKey) {
+          const existing = db2.prepare(
+            "SELECT * FROM task_continuity_events WHERE project_id = ? AND task_id = ? AND event_key = ?"
+          ).get(projectId, taskId, eventKey);
+          if (existing) return rowToEvent4(existing);
+        }
+        const existingCount = db2.prepare(
+          "SELECT COUNT(*) AS count FROM task_continuity_events WHERE project_id = ? AND task_id = ?"
+        ).get(projectId, taskId);
+        if (Number(existingCount?.count ?? 0) >= MAX_EVENTS_PER_TASK) {
+          throw new Error("Task continuity ledger reached its 200-event limit.");
+        }
+        const event = {
+          id: randomUUID17(),
+          projectId,
+          taskId,
+          task: clean(input.task, MAX_TASK_LENGTH),
+          kind: input.kind,
+          content: clean(input.content),
+          ...input.status ? { status: input.status } : {},
+          ...input.sourceRef ? { sourceRef: clean(input.sourceRef, 500) } : {},
+          evidenceRefs: cleanList(input.evidenceRefs, 500).slice(0, MAX_EVIDENCE_REFS),
+          ...input.actor ? { actor: clean(input.actor, 200) } : {},
+          at: input.at ?? (/* @__PURE__ */ new Date()).toISOString(),
+          ...eventKey ? { eventKey } : {},
+          ...input.itemKey ? { itemKey: clean(input.itemKey, 120) } : {},
+          ...input.supersedesId ? { supersedesId: clean(input.supersedesId, 120) } : {}
+        };
+        db2.prepare(`
+      INSERT INTO task_continuity_events (
+        id, project_id, task_id, task, kind, content, item_status,
+        source_ref, evidence_json, actor, created_at, event_key, item_key, supersedes_id
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+          event.id,
+          event.projectId,
+          event.taskId,
+          event.task,
+          event.kind,
+          event.content,
+          event.status ?? null,
+          event.sourceRef ?? null,
+          JSON.stringify(event.evidenceRefs),
+          event.actor ?? null,
+          event.at,
+          event.eventKey ?? null,
+          event.itemKey ?? null,
+          event.supersedesId ?? null
+        );
+        return event;
+      }
+      start(input) {
+        const task = clean(input.task, MAX_TASK_LENGTH);
+        if (!task) throw new Error("A non-empty task is required.");
+        const idempotencyKey = input.idempotencyKey ? clean(input.idempotencyKey, 200) : void 0;
+        const taskId = clean(input.taskId ?? idempotencyKey ?? "", 120) || randomUUID17();
+        const requirements = cleanList(input.requirements);
+        const transaction = this.requireDb().transaction(() => {
+          this.insert({
+            projectId: input.projectId,
+            taskId,
+            task,
+            kind: "task",
+            content: task,
+            status: "open",
+            actor: input.actor,
+            ...idempotencyKey ? { eventKey: `start:${idempotencyKey}` } : {}
+          });
+          for (const requirement of requirements) {
+            this.insert({
+              projectId: input.projectId,
+              taskId,
+              task,
+              kind: "requirement",
+              content: requirement,
+              actor: input.actor
+            });
+          }
+        });
+        transaction.immediate();
+        return { taskId, ledger: this.get(input.projectId, taskId) };
+      }
+      record(input) {
+        const projectId = clean(input.projectId, 500);
+        const taskId = clean(input.taskId, 120);
+        const existing = this.get(projectId, taskId);
+        if (!existing) throw new Error("Task continuity ledger not found: " + taskId);
+        const transaction = this.requireDb().transaction(() => this.insert({
+          projectId,
+          taskId,
+          task: existing.task,
+          kind: input.kind,
+          content: input.content,
+          ...input.kind === "verification" && input.verificationStatus ? { status: input.verificationStatus } : {},
+          sourceRef: input.sourceRef,
+          evidenceRefs: input.evidenceRefs,
+          actor: input.actor,
+          at: input.at,
+          ...input.idempotencyKey ? { eventKey: input.idempotencyKey } : {},
+          ...input.verificationId ? { itemKey: input.verificationId } : {}
+        }));
+        const event = transaction.immediate();
+        return { event, ledger: this.get(projectId, taskId) };
+      }
+      close(input) {
+        const projectId = clean(input.projectId, 500);
+        const taskId = clean(input.taskId, 120);
+        const existing = this.get(projectId, taskId);
+        if (!existing) throw new Error("Task continuity ledger not found: " + taskId);
+        const transaction = this.requireDb().transaction(() => this.insert({
+          projectId,
+          taskId,
+          task: existing.task,
+          kind: "outcome",
+          content: input.content,
+          status: input.status,
+          sourceRef: input.sourceRef,
+          evidenceRefs: input.evidenceRefs,
+          actor: input.actor,
+          at: input.at,
+          ...input.idempotencyKey ? { eventKey: input.idempotencyKey } : {}
+        }));
+        const event = transaction.immediate();
+        return { event, ledger: this.get(projectId, taskId) };
+      }
+      get(projectId, taskId) {
+        const normalizedProjectId = clean(projectId, 500);
+        const normalizedTaskId = clean(taskId, 120);
+        const rows = this.requireDb().prepare(`
+      SELECT * FROM task_continuity_events
+      WHERE project_id = ? AND task_id = ?
+      ORDER BY created_at ASC, rowid ASC
+    `).all(normalizedProjectId, normalizedTaskId);
+        if (rows.length === 0) return void 0;
+        return aggregate(rows.map(rowToEvent4));
+      }
+      list(projectId, limit2 = 20) {
+        const rows = this.requireDb().prepare(`
+      SELECT task_id
+      FROM task_continuity_events
+      WHERE project_id = ?
+      GROUP BY task_id
+      ORDER BY MAX(created_at) DESC
+      LIMIT ?
+    `).all(projectId, Math.min(100, Math.max(1, Math.floor(limit2))));
+        return rows.map((row) => this.get(projectId, String(row.task_id))).filter((ledger) => Boolean(ledger));
+      }
+    };
+  }
+});
+
 // src/codegraph/auto-context.ts
 var auto_context_exports = {};
 __export(auto_context_exports, {
@@ -163084,6 +163746,16 @@ async function buildAutoProjectContext(input) {
       };
     }
   }
+  let continuity = input.continuity;
+  if (!continuity && input.taskId) {
+    try {
+      const { TaskContinuityStore: TaskContinuityStore2 } = await Promise.resolve().then(() => (init_task_continuity(), task_continuity_exports));
+      const continuityStore = new TaskContinuityStore2();
+      await continuityStore.init(input.dataDir);
+      continuity = continuityStore.get(input.project.id, input.taskId);
+    } catch {
+    }
+  }
   const alwaysOn = await buildAlwaysOnBlock({
     dataDir: input.dataDir,
     projectId: input.project.id,
@@ -163102,6 +163774,7 @@ async function buildAutoProjectContext(input) {
     providerQuality: providerQuality2,
     currentFacts: worksetFactLines(currentFacts),
     ...continuation ? { continuation } : {},
+    ...continuity ? { continuity } : {},
     codeState: codeStateLine(overview),
     ...codeEvolution ? { codeEvolution } : {},
     reliableMemory: sourceSets.reliableSources.slice(0, lens.sourceLimit).map((source) => ({
@@ -163149,6 +163822,7 @@ async function buildAutoProjectContext(input) {
     refresh,
     providerQuality: providerQuality2,
     ...continuationRequested && workset.continuation ? { continuation: workset.continuation } : {},
+    ...workset.continuity ? { continuity: workset.continuity } : {},
     workset
   };
 }
@@ -163450,7 +164124,14 @@ function buildBoundedContextReceipt(input) {
       externalState: provider2?.external.state ?? "not-detected",
       ...input.workset.provenance.snapshotId ? { snapshotId: input.workset.provenance.snapshotId } : {}
     },
-    ...input.workset.agentLoadout ? { loadout: input.workset.agentLoadout } : {}
+    ...input.workset.agentLoadout ? { loadout: input.workset.agentLoadout } : {},
+    ...input.workset.continuity ? {
+      continuity: {
+        taskId: input.workset.continuity.taskId,
+        status: input.workset.continuity.status,
+        outcome: input.workset.continuity.outcome
+      }
+    } : {}
   };
 }
 var init_context_receipt = __esm({
@@ -164082,15 +164763,21 @@ var team_store_exports = {};
 __export(team_store_exports, {
   AGENT_TYPE_ROLE_MAP: () => AGENT_TYPE_ROLE_MAP,
   DEFAULT_ROLES: () => DEFAULT_ROLES,
+  DEFAULT_TEAM_QUERY_LIMIT: () => DEFAULT_TEAM_QUERY_LIMIT,
+  MAX_TEAM_QUERY_LIMIT: () => MAX_TEAM_QUERY_LIMIT,
   TeamStore: () => TeamStore,
   getTeamStore: () => getTeamStore,
   initTeamStore: () => initTeamStore,
   isTeamStoreInitialized: () => isTeamStoreInitialized,
   resetTeamStore: () => resetTeamStore
 });
-import { randomUUID as randomUUID17 } from "crypto";
+import { randomUUID as randomUUID18 } from "crypto";
 import path31 from "path";
 import fs18 from "fs";
+function clampTeamQueryLimit(limit2) {
+  if (!Number.isFinite(limit2) || limit2 == null) return DEFAULT_TEAM_QUERY_LIMIT;
+  return Math.min(MAX_TEAM_QUERY_LIMIT, Math.max(1, Math.floor(limit2)));
+}
 function getTeamStore() {
   if (!_teamStore) {
     throw new Error("[memorix] TeamStore not initialized \u2014 call initTeamStore() first");
@@ -164114,12 +164801,14 @@ function resetTeamStore() {
   _teamStore = null;
   _teamStoreDataDir = null;
 }
-var DEFAULT_ROLES, AGENT_TYPE_ROLE_MAP, TeamStore, _teamStore, _teamStoreDataDir;
+var DEFAULT_TEAM_QUERY_LIMIT, MAX_TEAM_QUERY_LIMIT, DEFAULT_ROLES, AGENT_TYPE_ROLE_MAP, TeamStore, _teamStore, _teamStoreDataDir;
 var init_team_store = __esm({
   "src/team/team-store.ts"() {
     "use strict";
     init_esm_shims();
     init_sqlite_db();
+    DEFAULT_TEAM_QUERY_LIMIT = 100;
+    MAX_TEAM_QUERY_LIMIT = 500;
     DEFAULT_ROLES = [
       { roleId: "planner", label: "Planner", description: "Breaks down requirements, creates tasks, defines dependencies", preferredAgentTypes: ["claude-code", "cursor", "codex"], maxConcurrent: 2 },
       { roleId: "researcher", label: "Researcher", description: "Investigates codebase, gathers context, answers questions", preferredAgentTypes: ["claude-code", "cursor", "gemini-cli"], maxConcurrent: 2 },
@@ -164377,7 +165066,7 @@ var init_team_store = __esm({
        * reactivate it (preserving agent_id). Otherwise create a new one.
        */
       registerAgent(input) {
-        const instanceId = input.instanceId || randomUUID17();
+        const instanceId = input.instanceId || randomUUID18();
         const now3 = Date.now();
         const existing = this.stmtAgentFindByInstance.get(
           input.projectId,
@@ -164403,7 +165092,7 @@ var init_team_store = __esm({
           this.eventBus?.emit("agent:joined", { agentId: row2.agent_id, projectId: input.projectId, agentType: input.agentType });
           return row2;
         }
-        const agentId = randomUUID17();
+        const agentId = randomUUID18();
         this.stmtAgentUpsert.run({
           agent_id: agentId,
           project_id: input.projectId,
@@ -164429,32 +165118,37 @@ var init_team_store = __esm({
         return this.stmtAgentFindByInstance.get(projectId, agentType, instanceId);
       }
       listAgents(projectId, filter) {
-        const all = this.stmtAgentListByProject.all(projectId);
+        const limit2 = clampTeamQueryLimit(filter?.limit);
         if (filter?.status) {
-          return all.filter((a) => a.status === filter.status);
+          return this.db.prepare(
+            `SELECT * FROM team_agents WHERE project_id = ? AND status = ? ORDER BY joined_at DESC LIMIT ?`
+          ).all(projectId, filter.status, limit2);
         }
-        return all;
+        return this.db.prepare(
+          `SELECT * FROM team_agents WHERE project_id = ? ORDER BY joined_at DESC LIMIT ?`
+        ).all(projectId, limit2);
       }
       /** List agents across all projects (for global scope) */
-      listAllAgents() {
+      listAllAgents(limit2) {
         if (!this.db) return [];
-        return this.db.prepare("SELECT * FROM team_agents ORDER BY last_heartbeat DESC").all();
+        return this.db.prepare("SELECT * FROM team_agents ORDER BY last_heartbeat DESC LIMIT ?").all(clampTeamQueryLimit(limit2));
       }
       /** List locks across all projects (for global scope) */
-      listAllLocks() {
+      listAllLocks(limit2) {
         if (!this.db) return [];
         this.db.prepare("DELETE FROM team_locks WHERE expires_at <= ?").run(Date.now());
-        return this.db.prepare("SELECT * FROM team_locks WHERE expires_at > ? ORDER BY locked_at DESC").all(Date.now());
+        return this.db.prepare("SELECT * FROM team_locks WHERE expires_at > ? ORDER BY locked_at DESC LIMIT ?").all(Date.now(), clampTeamQueryLimit(limit2));
       }
       /** List tasks across all projects (for global scope) */
       listAllTasks(filter) {
         if (!this.db) return [];
+        const limit2 = clampTeamQueryLimit(filter?.limit);
         if (filter?.available) {
           return this.db.prepare(
-            `SELECT t.* FROM team_tasks t WHERE t.status = 'pending' AND t.assignee_agent_id IS NULL ORDER BY t.created_at DESC`
-          ).all();
+            `SELECT t.* FROM team_tasks t WHERE t.status = 'pending' AND t.assignee_agent_id IS NULL ORDER BY t.created_at DESC LIMIT ?`
+          ).all(limit2);
         }
-        return this.db.prepare("SELECT * FROM team_tasks ORDER BY created_at DESC").all();
+        return this.db.prepare("SELECT * FROM team_tasks ORDER BY created_at DESC LIMIT ?").all(limit2);
       }
       heartbeat(agentId) {
         const info = this.stmtAgentUpdateHeartbeat.run(Date.now(), agentId);
@@ -164489,7 +165183,10 @@ var init_team_store = __esm({
         return staleIds;
       }
       getActiveCount(projectId) {
-        return this.listAgents(projectId, { status: "active" }).length;
+        const row = this.db.prepare(
+          `SELECT COUNT(*) AS count FROM team_agents WHERE project_id = ? AND status = 'active'`
+        ).get(projectId);
+        return Number(row?.count ?? 0);
       }
       // ═══════════════════════════════════════════════════════════════════
       // Message Operations
@@ -164505,7 +165202,7 @@ var init_team_store = __esm({
             return { error: `Recipient agent '${input.recipientAgentId}' not found \u2014 cannot send to unknown agent` };
           }
         }
-        const id = randomUUID17();
+        const id = randomUUID18();
         const now3 = Date.now();
         const row = {
           id,
@@ -164524,8 +165221,14 @@ var init_team_store = __esm({
         this.stmtMsgInsert.run(row);
         return row;
       }
-      getInbox(projectId, agentId) {
-        return this.stmtMsgInbox.all(projectId, agentId);
+      getInbox(projectId, agentId, limit2) {
+        return this.db.prepare(`
+      SELECT * FROM team_messages
+      WHERE project_id = ?
+        AND (recipient_agent_id = ? OR recipient_agent_id IS NULL)
+      ORDER BY created_at ASC
+      LIMIT ?
+    `).all(projectId, agentId, clampTeamQueryLimit(limit2));
       }
       getUnreadCount(projectId, agentId) {
         const row = this.stmtMsgUnreadCount.get(projectId, agentId);
@@ -164555,7 +165258,7 @@ var init_team_store = __esm({
       // Task Operations (with atomic claim semantics)
       // ═══════════════════════════════════════════════════════════════════
       createTask(input) {
-        const taskId = randomUUID17();
+        const taskId = randomUUID18();
         const now3 = Date.now();
         const row = {
           task_id: taskId,
@@ -164682,17 +165385,22 @@ var init_team_store = __esm({
         return info.changes;
       }
       listTasks(projectId, filter) {
-        if (filter?.available) {
-          return this.stmtTaskAvailable.all(projectId);
-        }
-        const all = this.stmtTaskListByProject.all(projectId);
+        const clauses = ["project_id = ?"];
+        const values = [projectId];
+        if (filter?.available) clauses.push("status = 'pending'", "assignee_agent_id IS NULL");
         if (filter?.status) {
-          return all.filter((t2) => t2.status === filter.status);
+          clauses.push("status = ?");
+          values.push(filter.status);
         }
         if (filter?.assignee) {
-          return all.filter((t2) => t2.assignee_agent_id === filter.assignee);
+          clauses.push("assignee_agent_id = ?");
+          values.push(filter.assignee);
         }
-        return all;
+        values.push(clampTeamQueryLimit(filter?.limit));
+        const orderBy = filter?.available ? "created_at ASC, rowid ASC" : "created_at DESC, rowid DESC";
+        return this.db.prepare(
+          `SELECT * FROM team_tasks WHERE ${clauses.join(" AND ")} ORDER BY ${orderBy} LIMIT ?`
+        ).all(...values);
       }
       /**
        * List available tasks for a specific agent, sorted by role affinity.
@@ -164704,7 +165412,7 @@ var init_team_store = __esm({
         const agent = this.stmtAgentFindById.get(agentId);
         if (!agent) return [];
         const agentRole = agent.role;
-        const available = this.stmtTaskAvailable.all(projectId);
+        const available = this.listTasks(projectId, { available: true, limit: MAX_TEAM_QUERY_LIMIT });
         const eligible = available.filter((t2) => !t2.required_role || t2.required_role === agentRole);
         const score = (t2) => {
           if (t2.preferred_role === agentRole) return 0;
@@ -164758,12 +165466,16 @@ var init_team_store = __esm({
         const row = this.stmtLockGet.get(file, projectId);
         return row ?? null;
       }
-      listLocks(projectId, agentId) {
+      listLocks(projectId, agentId, limit2) {
         this.stmtLockDeleteExpired.run(projectId, Date.now());
         if (agentId) {
-          return this.stmtLockListByAgent.all(projectId, agentId);
+          return this.db.prepare(
+            `SELECT * FROM team_locks WHERE project_id = ? AND locked_by = ? ORDER BY locked_at DESC LIMIT ?`
+          ).all(projectId, agentId, clampTeamQueryLimit(limit2));
         }
-        return this.stmtLockListByProject.all(projectId);
+        return this.db.prepare(
+          `SELECT * FROM team_locks WHERE project_id = ? ORDER BY locked_at DESC LIMIT ?`
+        ).all(projectId, clampTeamQueryLimit(limit2));
       }
       releaseAllLocks(agentId) {
         const info = this.stmtLockDeleteByAgent.run(agentId);
@@ -164827,7 +165539,7 @@ var init_team_store = __esm({
               for (const [agentId, msgs] of Object.entries(snap.messages.inboxes)) {
                 for (const msg of msgs) {
                   this.stmtMsgInsert.run({
-                    id: msg.id ?? randomUUID17(),
+                    id: msg.id ?? randomUUID18(),
                     project_id: "migrated",
                     sender_agent_id: msg.from ?? "unknown",
                     recipient_agent_id: msg.to === "__broadcast__" ? null : msg.to ?? agentId,
@@ -166539,8 +167251,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 +167295,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 +167489,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 +167694,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 +167709,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
@@ -167787,7 +168497,7 @@ __export(planner_exports, {
   materializeTaskGraph: () => materializeTaskGraph,
   seedAutonomousPipeline: () => seedAutonomousPipeline
 });
-import { randomUUID as randomUUID18 } from "crypto";
+import { randomUUID as randomUUID19 } from "crypto";
 function isPlannerTask(metadata) {
   if (!metadata) return null;
   try {
@@ -167845,7 +168555,7 @@ function seedAutonomousPipeline(teamStore, projectId, config, opts) {
   const maxIterations = config.maxIterations ?? 3;
   const taskBudget = config.taskBudget ?? 15;
   const structuredPlan = opts?.structuredPlan ?? true;
-  const pipelineId = randomUUID18();
+  const pipelineId = randomUUID19();
   const meta = {
     plannerType: "plan",
     pipelineId,
@@ -168526,6 +169236,7 @@ var init_official_skills = __esm({
           "| Need the sequence around one memory | `memorix_timeline` | `memorix memory timeline --id <id>` |",
           "| Check source and freshness for a memory | `memorix_evidence` | `memorix evidence list|get|events` |",
           "| Record whether a memory helped, conflicted, or was corrected | `memorix_feedback` | `memorix feedback record|show|audit` |",
+          "| Track task requirements, decisions, verification, and outcome | `memorix_continuity` | `memorix continuity start|record|show|close` |",
           "| Inspect or import controlled media | `memorix_media` | `memorix media import|attach|list|show|status` |",
           '| Learned reusable project knowledge | `memorix_store` | `memorix memory store --type <type> --entity <name> --title "<title>" "<text>"` |',
           "| Task or bug is complete/outdated | `memorix_resolve` | `memorix memory resolve --ids <ids>` |",
@@ -168549,6 +169260,7 @@ var init_official_skills = __esm({
           "3. Use stale or unbound memory only as a warning or search lead.",
           "4. Store durable decisions, fixes, and gotchas after the project state changes.",
           "5. Resolve completed or obsolete memories so future briefs stay small.",
+          "6. For multi-step work, start a continuity ledger and pass its taskId back to memorix_project_context.",
           "",
           "## Store Rules",
           "",
@@ -170270,7 +170982,7 @@ __export(server_exports2, {
   createMemorixServer: () => createMemorixServer,
   shouldAwaitProjectRuntime: () => shouldAwaitProjectRuntime
 });
-import { createHash as createHash18 } from "crypto";
+import { createHash as createHash19 } from "crypto";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z as z627 } from "zod";
 function formatFormationStageDurations(stageDurationsMs) {
@@ -170354,7 +171066,7 @@ function coerceObjectArray(val) {
   return [];
 }
 function createDeterministicInstanceId(projectId, agentType, agentName) {
-  const digest2 = createHash18("sha256").update(projectId).update("\n").update(agentType).update("\n").update(agentName ?? "").digest("hex").slice(0, 24);
+  const digest2 = createHash19("sha256").update(projectId).update("\n").update(agentType).update("\n").update(agentName ?? "").digest("hex").slice(0, 24);
   return `auto-${digest2}`;
 }
 function shouldAwaitProjectRuntime(toolName) {
@@ -170445,7 +171157,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 +171169,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();
@@ -170561,6 +171273,22 @@ async function createMemorixServer(cwd, existingServer, sharedTeam, options = {}
     }
     await projectRuntimeInitPromise;
   };
+  const activateProjectRuntime = async () => {
+    if (!projectResolved) return;
+    await initObservationStore(projectDir2);
+    await initMiniSkillStore(projectDir2);
+    await initSessionStore(projectDir2);
+    await initObservations(projectDir2, { skipCorpusLoad: true });
+    try {
+      const { initProjectRoot: initProjectRoot2 } = await Promise.resolve().then(() => (init_yaml_loader(), yaml_loader_exports));
+      const { resetDotenv: resetDotenv2, loadDotenv: loadDotenv2 } = await Promise.resolve().then(() => (init_dotenv_loader(), dotenv_loader_exports));
+      initProjectRoot2(project.rootPath);
+      resetDotenv2();
+      loadDotenv2(project.rootPath);
+    } catch {
+    }
+    initLLM({ projectRoot: project.rootPath });
+  };
   let maintenanceWorker = null;
   const startProjectMaintenanceWorker = async (autoCleanup = false) => {
     maintenanceWorker?.stop();
@@ -171476,6 +172204,7 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
       description: "Build a compact Memory Autopilot brief for the current coding task. Schedules Code Memory refresh when needed, includes Start here files, reliable code-bound memories, stale/suspect cautions, and verification hints. Use this at the start of a new coding turn or after switching tasks.",
       inputSchema: {
         task: z627.string().optional().describe("Current coding task or question"),
+        taskId: z627.string().max(120).optional().describe("Optional task continuity ledger id to include in the brief"),
         refresh: z627.enum(["auto", "always", "never"]).optional().default("auto").describe(
           "Code Memory refresh policy. auto refreshes only when missing or stale."
         ),
@@ -171500,7 +172229,7 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
         limit: z627.number().optional().describe("Reserved for future source limits; current prompt stays compact by default.")
       }
     },
-    async ({ task, refresh, format, agent }) => {
+    async ({ task, taskId, refresh, format, agent }) => {
       const unresolved = requireResolvedProject("build project context for the current project");
       if (unresolved) return unresolved;
       const [
@@ -171530,6 +172259,7 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
         dataDir: projectDir2,
         observations: observations2,
         task,
+        taskId,
         agent,
         refresh: refresh ?? "auto",
         reader: getObservationReader(),
@@ -173955,6 +174685,94 @@ ${json2}
       }
     }
   );
+  server.registerTool(
+    "memorix_continuity",
+    {
+      title: "Task Continuity Ledger",
+      description: "Maintain a bounded, append-only continuity ledger for a coding task. Use start for requirements, record for decisions/verification/risks, show or list to inspect, and close for the final outcome. Pass the returned taskId to memorix_project_context so the current brief includes this ledger.",
+      inputSchema: {
+        action: z627.enum(["start", "record", "show", "list", "close"]).describe("Continuity operation"),
+        taskId: z627.string().max(120).optional().describe("Continuity task id"),
+        task: z627.string().max(1e3).optional().describe("Task description for start"),
+        requirements: z627.array(z627.string().max(2e3)).max(8).optional().describe("Requirements for start"),
+        kind: z627.enum(["requirement", "decision", "verification", "risk"]).optional().describe("Entry kind for record"),
+        content: z627.string().max(2e3).optional().describe("Requirement, decision, verification, risk, or outcome text"),
+        verificationStatus: z627.enum(["pending", "passed", "failed", "skipped"]).optional(),
+        verificationId: z627.string().max(120).optional().describe("Stable verification obligation id; reuse it to move pending to passed/failed"),
+        idempotencyKey: z627.string().max(200).optional().describe("Stable retry key; repeating the same operation returns the original event"),
+        status: z627.enum(["completed", "blocked", "abandoned"]).optional().describe("Outcome status for close"),
+        sourceRef: z627.string().max(500).optional().describe("Evidence or source reference"),
+        evidenceRefs: z627.array(z627.string().max(500)).max(8).optional(),
+        actor: z627.string().max(200).optional(),
+        limit: z627.number().int().positive().max(100).optional().default(20)
+      }
+    },
+    async ({ action, taskId, task, requirements, kind, content, verificationStatus, verificationId, idempotencyKey, status, sourceRef, evidenceRefs: evidenceRefs2, actor, limit: limit2 }) => {
+      const unresolved = requireResolvedProject("manage task continuity for the current project");
+      if (unresolved) return unresolved;
+      const { TaskContinuityStore: TaskContinuityStore2 } = await Promise.resolve().then(() => (init_task_continuity(), task_continuity_exports));
+      const continuity = new TaskContinuityStore2();
+      await continuity.init(projectDir2);
+      const effectiveActor = actor ?? currentAgentId;
+      try {
+        if (action === "start") {
+          if (!task?.trim()) return { content: [{ type: "text", text: "task is required for continuity start." }], isError: true };
+          const result2 = continuity.start({
+            projectId: project.id,
+            task,
+            ...taskId ? { taskId } : {},
+            requirements,
+            ...effectiveActor ? { actor: effectiveActor } : {},
+            ...idempotencyKey ? { idempotencyKey } : {}
+          });
+          return { content: [{ type: "text", text: JSON.stringify({ projectId: project.id, ...result2 }, null, 2) }] };
+        }
+        if (action === "list") {
+          return { content: [{ type: "text", text: JSON.stringify({ projectId: project.id, ledgers: continuity.list(project.id, limit2) }, null, 2) }] };
+        }
+        if (!taskId?.trim()) return { content: [{ type: "text", text: "taskId is required for this continuity action." }], isError: true };
+        if (action === "show") {
+          const ledger = continuity.get(project.id, taskId);
+          if (!ledger) return { content: [{ type: "text", text: "Task continuity ledger not found." }], isError: true };
+          return { content: [{ type: "text", text: JSON.stringify({ projectId: project.id, ledger }, null, 2) }] };
+        }
+        if (action === "record") {
+          if (!kind || !content?.trim()) {
+            return { content: [{ type: "text", text: "record requires kind and content." }], isError: true };
+          }
+          const result2 = continuity.record({
+            projectId: project.id,
+            taskId,
+            kind,
+            content,
+            ...verificationStatus ? { verificationStatus } : {},
+            ...sourceRef ? { sourceRef } : {},
+            ...evidenceRefs2 ? { evidenceRefs: evidenceRefs2 } : {},
+            ...effectiveActor ? { actor: effectiveActor } : {},
+            ...verificationId ? { verificationId } : {},
+            ...idempotencyKey ? { idempotencyKey } : {}
+          });
+          return { content: [{ type: "text", text: JSON.stringify({ projectId: project.id, ...result2 }, null, 2) }] };
+        }
+        if (!status || !content?.trim()) {
+          return { content: [{ type: "text", text: "close requires status and content." }], isError: true };
+        }
+        const result = continuity.close({
+          projectId: project.id,
+          taskId,
+          status,
+          content,
+          ...sourceRef ? { sourceRef } : {},
+          ...evidenceRefs2 ? { evidenceRefs: evidenceRefs2 } : {},
+          ...effectiveActor ? { actor: effectiveActor } : {},
+          ...idempotencyKey ? { idempotencyKey } : {}
+        });
+        return { content: [{ type: "text", text: JSON.stringify({ projectId: project.id, ...result }, null, 2) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: true };
+      }
+    }
+  );
   if (teamFeaturesEnabled) {
     const { initTeamStore: initTeamStore2 } = await Promise.resolve().then(() => (init_team_store(), team_store_exports));
     initTeamStoreForProject = initTeamStore2;
@@ -174982,7 +175800,9 @@ fi
     graphManager,
     projectId: project.id,
     deferredInit,
+    activateProjectRuntime,
     switchProject,
+    getProjectDataDir: () => projectDir2,
     isExplicitlyBound: () => projectBinding.isExplicit(),
     getRequestContext,
     handleTransportClose
@@ -175333,7 +176153,10 @@ var init_mcp_root_path = __esm({
 // src/server/modern-mcp-bridge.ts
 var modern_mcp_bridge_exports = {};
 __export(modern_mcp_bridge_exports, {
-  createModernMcpBridge: () => createModernMcpBridge
+  ModernMcpRuntimePool: () => ModernMcpRuntimePool,
+  createModernMcpBridge: () => createModernMcpBridge,
+  createModernMcpRuntime: () => createModernMcpRuntime,
+  withBusinessRuntimeQueue: () => withBusinessRuntimeQueue
 });
 import {
   fromJsonSchema,
@@ -175341,7 +176164,12 @@ import {
 } from "@modelcontextprotocol/server";
 import { Client as LegacyClient } from "@modelcontextprotocol/sdk/client/index.js";
 import { InMemoryTransport as LegacyInMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
-async function createModernMcpBridge(options) {
+function withBusinessRuntimeQueue(work) {
+  const result = businessRuntimeQueue.then(work);
+  businessRuntimeQueue = result.catch(() => void 0);
+  return result;
+}
+async function createModernMcpRuntime(options) {
   const { createMemorixServer: createMemorixServer2 } = await Promise.resolve().then(() => (init_server2(), server_exports2));
   const legacy = await createMemorixServer2(
     options.projectRoot,
@@ -175362,46 +176190,135 @@ async function createModernMcpBridge(options) {
   await legacy.server.connect(serverTransport);
   await legacyClient.connect(clientTransport);
   const listed = await legacyClient.listTools();
-  const modern = new ModernMcpServer(getMcpServerInfo());
-  for (const tool of listed.tools) {
-    modern.registerTool(
-      tool.name,
-      {
-        ...tool.title ? { title: tool.title } : {},
-        ...tool.description ? { description: tool.description } : {},
-        inputSchema: fromJsonSchema(tool.inputSchema)
-      },
-      async (args) => await legacyClient.callTool({
-        name: tool.name,
-        arguments: args
-      })
-    );
-  }
-  const bridge = modern;
-  bridge.memorix = {
+  const callTool = (name, args) => withBusinessRuntimeQueue(async () => {
+    await legacy.activateProjectRuntime();
+    return await legacyClient.callTool({ name, arguments: args });
+  });
+  const lifecycle = {
     projectId: legacy.projectId,
     deferredInit: legacy.deferredInit,
+    activateProjectRuntime: legacy.activateProjectRuntime,
     switchProject: legacy.switchProject,
+    getProjectDataDir: legacy.getProjectDataDir,
     isExplicitlyBound: legacy.isExplicitlyBound,
     handleTransportClose: legacy.handleTransportClose
   };
   let closed = false;
-  const modernClose = modern.close.bind(modern);
-  modern.close = async () => {
+  return {
+    projectId: legacy.projectId,
+    getProjectDataDir: legacy.getProjectDataDir,
+    createBridge: () => {
+      const requestServer = new ModernMcpServer(getMcpServerInfo());
+      for (const tool of listed.tools) {
+        requestServer.registerTool(
+          tool.name,
+          {
+            ...tool.title ? { title: tool.title } : {},
+            ...tool.description ? { description: tool.description } : {},
+            inputSchema: fromJsonSchema(tool.inputSchema)
+          },
+          async (args) => await callTool(tool.name, args)
+        );
+      }
+      requestServer.memorix = lifecycle;
+      return requestServer;
+    },
+    close: async () => {
+      if (closed) return;
+      closed = true;
+      await legacyClient.close().catch(() => void 0);
+      await legacy.server.close().catch(() => void 0);
+      legacy.handleTransportClose();
+    }
+  };
+}
+async function createModernMcpBridge(options) {
+  const runtime = await createModernMcpRuntime(options);
+  const bridge = runtime.createBridge();
+  const close = bridge.close.bind(bridge);
+  let closed = false;
+  bridge.close = async () => {
     if (closed) return;
     closed = true;
-    await modernClose();
-    await legacyClient.close().catch(() => void 0);
-    await legacy.server.close().catch(() => void 0);
-    legacy.handleTransportClose();
+    await close();
+    await runtime.close();
   };
   return bridge;
 }
+var businessRuntimeQueue, ModernMcpRuntimePool;
 var init_modern_mcp_bridge = __esm({
   "src/server/modern-mcp-bridge.ts"() {
     "use strict";
     init_esm_shims();
     init_mcp_discovery();
+    businessRuntimeQueue = Promise.resolve();
+    ModernMcpRuntimePool = class {
+      constructor(maxEntries = 32) {
+        this.maxEntries = maxEntries;
+      }
+      maxEntries;
+      entries = /* @__PURE__ */ new Map();
+      pending = /* @__PURE__ */ new Map();
+      async createBridge(key, create2) {
+        let entry = this.entries.get(key);
+        if (!entry) {
+          let pending = this.pending.get(key);
+          if (!pending) {
+            pending = create2().then((runtime) => {
+              const created = { runtime, refs: 0, lastUsedAt: Date.now() };
+              this.entries.set(key, created);
+              return created;
+            });
+            this.pending.set(key, pending);
+          }
+          try {
+            entry = await pending;
+          } finally {
+            this.pending.delete(key);
+          }
+        }
+        entry.refs++;
+        entry.lastUsedAt = Date.now();
+        const bridge = entry.runtime.createBridge();
+        const close = bridge.close.bind(bridge);
+        let released = false;
+        bridge.close = async () => {
+          try {
+            await close();
+          } finally {
+            if (!released) {
+              released = true;
+              entry.refs = Math.max(0, entry.refs - 1);
+              entry.lastUsedAt = Date.now();
+            }
+          }
+        };
+        return bridge;
+      }
+      async evictIdle() {
+        let closed = 0;
+        const idle = [...this.entries.entries()].filter(([, entry]) => entry.refs === 0).sort(([, left], [, right]) => left.lastUsedAt - right.lastUsedAt);
+        for (const [key, entry] of idle) {
+          if (this.entries.size <= this.maxEntries || entry.refs > 0) continue;
+          this.entries.delete(key);
+          await entry.runtime.close();
+          closed++;
+        }
+        return closed;
+      }
+      async close() {
+        const entries = [...this.entries.values()];
+        this.entries.clear();
+        await Promise.all(entries.map((entry) => entry.runtime.close().catch(() => void 0)));
+      }
+      stats() {
+        return {
+          entries: this.entries.size,
+          activeRefs: [...this.entries.values()].reduce((sum, entry) => sum + entry.refs, 0),
+          pending: this.pending.size
+        };
+      }
+    };
   }
 });
 
@@ -175513,7 +176430,7 @@ var init_serve_shared = __esm({
 
 // src/cli/version.ts
 function getCliVersion() {
-  return true ? "1.9.4" : pkg.version;
+  return true ? "1.9.6" : pkg.version;
 }
 var init_version3 = __esm({
   "src/cli/version.ts"() {