memorix 1.9.5 → 1.9.7

package/dist/cli/index.js

@@ -3232,7 +3232,7 @@ ${import_picocolors.default.gray(m3)}  ${s4}
 
 // src/cli/version.ts
 function getCliVersion() {
-  return true ? "1.9.5" : pkg.version;
+  return true ? "1.9.7" : pkg.version;
 }
 var init_version = __esm({
   "src/cli/version.ts"() {
@@ -9349,6 +9349,74 @@ var init_launch_root = __esm({
   }
 });
 
+// src/store/sqlite-reliability.ts
+function isTransientSqliteError(error40) {
+  const code = error40?.code;
+  if (typeof code === "string") {
+    return /^SQLITE_BUSY(?:_|$)/i.test(code);
+  }
+  return error40 instanceof Error && /\bdatabase is locked\b|\bdatabase is busy\b/i.test(error40.message);
+}
+function isSqliteUnavailableError(error40) {
+  return error40 instanceof SqliteUnavailableError || error40 instanceof Error && /SQLite is not available|better-sqlite3.*failed|node:sqlite.*failed|bun:sqlite.*failed/i.test(error40.message);
+}
+function degradedReadError(storeName) {
+  return new Error(`[memorix] Cannot read ${storeName}: SQLite backend unavailable (memory is not loaded)`);
+}
+function degradedWriteError(storeName) {
+  return new Error(`[memorix] Cannot write ${storeName}: SQLite backend unavailable (degraded mode; read-only)`);
+}
+function formatSqliteFailure(error40) {
+  return error40 instanceof Error && error40.message ? error40.message : String(error40);
+}
+function delay(ms2) {
+  return new Promise((resolve9) => setTimeout(resolve9, ms2));
+}
+async function retrySqliteBusy(operation, label) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await operation();
+    } catch (error40) {
+      if (!isTransientSqliteError(error40) || attempt >= SQLITE_BUSY_RETRY_DELAYS_MS.length) throw error40;
+      const waitMs = SQLITE_BUSY_RETRY_DELAYS_MS[attempt];
+      console.error(
+        `[memorix] ${label} SQLite busy (attempt ${attempt + 1}/${SQLITE_BUSY_RETRY_DELAYS_MS.length + 1}), retrying in ${waitMs}ms`
+      );
+      await delay(waitMs);
+    }
+  }
+}
+async function initializeSqliteStore(factory, dataDir, label) {
+  try {
+    loadBetterSqlite3();
+  } catch (error40) {
+    throw new SqliteUnavailableError(error40);
+  }
+  return retrySqliteBusy(async () => {
+    const store2 = factory();
+    await store2.init(dataDir);
+    return store2;
+  }, label);
+}
+var SQLITE_BUSY_RETRY_DELAYS_MS, SqliteUnavailableError;
+var init_sqlite_reliability = __esm({
+  "src/store/sqlite-reliability.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sqlite_db();
+    SQLITE_BUSY_RETRY_DELAYS_MS = [50, 150, 400, 1e3, 2500];
+    SqliteUnavailableError = class extends Error {
+      code = "MEMORIX_SQLITE_UNAVAILABLE";
+      constructor(cause) {
+        super(
+          cause instanceof Error && cause.message ? cause.message : "[memorix] SQLite is unavailable (install a supported SQLite runtime)"
+        );
+        this.name = "SqliteUnavailableError";
+      }
+    };
+  }
+});
+
 // src/store/sqlite-fts.ts
 function normalizeFtsToken(token) {
   return token.replace(/"/g, '""');
@@ -9362,22 +9430,27 @@ function buildFtsQuery(query) {
 function initializeObservationLexicalIndex(db2) {
   const known = ftsAvailability.get(db2);
   if (known !== void 0) return known;
-  try {
-    db2.exec(CREATE_OBSERVATION_FTS);
-    const observationCount = Number(db2.prepare("SELECT COUNT(*) AS count FROM observations").get()?.count ?? 0);
-    const indexedCount = Number(db2.prepare(`SELECT COUNT(*) AS count FROM ${FTS_TABLE}`).get()?.count ?? 0);
-    if (observationCount !== indexedCount) {
-      db2.exec(`INSERT INTO ${FTS_TABLE}(${FTS_TABLE}) VALUES ('rebuild')`);
+  let lastError;
+  for (let attempt = 1; attempt <= FTS_INIT_MAX_ATTEMPTS; attempt++) {
+    try {
+      db2.exec(CREATE_OBSERVATION_FTS);
+      const observationCount = Number(db2.prepare("SELECT COUNT(*) AS count FROM observations").get()?.count ?? 0);
+      const indexedCount = Number(db2.prepare(`SELECT COUNT(*) AS count FROM ${FTS_TABLE}`).get()?.count ?? 0);
+      if (observationCount !== indexedCount) {
+        db2.exec(`INSERT INTO ${FTS_TABLE}(${FTS_TABLE}) VALUES ('rebuild')`);
+      }
+      ftsAvailability.set(db2, true);
+      return true;
+    } catch (error40) {
+      lastError = error40;
+      if (!isTransientSqliteError(error40) || attempt === FTS_INIT_MAX_ATTEMPTS) break;
     }
-    ftsAvailability.set(db2, true);
-    return true;
-  } catch (error40) {
-    ftsAvailability.set(db2, false);
-    console.warn(
-      `[memorix] SQLite FTS5 unavailable; using the existing search fallback: ${error40 instanceof Error ? error40.message : String(error40)}`
-    );
-    return false;
   }
+  ftsAvailability.set(db2, false);
+  console.warn(
+    `[memorix] SQLite FTS5 unavailable; using the existing search fallback: ${lastError instanceof Error ? lastError.message : String(lastError)}`
+  );
+  return false;
 }
 function isObservationLexicalIndexEnabled(db2) {
   return ftsAvailability.get(db2) === true;
@@ -9431,11 +9504,12 @@ function searchObservationLexically(db2, options) {
     score: Math.max(0, Number(row.lexical_score ?? 0))
   }));
 }
-var ftsAvailability, FTS_TABLE, CREATE_OBSERVATION_FTS;
+var ftsAvailability, FTS_TABLE, CREATE_OBSERVATION_FTS, FTS_INIT_MAX_ATTEMPTS;
 var init_sqlite_fts = __esm({
   "src/store/sqlite-fts.ts"() {
     "use strict";
     init_esm_shims();
+    init_sqlite_reliability();
     ftsAvailability = /* @__PURE__ */ new WeakMap();
     FTS_TABLE = "observations_fts";
     CREATE_OBSERVATION_FTS = `
@@ -9469,15 +9543,19 @@ CREATE TRIGGER IF NOT EXISTS observations_fts_au AFTER UPDATE ON observations BE
   VALUES (new.id, new.entityName, new.title, new.narrative, new.facts, new.filesModified, new.concepts, new.attachments);
 END;
 `;
+    FTS_INIT_MAX_ATTEMPTS = 3;
   }
 });
 
 // src/store/sqlite-db.ts
 var sqlite_db_exports = {};
 __export(sqlite_db_exports, {
+  acquireDatabase: () => acquireDatabase,
   closeAllDatabases: () => closeAllDatabases,
   closeDatabase: () => closeDatabase,
+  evictIdleDatabases: () => evictIdleDatabases,
   getDatabase: () => getDatabase,
+  getDatabaseStats: () => getDatabaseStats,
   isSqliteAvailable: () => isSqliteAvailable,
   loadBetterSqlite3: () => loadBetterSqlite3
 });
@@ -9515,11 +9593,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");
@@ -9549,6 +9637,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 {
@@ -9587,7 +9677,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 (error40) {
     try {
@@ -9597,8 +9687,46 @@ function getDatabase(dataDir) {
     throw error40;
   }
 }
+function acquireDatabase(dataDir) {
+  const normalized = normalizeDataDir(dataDir);
+  const db2 = getDatabase(normalized);
+  _dbLeases.set(normalized, (_dbLeases.get(normalized) ?? 0) + 1);
+  let released = false;
+  return {
+    dataDir: normalized,
+    db: db2,
+    release: () => {
+      if (released) return;
+      released = true;
+      const count3 = (_dbLeases.get(normalized) ?? 0) - 1;
+      if (count3 > 0) _dbLeases.set(normalized, count3);
+      else _dbLeases.delete(normalized);
+    }
+  };
+}
+function getDatabaseStats() {
+  let leased = 0;
+  for (const count3 of _dbLeases.values()) leased += count3;
+  return { cached: _dbCache.size, leased, leasedDataDirs: _dbLeases.size };
+}
+function evictIdleDatabases(maxCached) {
+  const target = Math.max(0, Math.floor(maxCached));
+  let evicted = 0;
+  for (const [normalized, db2] of [..._dbCache]) {
+    if (_dbCache.size <= target) break;
+    if ((_dbLeases.get(normalized) ?? 0) > 0) continue;
+    try {
+      db2.close();
+    } catch {
+    }
+    _dbCache.delete(normalized);
+    evicted++;
+  }
+  return evicted;
+}
 function closeDatabase(dataDir) {
-  const normalized = path3.resolve(dataDir);
+  const normalized = normalizeDataDir(dataDir);
+  if ((_dbLeases.get(normalized) ?? 0) > 0) return;
   const db2 = _dbCache.get(normalized);
   if (db2) {
     try {
@@ -9616,6 +9744,7 @@ function closeAllDatabases() {
     }
     _dbCache.delete(key);
   }
+  _dbLeases.clear();
 }
 function isSqliteAvailable() {
   try {
@@ -9625,7 +9754,7 @@ function isSqliteAvailable() {
     return false;
   }
 }
-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";
@@ -10342,6 +10471,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 (
@@ -10420,7 +10586,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');
@@ -10591,6 +10768,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)");
         }
       },
       {
@@ -10601,77 +10780,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();
-  }
-});
-
-// src/store/sqlite-reliability.ts
-function isTransientSqliteError(error40) {
-  const code = error40?.code;
-  if (typeof code === "string") {
-    return /^SQLITE_BUSY(?:_|$)/i.test(code);
-  }
-  return error40 instanceof Error && /\bdatabase is locked\b|\bdatabase is busy\b/i.test(error40.message);
-}
-function isSqliteUnavailableError(error40) {
-  return error40 instanceof SqliteUnavailableError || error40 instanceof Error && /SQLite is not available|better-sqlite3.*failed|node:sqlite.*failed|bun:sqlite.*failed/i.test(error40.message);
-}
-function degradedReadError(storeName) {
-  return new Error(`[memorix] Cannot read ${storeName}: SQLite backend unavailable (memory is not loaded)`);
-}
-function degradedWriteError(storeName) {
-  return new Error(`[memorix] Cannot write ${storeName}: SQLite backend unavailable (degraded mode; read-only)`);
-}
-function formatSqliteFailure(error40) {
-  return error40 instanceof Error && error40.message ? error40.message : String(error40);
-}
-function delay(ms2) {
-  return new Promise((resolve9) => setTimeout(resolve9, ms2));
-}
-async function retrySqliteBusy(operation, label) {
-  for (let attempt = 0; ; attempt++) {
-    try {
-      return await operation();
-    } catch (error40) {
-      if (!isTransientSqliteError(error40) || attempt >= SQLITE_BUSY_RETRY_DELAYS_MS.length) throw error40;
-      const waitMs = SQLITE_BUSY_RETRY_DELAYS_MS[attempt];
-      console.error(
-        `[memorix] ${label} SQLite busy (attempt ${attempt + 1}/${SQLITE_BUSY_RETRY_DELAYS_MS.length + 1}), retrying in ${waitMs}ms`
-      );
-      await delay(waitMs);
-    }
-  }
-}
-async function initializeSqliteStore(factory, dataDir, label) {
-  try {
-    loadBetterSqlite3();
-  } catch (error40) {
-    throw new SqliteUnavailableError(error40);
-  }
-  return retrySqliteBusy(async () => {
-    const store2 = factory();
-    await store2.init(dataDir);
-    return store2;
-  }, label);
-}
-var SQLITE_BUSY_RETRY_DELAYS_MS, SqliteUnavailableError;
-var init_sqlite_reliability = __esm({
-  "src/store/sqlite-reliability.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_sqlite_db();
-    SQLITE_BUSY_RETRY_DELAYS_MS = [50, 150, 400, 1e3, 2500];
-    SqliteUnavailableError = class extends Error {
-      code = "MEMORIX_SQLITE_UNAVAILABLE";
-      constructor(cause) {
-        super(
-          cause instanceof Error && cause.message ? cause.message : "[memorix] SQLite is unavailable (install a supported SQLite runtime)"
-        );
-        this.name = "SqliteUnavailableError";
-      }
-    };
+    _dbLeases = /* @__PURE__ */ new Map();
   }
 });
 
@@ -21094,18 +21218,23 @@ __export(yaml_loader_exports, {
 });
 import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
 import { homedir } from "os";
+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 cached2 = configCache.get(resolvedRoot ?? null);
+  const key = cacheKey(homeDir, resolvedRoot);
+  const cached2 = configCache.get(key);
   if (cached2) return cached2;
-  const userYaml = getGlobalYamlPath(homedir());
+  const userYaml = getGlobalYamlPath(homeDir);
   const projectYaml = resolvedRoot ? getProjectYamlPath(resolvedRoot) : null;
   let userConfig = {};
   let projectConfig = {};
@@ -21137,12 +21266,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();
   }
@@ -21353,9 +21482,9 @@ var init_detector = __esm({
 // src/config/legacy-loader.ts
 import { existsSync as existsSync6, readFileSync as readFileSync5 } 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 (existsSync6(configPath)) {
       cachedConfig = JSON.parse(readFileSync5(configPath, "utf-8"));
@@ -21385,15 +21514,15 @@ import { homedir as homedir3 } from "os";
 function loadTomlConfig(options = {}) {
   const homeDir = options.homeDir ?? homedir3();
   const projectRoot = options.projectRoot ?? null;
-  const cacheKey2 = `${homeDir}\0${projectRoot ?? ""}`;
-  const cached2 = configCache2.get(cacheKey2);
+  const cacheKey4 = `${homeDir}\0${projectRoot ?? ""}`;
+  const cached2 = configCache2.get(cacheKey4);
   if (cached2) return cached2;
   const userToml = getGlobalConfigTomlPath(homeDir);
   const projectToml = projectRoot ? getProjectConfigTomlPath(projectRoot) : null;
   const userConfig = existsSync7(userToml) ? parseTomlConfig(readFileSync6(userToml, "utf8"), userToml) : {};
   const projectConfig = projectToml && existsSync7(projectToml) ? parseTomlConfig(readFileSync6(projectToml, "utf8"), projectToml) : {};
   const merged = mergeTomlConfig(userConfig, projectConfig);
-  configCache2.set(cacheKey2, merged);
+  configCache2.set(cacheKey4, merged);
   return merged;
 }
 function mergeTomlConfig(base, override) {
@@ -21989,8 +22118,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(
@@ -22012,15 +22141,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: {
@@ -22199,7 +22330,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) {
@@ -22418,12 +22550,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 [k6, v6] of entries) cache.set(k6, v6);
-    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 {
@@ -22434,7 +22599,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";
@@ -22444,6 +22609,9 @@ var init_fastembed_provider = __esm({
     CACHE_FILE = join3(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";
@@ -22485,7 +22653,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) {
@@ -22510,7 +22678,7 @@ var init_fastembed_provider = __esm({
               const originalIdx = uncachedIndices[batchIdx];
               const plain = Array.from(vec2);
               results[originalIdx] = plain;
-              this.cacheSet(textHash(uncachedTexts[batchIdx]), plain);
+              cacheSet(textHash(uncachedTexts[batchIdx]), plain);
               batchIdx++;
             }
           }
@@ -22518,14 +22686,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;
-      }
     };
   }
 });
@@ -22535,7 +22695,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";
@@ -22543,6 +22711,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;
@@ -22577,7 +22747,7 @@ var init_transformers_provider = __esm({
         return Promise.all(inputs.map((input) => this.embedInput(input, options)));
       }
       async embed(text3) {
-        const cached2 = cache2.get(text3);
+        const cached2 = cache2.get(cacheKey2(text3));
         if (cached2) return cached2;
         const output = await this.extractor(text3, {
           pooling: "mean",
@@ -22587,7 +22757,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) {
@@ -22595,7 +22765,7 @@ var init_transformers_provider = __esm({
         const uncachedIndices = [];
         const uncachedTexts = [];
         for (let i4 = 0; i4 < texts.length; i4++) {
-          const cached2 = cache2.get(texts[i4]);
+          const cached2 = cache2.get(cacheKey2(texts[i4]));
           if (cached2) {
             results[i4] = cached2;
           } else {
@@ -22613,17 +22783,27 @@ var init_transformers_provider = __esm({
             const vec2 = Array.from(allVecs[i4]);
             const originalIdx = uncachedIndices[i4];
             results[originalIdx] = vec2;
-            this.cacheSet(uncachedTexts[i4], vec2);
+            this.cacheSet(cacheKey2(uncachedTexts[i4]), vec2);
           }
         }
         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;
       }
     };
   }
@@ -22645,7 +22825,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 join4 } from "path";
@@ -22672,7 +22852,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);
@@ -22682,7 +22862,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) {
@@ -22695,13 +22875,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");
@@ -22728,12 +22910,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() {
@@ -22769,7 +22951,7 @@ function cacheNamespace(config2) {
   ].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({
@@ -23111,7 +23293,7 @@ function getApiEmbeddingDiskCacheLoadCountForTests() {
 }
 function resetApiEmbeddingCacheForTests() {
   cache3.clear();
-  cachePayloadBytes = 0;
+  cachePayloadBytes3 = 0;
   cacheDimensions = null;
   diskCacheEntryCount = 0;
   diskCacheLoaded = false;
@@ -23122,14 +23304,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;
@@ -23303,7 +23485,7 @@ function scheduleDiskSave() {
     diskSaveTimer = null;
   }, DISK_SAVE_DEBOUNCE_MS);
 }
-function cacheSet(hash4, value) {
+function cacheSet2(hash4, value) {
   cacheInsert(hash4, value, true);
 }
 function resolveEnvEmbeddingApiKey() {
@@ -23423,7 +23605,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";
@@ -23435,7 +23617,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;
@@ -23620,7 +23802,7 @@ var init_api_provider = __esm({
         } else {
           embedding = await apiCall();
         }
-        cacheSet(hash4, embedding);
+        cacheSet2(hash4, embedding);
         scheduleDiskSave();
         return embedding;
       }
@@ -23668,7 +23850,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 (error40) {
             const providerLimit = parseBatchLimit(error40);
@@ -23746,7 +23928,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;
       }
@@ -25129,6 +25311,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;
@@ -25892,7 +26075,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 path10 from "path";
 function createSemanticIndexProfile(provider2) {
@@ -25906,7 +26089,7 @@ function stateKey(dataDir, profile) {
   return `${path10.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) {
@@ -26205,6 +26388,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,
@@ -26254,7 +26438,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";
@@ -26281,6 +26465,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) {
@@ -26407,18 +26592,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) {
@@ -26777,7 +26965,7 @@ __export(evidence_store_exports, {
   EvidenceCardStore: () => EvidenceCardStore,
   buildEvidenceCardId: () => buildEvidenceCardId
 });
-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 {
@@ -26811,7 +26999,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,
@@ -27408,13 +27596,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 fs7 } from "fs";
 import path12 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);
@@ -28567,14 +28755,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 path13 from "path";
 function mediaRoot(dataDir) {
   return path13.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, candidate2) {
   const resolved = path13.resolve(candidate2);
@@ -28634,7 +28822,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, sha2562, extension3) {
   const relative5 = path13.join("assets", projectStorageKey(projectId), sha2562.slice(0, 2), `${sha2562}${extension3}`);
@@ -28740,7 +28928,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 sha2562 = createHash6("sha256").update(input.bytes).digest("hex");
+  const sha2562 = createHash7("sha256").update(input.bytes).digest("hex");
   return importKnownMedia({
     dataDir: input.dataDir,
     projectId: input.projectId,
@@ -28758,7 +28946,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 sha2562 = createHash6("sha256").update(bytes).digest("hex");
+  const sha2562 = createHash7("sha256").update(bytes).digest("hex");
   if (sha2562 !== asset.sha256) throw new Error(`Media asset hash no longer matches metadata: ${asset.id}`);
   return bytes;
 }
@@ -81628,7 +81816,7 @@ var require_gaxios = __commonJS({
     var retry_js_1 = require_retry3();
     var stream_1 = __require("stream");
     var interceptor_js_1 = require_interceptor();
-    var randomUUID21 = async () => globalThis.crypto?.randomUUID() || (await import("crypto")).randomUUID();
+    var randomUUID23 = async () => globalThis.crypto?.randomUUID() || (await import("crypto")).randomUUID();
     var HTTP_STATUS_NO_CONTENT = 204;
     var Gaxios = class {
       agentCache = /* @__PURE__ */ new Map();
@@ -81901,7 +82089,7 @@ var require_gaxios = __commonJS({
          */
         ["Blob", "File", "FormData"].includes(opts.data?.constructor?.name || "");
         if (opts.multipart?.length) {
-          const boundary = await randomUUID21();
+          const boundary = await randomUUID23();
           preparedHeaders.set("content-type", `multipart/related; boundary=${boundary}`);
           opts.body = stream_1.Readable.from(this.getMultipartRequest(opts.multipart, boundary));
         } else if (shouldDirectlyPassData) {
@@ -87573,16 +87761,16 @@ var require_jwtaccess = __commonJS({
        * @returns A string that returns the cached key.
        */
       getCachedKey(url2, scopes) {
-        let cacheKey2 = url2;
+        let cacheKey4 = url2;
         if (scopes && Array.isArray(scopes) && scopes.length) {
-          cacheKey2 = url2 ? `${url2}_${scopes.join("_")}` : `${scopes.join("_")}`;
+          cacheKey4 = url2 ? `${url2}_${scopes.join("_")}` : `${scopes.join("_")}`;
         } else if (typeof scopes === "string") {
-          cacheKey2 = url2 ? `${url2}_${scopes}` : scopes;
+          cacheKey4 = url2 ? `${url2}_${scopes}` : scopes;
         }
-        if (!cacheKey2) {
+        if (!cacheKey4) {
           throw Error("Scopes or url must be provided");
         }
-        return cacheKey2;
+        return cacheKey4;
       }
       /**
        * Get a non-expired access token, after refreshing if necessary.
@@ -94128,7 +94316,7 @@ var require_websocket = __commonJS({
     var http3 = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes3, createHash: createHash27 } = __require("crypto");
+    var { randomBytes: randomBytes3, createHash: createHash29 } = __require("crypto");
     var { Duplex, Readable: Readable3 } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -94796,7 +94984,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest2 = createHash27("sha1").update(key + GUID).digest("base64");
+        const digest2 = createHash29("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest2) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -95168,7 +95356,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter2 = __require("events");
     var http3 = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash27 } = __require("crypto");
+    var { createHash: createHash29 } = __require("crypto");
     var extension3 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -95475,7 +95663,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest2 = createHash27("sha1").update(key + GUID).digest("base64");
+        const digest2 = createHash29("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -175397,9 +175585,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;
 }
@@ -180041,9 +180229,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(path50) {
   return path50.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/");
@@ -181091,7 +181279,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 {
@@ -181120,7 +181308,7 @@ function changedPathCount(status) {
   return count3;
 }
 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([
@@ -181214,12 +181402,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 as resolve3 } 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 = resolve3(value).replace(/\\/g, "/");
@@ -181564,11 +181752,11 @@ __export(lite_provider_exports, {
   indexProjectLite: () => indexProjectLite,
   refreshProjectLite: () => refreshProjectLite
 });
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 import { existsSync as existsSync14, readdirSync as readdirSync2, readFileSync as readFileSync9, statSync as statSync4 } from "fs";
 import { join as join5, relative as relative2 } from "path";
 function hashText2(text3) {
-  return createHash10("sha256").update(text3).digest("hex");
+  return createHash11("sha256").update(text3).digest("hex");
 }
 function extension2(path50) {
   const index = path50.lastIndexOf(".");
@@ -182201,7 +182389,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;
 }
@@ -182254,7 +182442,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,
@@ -182452,7 +182640,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, " ");
@@ -182464,7 +182652,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);
@@ -182705,7 +182893,7 @@ function supersedeClaim(store2, input) {
   });
 }
 function hashObservation(observation) {
-  return createHash12("sha256").update(JSON.stringify([
+  return createHash13("sha256").update(JSON.stringify([
     observation.title,
     observation.narrative,
     observation.facts,
@@ -182949,11 +183137,11 @@ var init_frontmatter = __esm({
 });
 
 // src/knowledge/markdown.ts
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash14 } from "crypto";
 import { promises as fs11 } from "fs";
 import path20 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];
@@ -183079,11 +183267,11 @@ __export(wiki_exports, {
   lintKnowledgeWorkspace: () => lintKnowledgeWorkspace,
   readKnowledgePage: () => readKnowledgePage
 });
-import { createHash as createHash14 } from "crypto";
+import { createHash as createHash15 } from "crypto";
 import { promises as fs12 } from "fs";
 import path21 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();
@@ -184302,11 +184490,11 @@ __export(workflows_exports, {
   syncCanonicalWorkflows: () => syncCanonicalWorkflows,
   writeCanonicalWorkflow: () => writeCanonicalWorkflow
 });
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 import { promises as fs13 } from "fs";
 import path22 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();
@@ -188043,6 +188231,7 @@ async function searchObservations(options) {
   };
   let queryVector = null;
   let embeddingProviderForSearch = null;
+  let embeddingUnavailable = false;
   if (quality !== "fast" && embeddingEnabled && hasQuery && tier !== "fast") {
     try {
       const provider2 = await getEmbeddingProvider();
@@ -188050,6 +188239,7 @@ async function searchObservations(options) {
         embeddingProviderForSearch = provider2;
         const activeVectorDimensions = getVectorDimensions();
         if (activeVectorDimensions !== null && provider2.dimensions !== activeVectorDimensions) {
+          embeddingUnavailable = true;
           rememberSearchMode(
             modeKey,
             `fulltext (embedding dimension mismatch: provider ${provider2.dimensions}d vs index ${activeVectorDimensions}d)`
@@ -188089,8 +188279,11 @@ async function searchObservations(options) {
             hybridWeights: isCJKHeavy ? { text: 0.2, vector: 0.8 } : { text: 0.6, vector: 0.4 }
           };
         }
+      } else {
+        embeddingUnavailable = true;
       }
     } catch (error40) {
+      embeddingUnavailable = true;
       rememberSearchMode(modeKey, "fulltext (embedding unavailable)");
       console.error("[memorix] Embedding failed or timed out, falling back to fulltext search");
     }
@@ -188098,7 +188291,7 @@ async function searchObservations(options) {
   mark("preSearch");
   let results;
   const persistentCorpusEligible = await shouldUsePersistentSearch(projectIds, options.projectId);
-  const canUsePersistentLexical = persistentCorpusEligible && Boolean(hasQuery) && !queryVector && (quality === "fast" || tier === "fast" || !embeddingEnabled);
+  const canUsePersistentLexical = persistentCorpusEligible && Boolean(hasQuery) && !queryVector && (quality === "fast" || tier === "fast" || !embeddingEnabled || embeddingUnavailable);
   let persistent = persistentCorpusEligible && queryVector && embeddingProviderForSearch ? await searchPersistentSemantically(options, projectIds, requestLimit, queryVector, embeddingProviderForSearch) : canUsePersistentLexical ? await searchPersistentLexically(options, projectIds, requestLimit) : null;
   const durableStore = getOptionalObservationStore();
   if (!persistent && queryVector && durableStore?.hasLexicalIndex?.() && count2(database) === 0) {
@@ -189337,6 +189530,8 @@ 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,
@@ -189346,6 +189541,10 @@ __export(team_store_exports, {
 import { randomUUID as randomUUID16 } from "crypto";
 import path25 from "path";
 import fs15 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");
@@ -189369,12 +189568,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 },
@@ -189684,32 +189885,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((a4) => a4.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 info2 = this.stmtAgentUpdateHeartbeat.run(Date.now(), agentId);
@@ -189744,7 +189950,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
@@ -189779,8 +189988,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);
@@ -189937,17 +190152,22 @@ var init_team_store = __esm({
         return info2.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((t4) => t4.status === filter.status);
+          clauses.push("status = ?");
+          values.push(filter.status);
         }
         if (filter?.assignee) {
-          return all.filter((t4) => t4.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.
@@ -189959,7 +190179,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((t4) => !t4.required_role || t4.required_role === agentRole);
         const score = (t4) => {
           if (t4.preferred_role === agentRole) return 0;
@@ -190013,12 +190233,16 @@ var init_team_store = __esm({
         const row = this.stmtLockGet.get(file2, 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 info2 = this.stmtLockDeleteByAgent.run(agentId);
@@ -192869,6 +193093,8 @@ function buildInitTomlConfig(options) {
       lines.push('model = "claude-3-haiku-20240307"');
     } else if (options.llmProvider === "openrouter") {
       lines.push('# model = "openai/gpt-4o-mini"');
+    } else if (options.llmProvider === "atlascloud") {
+      lines.push('model = "deepseek-ai/deepseek-v3.2"');
     }
     if (options.llmProvider === "custom") {
       lines.push("# OpenAI-compatible endpoint, for example DashScope, DeepSeek, Ollama, or an internal gateway.");
@@ -193001,6 +193227,7 @@ var init_init = __esm({
             { value: "openai", label: "OpenAI", hint: "gpt-4o-mini" },
             { value: "anthropic", label: "Anthropic", hint: "claude-3-haiku" },
             { value: "openrouter", label: "OpenRouter", hint: "multi-provider" },
+            { value: "atlascloud", label: "Atlas Cloud", hint: "DeepSeek V3.2" },
             { value: "custom", label: "Custom", hint: "OpenAI-compatible endpoint" }
           ]
         });
@@ -193054,7 +193281,7 @@ var init_init = __esm({
         ];
         if (llmProvider !== "none") {
           envLines.push("# LLM API key");
-          if (llmProvider === "openai" || llmProvider === "custom") {
+          if (llmProvider === "openai" || llmProvider === "custom" || llmProvider === "atlascloud") {
             envLines.push("MEMORIX_LLM_API_KEY=sk-your-key-here");
           } else if (llmProvider === "anthropic") {
             envLines.push("MEMORIX_LLM_API_KEY=sk-ant-your-key-here");
@@ -194595,6 +194822,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>` |",
@@ -194618,6 +194846,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",
           "",
@@ -198185,6 +198414,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";
@@ -198295,6 +198525,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) {
@@ -198818,6 +199119,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 } : {},
@@ -201226,7 +201528,7 @@ var compaction_checkpoint_store_exports = {};
 __export(compaction_checkpoint_store_exports, {
   CompactionCheckpointStore: () => CompactionCheckpointStore
 });
-import { createHash as createHash16, randomUUID as randomUUID17 } from "crypto";
+import { createHash as createHash17, randomUUID as randomUUID17 } from "crypto";
 function optionalText7(value) {
   return typeof value === "string" && value ? value : void 0;
 }
@@ -201268,7 +201570,7 @@ function sourceKeyFor(input, summary) {
     input.tokensBefore ?? "",
     input.firstKeptEntryId ?? ""
   ].join("\0");
-  return `derived:${createHash16("sha256").update(material).digest("hex").slice(0, 32)}`;
+  return `derived:${createHash17("sha256").update(material).digest("hex").slice(0, 32)}`;
 }
 function rowToCheckpoint(row) {
   return {
@@ -201526,6 +201828,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 randomUUID18 } 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: randomUUID18(),
+          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) || randomUUID18();
+        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, {
@@ -201782,6 +202383,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,
@@ -201800,6 +202411,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) => ({
@@ -201847,6 +202459,7 @@ async function buildAutoProjectContext(input) {
     refresh,
     providerQuality: providerQuality2,
     ...continuationRequested && workset.continuation ? { continuation: workset.continuation } : {},
+    ...workset.continuity ? { continuity: workset.continuity } : {},
     workset
   };
 }
@@ -202148,7 +202761,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({
@@ -202159,10 +202779,10 @@ var init_context_receipt = __esm({
 });
 
 // src/cli/fallback-budget.ts
-import { createHash as createHash17 } from "crypto";
+import { createHash as createHash18 } from "crypto";
 function fallbackRequestKey(projectId, task) {
   const normalized = (task ?? "").trim().toLowerCase().replace(/\s+/g, " ");
-  return createHash17("sha256").update(`${projectId}
+  return createHash18("sha256").update(`${projectId}
 ${normalized}`).digest("hex").slice(0, 32);
 }
 var DEFAULT_FALLBACK_TTL_MS, CliFallbackBudget;
@@ -202247,6 +202867,7 @@ var init_context2 = __esm({
       },
       args: {
         task: { type: "string", description: "Current task for context shaping" },
+        taskId: { type: "string", description: "Optional task continuity ledger id to include" },
         input: {
           type: "positional",
           description: "Current task for context shaping (ergonomic positional form)",
@@ -202278,6 +202899,7 @@ var init_context2 = __esm({
             dataDir,
             observations: filterReadableObservations(getAllObservations(), reader2),
             task,
+            taskId: args.taskId?.trim() || void 0,
             agent: coerceAgentTarget(args.agent),
             refresh: coerceRefreshMode(args.refresh),
             reader: reader2,
@@ -203780,6 +204402,158 @@ var init_feedback2 = __esm({
   }
 });
 
+// src/cli/commands/continuity.ts
+var continuity_exports = {};
+__export(continuity_exports, {
+  default: () => continuity_default
+});
+var recordKinds, continuity_default;
+var init_continuity = __esm({
+  "src/cli/commands/continuity.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_dist2();
+    init_task_continuity();
+    init_operator_shared();
+    recordKinds = [
+      "requirement",
+      "decision",
+      "verification",
+      "risk"
+    ];
+    continuity_default = defineCommand({
+      meta: {
+        name: "continuity",
+        description: "Track task requirements, decisions, verification, risks, and outcomes"
+      },
+      args: {
+        taskId: { type: "string", description: "Continuity task id" },
+        task: { type: "string", description: "Task description for start" },
+        requirements: { type: "string", description: "Comma-separated requirements for start" },
+        kind: { type: "string", description: "requirement, decision, verification, or risk" },
+        content: { type: "string", description: "Entry or outcome text" },
+        verificationStatus: { type: "string", description: "pending, passed, failed, or skipped" },
+        verificationId: { type: "string", description: "Stable verification obligation id for status transitions" },
+        idempotencyKey: { type: "string", description: "Stable retry key for idempotent writes" },
+        status: { type: "string", description: "completed, blocked, or abandoned for close" },
+        source: { type: "string", description: "Source or evidence reference" },
+        evidence: { type: "string", description: "Comma-separated evidence references" },
+        actor: { type: "string", description: "Actor id or label" },
+        limit: { type: "string", description: "Maximum ledgers for list" },
+        json: { type: "boolean", description: "Emit machine-readable JSON output" }
+      },
+      run: async ({ args }) => {
+        const action = args._?.[0] || "";
+        const asJson = !!args.json;
+        try {
+          const { project, dataDir, identity } = await getCliProjectContext({ searchIndex: false });
+          const store2 = new TaskContinuityStore();
+          await store2.init(dataDir);
+          const actor = String(args.actor || identity?.agentId || "").trim() || void 0;
+          if (action === "start") {
+            if (!args.task) {
+              emitError('task is required for "memorix continuity start"', asJson);
+              return;
+            }
+            const result = store2.start({
+              projectId: project.id,
+              task: String(args.task),
+              ...args.taskId ? { taskId: String(args.taskId) } : {},
+              requirements: parseCsvList(args.requirements),
+              ...actor ? { actor } : {},
+              ...args.idempotencyKey ? { idempotencyKey: String(args.idempotencyKey) } : {}
+            });
+            emitResult({ project, ...result }, "Continuity started: " + result.taskId, asJson);
+            return;
+          }
+          if (action === "list") {
+            const ledgers = store2.list(project.id, Number(args.limit || 20));
+            emitResult(
+              { project, ledgers },
+              ledgers.length ? ledgers.map((item) => item.status + ": " + item.taskId + " " + item.task).join("\n") : "No continuity ledgers found.",
+              asJson
+            );
+            return;
+          }
+          const taskId = String(args.taskId || "").trim();
+          if (!taskId) {
+            emitError("taskId is required for this continuity action.", asJson);
+            return;
+          }
+          if (action === "show") {
+            const ledger = store2.get(project.id, taskId);
+            if (!ledger) {
+              emitError("Task continuity ledger not found.", asJson);
+              return;
+            }
+            emitResult({ project, ledger }, JSON.stringify(ledger, null, 2), asJson);
+            return;
+          }
+          if (action === "record") {
+            const kind = String(args.kind || "").trim();
+            const content = String(args.content || "").trim();
+            if (!recordKinds.includes(kind) || !content) {
+              emitError("record requires --kind (requirement, decision, verification, risk) and --content.", asJson);
+              return;
+            }
+            const verificationStatus = args.verificationStatus ? String(args.verificationStatus).trim() : void 0;
+            if (verificationStatus && !["pending", "passed", "failed", "skipped"].includes(verificationStatus)) {
+              emitError("verificationStatus must be pending, passed, failed, or skipped.", asJson);
+              return;
+            }
+            const result = store2.record({
+              projectId: project.id,
+              taskId,
+              kind,
+              content,
+              ...verificationStatus ? { verificationStatus } : {},
+              ...args.source ? { sourceRef: String(args.source) } : {},
+              evidenceRefs: parseCsvList(args.evidence),
+              ...actor ? { actor } : {},
+              ...args.verificationId ? { verificationId: String(args.verificationId) } : {},
+              ...args.idempotencyKey ? { idempotencyKey: String(args.idempotencyKey) } : {}
+            });
+            emitResult({ project, ...result }, "Continuity recorded: " + kind, asJson);
+            return;
+          }
+          if (action === "close") {
+            const status = String(args.status || "").trim();
+            const content = String(args.content || "").trim();
+            if (!["completed", "blocked", "abandoned"].includes(status) || !content) {
+              emitError("close requires --status (completed, blocked, abandoned) and --content.", asJson);
+              return;
+            }
+            const result = store2.close({
+              projectId: project.id,
+              taskId,
+              status,
+              content,
+              ...args.source ? { sourceRef: String(args.source) } : {},
+              evidenceRefs: parseCsvList(args.evidence),
+              ...actor ? { actor } : {},
+              ...args.idempotencyKey ? { idempotencyKey: String(args.idempotencyKey) } : {}
+            });
+            emitResult({ project, ...result }, "Continuity closed: " + status, asJson);
+            return;
+          }
+          console.log("Memorix Task Continuity");
+          console.log("");
+          console.log("Usage:");
+          console.log('  memorix continuity start --task "..." [--requirements "a,b"]');
+          console.log('  memorix continuity record --taskId <id> --kind decision --content "..."');
+          console.log('  memorix continuity record --taskId <id> --kind verification --verificationStatus passed --content "..."');
+          console.log("    Use --verificationId <id> to transition an existing verification obligation.");
+          console.log("  memorix continuity show --taskId <id>");
+          console.log("  memorix continuity list [--limit 20]");
+          console.log('  memorix continuity close --taskId <id> --status completed --content "..."');
+        } catch (error40) {
+          emitError(error40 instanceof Error ? error40.message : String(error40), asJson);
+        }
+      }
+    });
+  }
+});
+
 // src/cli/commands/reasoning.ts
 var reasoning_exports = {};
 __export(reasoning_exports, {
@@ -206980,7 +207754,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 {
@@ -207038,7 +207812,7 @@ function seedAutonomousPipeline(teamStore, projectId, config2, opts) {
   const maxIterations = config2.maxIterations ?? 3;
   const taskBudget = config2.taskBudget ?? 15;
   const structuredPlan = opts?.structuredPlan ?? true;
-  const pipelineId = randomUUID18();
+  const pipelineId = randomUUID19();
   const meta = {
     plannerType: "plan",
     pipelineId,
@@ -207957,11 +208731,11 @@ __export(receipt_service_exports, {
   buildHandoffReceipt: () => buildHandoffReceipt,
   formatHandoffReceipt: () => formatHandoffReceipt
 });
-import { createHash as createHash18 } from "crypto";
+import { createHash as createHash19 } from "crypto";
 import { existsSync as existsSync23, readFileSync as readFileSync15 } from "fs";
 import path37 from "path";
 function sha256(value) {
-  return `sha256:${createHash18("sha256").update(value).digest("hex")}`;
+  return `sha256:${createHash19("sha256").update(value).digest("hex")}`;
 }
 function hashId(projectId, id) {
   return sha256(`${projectId}:obs:${id}`);
@@ -208194,6 +208968,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"],
@@ -208244,7 +209019,7 @@ var init_tool_profile = __esm({
 function getMcpServerInfo() {
   return {
     name: "memorix",
-    version: true ? "1.9.5" : "1.0.1"
+    version: true ? "1.9.7" : "1.0.1"
   };
 }
 function createMcpDiscoverResult(capabilities, serverInfo) {
@@ -215850,8 +216625,8 @@ var require_core = __commonJS({
             return this;
           }
           case "object": {
-            const cacheKey2 = schemaKeyRef;
-            this._cache.delete(cacheKey2);
+            const cacheKey4 = schemaKeyRef;
+            this._cache.delete(cacheKey4);
             let id = schemaKeyRef[this.opts.schemaId];
             if (id) {
               id = (0, resolve_1.normalizeId)(id);
@@ -221039,9 +221814,9 @@ var init_graph_scope = __esm({
 });
 
 // src/rules/utils.ts
-import { createHash as createHash19 } from "crypto";
+import { createHash as createHash20 } from "crypto";
 function hashContent2(content) {
-  return createHash19("sha256").update(content.trim()).digest("hex").substring(0, 16);
+  return createHash20("sha256").update(content.trim()).digest("hex").substring(0, 16);
 }
 function generateRuleId(source, filePath) {
   const sanitized = filePath.replace(/[\/\\]/g, "-").replace(/^\./, "");
@@ -222630,8 +223405,8 @@ function legacyBehavior(homeDir) {
 function getBehaviorConfig(options = {}) {
   const homeDir = options.homeDir ?? homedir34();
   const projectRoot = options.projectRoot === void 0 ? detectProject()?.rootPath ?? null : options.projectRoot;
-  const cacheKey2 = `${homeDir}\0${projectRoot ?? ""}`;
-  const cached2 = cache4.get(cacheKey2);
+  const cacheKey4 = `${homeDir}\0${projectRoot ?? ""}`;
+  const cached2 = cache4.get(cacheKey4);
   if (cached2) return cached2;
   const legacy = legacyBehavior(homeDir);
   let resolved = {};
@@ -222645,7 +223420,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(cacheKey2, config2);
+  cache4.set(cacheKey4, config2);
   return config2;
 }
 function resetBehaviorConfigCache() {
@@ -264676,7 +265451,7 @@ __export(server_exports2, {
   createMemorixServer: () => createMemorixServer,
   shouldAwaitProjectRuntime: () => shouldAwaitProjectRuntime
 });
-import { createHash as createHash20 } from "crypto";
+import { createHash as createHash21 } from "crypto";
 function formatFormationStageDurations(stageDurationsMs) {
   const orderedStages = ["extract", "resolve", "evaluate"];
   const parts = orderedStages.filter((stage) => stageDurationsMs[stage] !== void 0).map((stage) => `${stage}=${stageDurationsMs[stage]}ms`);
@@ -264758,7 +265533,7 @@ function coerceObjectArray(val) {
   return [];
 }
 function createDeterministicInstanceId(projectId, agentType, agentName) {
-  const digest2 = createHash20("sha256").update(projectId).update("\n").update(agentType).update("\n").update(agentName ?? "").digest("hex").slice(0, 24);
+  const digest2 = createHash21("sha256").update(projectId).update("\n").update(agentType).update("\n").update(agentName ?? "").digest("hex").slice(0, 24);
   return `auto-${digest2}`;
 }
 function shouldAwaitProjectRuntime(toolName) {
@@ -264965,6 +265740,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();
@@ -265880,6 +266671,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: external_exports2.string().optional().describe("Current coding task or question"),
+        taskId: external_exports2.string().max(120).optional().describe("Optional task continuity ledger id to include in the brief"),
         refresh: external_exports2.enum(["auto", "always", "never"]).optional().default("auto").describe(
           "Code Memory refresh policy. auto refreshes only when missing or stale."
         ),
@@ -265904,7 +266696,7 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
         limit: external_exports2.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 [
@@ -265934,6 +266726,7 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
         dataDir: projectDir2,
         observations: observations2,
         task,
+        taskId,
         agent,
         refresh: refresh ?? "auto",
         reader: getObservationReader(),
@@ -268359,6 +269152,94 @@ ${json4}
       }
     }
   );
+  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: external_exports2.enum(["start", "record", "show", "list", "close"]).describe("Continuity operation"),
+        taskId: external_exports2.string().max(120).optional().describe("Continuity task id"),
+        task: external_exports2.string().max(1e3).optional().describe("Task description for start"),
+        requirements: external_exports2.array(external_exports2.string().max(2e3)).max(8).optional().describe("Requirements for start"),
+        kind: external_exports2.enum(["requirement", "decision", "verification", "risk"]).optional().describe("Entry kind for record"),
+        content: external_exports2.string().max(2e3).optional().describe("Requirement, decision, verification, risk, or outcome text"),
+        verificationStatus: external_exports2.enum(["pending", "passed", "failed", "skipped"]).optional(),
+        verificationId: external_exports2.string().max(120).optional().describe("Stable verification obligation id; reuse it to move pending to passed/failed"),
+        idempotencyKey: external_exports2.string().max(200).optional().describe("Stable retry key; repeating the same operation returns the original event"),
+        status: external_exports2.enum(["completed", "blocked", "abandoned"]).optional().describe("Outcome status for close"),
+        sourceRef: external_exports2.string().max(500).optional().describe("Evidence or source reference"),
+        evidenceRefs: external_exports2.array(external_exports2.string().max(500)).max(8).optional(),
+        actor: external_exports2.string().max(200).optional(),
+        limit: external_exports2.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 (error40) {
+        return { content: [{ type: "text", text: error40 instanceof Error ? error40.message : String(error40) }], isError: true };
+      }
+    }
+  );
   if (teamFeaturesEnabled) {
     const { initTeamStore: initTeamStore2 } = await Promise.resolve().then(() => (init_team_store(), team_store_exports));
     initTeamStoreForProject = initTeamStore2;
@@ -269386,7 +270267,9 @@ fi
     graphManager,
     projectId: project.id,
     deferredInit,
+    activateProjectRuntime,
     switchProject,
+    getProjectDataDir: () => projectDir2,
     isExplicitlyBound: () => projectBinding.isExplicit(),
     getRequestContext,
     handleTransportClose
@@ -269462,13 +270345,21 @@ var init_server4 = __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,
   McpServer as ModernMcpServer
 } from "@modelcontextprotocol/server";
-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_server4(), server_exports2));
   const legacy = await createMemorixServer2(
     options.projectRoot,
@@ -269489,41 +270380,62 @@ 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";
@@ -269531,6 +270443,74 @@ var init_modern_mcp_bridge = __esm({
     init_client4();
     init_inMemory();
     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, create6) {
+        let entry = this.entries.get(key);
+        if (!entry) {
+          let pending = this.pending.get(key);
+          if (!pending) {
+            pending = create6().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
+        };
+      }
+    };
   }
 });
 
@@ -270159,7 +271139,7 @@ function writeFromReadableStream(stream2, writable) {
   else if (writable.destroyed) return;
   return writeFromReadableStreamDefaultReader(stream2.getReader(), writable);
 }
-var RequestError, reValidRequestUrl, reDotSegment, reValidHost, buildUrl, toRequestError, GlobalRequest, Request$1, newHeadersFromIncoming, wrapBodyStream, byteExactEncodings, isByteExactEncoding, bodyBufferedBeforeDisconnectKey, bodyBufferedLengthBeforeDisconnectKey, toBufferChunk, isRecoverableDisconnectedIncoming, recordBodyBufferedBeforeDisconnect, readBodyBufferedBeforeDisconnect, enqueueBufferedBody, newRequestFromIncoming, getRequestCache, requestCache, incomingKey, urlKey, methodKey, headersKey, abortControllerKey, getAbortController, abortRequest, bodyBufferKey, bodyReadPromiseKey, bodyConsumedDirectlyKey, bodyLockReaderKey, abortReasonKey, newBodyUnusableError, rejectBodyUnusable, textDecoder2, consumeBodyDirectOnce, toArrayBuffer, contentType, methodTokenRegExp, normalizeIncomingMethod, validateDirectReadMethod, readBodyWithFastPath, readRawBodyIfAvailable, normalizeAbortError, readBodyDirect, requestPrototype, newRequest, defaultContentType, responseCache, getResponseCache, cacheKey, GlobalResponse, Response$1, validRedirectUrl, parseRedirectUrl, validRedirectStatuses, buildOutgoingHttpHeaders, outgoingEnded, incomingDraining, DRAIN_TIMEOUT_MS, MAX_DRAIN_BYTES, drainIncoming, makeCloseHandler, isImmediateCacheableResponse, handleRequestError, handleFetchError, handleResponseError, flushHeaders, responseViaCache, isPromise, responseViaResponseObject, getRequestListener, CloseEvent, ErrorEvent, generateConnectionSymbol, CONNECTION_SYMBOL_KEY, WAIT_FOR_WEBSOCKET_SYMBOL, upgradeWebSocket;
+var RequestError, reValidRequestUrl, reDotSegment, reValidHost, buildUrl, toRequestError, GlobalRequest, Request$1, newHeadersFromIncoming, wrapBodyStream, byteExactEncodings, isByteExactEncoding, bodyBufferedBeforeDisconnectKey, bodyBufferedLengthBeforeDisconnectKey, toBufferChunk, isRecoverableDisconnectedIncoming, recordBodyBufferedBeforeDisconnect, readBodyBufferedBeforeDisconnect, enqueueBufferedBody, newRequestFromIncoming, getRequestCache, requestCache, incomingKey, urlKey, methodKey, headersKey, abortControllerKey, getAbortController, abortRequest, bodyBufferKey, bodyReadPromiseKey, bodyConsumedDirectlyKey, bodyLockReaderKey, abortReasonKey, newBodyUnusableError, rejectBodyUnusable, textDecoder2, consumeBodyDirectOnce, toArrayBuffer, contentType, methodTokenRegExp, normalizeIncomingMethod, validateDirectReadMethod, readBodyWithFastPath, readRawBodyIfAvailable, normalizeAbortError, readBodyDirect, requestPrototype, newRequest, defaultContentType, responseCache, getResponseCache, cacheKey3, GlobalResponse, Response$1, validRedirectUrl, parseRedirectUrl, validRedirectStatuses, buildOutgoingHttpHeaders, outgoingEnded, incomingDraining, DRAIN_TIMEOUT_MS, MAX_DRAIN_BYTES, drainIncoming, makeCloseHandler, isImmediateCacheableResponse, handleRequestError, handleFetchError, handleResponseError, flushHeaders, responseViaCache, isPromise, responseViaResponseObject, getRequestListener, CloseEvent, ErrorEvent, generateConnectionSymbol, CONNECTION_SYMBOL_KEY, WAIT_FOR_WEBSOCKET_SYMBOL, upgradeWebSocket;
 var init_dist8 = __esm({
   "node_modules/@hono/node-server/dist/index.mjs"() {
     "use strict";
@@ -270630,15 +271610,15 @@ var init_dist8 = __esm({
     defaultContentType = "text/plain; charset=UTF-8";
     responseCache = /* @__PURE__ */ Symbol("responseCache");
     getResponseCache = /* @__PURE__ */ Symbol("getResponseCache");
-    cacheKey = /* @__PURE__ */ Symbol("cache");
+    cacheKey3 = /* @__PURE__ */ Symbol("cache");
     GlobalResponse = global.Response;
     Response$1 = class Response$12 {
       #body;
       #init;
       [getResponseCache]() {
-        const cache5 = this[cacheKey];
+        const cache5 = this[cacheKey3];
         const liveHeaders = cache5 && cache5[2] instanceof Headers ? cache5[2] : void 0;
-        delete this[cacheKey];
+        delete this[cacheKey3];
         return this[responseCache] ||= new GlobalResponse(this.#body, liveHeaders ? {
           status: this.#init?.status,
           statusText: this.#init?.statusText,
@@ -270658,14 +271638,14 @@ var init_dist8 = __esm({
           this.#init = init2 instanceof Response$12 ? init2.#init : init2;
           headers = new Headers(init2.headers);
         } else this.#init = init2;
-        if (body == null || typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) this[cacheKey] = [
+        if (body == null || typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) this[cacheKey3] = [
           init2?.status || 200,
           body ?? null,
           headers || init2?.headers
         ];
       }
       get headers() {
-        const cache5 = this[cacheKey];
+        const cache5 = this[cacheKey3];
         if (cache5) {
           if (!(cache5[2] instanceof Headers)) cache5[2] = new Headers(cache5[2] || (cache5[1] === null ? void 0 : { "content-type": defaultContentType }));
           return cache5[2];
@@ -270673,7 +271653,7 @@ var init_dist8 = __esm({
         return this[getResponseCache]().headers;
       }
       get status() {
-        return this[cacheKey]?.[0] ?? this[getResponseCache]().status;
+        return this[cacheKey3]?.[0] ?? this[getResponseCache]().status;
       }
       get ok() {
         const status = this.status;
@@ -270826,8 +271806,8 @@ var init_dist8 = __esm({
       });
     };
     isImmediateCacheableResponse = (res) => {
-      if (!(cacheKey in res)) return false;
-      const body = res[cacheKey][1];
+      if (!(cacheKey3 in res)) return false;
+      const body = res[cacheKey3][1];
       return body === null || typeof body === "string" || body instanceof Uint8Array;
     };
     handleRequestError = () => new Response(null, { status: 400 });
@@ -270846,7 +271826,7 @@ var init_dist8 = __esm({
       if ("flushHeaders" in outgoing && outgoing.writable) outgoing.flushHeaders();
     };
     responseViaCache = async (res, outgoing) => {
-      let [status, body, header] = res[cacheKey];
+      let [status, body, header] = res[cacheKey3];
       if (!header) {
         if (body === null) {
           outgoing.writeHead(status);
@@ -270914,7 +271894,7 @@ var init_dist8 = __esm({
         res = errRes;
       }
       else res = await res.catch(handleFetchError);
-      if (cacheKey in res) return responseViaCache(res, outgoing);
+      if (cacheKey3 in res) return responseViaCache(res, outgoing);
       const resHeaderRecord = buildOutgoingHttpHeaders(res.headers, res.body === null ? void 0 : defaultContentType);
       if (res.body) {
         const reader2 = res.body.getReader();
@@ -272151,7 +273131,7 @@ __export(mcp_binding_store_exports, {
   DEFAULT_MCP_BINDING_TTL_MS: () => DEFAULT_MCP_BINDING_TTL_MS,
   McpBindingStore: () => McpBindingStore
 });
-import { randomUUID as randomUUID19 } from "crypto";
+import { randomUUID as randomUUID20 } from "crypto";
 function rowToBinding(row) {
   return {
     handleId: String(row.handle_id),
@@ -272183,7 +273163,7 @@ var init_mcp_binding_store = __esm({
         const now3 = /* @__PURE__ */ new Date();
         const ttlMs = input.ttlMs ?? DEFAULT_MCP_BINDING_TTL_MS;
         const binding = {
-          handleId: `mxh_${randomUUID19().replace(/-/g, "")}`,
+          handleId: `mxh_${randomUUID20().replace(/-/g, "")}`,
           projectId: input.projectId,
           projectRoot: input.projectRoot,
           dataDir: input.dataDir,
@@ -272310,10 +273290,14 @@ var init_control_plane_maintenance = __esm({
 var serve_http_exports = {};
 __export(serve_http_exports, {
   DEFAULT_HTTP_BODY_LIMIT_BYTES: () => DEFAULT_HTTP_BODY_LIMIT_BYTES,
+  DEFAULT_MAX_HTTP_SESSIONS: () => DEFAULT_MAX_HTTP_SESSIONS,
   DEFAULT_SESSION_TIMEOUT_MS: () => DEFAULT_SESSION_TIMEOUT_MS,
   EXPIRED_SESSION_TTL_MS: () => EXPIRED_SESSION_TTL_MS,
   HttpPayloadTooLargeError: () => HttpPayloadTooLargeError,
   MAX_HTTP_BODY_LIMIT_BYTES: () => MAX_HTTP_BODY_LIMIT_BYTES,
+  MAX_HTTP_SESSIONS_LIMIT: () => MAX_HTTP_SESSIONS_LIMIT,
+  MAX_PROJECT_CACHE_ENTRIES: () => MAX_PROJECT_CACHE_ENTRIES,
+  MAX_STORE_CACHE_ENTRIES: () => MAX_STORE_CACHE_ENTRIES,
   MCP_SDK_COMPAT_PROTOCOL_VERSION: () => MCP_SDK_COMPAT_PROTOCOL_VERSION,
   MIN_HTTP_BODY_LIMIT_BYTES: () => MIN_HTTP_BODY_LIMIT_BYTES,
   _testing: () => _testing2,
@@ -272322,11 +273306,13 @@ __export(serve_http_exports, {
   isServerDiscoverRequest: () => isServerDiscoverRequest,
   parseHttpBodyLimit: () => parseHttpBodyLimit,
   parseJsonBody: () => parseJsonBody,
+  parseMaxHttpSessions: () => parseMaxHttpSessions,
   parseSessionTimeoutMs: () => parseSessionTimeoutMs,
   resolveServeHttpDefaults: () => resolveServeHttpDefaults,
   validateHttpBindSecurity: () => validateHttpBindSecurity
 });
 import { getHeapStatistics } from "v8";
+import { monitorEventLoopDelay } from "perf_hooks";
 import { timingSafeEqual as timingSafeEqual2 } from "crypto";
 function isServerDiscoverRequest(body) {
   return Boolean(body && typeof body === "object" && !Array.isArray(body) && body.method === "server/discover");
@@ -272347,6 +273333,13 @@ function parseHttpBodyLimit(raw) {
   }
   return Math.min(parsed, MAX_HTTP_BODY_LIMIT_BYTES);
 }
+function parseMaxHttpSessions(raw) {
+  const value = raw?.trim();
+  if (!value) return DEFAULT_MAX_HTTP_SESSIONS;
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed < 1) return DEFAULT_MAX_HTTP_SESSIONS;
+  return Math.min(parsed, MAX_HTTP_SESSIONS_LIMIT);
+}
 function isLoopbackHost(host) {
   const normalized = host.trim().toLowerCase();
   return normalized === "localhost" || normalized === "127.0.0.1" || normalized === "::1" || normalized === "[::1]";
@@ -272419,7 +273412,7 @@ function resolveServeHttpDefaults(argsPort, configured) {
   const transportNotice = configured.transport === "stdio" ? '[memorix] config server.transport = "stdio"; serve-http continues on HTTP (the explicit command wins).' : void 0;
   return { port, transportNotice };
 }
-var DEFAULT_SESSION_TIMEOUT_MS, EXPIRED_SESSION_TTL_MS, DEFAULT_HTTP_BODY_LIMIT_BYTES, MAX_HTTP_BODY_LIMIT_BYTES, MIN_HTTP_BODY_LIMIT_BYTES, MCP_SDK_COMPAT_PROTOCOL_VERSION, HttpPayloadTooLargeError, serve_http_default, _testing2;
+var DEFAULT_SESSION_TIMEOUT_MS, EXPIRED_SESSION_TTL_MS, DEFAULT_HTTP_BODY_LIMIT_BYTES, MAX_HTTP_BODY_LIMIT_BYTES, MIN_HTTP_BODY_LIMIT_BYTES, MAX_PROJECT_CACHE_ENTRIES, MAX_STORE_CACHE_ENTRIES, DEFAULT_MAX_HTTP_SESSIONS, MAX_HTTP_SESSIONS_LIMIT, MCP_SDK_COMPAT_PROTOCOL_VERSION, HttpPayloadTooLargeError, serve_http_default, _testing2;
 var init_serve_http = __esm({
   "src/cli/commands/serve-http.ts"() {
     "use strict";
@@ -272438,6 +273431,10 @@ var init_serve_http = __esm({
     DEFAULT_HTTP_BODY_LIMIT_BYTES = 10 * 1024 * 1024;
     MAX_HTTP_BODY_LIMIT_BYTES = 64 * 1024 * 1024;
     MIN_HTTP_BODY_LIMIT_BYTES = 64 * 1024;
+    MAX_PROJECT_CACHE_ENTRIES = 256;
+    MAX_STORE_CACHE_ENTRIES = 32;
+    DEFAULT_MAX_HTTP_SESSIONS = 64;
+    MAX_HTTP_SESSIONS_LIMIT = 512;
     MCP_SDK_COMPAT_PROTOCOL_VERSION = "2025-11-25";
     HttpPayloadTooLargeError = class extends Error {
       statusCode = 413;
@@ -272475,7 +273472,7 @@ var init_serve_http = __esm({
       },
       run: async ({ args }) => {
         const { createServer: createServer3 } = await import("http");
-        const { randomUUID: randomUUID21 } = await import("crypto");
+        const { randomUUID: randomUUID23 } = await import("crypto");
         const { StreamableHTTPServerTransport: StreamableHTTPServerTransport2 } = await Promise.resolve().then(() => (init_streamableHttp(), streamableHttp_exports));
         const { isInitializeRequest: isInitializeRequest2 } = await Promise.resolve().then(() => (init_types8(), types_exports3));
         const { createMemorixServer: createMemorixServer2 } = await Promise.resolve().then(() => (init_server4(), server_exports2));
@@ -272485,7 +273482,8 @@ var init_serve_http = __esm({
         const { homedir: homedir38 } = await import("os");
         const { McpBindingStore: McpBindingStore2 } = await Promise.resolve().then(() => (init_mcp_binding_store(), mcp_binding_store_exports));
         const { MemoryFeedbackStore: MemoryFeedbackStore2 } = await Promise.resolve().then(() => (init_feedback(), feedback_exports));
-        const { createModernMcpBridge: createModernMcpBridge2 } = await Promise.resolve().then(() => (init_modern_mcp_bridge(), modern_mcp_bridge_exports));
+        const { createModernMcpRuntime: createModernMcpRuntime2, ModernMcpRuntimePool: ModernMcpRuntimePool2, withBusinessRuntimeQueue: withBusinessRuntimeQueue2 } = await Promise.resolve().then(() => (init_modern_mcp_bridge(), modern_mcp_bridge_exports));
+        const { acquireDatabase: acquireDatabase2, evictIdleDatabases: evictIdleDatabases2, getDatabaseStats: getDatabaseStats2 } = await Promise.resolve().then(() => (init_sqlite_db(), sqlite_db_exports));
         const { createMcpHandler } = await import("@modelcontextprotocol/server");
         const { toNodeHandler } = await import("@modelcontextprotocol/node");
         let configuredDefaults = {};
@@ -272537,42 +273535,108 @@ var init_serve_http = __esm({
         console.error(`[memorix] Project root: ${projectRoot}`);
         const sessionTimeoutMs = parseSessionTimeoutMs(process.env.MEMORIX_SESSION_TIMEOUT_MS);
         const httpBodyLimitBytes = parseHttpBodyLimit(process.env.MEMORIX_HTTP_MAX_BODY_BYTES);
+        const maxHttpSessions = parseMaxHttpSessions(process.env.MEMORIX_MAX_HTTP_SESSIONS);
+        const eventLoopDelay = monitorEventLoopDelay({ resolution: 20 });
+        eventLoopDelay.enable();
         console.error(
           sessionTimeoutMs === 0 ? "[memorix] HTTP session idle timeout: disabled" : `[memorix] HTTP session idle timeout: ${Math.round(sessionTimeoutMs / 6e4)}min (${sessionTimeoutMs}ms)`
         );
+        console.error(`[memorix] HTTP session limit: ${maxHttpSessions}`);
         const teamStoreCache = /* @__PURE__ */ new Map();
+        const teamStoreLeases = /* @__PURE__ */ new Map();
         const { initTeamStore: initTeamStore2 } = await Promise.resolve().then(() => (init_team_store(), team_store_exports));
+        function cacheSet3(cache5, key, value, limit2, onEvict) {
+          cache5.delete(key);
+          cache5.set(key, value);
+          while (cache5.size > limit2) {
+            const oldest = cache5.keys().next().value;
+            if (oldest === void 0) break;
+            const oldValue = cache5.get(oldest);
+            cache5.delete(oldest);
+            if (oldValue !== void 0) onEvict?.(oldest, oldValue);
+          }
+        }
         async function getTeamStore2(dataDir) {
           const existing = teamStoreCache.get(dataDir);
-          if (existing) return existing;
-          const store2 = await initTeamStore2(dataDir);
-          teamStoreCache.set(dataDir, store2);
-          return store2;
+          if (existing) {
+            cacheSet3(teamStoreCache, dataDir, existing, MAX_STORE_CACHE_ENTRIES);
+            return existing;
+          }
+          const lease = acquireDatabase2(dataDir);
+          try {
+            const store2 = await initTeamStore2(dataDir);
+            teamStoreLeases.set(dataDir, lease);
+            cacheSet3(teamStoreCache, dataDir, store2, MAX_STORE_CACHE_ENTRIES, (evictedDataDir) => {
+              teamStoreLeases.get(evictedDataDir)?.release();
+              teamStoreLeases.delete(evictedDataDir);
+              evictIdleDatabases2(MAX_STORE_CACHE_ENTRIES);
+            });
+            return store2;
+          } catch (error40) {
+            lease.release();
+            throw error40;
+          }
         }
+        const controlPlaneBaseDir = persistMod.getBaseDataDir();
+        const controlPlaneBaseLease = acquireDatabase2(controlPlaneBaseDir);
         const statelessBindingStore = new McpBindingStore2();
-        await statelessBindingStore.init(persistMod.getBaseDataDir());
+        await statelessBindingStore.init(controlPlaneBaseDir);
+        const modernRuntimePool = new ModernMcpRuntimePool2(MAX_STORE_CACHE_ENTRIES);
+        async function resolveModernDataDir(root, persisted) {
+          if (persisted?.dataDir) return persisted.dataDir;
+          const detected = detectorMod.detectProject(root);
+          return detected ? persistMod.getProjectDataDir(detected.id) : controlPlaneBaseDir;
+        }
         const modernMcpHandler = createMcpHandler(async ({ requestInfo }) => {
           const handleId = requestInfo?.headers.get("mcp-project-handle") ?? void 0;
           const persisted = handleId ? statelessBindingStore.touch(handleId) : void 0;
           const requestedRoot = requestInfo?.headers.get("mcp-project-root") ?? void 0;
           const root = persisted?.projectRoot ?? requestedRoot ?? projectRoot;
-          return createModernMcpBridge2({
-            projectRoot: root,
-            allowUntrackedFallback: false,
-            deferProjectInitUntilBound: true,
-            deferProjectRuntimeInit: true,
-            dashboardMode: "control-plane",
-            dashboardPort: port,
-            toolProfile
-          });
+          const dataDir = await resolveModernDataDir(root, persisted);
+          const runtimeKey = JSON.stringify([dataDir, root]);
+          return modernRuntimePool.createBridge(runtimeKey, () => withBusinessRuntimeQueue2(async () => {
+            const lease = acquireDatabase2(dataDir);
+            try {
+              const runtime = await createModernMcpRuntime2({
+                projectRoot: root,
+                allowUntrackedFallback: false,
+                deferProjectInitUntilBound: true,
+                deferProjectRuntimeInit: true,
+                dashboardMode: "control-plane",
+                dashboardPort: port,
+                toolProfile
+              });
+              const close = runtime.close.bind(runtime);
+              return {
+                ...runtime,
+                close: async () => {
+                  try {
+                    await close();
+                  } finally {
+                    lease.release();
+                  }
+                }
+              };
+            } catch (error40) {
+              lease.release();
+              throw error40;
+            }
+          }));
         }, {
           // Legacy requests are routed to the existing sessionful implementation
           // below; this handler is strict modern-only by construction.
           legacy: "reject",
-          responseMode: "auto"
+          responseMode: "auto",
+          onerror: (error40) => {
+            const message = error40 instanceof Error ? error40.message : String(error40);
+            const stack = error40 instanceof Error ? error40.stack : void 0;
+            console.error(`[memorix] modern MCP request failed: ${message}${stack ? `
+${stack}` : ""}`);
+          }
         });
         const modernNodeHandler = toNodeHandler(modernMcpHandler);
         const sessions = /* @__PURE__ */ new Map();
+        let pendingSessionInitializations = 0;
         const sessionLastActivity = /* @__PURE__ */ new Map();
         const expiredSessions = /* @__PURE__ */ new Map();
         let suppressedProbeCount = 0;
@@ -272747,7 +273811,11 @@ var init_serve_http = __esm({
           if (sessionId && sessions.has(sessionId)) {
             sessionLastActivity.set(sessionId, Date.now());
             patchMcpResponse(res);
-            await sessions.get(sessionId).transport.handleRequest(req, res, body);
+            const session = sessions.get(sessionId);
+            await withBusinessRuntimeQueue2(async () => {
+              await session.activateProjectRuntime();
+              await session.transport.handleRequest(req, res, body);
+            });
             return;
           }
           if (sessionId) {
@@ -272755,11 +273823,32 @@ var init_serve_http = __esm({
             return;
           }
           if (!sessionId && isInitializeRequest2(body)) {
+            if (sessions.size + pendingSessionInitializations >= maxHttpSessions) {
+              res.writeHead(429, {
+                "Content-Type": "application/json",
+                "Retry-After": "5"
+              });
+              res.end(JSON.stringify({
+                jsonrpc: "2.0",
+                error: { code: -32029, message: `HTTP session limit reached (${maxHttpSessions}). Retry after an existing session closes.` },
+                id: body.id ?? null
+              }));
+              return;
+            }
+            pendingSessionInitializations++;
+            let pendingReservationReleased = false;
+            const releasePendingReservation = () => {
+              if (pendingReservationReleased) return;
+              pendingReservationReleased = true;
+              pendingSessionInitializations = Math.max(0, pendingSessionInitializations - 1);
+            };
             let createdState = null;
+            const sessionLeases = [acquireDatabase2(defaultDataDir)];
             const transport = new StreamableHTTPServerTransport2({
-              sessionIdGenerator: () => randomUUID21(),
+              sessionIdGenerator: () => randomUUID23(),
               enableJsonResponse: true,
               onsessioninitialized: (sid) => {
+                releasePendingReservation();
                 if (createdState) sessions.set(sid, createdState);
                 sessionLastActivity.set(sid, Date.now());
                 const timer = setTimeout(() => {
@@ -272770,6 +273859,7 @@ var init_serve_http = __esm({
               }
             });
             transport.onclose = () => {
+              releasePendingReservation();
               const sid = transport.sessionId;
               if (sid) {
                 const pending = pendingLogTimers.get(sid);
@@ -272785,26 +273875,49 @@ var init_serve_http = __esm({
                 sessionLastActivity.delete(sid);
               }
               handleTransportClose();
+              for (const lease of sessionLeases) lease.release();
+              evictIdleDatabases2(MAX_STORE_CACHE_ENTRIES);
             };
             const binding = createProjectBindingController2(projectRoot);
-            const { server, switchProject, handleTransportClose } = await createMemorixServer2(
-              projectRoot,
-              void 0,
-              void 0,
-              {
-                allowUntrackedFallback: false,
-                deferProjectInitUntilBound: true,
-                // Same as stdio: initialize/tools/list must not hydrate 40k+
-                // observations on the HTTP thread. /health and the LaunchAgent
-                // watchdog die if createMemorixServer blocks here.
-                deferProjectRuntimeInit: true,
-                dashboardMode: "control-plane",
-                dashboardPort: port,
-                toolProfile,
-                projectBinding: binding
+            let server;
+            let activateProjectRuntime;
+            let handleTransportClose;
+            let getProjectDataDirForSession;
+            let switchProject;
+            try {
+              ({ server, activateProjectRuntime, switchProject, handleTransportClose, getProjectDataDir: getProjectDataDirForSession } = await createMemorixServer2(
+                projectRoot,
+                void 0,
+                void 0,
+                {
+                  allowUntrackedFallback: false,
+                  deferProjectInitUntilBound: true,
+                  // Same as stdio: initialize/tools/list must not hydrate 40k+
+                  // observations on the HTTP thread. /health and the LaunchAgent
+                  // watchdog die if createMemorixServer blocks here.
+                  deferProjectRuntimeInit: true,
+                  dashboardMode: "control-plane",
+                  dashboardPort: port,
+                  toolProfile,
+                  projectBinding: binding
+                }
+              ));
+            } catch (error40) {
+              releasePendingReservation();
+              for (const lease of sessionLeases) lease.release();
+              throw error40;
+            }
+            const switchProjectWithLease = async (newCwd, source) => {
+              const before = getProjectDataDirForSession();
+              const changed = await switchProject(newCwd, source);
+              const after = getProjectDataDirForSession();
+              if (changed && after !== before) {
+                sessionLeases[0].release();
+                sessionLeases[0] = acquireDatabase2(after);
               }
-            );
-            createdState = { transport, server, switchProject, binding };
+              return changed;
+            };
+            createdState = { transport, server, activateProjectRuntime, switchProject: switchProjectWithLease, binding, leases: sessionLeases };
             await server.connect(transport);
             const tryRootsSwitch = async () => {
               try {
@@ -272843,7 +273956,14 @@ var init_serve_http = __esm({
             } catch {
             }
             patchMcpResponse(res);
-            await transport.handleRequest(req, res, body);
+            try {
+              await withBusinessRuntimeQueue2(async () => {
+                await activateProjectRuntime();
+                await transport.handleRequest(req, res, body);
+              });
+            } finally {
+              if (!transport.sessionId) releasePendingReservation();
+            }
             return;
           }
           res.writeHead(400, { "Content-Type": "application/json" });
@@ -272877,7 +273997,7 @@ var init_serve_http = __esm({
             sendUnknownSession(res, sessionId);
             return;
           }
-          await sessions.get(sessionId).transport.handleRequest(req, res);
+          await withBusinessRuntimeQueue2(() => sessions.get(sessionId).transport.handleRequest(req, res));
         }
         const { detectProject: detectProject2 } = await Promise.resolve().then(() => (init_detector(), detector_exports));
         const { getProjectDataDir: getProjectDataDir2, getBaseDataDir: getBaseDataDir2 } = await Promise.resolve().then(() => (init_persistence(), persistence_exports));
@@ -272898,8 +274018,9 @@ var init_serve_http = __esm({
         });
         controlPlaneMaintenanceWorker.start();
         const projectDataDirCache = /* @__PURE__ */ new Map();
-        projectDataDirCache.set(defaultProject.id, defaultDataDir);
+        cacheSet3(projectDataDirCache, defaultProject.id, defaultDataDir, MAX_PROJECT_CACHE_ENTRIES);
         const dashboardObservationStores = /* @__PURE__ */ new Map();
+        const dashboardStoreLeases = /* @__PURE__ */ new Map();
         async function resolveRequestProject(url2) {
           const requestedId = url2.searchParams.get("project");
           if (!requestedId || requestedId === defaultProject.id) {
@@ -272908,18 +274029,36 @@ var init_serve_http = __esm({
           let dataDir = projectDataDirCache.get(requestedId);
           if (!dataDir) {
             dataDir = await getProjectDataDir2(requestedId);
-            projectDataDirCache.set(requestedId, dataDir);
+            cacheSet3(projectDataDirCache, requestedId, dataDir, MAX_PROJECT_CACHE_ENTRIES);
           }
           const name = requestedId.split("/").pop() || requestedId;
           return { projectId: requestedId, projectName: name, dataDir };
         }
         async function getDashboardObservationStore(dataDir) {
           const cached2 = dashboardObservationStores.get(dataDir);
-          if (cached2) return cached2;
+          if (cached2) {
+            cacheSet3(dashboardObservationStores, dataDir, cached2, MAX_STORE_CACHE_ENTRIES);
+            return cached2;
+          }
           const { createObservationStore: createObservationStore2 } = await Promise.resolve().then(() => (init_obs_store(), obs_store_exports));
-          const store2 = await createObservationStore2(dataDir);
-          dashboardObservationStores.set(dataDir, store2);
-          return store2;
+          const lease = acquireDatabase2(dataDir);
+          try {
+            const store2 = await createObservationStore2(dataDir);
+            dashboardStoreLeases.set(dataDir, lease);
+            cacheSet3(dashboardObservationStores, dataDir, store2, MAX_STORE_CACHE_ENTRIES, (evictedDataDir, evictedStore) => {
+              try {
+                evictedStore.close();
+              } catch {
+              }
+              dashboardStoreLeases.get(evictedDataDir)?.release();
+              dashboardStoreLeases.delete(evictedDataDir);
+              evictIdleDatabases2(MAX_STORE_CACHE_ENTRIES);
+            });
+            return store2;
+          } catch (error40) {
+            lease.release();
+            throw error40;
+          }
         }
         async function loadDashboardObservations(dataDir) {
           const store2 = await getDashboardObservationStore(dataDir);
@@ -273749,6 +274888,18 @@ var init_serve_http = __esm({
                 arrayBuffers: memory.arrayBuffers,
                 heapLimit: heap.heap_size_limit
               },
+              sqlite: getDatabaseStats2(),
+              sessions: {
+                active: sessions.size,
+                pending: pendingSessionInitializations,
+                limit: maxHttpSessions
+              },
+              modernRuntime: modernRuntimePool.stats(),
+              eventLoop: {
+                meanMs: Number.isFinite(eventLoopDelay.mean) ? eventLoopDelay.mean / 1e6 : null,
+                p95Ms: eventLoopDelay.percentile(95) / 1e6,
+                maxMs: eventLoopDelay.max / 1e6
+              },
               embedding: getEmbeddingRuntimeHealth2()
             }));
             return;
@@ -273865,6 +275016,13 @@ var init_serve_http = __esm({
             }
           }
           dashboardObservationStores.clear();
+          for (const lease of dashboardStoreLeases.values()) lease.release();
+          dashboardStoreLeases.clear();
+          for (const lease of teamStoreLeases.values()) lease.release();
+          teamStoreLeases.clear();
+          controlPlaneBaseLease.release();
+          await modernRuntimePool.close();
+          eventLoopDelay.disable();
           const { closeAllDatabases: closeAllDatabases2 } = await Promise.resolve().then(() => (init_sqlite_db(), sqlite_db_exports));
           closeAllDatabases2();
           throw error40;
@@ -273875,6 +275033,8 @@ var init_serve_http = __esm({
           const now3 = Date.now();
           forgetExpiredSessions(now3);
           statelessBindingStore.cleanupExpired(now3);
+          evictIdleDatabases2(MAX_STORE_CACHE_ENTRIES);
+          void modernRuntimePool.evictIdle();
           if (SESSION_TIMEOUT_MS === 0) return;
           for (const [sid, state] of sessions) {
             const lastActive = sessionLastActivity.get(sid) ?? 0;
@@ -273918,6 +275078,10 @@ var init_serve_http = __esm({
             }
           }
           dashboardObservationStores.clear();
+          for (const lease of dashboardStoreLeases.values()) lease.release();
+          dashboardStoreLeases.clear();
+          for (const lease of teamStoreLeases.values()) lease.release();
+          teamStoreLeases.clear();
           for (const [sid, state] of sessions) {
             try {
               await state.transport.close();
@@ -273926,8 +275090,10 @@ var init_serve_http = __esm({
               console.error(`[memorix] Error closing session ${sid}:`, err);
             }
           }
+          await modernRuntimePool.close();
           clearInterval(gcInterval);
           clearInterval(heartbeatInterval);
+          eventLoopDelay.disable();
           await new Promise((resolve9) => {
             if (!httpServer.listening) {
               resolve9();
@@ -273936,6 +275102,7 @@ var init_serve_http = __esm({
             httpServer.close(() => resolve9());
           });
           const { closeAllDatabases: closeAllDatabases2 } = await Promise.resolve().then(() => (init_sqlite_db(), sqlite_db_exports));
+          controlPlaneBaseLease.release();
           closeAllDatabases2();
           process.exit(0);
         };
@@ -273979,6 +275146,7 @@ var init_serve_http = __esm({
       MAX_HTTP_BODY_LIMIT_BYTES,
       MIN_HTTP_BODY_LIMIT_BYTES,
       parseSessionTimeoutMs,
+      parseMaxHttpSessions,
       parseHttpBodyLimit,
       isLoopbackHost,
       validateHttpBindSecurity,
@@ -274328,7 +275496,7 @@ var init_merge = __esm({
 });
 
 // src/sync/journal.ts
-import { createHash as createHash21 } from "crypto";
+import { createHash as createHash22 } from "crypto";
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -274340,7 +275508,7 @@ function deriveSyncKey(obs, originDevice) {
 function contentHash(obs) {
   const { id: _id, writeGeneration: _wg, ...rest } = obs;
   const stable = stableJson(rest);
-  return createHash21("sha256").update(stable).digest("hex");
+  return createHash22("sha256").update(stable).digest("hex");
 }
 function stableJson(value) {
   if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
@@ -274463,9 +275631,9 @@ var init_policy2 = __esm({
 });
 
 // src/sync/namespace.ts
-import { createHash as createHash22 } from "crypto";
+import { createHash as createHash23 } from "crypto";
 function syncNamespace(projectId) {
-  return `project-${createHash22("sha256").update(projectId).digest("hex").slice(0, 32)}`;
+  return `project-${createHash23("sha256").update(projectId).digest("hex").slice(0, 32)}`;
 }
 function userSyncNamespace(env3 = process.env) {
   const override = env3.MEMORIX_SYNC_USER_NAMESPACE?.trim();
@@ -274491,7 +275659,7 @@ var init_namespace = __esm({
 });
 
 // src/sync/engine.ts
-import { createHash as createHash23 } from "crypto";
+import { createHash as createHash24 } from "crypto";
 async function runSync(store2, remote, opts) {
   const report = {
     remote: remote.kind,
@@ -274695,7 +275863,7 @@ async function recordConcurrentConflict(store2, report, local, incoming, localRo
   const incomingWins = compareVersion(incoming.version, { revision: local.revision, writer: local.writer }) > 0;
   const loser = incomingWins ? { revision: local.revision, writer: local.writer } : incoming.version;
   const loserRow = incomingWins ? localRow : incoming.row;
-  const id = createHash23("sha256").update(`${store2.projectId()}|${incoming.syncKey}|${local.revision}|${local.writer}|${incoming.version.revision}|${incoming.version.writer}`).digest("hex");
+  const id = createHash24("sha256").update(`${store2.projectId()}|${incoming.syncKey}|${local.revision}|${local.writer}|${incoming.version.revision}|${incoming.version.writer}`).digest("hex");
   await store2.recordConflict({
     id,
     projectId: store2.projectId(),
@@ -274734,7 +275902,7 @@ var init_engine6 = __esm({
 
 // src/sync/store-port.ts
 import os7 from "os";
-import { randomUUID as randomUUID20 } from "crypto";
+import { randomUUID as randomUUID21 } from "crypto";
 function createSqliteSyncStore(dataDir, store2, projectId, options = {}) {
   const db2 = getDatabase(dataDir);
   const scope = options.scope ?? "project";
@@ -274784,7 +275952,7 @@ function createSqliteSyncStore(dataDir, store2, projectId, options = {}) {
   function ensureDevice() {
     const row = getMeta.get(DEVICE_KEY);
     if (row?.value) return row.value;
-    const id = `dev_${randomUUID20().replaceAll("-", "")}`;
+    const id = `dev_${randomUUID21().replaceAll("-", "")}`;
     setMeta.run(DEVICE_KEY, id);
     setMeta.run(FINGERPRINT_KEY, deviceFingerprint);
     return id;
@@ -274814,7 +275982,7 @@ function createSqliteSyncStore(dataDir, store2, projectId, options = {}) {
     assertCanPublish,
     rotateDevice: () => {
       const previous = ensureDevice();
-      const id = `dev_${randomUUID20().replaceAll("-", "")}`;
+      const id = `dev_${randomUUID21().replaceAll("-", "")}`;
       const pending = pendingForDevice.all(previous);
       const rotate = db2.transaction(() => {
         setMeta.run(DEVICE_KEY, id);
@@ -277591,10 +278759,10 @@ __export(handler_exports, {
   resetCooldowns: () => resetCooldowns,
   runHook: () => runHook
 });
-import { createHash as createHash24 } from "crypto";
+import { createHash as createHash25 } from "crypto";
 function deriveHookActorId(input) {
   const material = `${input.agent ?? "unknown"}\0${input.sessionId ?? "unknown"}`;
-  return `hook:${createHash24("sha256").update(material).digest("hex").slice(0, 24)}`;
+  return `hook:${createHash25("sha256").update(material).digest("hex").slice(0, 24)}`;
 }
 function classifyTool(input) {
   if (input.event === "post_edit") return "file_modify";
@@ -279556,10 +280724,10 @@ var init_ingest = __esm({
 });
 
 // src/media/embedding.ts
-import { createHash as createHash25 } from "crypto";
+import { createHash as createHash26 } from "crypto";
 function profileKey(provider2, asset) {
   const identity = `${provider2.name}\0${provider2.dimensions}\0${asset.kind}`;
-  return `media:${createHash25("sha256").update(identity).digest("hex").slice(0, 20)}`;
+  return `media:${createHash26("sha256").update(identity).digest("hex").slice(0, 20)}`;
 }
 function supportsAsset(provider2, asset) {
   return !!provider2.embedInput && (provider2.supportedModalities?.includes(asset.kind) ?? false);
@@ -284751,13 +285919,21 @@ var init_capability_router = __esm({
 // src/orchestrate/pipeline-trace.ts
 function initTraceTable(db2) {
   db2.exec(CREATE_TABLE_SQL);
+  for (const column of ["attempt INTEGER", "risk_tier TEXT", "effect_key TEXT", "memory_refs TEXT"]) {
+    try {
+      db2.exec(`ALTER TABLE pipeline_traces ADD COLUMN ${column}`);
+    } catch {
+    }
+  }
   db2.exec(CREATE_INDEX_SQL);
 }
 function writeTrace(db2, event) {
   if (!_insertStmt) {
     _insertStmt = db2.prepare(`
-      INSERT INTO pipeline_traces (pipeline_id, timestamp, type, task_id, agent, detail, duration_ms)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO pipeline_traces (
+        pipeline_id, timestamp, type, task_id, agent, detail, duration_ms,
+        attempt, risk_tier, effect_key, memory_refs
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
   }
   _insertStmt.run(
@@ -284766,8 +285942,12 @@ function writeTrace(db2, event) {
     event.type,
     event.taskId ?? null,
     event.agent ?? null,
-    event.detail,
-    event.durationMs ?? null
+    sanitizeCredentials(event.detail).slice(0, 2e3),
+    event.durationMs ?? null,
+    event.attempt ?? null,
+    event.riskTier ?? null,
+    event.effectKey ?? null,
+    event.memoryRefs ? JSON.stringify(event.memoryRefs.slice(0, 16)) : null
   );
 }
 function pruneOldTraces(db2, keepPipelines = 20) {
@@ -284796,6 +285976,7 @@ var init_pipeline_trace = __esm({
   "src/orchestrate/pipeline-trace.ts"() {
     "use strict";
     init_esm_shims();
+    init_secret_filter();
     CREATE_TABLE_SQL = `
   CREATE TABLE IF NOT EXISTS pipeline_traces (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -284805,7 +285986,11 @@ var init_pipeline_trace = __esm({
     task_id TEXT,
     agent TEXT,
     detail TEXT NOT NULL,
-    duration_ms INTEGER
+    duration_ms INTEGER,
+    attempt INTEGER,
+    risk_tier TEXT,
+    effect_key TEXT,
+    memory_refs TEXT
   )
 `;
     CREATE_INDEX_SQL = `
@@ -285568,8 +286753,140 @@ var init_permission = __esm({
   }
 });
 
+// src/orchestrate/effect-ledger.ts
+import { createHash as createHash27, randomUUID as randomUUID22 } from "crypto";
+function fingerprintEffectInput(input) {
+  if (input === void 0) return void 0;
+  try {
+    const safe = sanitizeCredentials(JSON.stringify(input));
+    return createHash27("sha256").update(safe).digest("hex").slice(0, 24);
+  } catch {
+    return void 0;
+  }
+}
+function rowToEffect(row) {
+  return {
+    id: String(row.id),
+    pipelineId: String(row.pipeline_id),
+    taskId: String(row.task_id),
+    attempt: Number(row.attempt),
+    effectKey: String(row.effect_key),
+    tool: String(row.tool),
+    riskTier: row.risk_tier,
+    replayPolicy: row.replay_policy,
+    status: row.status,
+    ...row.call_id ? { callId: String(row.call_id) } : {},
+    idempotencyKey: String(row.idempotency_key),
+    ...row.input_fingerprint ? { inputFingerprint: String(row.input_fingerprint) } : {},
+    ...row.detail ? { detail: String(row.detail) } : {},
+    startedAt: Number(row.started_at),
+    ...row.finished_at ? { finishedAt: Number(row.finished_at) } : {}
+  };
+}
+var AgentEffectLedger;
+var init_effect_ledger = __esm({
+  "src/orchestrate/effect-ledger.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_secret_filter();
+    init_permission();
+    AgentEffectLedger = class {
+      constructor(db2) {
+        this.db = db2;
+      }
+      db;
+      observe(input) {
+        const existing = this.db.prepare(`
+      SELECT * FROM agent_effects
+      WHERE pipeline_id = ? AND task_id = ? AND attempt = ? AND effect_key = ?
+    `).get(input.pipelineId, input.taskId, input.attempt, input.effectKey);
+        if (existing) return rowToEffect(existing);
+        const riskTier = classifyTool2(input.tool);
+        const replayPolicy = riskTier === "safe" ? "safe" : "requires-idempotency-key";
+        const idempotencyKey = `${input.pipelineId}:${input.taskId}:${input.attempt}:${input.effectKey}`;
+        const now3 = Date.now();
+        const record2 = {
+          id: randomUUID22(),
+          pipelineId: input.pipelineId,
+          taskId: input.taskId,
+          attempt: input.attempt,
+          effectKey: input.effectKey,
+          tool: input.tool.slice(0, 200),
+          riskTier,
+          replayPolicy,
+          status: "observed",
+          ...input.callId ? { callId: input.callId.slice(0, 200) } : {},
+          idempotencyKey,
+          ...fingerprintEffectInput(input.input) ? { inputFingerprint: fingerprintEffectInput(input.input) } : {},
+          startedAt: now3
+        };
+        this.db.prepare(`
+      INSERT OR IGNORE INTO agent_effects (
+        id, pipeline_id, task_id, attempt, effect_key, tool, risk_tier,
+        replay_policy, status, call_id, idempotency_key, input_fingerprint,
+        detail, started_at, finished_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+          record2.id,
+          record2.pipelineId,
+          record2.taskId,
+          record2.attempt,
+          record2.effectKey,
+          record2.tool,
+          record2.riskTier,
+          record2.replayPolicy,
+          record2.status,
+          record2.callId ?? null,
+          record2.idempotencyKey,
+          record2.inputFingerprint ?? null,
+          null,
+          record2.startedAt,
+          null
+        );
+        return rowToEffect(this.db.prepare(`
+      SELECT * FROM agent_effects
+      WHERE pipeline_id = ? AND task_id = ? AND attempt = ? AND effect_key = ?
+    `).get(input.pipelineId, input.taskId, input.attempt, input.effectKey));
+      }
+      settle(input) {
+        const detail = input.detail ? sanitizeCredentials(input.detail).slice(0, 500) : void 0;
+        this.db.prepare(`
+      UPDATE agent_effects
+      SET status = ?, detail = ?, finished_at = ?
+      WHERE pipeline_id = ? AND task_id = ? AND attempt = ? AND effect_key = ?
+    `).run(
+          input.status,
+          detail ?? null,
+          Date.now(),
+          input.pipelineId,
+          input.taskId,
+          input.attempt,
+          input.effectKey
+        );
+        const row = this.db.prepare(`
+      SELECT * FROM agent_effects
+      WHERE pipeline_id = ? AND task_id = ? AND attempt = ? AND effect_key = ?
+    `).get(input.pipelineId, input.taskId, input.attempt, input.effectKey);
+        return row ? rowToEffect(row) : void 0;
+      }
+      markAttemptUnknown(pipelineId, taskId, attempt) {
+        const result = this.db.prepare(`
+      UPDATE agent_effects
+      SET status = 'unknown', detail = COALESCE(detail, 'No matching tool result observed'), finished_at = ?
+      WHERE pipeline_id = ? AND task_id = ? AND attempt = ? AND status = 'observed'
+    `).run(Date.now(), pipelineId, taskId, attempt);
+        return Number(result.changes ?? 0);
+      }
+      list(pipelineId, taskId) {
+        const rows = taskId ? this.db.prepare("SELECT * FROM agent_effects WHERE pipeline_id = ? AND task_id = ? ORDER BY started_at ASC, rowid ASC").all(pipelineId, taskId) : this.db.prepare("SELECT * FROM agent_effects WHERE pipeline_id = ? ORDER BY started_at ASC, rowid ASC").all(pipelineId);
+        return rows.map(rowToEffect);
+      }
+    };
+  }
+});
+
 // src/orchestrate/memorix-bridge.ts
-import { createHash as createHash26 } from "crypto";
+import { createHash as createHash28 } from "crypto";
 async function getStoreObservation() {
   if (!_storeObservation) {
     const mod = await Promise.resolve().then(() => (init_observations(), observations_exports));
@@ -285585,7 +286902,7 @@ async function getSearchObservations() {
   return _searchObservations;
 }
 function automaticActorId(...parts) {
-  return `orchestrator:${createHash26("sha256").update(parts.join("\0")).digest("hex").slice(0, 24)}`;
+  return `orchestrator:${createHash28("sha256").update(parts.join("\0")).digest("hex").slice(0, 24)}`;
 }
 function isEligibleAutomaticLesson(entry) {
   return entry.admissionState !== "candidate" && entry.admissionState !== "ephemeral";
@@ -285732,7 +287049,7 @@ function sanitizeErrorPattern(text3) {
 }
 function hashErrorPattern(errorOutput) {
   const sanitized = sanitizeErrorPattern(errorOutput).slice(0, 500);
-  return createHash26("sha256").update(sanitized).digest("hex").slice(0, 12);
+  return createHash28("sha256").update(sanitized).digest("hex").slice(0, 12);
 }
 function sleep6(ms2) {
   return new Promise((resolve9) => setTimeout(() => resolve9([]), ms2));
@@ -285843,10 +287160,12 @@ async function runCoordinationLoop(config2) {
   const dispatchedAdapterNames = /* @__PURE__ */ new Set();
   const routingDecisions = [];
   let traceDb = null;
+  let effectLedger = null;
   try {
     traceDb = teamStore.getDb();
     resetTraceCache();
     initTraceTable(traceDb);
+    if (pipelineId) effectLedger = new AgentEffectLedger(traceDb);
   } catch {
   }
   if (useWorktrees) {
@@ -286147,6 +287466,32 @@ ${formatCostSummary(costSummary)}`);
               for await (const msg of agentProcess.messages) {
                 if (msg.type === "tool_use") {
                   dispatch.toolCount++;
+                  const effectKey = msg.callId ?? `seq:${dispatch.toolCount}`;
+                  const effect = effectLedger?.observe({
+                    pipelineId,
+                    taskId: dispatch.taskId,
+                    attempt: dispatch.attempt,
+                    effectKey,
+                    tool: msg.tool ?? "unknown",
+                    ...msg.callId ? { callId: msg.callId } : {},
+                    ...msg.input ? { input: msg.input } : {}
+                  });
+                  if (effect && traceDb && pipelineId) {
+                    try {
+                      writeTrace(traceDb, {
+                        pipelineId,
+                        timestamp: Date.now(),
+                        type: "effect",
+                        taskId: dispatch.taskId,
+                        agent: dispatch.adapterName,
+                        detail: `observed tool=${effect.tool} risk=${effect.riskTier} replay=${effect.replayPolicy} effect=${effect.effectKey}`,
+                        attempt: dispatch.attempt,
+                        riskTier: effect.riskTier,
+                        effectKey: effect.effectKey
+                      });
+                    } catch {
+                    }
+                  }
                   if (msg.tool) tracker.record(msg.tool);
                   emit("agent:tool_use", `[${adapter.name}] tool #${dispatch.toolCount}: ${msg.tool ?? "unknown"}`, {
                     taskId: task.task_id,
@@ -286166,6 +287511,16 @@ ${formatCostSummary(costSummary)}`);
                     }
                   }
                 }
+                if (msg.type === "tool_result" && msg.callId && effectLedger && pipelineId) {
+                  effectLedger.settle({
+                    pipelineId,
+                    taskId: dispatch.taskId,
+                    attempt: dispatch.attempt,
+                    effectKey: msg.callId,
+                    status: "succeeded",
+                    detail: "tool result observed"
+                  });
+                }
                 if (msg.type === "text" && msg.content) {
                   dispatch.accumulatedText += msg.content;
                 }
@@ -286248,6 +287603,9 @@ ${formatCostSummary(costSummary)}`);
           if (result.sessionId) {
             taskSessionIds.set(dispatch.taskId, result.sessionId);
           }
+          if (effectLedger && pipelineId) {
+            effectLedger.markAttemptUnknown(pipelineId, dispatch.taskId, dispatch.attempt);
+          }
           const taskState = teamStore.getTask(dispatch.taskId);
           const taskDesc = taskState?.description ?? dispatch.taskId;
           if (!result.killed && result.exitCode === 0) {
@@ -286311,6 +287669,25 @@ ${formatCostSummary(costSummary)}`);
                       for await (const msg of fixProcess.messages) {
                         if (msg.type === "tool_use") {
                           fixDispatch.toolCount++;
+                          effectLedger?.observe({
+                            pipelineId,
+                            taskId: fixDispatch.taskId,
+                            attempt: fixDispatch.attempt,
+                            effectKey: msg.callId ?? `seq:${fixDispatch.toolCount}`,
+                            tool: msg.tool ?? "unknown",
+                            ...msg.callId ? { callId: msg.callId } : {},
+                            ...msg.input ? { input: msg.input } : {}
+                          });
+                        }
+                        if (msg.type === "tool_result" && msg.callId && effectLedger && pipelineId) {
+                          effectLedger.settle({
+                            pipelineId,
+                            taskId: fixDispatch.taskId,
+                            attempt: fixDispatch.attempt,
+                            effectKey: msg.callId,
+                            status: "succeeded",
+                            detail: "tool result observed"
+                          });
                         }
                         if (msg.type === "text" && msg.content) {
                           fixDispatch.accumulatedText += msg.content;
@@ -286740,6 +288117,7 @@ var init_coordinator = __esm({
     init_cost_tracker();
     init_evidence2();
     init_permission();
+    init_effect_ledger();
     init_memorix_bridge();
   }
 });
@@ -288149,6 +289527,7 @@ function ConfigureView({ onBack }) {
     { key: "openai", label: "OpenAI", hint: "gpt-4o-mini" },
     { key: "anthropic", label: "Anthropic", hint: "claude-3-haiku" },
     { key: "openrouter", label: "OpenRouter", hint: "multi-provider" },
+    { key: "atlascloud", label: "Atlas Cloud", hint: "DeepSeek V3.2" },
     { key: "custom", label: "Custom endpoint", hint: "OpenAI-compatible" },
     { key: "disable", label: "Disable LLM", hint: "free heuristic mode", color: COLORS.warning },
     { key: "back", label: "Back", hint: "", color: COLORS.muted }
@@ -288441,6 +289820,7 @@ function ConfigureView({ onBack }) {
 function getDefaultModel(provider2) {
   if (provider2 === "anthropic") return "claude-3-haiku-20240307";
   if (provider2 === "openrouter") return "openai/gpt-4o-mini";
+  if (provider2 === "atlascloud") return "deepseek-ai/deepseek-v3.2";
   return "gpt-4o-mini";
 }
 var init_ConfigureView = __esm({
@@ -291646,10 +293026,22 @@ var GUIDES = {
   context: {
     summary: "Build the bounded task Workset used to resume or begin real work.",
     usage: [
-      'memorix context "continue the release fix" [--refresh auto|always|never]',
+      'memorix context "continue the release fix" [--task-id <continuity-id>] [--refresh auto|always|never]',
       'memorix resume "continue the release fix" [--refresh auto|always|never]'
     ]
   },
+  continuity: {
+    summary: "Track task requirements, decisions, verification, risks, and outcomes.",
+    usage: [
+      'memorix continuity start --task "Harden the release path" [--requirements "a,b"]',
+      'memorix continuity record --task-id <id> --kind decision --content "..."',
+      'memorix continuity record --task-id <id> --kind verification --verification-status passed --content "..."',
+      "memorix continuity show --task-id <id>",
+      'memorix continuity close --task-id <id> --status completed --content "..."',
+      "memorix continuity list"
+    ],
+    notes: ["Pass the returned task id to memorix context --task-id so the bounded brief includes the ledger."]
+  },
   explain: {
     summary: "Show why a task context contains its current facts and memory evidence.",
     usage: ["memorix explain [--refresh auto|always|never]"]
@@ -292058,6 +293450,7 @@ var main2 = defineCommand({
     knowledge: () => Promise.resolve().then(() => (init_knowledge(), knowledge_exports)).then((m6) => m6.default),
     evidence: () => Promise.resolve().then(() => (init_evidence(), evidence_exports)).then((m6) => m6.default),
     feedback: () => Promise.resolve().then(() => (init_feedback2(), feedback_exports2)).then((m6) => m6.default),
+    continuity: () => Promise.resolve().then(() => (init_continuity(), continuity_exports)).then((m6) => m6.default),
     reasoning: () => Promise.resolve().then(() => (init_reasoning(), reasoning_exports)).then((m6) => m6.default),
     retention: () => Promise.resolve().then(() => (init_retention2(), retention_exports2)).then((m6) => m6.default),
     formation: () => Promise.resolve().then(() => (init_formation2(), formation_exports2)).then((m6) => m6.default),
@@ -292158,6 +293551,7 @@ var main2 = defineCommand({
       "poll",
       "evidence",
       "feedback",
+      "continuity",
       "receipt",
       "serve",
       "serve-http",
@@ -292222,6 +293616,7 @@ var main2 = defineCommand({
       console.error("  knowledge  Review source-backed knowledge pages and project workflows");
       console.error("  evidence   Inspect source-backed evidence cards");
       console.error("  feedback   Record or audit memory feedback");
+      console.error("  continuity Record task requirements, decisions, verification, and outcome");
       console.error("  reasoning  Store/search decision rationale");
       console.error("  retention  Inspect stale/archive status");
       console.error("  formation  Inspect Memory Formation metrics");