memorix 1.9.5 → 1.9.6

package/dist/index.js

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