memorix 1.2.3 → 1.2.5

package/dist/index.js

@@ -35,36 +35,111 @@ var init_esm_shims = __esm({
 
 // src/store/bun-sqlite-compat.ts
 import { createRequire } from "module";
+function loadNodeSqlite() {
+  const nodeSqlite = requireFromHere("node:sqlite");
+  return nodeSqlite.DatabaseSync;
+}
+function isNativeBindingFailure(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /could not locate the bindings file|better_sqlite3\.node|module did not self-register/i.test(message);
+}
+function addCompatibility(db2) {
+  if (!db2.pragma) {
+    db2.pragma = function(pragma, options) {
+      const statement = db2.prepare(`PRAGMA ${pragma}`);
+      if (options?.simple) {
+        const result = statement.get();
+        return result ? Object.values(result)[0] : void 0;
+      }
+      return statement.all();
+    };
+  }
+  if (!db2.transaction) {
+    let depth = 0;
+    let sequence = 0;
+    db2.transaction = function(fn) {
+      return (...args) => {
+        const outermost = depth === 0;
+        const savepoint = `memorix_tx_${++sequence}`;
+        if (outermost) {
+          db2.exec("BEGIN IMMEDIATE");
+        } else {
+          db2.exec(`SAVEPOINT ${savepoint}`);
+        }
+        depth += 1;
+        try {
+          const result = fn(...args);
+          if (result && typeof result.then === "function") {
+            throw new Error("[memorix] SQLite transactions must be synchronous");
+          }
+          depth -= 1;
+          if (outermost) {
+            db2.exec("COMMIT");
+          } else {
+            db2.exec(`RELEASE SAVEPOINT ${savepoint}`);
+          }
+          return result;
+        } catch (error) {
+          depth -= 1;
+          try {
+            if (outermost) {
+              db2.exec("ROLLBACK");
+            } else {
+              db2.exec(`ROLLBACK TO SAVEPOINT ${savepoint}`);
+              db2.exec(`RELEASE SAVEPOINT ${savepoint}`);
+            }
+          } catch {
+          }
+          throw error;
+        }
+      };
+    };
+  }
+  return db2;
+}
+function instantiateDatabase(Sqlite, filePath, options) {
+  return driver === "node:sqlite" && options === void 0 ? new Sqlite(filePath) : new Sqlite(filePath, options);
+}
 function loadSqlite() {
   if (Database) return Database;
+  if (process.env.MEMORIX_SQLITE_DRIVER === "node") {
+    Database = loadNodeSqlite();
+    driver = "node:sqlite";
+    return Database;
+  }
   try {
     Database = requireFromHere("better-sqlite3");
+    driver = "better-sqlite3";
+    return Database;
+  } catch {
+  }
+  try {
+    Database = loadNodeSqlite();
+    driver = "node:sqlite";
     return Database;
   } catch {
   }
   try {
     const bunSqlite = requireFromHere("bun:sqlite");
     Database = bunSqlite.Database;
+    driver = "bun:sqlite";
     return Database;
   } catch {
-    throw new Error("[memorix] Neither better-sqlite3 nor bun:sqlite is available");
+    throw new Error("[memorix] SQLite is unavailable (better-sqlite3, node:sqlite, and bun:sqlite failed)");
   }
 }
 function createDatabase(path25, options) {
   const Sqlite = loadSqlite();
-  const db2 = new Sqlite(path25, options);
-  if (!db2.pragma) {
-    db2.pragma = function(pragma, options2) {
-      if (options2 && options2.simple) {
-        const result = db2.prepare(`PRAGMA ${pragma}`).get();
-        return result ? Object.values(result)[0] : void 0;
-      }
-      return db2.prepare(`PRAGMA ${pragma}`).all();
-    };
+  try {
+    return addCompatibility(instantiateDatabase(Sqlite, path25, options));
+  } catch (error) {
+    if (driver !== "better-sqlite3" || !isNativeBindingFailure(error)) throw error;
+    Database = loadNodeSqlite();
+    driver = "node:sqlite";
+    return addCompatibility(instantiateDatabase(Database, path25, options));
   }
-  return db2;
 }
-var Database, requireFromHere;
+var Database, driver, requireFromHere;
 var init_bun_sqlite_compat = __esm({
   "src/store/bun-sqlite-compat.ts"() {
     "use strict";
@@ -83,7 +158,7 @@ function loadBetterSqlite3() {
     BetterSqlite3 = loadSqlite();
     return BetterSqlite3;
   } catch {
-    throw new Error("[memorix] SQLite is not available (neither better-sqlite3 nor bun:sqlite)");
+    throw new Error("[memorix] SQLite is not available (better-sqlite3, node:sqlite, and bun:sqlite all failed)");
   }
 }
 function hasColumn(db2, table, column) {
@@ -1886,7 +1961,16 @@ function truncateToTokenBudget(text, budget) {
       result = result.slice(0, Math.floor(result.length * 0.9));
     }
     if (result.length < text.length) {
-      result += "...";
+      const nextCharacter = text.charAt(result.length);
+      if (nextCharacter && !/[\s.,;:!?)}\]]/.test(nextCharacter)) {
+        const boundary = result.search(/\s+\S*$/);
+        result = boundary > 0 ? result.slice(0, boundary).trimEnd() : "";
+      }
+      while (result && fitsInBudget(result + "...", budget) === false) {
+        const boundary = result.lastIndexOf(" ");
+        result = boundary > 0 ? result.slice(0, boundary).trimEnd() : "";
+      }
+      result = result ? result + "..." : "...";
     }
   }
   return result;
@@ -2591,6 +2675,9 @@ function parseTomlValue(raw, filePath, line) {
   if (raw.startsWith('"') && raw.endsWith('"')) {
     return raw.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, "\\");
   }
+  if (raw.startsWith("'") && raw.endsWith("'")) {
+    return raw.slice(1, -1);
+  }
   if (raw === "true") return true;
   if (raw === "false") return false;
   if (/^-?\d+$/.test(raw)) return Number.parseInt(raw, 10);
@@ -2603,7 +2690,7 @@ function parseTomlValue(raw, filePath, line) {
   throw new Error(`Unsupported TOML value in ${filePath}:${line}`);
 }
 function stripComment(line) {
-  let inString = false;
+  let quote = null;
   let escaped = false;
   for (let i = 0; i < line.length; i++) {
     const char = line[i];
@@ -2611,15 +2698,16 @@ function stripComment(line) {
       escaped = false;
       continue;
     }
-    if (char === "\\" && inString) {
+    if (char === "\\" && quote === '"') {
       escaped = true;
       continue;
     }
-    if (char === '"') {
-      inString = !inString;
+    if (char === '"' || char === "'") {
+      if (quote === char) quote = null;
+      else if (quote === null) quote = char;
       continue;
     }
-    if (char === "#" && !inString) {
+    if (char === "#" && quote === null) {
       return line.slice(0, i);
     }
   }
@@ -2715,6 +2803,25 @@ function getResolvedConfig(options = {}) {
   const legacy = loadFileConfig();
   const embeddingBaseUrl = first(process.env.MEMORIX_EMBEDDING_BASE_URL, toml.embedding?.base_url, yaml2.embedding?.baseUrl, legacy.embeddingApi?.baseUrl);
   const openRouterEmbeddingApiKey = isOpenRouterUrl(embeddingBaseUrl) ? process.env.OPENROUTER_API_KEY : void 0;
+  const memoryLlmProvider = first(
+    process.env.MEMORIX_LLM_PROVIDER,
+    toml.memory?.llm?.provider,
+    yaml2.llm?.provider,
+    legacy.llm?.provider
+  );
+  const memoryLlmModel = first(
+    process.env.MEMORIX_LLM_MODEL,
+    toml.memory?.llm?.model,
+    yaml2.llm?.model,
+    legacy.llm?.model
+  );
+  const memoryLlmBaseUrl = first(
+    process.env.MEMORIX_LLM_BASE_URL,
+    toml.memory?.llm?.base_url,
+    yaml2.llm?.baseUrl,
+    legacy.llm?.baseUrl
+  );
+  const openRouterMemoryLlmApiKey = isOpenRouterMemoryLane(memoryLlmProvider, memoryLlmBaseUrl) ? process.env.OPENROUTER_API_KEY : void 0;
   const resolved = {
     agent: {
       provider: first(
@@ -2752,9 +2859,9 @@ function getResolvedConfig(options = {}) {
       autoCleanup: firstBool(toml.memory?.auto_cleanup, yaml2.behavior?.autoCleanup),
       syncAdvisory: firstBool(toml.memory?.sync_advisory, yaml2.behavior?.syncAdvisory),
       llm: {
-        provider: first(process.env.MEMORIX_LLM_PROVIDER, toml.memory?.llm?.provider, yaml2.llm?.provider, legacy.llm?.provider),
-        model: first(process.env.MEMORIX_LLM_MODEL, toml.memory?.llm?.model, yaml2.llm?.model, legacy.llm?.model),
-        baseUrl: first(process.env.MEMORIX_LLM_BASE_URL, toml.memory?.llm?.base_url, yaml2.llm?.baseUrl, legacy.llm?.baseUrl),
+        provider: memoryLlmProvider,
+        model: memoryLlmModel,
+        baseUrl: memoryLlmBaseUrl,
         apiKey: first(
           process.env.MEMORIX_LLM_API_KEY,
           process.env.MEMORIX_API_KEY,
@@ -2763,7 +2870,7 @@ function getResolvedConfig(options = {}) {
           legacy.llm?.apiKey,
           process.env.OPENAI_API_KEY,
           process.env.ANTHROPIC_API_KEY,
-          process.env.OPENROUTER_API_KEY
+          openRouterMemoryLlmApiKey
         )
       }
     },
@@ -2900,6 +3007,9 @@ function isOpenRouterUrl(value) {
     return /(^|\.)openrouter\.ai(?::|\/|$)/i.test(value);
   }
 }
+function isOpenRouterMemoryLane(provider2, baseUrl) {
+  return provider2?.trim().toLowerCase() === "openrouter" || isOpenRouterUrl(baseUrl);
+}
 function normalizeExternalContext(value) {
   const normalized = value?.trim().toLowerCase();
   if (normalized === "auto" || normalized === "off") return normalized;
@@ -4947,6 +5057,29 @@ Rules:
   }
 });
 
+// src/timeout.ts
+function withTimeout(promise, ms, label) {
+  return new Promise((resolve2, reject) => {
+    const timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve2(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
+var init_timeout = __esm({
+  "src/timeout.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // src/project/aliases.ts
 var aliases_exports = {};
 __export(aliases_exports, {
@@ -5712,8 +5845,12 @@ async function searchObservations(options) {
     }
   };
   const modeKey = options.projectId ?? SEARCH_MODE_DEFAULT_KEY;
-  lastSearchModeByProject.set(modeKey, embeddingEnabled ? "hybrid" : "fulltext");
+  const quality = options.quality ?? "balanced";
   const database = await getDb();
+  lastSearchModeByProject.set(
+    modeKey,
+    quality === "fast" ? "fulltext (fast profile)" : embeddingEnabled ? "hybrid" : "fulltext"
+  );
   let projectIds = null;
   if (options.projectId) {
     try {
@@ -5735,11 +5872,15 @@ async function searchObservations(options) {
   }
   const hasQuery = options.query && options.query.trim().length > 0;
   const originalQuery = options.query;
-  const tier = hasQuery ? classifyQueryTier(originalQuery) : "fast";
+  const tier = quality === "fast" ? "fast" : hasQuery ? classifyQueryTier(originalQuery) : "fast";
   mark(`tier=${tier}`);
-  const expandedEmbeddingQuery = tier === "heavy" ? await maybeExpandSearchQuery(options.query) : options.query;
+  if (quality === "thorough" && hasQuery) {
+    const { initLLM: initLLM2, isLLMEnabled: isLLMEnabled2 } = await Promise.resolve().then(() => (init_provider2(), provider_exports2));
+    if (!isLLMEnabled2()) initLLM2();
+  }
+  const expandedEmbeddingQuery = quality === "thorough" && tier === "heavy" ? await maybeExpandSearchQuery(options.query) : options.query;
   mark("queryExpansion");
-  const intentResult = hasQuery ? detectQueryIntent(originalQuery) : null;
+  const intentResult = quality === "fast" || !hasQuery ? null : detectQueryIntent(originalQuery);
   const requestLimit = projectIds ? (options.limit ?? 20) * 3 : options.limit ?? 20;
   const defaultBoost = {
     title: 3,
@@ -5753,17 +5894,21 @@ async function searchObservations(options) {
   let searchParams = {
     term: originalQuery,
     limit: requestLimit,
-    includeVectors: true,
+    // Fast search never uses vectors, so returning them only adds work and
+    // payload pressure to an explicitly latency-sensitive path.
+    includeVectors: quality !== "fast",
     ...Object.keys(filters).length > 0 ? { where: filters } : {},
     // Search specific fields (not tokens, accessCount, etc.)
     properties: ["title", "entityName", "narrative", "facts", "concepts", "filesModified"],
     // Field boosting: intent-aware or default
     boost: fieldBoost,
     // Fuzzy tolerance: allow 1-char typos for short queries, 2 for longer
-    ...hasQuery ? { tolerance: originalQuery.length > 6 ? 2 : 1 } : {}
+    // Fuzzy matching is useful for ordinary recall, but grows sharply with
+    // corpus size. The fast profile deliberately uses exact lexical matching.
+    ...hasQuery && quality !== "fast" ? { tolerance: originalQuery.length > 6 ? 2 : 1 } : {}
   };
   let queryVector = null;
-  if (embeddingEnabled && hasQuery && tier !== "fast") {
+  if (quality !== "fast" && embeddingEnabled && hasQuery && tier !== "fast") {
     try {
       const provider2 = await getEmbeddingProvider();
       if (provider2) {
@@ -5778,11 +5923,11 @@ async function searchObservations(options) {
           );
         } else {
           const EMBEDDING_TIMEOUT_MS = 15e3;
-          const embedPromise = provider2.embed(expandedEmbeddingQuery);
-          const timeoutPromise = new Promise(
-            (_, reject) => setTimeout(() => reject(new Error(`Embedding timeout after ${EMBEDDING_TIMEOUT_MS}ms`)), EMBEDDING_TIMEOUT_MS)
+          queryVector = await withTimeout(
+            provider2.embed(expandedEmbeddingQuery),
+            EMBEDDING_TIMEOUT_MS,
+            "Embedding"
           );
-          queryVector = await Promise.race([embedPromise, timeoutPromise]);
           mark("embedding");
           const cjkRatio = (originalQuery.match(/[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/g) || []).length / originalQuery.length;
           const isCJKHeavy = cjkRatio > 0.3;
@@ -6023,7 +6168,7 @@ async function searchObservations(options) {
       }
     }
   }
-  const shouldRerank = tier === "heavy" && hasQuery && intermediate.length > 2 && (() => {
+  const shouldRerank = quality === "thorough" && tier === "heavy" && hasQuery && intermediate.length > 2 && (() => {
     const top = intermediate[0]?.score ?? 0;
     const second = intermediate[1]?.score ?? 0;
     return top > 0 && second / top > 0.7;
@@ -6047,11 +6192,11 @@ async function searchObservations(options) {
       }));
       const _parsedRerank = parseInt(process.env.MEMORIX_RERANK_TIMEOUT_MS || "", 10);
       const RERANK_TIMEOUT_MS = Number.isFinite(_parsedRerank) && _parsedRerank > 0 ? _parsedRerank : 5e3;
-      const rerankPromise = rerankResults2(originalQuery, candidates);
-      const timeoutPromise = new Promise(
-        (_, reject) => setTimeout(() => reject(new Error(`LLM rerank timeout after ${RERANK_TIMEOUT_MS}ms`)), RERANK_TIMEOUT_MS)
+      const { reranked, usedLLM } = await withTimeout(
+        rerankResults2(originalQuery, candidates),
+        RERANK_TIMEOUT_MS,
+        "LLM rerank"
       );
-      const { reranked, usedLLM } = await Promise.race([rerankPromise, timeoutPromise]);
       mark(`rerank(usedLLM=${usedLLM})`);
       if (usedLLM) {
         lastSearchModeByProject.set(modeKey, (lastSearchModeByProject.get(modeKey) ?? "fulltext") + " + LLM rerank");
@@ -6243,6 +6388,7 @@ var init_orama_store = __esm({
     init_project_affinity();
     init_intent_detector();
     init_query_expansion();
+    init_timeout();
     db = null;
     dbInitPromise = null;
     dbGeneration = 0;
@@ -13691,6 +13837,7 @@ var init_workflow_store = __esm({
 var task_lens_exports = {};
 __export(task_lens_exports, {
   containsTaskKeyword: () => containsTaskKeyword,
+  isContinuationTask: () => isContinuationTask,
   lensPathCandidates: () => lensPathCandidates,
   lensVerificationHints: () => lensVerificationHints,
   rankLensPaths: () => rankLensPaths,
@@ -13756,6 +13903,12 @@ function resolveTaskLens(task) {
   }
   return best.score > 0 ? LENSES[best.id] : LENSES.general;
 }
+function isContinuationTask(task) {
+  const normalized = (task ?? "").trim().toLowerCase();
+  return normalized.length > 0 && CONTINUATION_KEYWORDS.some(
+    (keyword) => containsTaskKeyword(normalized, keyword)
+  );
+}
 function pathKindScore(path25, lens) {
   const normalized = normalizePath2(path25).toLowerCase();
   const name = normalized.split("/").pop() ?? normalized;
@@ -13899,7 +14052,7 @@ function shouldShowLensSource(source, lens, task) {
   if (lens.id === "onboarding" || lens.id === "release" || lens.id === "docs") return score >= 40;
   return score > 0;
 }
-var STOP_WORDS, LENSES, KEYWORDS, LENS_PRIORITY;
+var STOP_WORDS, LENSES, KEYWORDS, CONTINUATION_KEYWORDS, LENS_PRIORITY;
 var init_task_lens = __esm({
   "src/codegraph/task-lens.ts"() {
     "use strict";
@@ -14002,6 +14155,7 @@ var init_task_lens = __esm({
         "fail",
         "failing",
         "fix",
+        "fixing",
         "issue",
         "regression",
         "repro",
@@ -14019,6 +14173,18 @@ var init_task_lens = __esm({
       docs: ["doc", "docs", "readme", "\u6587\u6863", "\u8BF4\u660E"],
       test: ["coverage", "fixture", "smoke", "spec", "test", "tests", "testing", "vitest", "\u6D4B\u8BD5"]
     };
+    CONTINUATION_KEYWORDS = [
+      "continue",
+      "resume",
+      "pick up",
+      "carry on",
+      "previous session",
+      "\u7EE7\u7EED",
+      "\u63A5\u624B",
+      "\u6062\u590D",
+      "\u5EF6\u7EED",
+      "\u4E0A\u6B21\u4F1A\u8BDD"
+    ];
     LENS_PRIORITY = [
       "bugfix",
       "release",
@@ -14747,21 +14913,6 @@ async function loadWorkspaceForMaintenance(projectId, projectDir2, mode) {
   ]);
   return versioned ?? local;
 }
-function withTimeout(promise, ms, label) {
-  return new Promise((resolve2, reject) => {
-    const timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
-    promise.then(
-      (value) => {
-        clearTimeout(timer);
-        resolve2(value);
-      },
-      (error) => {
-        clearTimeout(timer);
-        reject(error);
-      }
-    );
-  });
-}
 async function runAutomaticConsolidation(projectId, projectDir2, options) {
   const { isLLMEnabled: isLLMEnabled2 } = await Promise.resolve().then(() => (init_provider2(), provider_exports2));
   if (!isLLMEnabled2()) {
@@ -15146,6 +15297,7 @@ var init_project_maintenance = __esm({
     init_esm_shims();
     init_isolated_maintenance();
     init_lifecycle();
+    init_timeout();
     DEFAULT_VECTOR_BATCH_SIZE = 12;
     DEFAULT_RETENTION_BATCH_SIZE = 100;
     DEFAULT_CONSOLIDATION_BATCH_SIZE = 200;
@@ -15229,6 +15381,7 @@ __export(session_exports, {
   endSession: () => endSession,
   getActiveSession: () => getActiveSession,
   getSessionContext: () => getSessionContext,
+  getSessionResumeBrief: () => getSessionResumeBrief,
   listSessions: () => listSessions,
   scoreObservationForSessionContext: () => scoreObservationForSessionContext,
   startSession: () => startSession
@@ -15296,6 +15449,62 @@ function isSystemSelfObservation(obs) {
   const text = stringifyObservation(obs, false);
   return SYSTEM_SELF_PATTERNS.some((pattern) => pattern.test(text));
 }
+function readerForAlias(reader, aliases, observation) {
+  if (!reader) return void 0;
+  return reader.projectId && aliases.has(observation.projectId) ? { ...reader, projectId: observation.projectId } : reader;
+}
+function readableAliasObservations(observations2, aliases, reader) {
+  return reader ? observations2.filter((observation) => canReadObservation(
+    observation,
+    readerForAlias(reader, aliases, observation)
+  )) : observations2;
+}
+function isUsefulSessionSummary(summary) {
+  return Boolean(summary) && !NOISE_PATTERNS2.some((pattern) => pattern.test(summary)) && !SYSTEM_SELF_PATTERNS.some((pattern) => pattern.test(summary));
+}
+function continuationTaskTokens(task) {
+  return [...new Set(
+    (task?.toLowerCase().match(/[a-z0-9_./-]+|[\u4e00-\u9fff]+/g) ?? []).map((token) => token.trim()).filter((token) => token.length > 1 && !["continue", "resume", "\u7EE7\u7EED", "\u63A5\u624B", "\u6062\u590D"].includes(token))
+  )].slice(0, 8);
+}
+function continuationScore(observation, projectTokens, task) {
+  let score = scoreObservationForSessionContext(observation, projectTokens);
+  if (observation.type === "session-request" || observation.type === "what-changed") score += 1;
+  const text = stringifyObservation(observation);
+  const matches = continuationTaskTokens(task).filter((token) => text.includes(token)).length;
+  score += Math.min(matches, 2) * 2;
+  return score;
+}
+async function getSessionResumeBrief(projectId, task, reader) {
+  const aliasSet = await resolveProjectIds(projectId);
+  const [sessions, allObs] = await Promise.all([
+    loadAliasSessions(aliasSet),
+    loadAliasActiveObservations(aliasSet)
+  ]);
+  const readableObs = readableAliasObservations(allObs, aliasSet, reader);
+  const previous = sessions.filter((session) => session.status === "completed").sort((a, b) => new Date(b.endedAt || b.startedAt).getTime() - new Date(a.endedAt || a.startedAt).getTime()).find((session) => session.summary && session.summary !== "(session ended implicitly by new session start)" && isUsefulSessionSummary(session.summary));
+  const projectTokens = tokenizeProjectId(projectId);
+  const memories = readableObs.filter((observation) => RESUME_TYPES.has(observation.type)).filter((observation) => classifyLayer(observation) === "L2").filter((observation) => !isNoiseObservation(observation) && !isSystemSelfObservation(observation)).map((observation) => ({
+    observation,
+    score: continuationScore(observation, projectTokens, task)
+  })).sort((a, b) => b.score - a.score || new Date(b.observation.createdAt).getTime() - new Date(a.observation.createdAt).getTime() || a.observation.id - b.observation.id).slice(0, 3).map(({ observation }) => ({
+    id: observation.id,
+    title: sanitizeCredentials(observation.title),
+    type: observation.type,
+    ...observation.facts?.[0] ? { detail: sanitizeCredentials(observation.facts[0]) } : observation.narrative ? { detail: sanitizeCredentials(observation.narrative) } : {}
+  }));
+  return {
+    ...previous?.summary ? {
+      previousSession: {
+        id: previous.id,
+        ...previous.agent ? { agent: previous.agent } : {},
+        ...previous.endedAt ? { endedAt: previous.endedAt } : {},
+        summary: sanitizeCredentials(previous.summary)
+      }
+    } : {},
+    memories
+  };
+}
 function scoreObservationForSessionContext(obs, projectTokens, now3 = Date.now()) {
   let score = TYPE_WEIGHTS2[obs.type] ?? 1;
   const text = stringifyObservation(obs);
@@ -15366,10 +15575,7 @@ async function getSessionContext(projectDir2, projectId, limit = 3, reader) {
     loadAliasSessions(aliasSet),
     loadAliasActiveObservations(aliasSet)
   ]);
-  const readableObs = reader ? allObs.filter((observation) => {
-    const observationReader = reader.projectId && aliasSet.has(observation.projectId) ? { ...reader, projectId: observation.projectId } : reader;
-    return canReadObservation(observation, observationReader);
-  }) : allObs;
+  const readableObs = readableAliasObservations(allObs, aliasSet, reader);
   const isNoisySummary = (summary) => {
     if (!summary) return false;
     return NOISE_PATTERNS2.some((p) => p.test(summary)) || SYSTEM_SELF_PATTERNS.some((p) => p.test(summary));
@@ -15520,7 +15726,7 @@ async function getActiveSession(projectDir2, projectId) {
   const sessions = await loadAliasActiveSessions(aliasSet);
   return sessions.sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime())[0] ?? null;
 }
-var PRIORITY_TYPES, TYPE_EMOJI, TYPE_WEIGHTS2, NOISE_PATTERNS2, COMMAND_TRACE_PATTERNS, SYSTEM_SELF_PATTERNS;
+var PRIORITY_TYPES, RESUME_TYPES, TYPE_EMOJI, TYPE_WEIGHTS2, NOISE_PATTERNS2, COMMAND_TRACE_PATTERNS, SYSTEM_SELF_PATTERNS;
 var init_session = __esm({
   "src/memory/session.ts"() {
     "use strict";
@@ -15534,6 +15740,17 @@ var init_session = __esm({
     init_secret_filter();
     init_visibility();
     PRIORITY_TYPES = /* @__PURE__ */ new Set(["gotcha", "decision", "problem-solution", "trade-off", "discovery"]);
+    RESUME_TYPES = /* @__PURE__ */ new Set([
+      "gotcha",
+      "decision",
+      "problem-solution",
+      "trade-off",
+      "discovery",
+      "how-it-works",
+      "what-changed",
+      "reasoning",
+      "session-request"
+    ]);
     TYPE_EMOJI = {
       "gotcha": "[DISCOVERY]",
       "decision": "[WHY]",
@@ -15694,6 +15911,7 @@ function freshnessForMemory(status) {
   return "unknown";
 }
 function receiptOmissionKind(raw) {
+  if (raw.includes("continuation")) return "continuation";
   if (raw.includes("task")) return "task";
   if (raw.includes("fact")) return "current-fact";
   if (raw.includes("state")) return "code-state";
@@ -15743,6 +15961,48 @@ function renderTaskWorksetPrompt(input) {
     trust: "source-backed"
   });
   appendLine(lines, "Task lens: " + input.lens, maxTokens, omitted, "lens");
+  const hasContinuation = Boolean(
+    input.continuation?.previousSession || (input.continuation?.memories.length ?? 0) > 0
+  );
+  if (hasContinuation && input.continuation) {
+    appendLine(lines, "", maxTokens, omitted, "continuation-heading");
+    appendLine(lines, "Resume from prior work", maxTokens, omitted, "continuation-heading");
+    if (input.continuation.previousSession) {
+      const session = input.continuation.previousSession;
+      const source = [session.agent, session.endedAt ? session.endedAt.slice(0, 10) : void 0].filter(Boolean).join(", ");
+      appendLine(
+        lines,
+        "- Previous session" + (source ? ` (${source})` : "") + ": " + short(session.summary, 44),
+        maxTokens,
+        omitted,
+        "continuation-session",
+        selected,
+        {
+          kind: "continuation",
+          id: "session:" + session.id,
+          reason: "latest meaningful project session summary",
+          trust: "historical"
+        }
+      );
+    }
+    for (const memory of input.continuation.memories.slice(0, 3)) {
+      const detail = memory.detail ? ": " + short(memory.detail, CONTINUATION_DETAIL_TOKEN_BUDGET) : "";
+      appendLine(
+        lines,
+        "- #" + memory.id + " " + memory.type + ": " + short(memory.title, 18) + detail,
+        maxTokens,
+        omitted,
+        "continuation-memory",
+        selected,
+        {
+          kind: "continuation",
+          id: "memory:" + memory.id,
+          reason: "durable prior-work memory",
+          trust: "historical"
+        }
+      );
+    }
+  }
   if (input.cautions.length > 0 || input.cautionMemory.length > 0) {
     appendLine(lines, "", maxTokens, omitted, "caution-heading");
     appendLine(lines, "Cautions", maxTokens, omitted, "caution-heading");
@@ -16011,11 +16271,25 @@ async function buildTaskWorkset(input) {
     ...input.verificationHints
   ]).slice(0, 4);
   const normalizedCautions = unique(cautions.map((caution) => caution.kind)).map((kind) => cautions.find((caution) => caution.kind === kind)).slice(0, 6);
+  const continuation = input.continuation && (input.continuation.previousSession || input.continuation.memories.length > 0) ? {
+    ...input.continuation.previousSession ? {
+      previousSession: {
+        ...input.continuation.previousSession,
+        summary: short(input.continuation.previousSession.summary, 52)
+      }
+    } : {},
+    memories: input.continuation.memories.slice(0, 3).map((memory) => ({
+      ...memory,
+      title: short(memory.title, 20),
+      ...memory.detail ? { detail: short(memory.detail, CONTINUATION_DETAIL_TOKEN_BUDGET) } : {}
+    }))
+  } : void 0;
   const base = {
     version: "1.2",
     task,
     lens: input.lens,
     currentFacts: input.currentFacts?.map((fact) => fact.startsWith("Historical note:") ? short(fact, 48) : short(fact, 28)).slice(0, 4) ?? [],
+    ...continuation ? { continuation } : {},
     ...input.codeState ? { codeState: short(input.codeState, 28) } : {},
     startHere: unique(input.startHere).slice(0, 5),
     ...input.semanticCode ? { semanticCode: input.semanticCode } : {},
@@ -16040,7 +16314,7 @@ async function buildTaskWorkset(input) {
     budget: { maxTokens }
   });
   const receipt = {
-    version: "1.2.2",
+    version: "1.2.4",
     target: input.deliveryTarget ?? "project-context",
     elapsedMs: Math.max(0, Date.now() - startedAt),
     budget: {
@@ -16062,6 +16336,7 @@ async function buildTaskWorkset(input) {
     prompt: rendered.prompt
   };
 }
+var CONTINUATION_DETAIL_TOKEN_BUDGET;
 var init_workset = __esm({
   "src/knowledge/workset.ts"() {
     "use strict";
@@ -16074,6 +16349,7 @@ var init_workset = __esm({
     init_workspace();
     init_workflow_store();
     init_workflows();
+    CONTINUATION_DETAIL_TOKEN_BUDGET = 20;
   }
 });
 
@@ -16866,6 +17142,7 @@ async function buildAutoProjectContext(input) {
   const now3 = input.now ?? /* @__PURE__ */ new Date();
   const task = input.task?.trim();
   const lens = resolveTaskLens(task);
+  const continuationRequested = input.continuation === "always" || input.continuation !== "never" && isContinuationTask(task);
   const codegraphConfig = getResolvedConfig({ projectRoot: input.project.rootPath }).codegraph;
   const exclude = input.exclude ?? codegraphConfig.excludePatterns;
   const maxFileBytes = input.maxFileBytes ?? codegraphConfig.maxFileBytes;
@@ -17002,6 +17279,11 @@ async function buildAutoProjectContext(input) {
   if (externalCaution) {
     runtimeCautions.push({ kind: "external-codegraph-fallback", message: externalCaution });
   }
+  let continuation;
+  if (continuationRequested) {
+    await initSessionStore(input.dataDir);
+    continuation = await getSessionResumeBrief(input.project.id, task, input.reader);
+  }
   const workset = await buildTaskWorkset({
     projectId: input.project.id,
     dataDir: input.dataDir,
@@ -17011,6 +17293,7 @@ async function buildAutoProjectContext(input) {
     ...externalOutline ? { semanticCode: externalOutline } : {},
     providerQuality: providerQuality2,
     currentFacts: worksetFactLines(currentFacts),
+    ...continuation ? { continuation } : {},
     codeState: codeStateLine(overview),
     reliableMemory: sourceSets.reliableSources.slice(0, lens.sourceLimit).map((source) => ({
       id: source.observationId,
@@ -17055,12 +17338,19 @@ async function buildAutoProjectContext(input) {
     explain,
     refresh,
     providerQuality: providerQuality2,
+    ...continuationRequested && workset.continuation ? { continuation: workset.continuation } : {},
     workset
   };
 }
 function formatLanguages(overview) {
   return overview.code.languages.length > 0 ? overview.code.languages.map((item) => `${item.language} ${item.files}`).join(", ") : "none indexed yet";
 }
+function compactContinuationText(text, budget) {
+  return truncateToTokenBudget(
+    sanitizeCredentials(text).replace(/\s+/g, " ").trim(),
+    budget
+  );
+}
 function codeStateLine(overview) {
   const snapshot = overview.code.latestSnapshot;
   if (!snapshot) return "- Code state: no completed snapshot yet";
@@ -17200,6 +17490,23 @@ function formatAutoProjectContextSummary(context) {
     "Reliable memory",
     reliableSources.length > 0 ? `- ${reliableSources.length} current code-bound memory link(s)` : "- none yet"
   );
+  const continuation = context.workset.continuation;
+  if (continuation?.previousSession || continuation?.memories.length) {
+    lines.push("", "Resume from prior work");
+    if (continuation.previousSession) {
+      const session = continuation.previousSession;
+      const source = [session.agent, session.endedAt ? session.endedAt.slice(0, 10) : void 0].filter(Boolean).join(", ");
+      lines.push(
+        "- Previous session" + (source ? ` (${source})` : "") + ": " + compactContinuationText(session.summary, 44)
+      );
+    }
+    for (const memory of continuation.memories.slice(0, 3)) {
+      const detail = memory.detail ? ": " + compactContinuationText(memory.detail, 20) : "";
+      lines.push(
+        "- #" + memory.id + " " + memory.type + ": " + compactContinuationText(memory.title, 18) + detail
+      );
+    }
+  }
   return lines.join("\n");
 }
 function formatAutoProjectContextPrompt(context) {
@@ -17270,8 +17577,10 @@ var init_auto_context = __esm({
   "src/codegraph/auto-context.ts"() {
     "use strict";
     init_esm_shims();
+    init_token_budget();
     init_resolved_config();
     init_workset();
+    init_secret_filter();
     init_binder();
     init_current_facts();
     init_lite_provider();
@@ -17279,6 +17588,8 @@ var init_auto_context = __esm({
     init_project_context();
     init_store();
     init_admission();
+    init_session();
+    init_session_store();
     init_task_lens();
     DEFAULT_MAX_AGE_MS = 10 * 60 * 1e3;
   }
@@ -21473,7 +21784,8 @@ var init_official_skills = __esm({
           "",
           "| Situation | Prefer | CLI fallback |",
           "|---|---|---|",
-          '| Starting or continuing a coding task and needing the best task-lensed project map | `memorix_project_context` with the user\'s task | `memorix context --task "<task>"` |',
+          '| Starting a coding task and needing the best task-lensed project map | `memorix_project_context` with the user\'s task | `memorix context "<task>" --json` |',
+          '| Continuing prior project work | `memorix_project_context` with the user\'s task | `memorix resume "<task>" --json` |',
           '| Need structured refs/freshness for code-bound memories | `memorix_context_pack` | `memorix codegraph context-pack --task "<topic>"` |',
           '| Explicit memory graph question | `memorix_graph_context` | `memorix memory graph-context --query "<topic>"` |',
           '| Specific past decision, bug, file, or change | `memorix_search` | `memorix memory search --query "<topic>"` |',
@@ -21486,9 +21798,10 @@ var init_official_skills = __esm({
           "",
           "- Default first step for non-trivial coding work: call `memorix_project_context` before progress files, dev-log reads, ad-hoc file reads, or git archaeology. Pass the user's actual task so Memorix can choose a bugfix, feature, release, onboarding, refactor, docs, test, or general brief. Start by reading its suggested files.",
           "- In Claude Code headless/print-mode, an initial MCP `pending` status is not a failure by itself. Prefer MCP first: use the client's tool discovery/dynamic loading to find `memorix_project_context` when it is not in the first visible tool list.",
-          '- Run `memorix context --task "<task>"` from the shell only after MCP is unavailable, disabled, or not discoverable, and pass the user\'s real task text. Do not skip memory, wait indefinitely on `pending`, or hand-write tool-call syntax.',
-          "- Use `memorix_search` for a specific decision, bug, file, or prior change that the project context did not answer.",
-          "- Fetch detail before relying on a specific memory.",
+          '- Continuation fallback is mandatory: when the user asks to continue, resume, take over, or explain prior work and MCP cannot be called in this turn, run `memorix resume "<task>" --json` exactly once before inspecting files, Git history, progress notes, or guessing. The absence of `.memorix` or visible memory files never proves project memory is empty. For a new task, use `memorix context "<task>" --json` instead. If that one command fails, report it and proceed normally; do not probe help, enumerate commands, or chain broad searches.',
+          "- After a successful `memorix_project_context`, the brief is the default retrieval boundary. Do not call more Memorix retrieval tools after a complete brief. Use Context Pack, search, or detail only when the brief lacks a specific reference, freshness field, or fact needed for the task, or when the user explicitly asks for deeper history. In MCP, name that missing fact in `purpose` when intentionally expanding beyond the brief. Do not retrieve the same decision twice just to confirm an already-complete brief.",
+          "- If the user asks for read-only work or says not to modify files, do not call `memorix_store` just to record an assessment. Store only when the user explicitly asks to preserve it.",
+          "- Use `memorix_search` for a specific decision, bug, file, or prior change that the project context did not answer. Fetch detail only for a result you still need after the brief.",
           "- Treat current code-bound memory as a map. Treat stale, suspect, or unbound memory as a lead that must be verified against the current code.",
           "- Skip memory lookup for greetings, tiny one-off edits, or questions fully answered by the current file.",
           "- If a fresh project has no memories, proceed normally and do not repeat the same empty search in the same turn.",
@@ -22709,17 +23022,18 @@ alwaysApply: true
     "",
     "## Start with Memory Autopilot",
     "",
-    `Default first step for non-trivial coding work: call \`memorix_project_context\` with the user's actual task before progress files, dev-log reads, ad-hoc file reads, or git archaeology. Memorix will choose a task-lensed brief (bugfix, feature, release, onboarding, refactor, docs, test, or general). Treat its "Start here" files as the first ${contextNoun} files to inspect.`,
+    `Default first step for non-trivial coding work: call \`memorix_project_context\` with the user's actual task before progress files, dev-log reads, ad-hoc file reads, or git archaeology. Memorix will choose a task-lensed brief (bugfix, feature, release, onboarding, refactor, docs, test, or general). When the task is continuing prior work, the same brief also includes a bounded prior-work projection. Treat its "Start here" files as the first ${contextNoun} files to inspect.`,
     "",
-    'If the MCP tool is not visible yet but the client supports tool discovery or dynamic loading, search/select `memorix_project_context` first. Run `memorix context --task "<task>"` only after MCP is unavailable, disabled, or not discoverable, and pass the user\'s real task text. Do not skip memory, wait indefinitely on MCP startup, or hand-write tool-call syntax.',
+    'If the MCP tool is not visible yet but the client supports tool discovery or dynamic loading, search/select `memorix_project_context` first. Continuation fallback is mandatory: when the user asks to continue, resume, take over, or explain prior work and MCP cannot be called in this turn, run exactly one CLI brief with the user\'s real task before inspecting files, Git history, progress notes, or guessing: `memorix resume "<task>" --json`. For a new task, use `memorix context "<task>" --json` instead. The absence of `.memorix` or visible memory files never proves project memory is empty. If that one command fails, report it and proceed normally. Do not probe help, enumerate commands, chain broad searches, wait indefinitely on MCP startup, or hand-write tool-call syntax.',
     "",
-    "Use `memorix_context_pack` when you need structured refs and freshness for code-bound memories.",
+    "After a successful `memorix_project_context` result, the brief is the default retrieval boundary. Do not call more Memorix retrieval tools after a complete brief. Use `memorix_context_pack`, `memorix_search`, or `memorix_detail` only when the brief lacks a specific reference, freshness field, or fact needed for the task, or when the user explicitly asks for deeper history. In MCP, name that missing fact in `purpose` when intentionally expanding beyond the brief. Do not retrieve the same decision twice just to confirm an already-complete brief.",
+    "If the user asks for read-only work or says not to modify files, do not call `memorix_store` just to record an assessment. Store only when the user explicitly asks to preserve it.",
     "",
     "## When to search memory",
     "",
     "Use `memorix_graph_context` for explicit memory graph questions or broad graph overview after the autopilot brief is not enough.",
     "",
-    `Use \`memorix_search\` when prior ${contextNoun} context would help \u2014 for example:`,
+    `Use \`memorix_search\` when prior ${contextNoun} context would help and the Autopilot brief did not already answer the question \u2014 for example:`,
     "- The user asks about a past decision, bug, or change",
     "- You need to understand why something was designed a certain way",
     "- You're continuing work that started in a previous session",
@@ -26619,18 +26933,10 @@ function parseFormationTimeoutMs(raw) {
 }
 
 // src/server.ts
+init_timeout();
 var FORMATION_TIMEOUT_MS = parseFormationTimeoutMs(process.env.MEMORIX_FORMATION_TIMEOUT_MS);
 var COMPACT_ON_WRITE_TIMEOUT_MS = 12e3;
 var COMPRESSION_TIMEOUT_MS = 5e3;
-function withTimeout2(promise, ms, label) {
-  let timer;
-  return Promise.race([
-    promise,
-    new Promise((_, reject) => {
-      timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
-    })
-  ]).finally(() => clearTimeout(timer));
-}
 function formatFormationStageDurations(stageDurationsMs) {
   const orderedStages = ["extract", "resolve", "evaluate"];
   const parts = orderedStages.filter((stage) => stageDurationsMs[stage] !== void 0).map((stage) => `${stage}=${stageDurationsMs[stage]}ms`);
@@ -26734,6 +27040,8 @@ var BOOTSTRAP_SAFE_TOOL_NAMES = /* @__PURE__ */ new Set([
   "memorix_graph_context",
   "memorix_context_pack"
 ]);
+var AUTOPILOT_RETRIEVAL_BOUNDARY_TTL_MS = 2 * 60 * 1e3;
+var READ_ONLY_TASK_PATTERN = /\b(?:do not|don't|never)\s+(?:modify|edit|change|write)\b|\bread[- ]only\b|(?:不要|不准|勿|禁止).{0,6}(?:修改|编辑|写入)|只读/i;
 function shouldAwaitProjectRuntime(toolName) {
   return !BOOTSTRAP_SAFE_TOOL_NAMES.has(toolName);
 }
@@ -27004,7 +27312,7 @@ The path should point to a directory containing a .git folder.`
   };
   const server = existingServer ?? new McpServer({
     name: "memorix",
-    version: true ? "1.2.3" : "1.0.1"
+    version: true ? "1.2.5" : "1.0.1"
   });
   const originalRegisterTool = server.registerTool.bind(server);
   server.registerTool = ((name, ...args) => {
@@ -27039,11 +27347,52 @@ The path should point to a directory containing a .git folder.`
       isTeamMember
     };
   };
+  let autopilotRetrievalBoundary = null;
+  const getActiveAutopilotRetrievalBoundary = () => {
+    const boundary = autopilotRetrievalBoundary;
+    if (!boundary) return null;
+    if (boundary.projectId === project.id && Date.now() - boundary.issuedAt <= AUTOPILOT_RETRIEVAL_BOUNDARY_TTL_MS) {
+      return boundary;
+    }
+    autopilotRetrievalBoundary = null;
+    return null;
+  };
+  const requireExplicitAutopilotExpansion = (toolName, purpose) => {
+    if (!getActiveAutopilotRetrievalBoundary() || purpose?.trim()) return null;
+    return {
+      content: [{
+        type: "text",
+        text: "Memorix Autopilot retrieval boundary: the latest `memorix_project_context` already supplied the default bounded brief for this coding turn, so no additional memory was retrieved. Verify the current project first. To intentionally expand beyond that brief, call `" + toolName + "` again with `purpose` naming the specific missing fact or the user's explicit request."
+      }]
+    };
+  };
+  const blockCoveredAutopilotEvidence = (toolName, observationIds, force) => {
+    const boundary = getActiveAutopilotRetrievalBoundary();
+    if (!boundary || force || observationIds.length === 0 || !observationIds.every((id) => boundary.coveredObservationIds.has(id))) {
+      return null;
+    }
+    return {
+      content: [{
+        type: "text",
+        text: "Memorix Autopilot retrieval boundary: every requested memory is already represented in the latest project brief, so no duplicate detail was retrieved. Inspect the current project or seek a new source. Retry with `force: true` only when the user explicitly asks to read the underlying record in full."
+      }]
+    };
+  };
+  const blockReadOnlyAutopilotWrite = (overrideReadOnly) => {
+    const boundary = getActiveAutopilotRetrievalBoundary();
+    if (!boundary?.readOnly || overrideReadOnly) return null;
+    return {
+      content: [{
+        type: "text",
+        text: "Memorix write boundary: the latest task is read-only or asks not to modify files, so no memory was stored. Persist a record only when the user explicitly asks to save it, then retry with `overrideReadOnly: true`."
+      }]
+    };
+  };
   server.registerTool(
     "memorix_store",
     {
       title: "Store Memory",
-      description: "Store a new observation/memory. Automatically indexed for search. Use type to classify: gotcha ([GOTCHA] critical pitfall), decision ([DECISION] architecture choice), problem-solution ([FIX] bug fix), how-it-works ([INFO] explanation), what-changed ([CHANGE] change), discovery ([DISCOVERY] insight), why-it-exists ([WHY] rationale), trade-off ([TRADEOFF] compromise), session-request ([SESSION] original goal). Project visibility is the default. Personal or team visibility requires an explicitly joined coordination identity.",
+      description: "Store a new observation/memory. Automatically indexed for search. Use type to classify: gotcha ([GOTCHA] critical pitfall), decision ([DECISION] architecture choice), problem-solution ([FIX] bug fix), how-it-works ([INFO] explanation), what-changed ([CHANGE] change), discovery ([DISCOVERY] insight), why-it-exists ([WHY] rationale), trade-off ([TRADEOFF] compromise), session-request ([SESSION] original goal). Project visibility is the default. Personal or team visibility requires an explicitly joined coordination identity. For a read-only task, do not store unless the user explicitly asks to save a record.",
       inputSchema: {
         entityName: z2.string().describe('The entity this observation belongs to (e.g., "auth-module", "port-config")'),
         type: z2.enum(OBSERVATION_TYPES).describe("Observation type for classification"),
@@ -27064,12 +27413,17 @@ The path should point to a directory containing a .git folder.`
         relatedEntities: z2.array(z2.string()).optional().describe("Other entity names this memory cross-references"),
         visibility: z2.enum(["personal", "project", "team"]).optional().describe(
           "Retrieval scope. Project is the normal shared default; personal/team require memorix_session_start with joinTeam=true."
+        ),
+        overrideReadOnly: z2.boolean().optional().describe(
+          "Use only when the user explicitly asks to save memory during a read-only or no-modification task."
         )
       }
     },
-    async ({ entityName: rawEntityName, type: rawType, title: rawTitle, narrative, facts, filesModified, concepts, topicKey, progress, relatedCommits, relatedEntities, visibility }) => {
+    async ({ entityName: rawEntityName, type: rawType, title: rawTitle, narrative, facts, filesModified, concepts, topicKey, progress, relatedCommits, relatedEntities, visibility, overrideReadOnly }) => {
       const unresolved = requireResolvedProject("store memory in the current project");
       if (unresolved) return unresolved;
+      const readOnlyBoundary = blockReadOnlyAutopilotWrite(overrideReadOnly);
+      if (readOnlyBoundary) return readOnlyBoundary;
       const requestedVisibility = visibility ?? "project";
       const reader = getObservationReader();
       if (requestedVisibility !== "project" && !currentAgentId) {
@@ -27155,7 +27509,7 @@ The path should point to a directory containing a .git folder.`
                 getEntityNames: () => graphManager.getEntityNames(),
                 onStageEvent: onFormationStageEvent
               };
-              formationResult = await withTimeout2(
+              formationResult = await withTimeout(
                 runFormation({
                   entityName,
                   type,
@@ -27276,7 +27630,7 @@ ${modeIcon} Formation[active]: ${formationResult.evaluation.category} (${formati
                   facts: d.facts,
                   score: similarEntries[i]?.score ?? 0
                 }));
-                const decision = await withTimeout2(
+                const decision = await withTimeout(
                   compactOnWrite(
                     { title, narrative, facts: safeFacts ?? [] },
                     existingMemories
@@ -27372,7 +27726,7 @@ Mode: ${decision.usedLLM ? "LLM" : "heuristic"}`
           let compressionNote = "";
           try {
             const { compressNarrative: compressNarrative2 } = await Promise.resolve().then(() => (init_quality(), quality_exports));
-            const { compressed, saved, usedLLM } = await withTimeout2(
+            const { compressed, saved, usedLLM } = await withTimeout(
               compressNarrative2(narrative, safeFacts, type),
               COMPRESSION_TIMEOUT_MS,
               "Narrative compression"
@@ -27494,7 +27848,7 @@ Auto-enriched: ${enrichmentParts.join(", ")}` : "";
                 },
                 getEntityNames: () => graphManager.getEntityNames()
               };
-              const formed = await withTimeout2(
+              const formed = await withTimeout(
                 runFormation({ entityName, type, title, narrative, facts: safeFacts, projectId: project.id, source: "explicit", topicKey }, formationConfig),
                 FORMATION_TIMEOUT_MS,
                 "Shadow formation"
@@ -27568,7 +27922,7 @@ Use this as the \`topicKey\` parameter in \`memorix_store\` to enable upsert beh
     "memorix_search",
     {
       title: "Search Memory",
-      description: "Search project memory. Returns a compact index (~50-100 tokens/result). Use memorix_detail to fetch full content for specific IDs. Use memorix_timeline to see chronological context. Searches across all observations stored from any IDE session \u2014 enabling cross-session and cross-agent context retrieval.",
+      description: "Search project memory. Returns a compact index (~50-100 tokens/result). Do not use as a follow-up to a complete memorix_project_context brief unless a specific fact is still missing or the user asks for deeper history; provide purpose when intentionally expanding. Use memorix_detail to fetch full content for specific IDs. Use memorix_timeline to see chronological context. Searches across all observations stored from any IDE session \u2014 enabling cross-session and cross-agent context retrieval.",
       inputSchema: {
         query: z2.string().describe("Search query (natural language or keywords)"),
         limit: z2.number().optional().describe("Max results (default: 20)"),
@@ -27584,14 +27938,27 @@ Use this as the \`topicKey\` parameter in \`memorix_store\` to enable upsert beh
         ),
         source: z2.enum(["agent", "git", "manual"]).optional().describe(
           'Filter by memory source. "git" returns only commit-derived ground truth memories. Omit for all sources.'
+        ),
+        quality: z2.enum(["fast", "balanced", "thorough"]).optional().default("balanced").describe(
+          "Retrieval profile: fast stays local, balanced uses configured embeddings, thorough explicitly permits optional LLM refinement."
+        ),
+        purpose: z2.string().optional().describe(
+          "Why this must expand beyond the latest Autopilot brief. Name the missing fact or the user's explicit request."
+        ),
+        force: z2.boolean().optional().describe(
+          "Use only when the user explicitly asks to read a record already represented in the latest Autopilot brief."
         )
       }
     },
-    async ({ query, limit, type, maxTokens, scope, since, until, status, source }) => {
+    async ({ query, limit, type, maxTokens, scope, since, until, status, source, quality, purpose, force }) => {
       if (scope !== "global") {
         const unresolved = requireResolvedProject("search the current project");
         if (unresolved) return unresolved;
       }
+      if (scope !== "global") {
+        const boundary = requireExplicitAutopilotExpansion("memorix_search", purpose);
+        if (boundary) return boundary;
+      }
       return withFreshIndex(async () => {
         const safeLimit = limit != null ? coerceNumber(limit, 20) : void 0;
         const safeMaxTokens = maxTokens != null ? coerceNumber(maxTokens, 0) : void 0;
@@ -27608,16 +27975,14 @@ Use this as the \`topicKey\` parameter in \`memorix_store\` to enable upsert beh
           projectId: scope === "global" ? void 0 : project.id,
           status: status ?? "active",
           source,
+          quality,
           reader: getObservationReader(scope === "global" ? "global" : "project")
         });
-        const timeoutPromise = new Promise(
-          (_, reject) => setTimeout(() => reject(new Error(`Search timeout after ${TIMEOUT_MS}ms`)), TIMEOUT_MS)
-        );
         let result;
         try {
-          result = await Promise.race([searchPromise, timeoutPromise]);
+          result = await withTimeout(searchPromise, TIMEOUT_MS, "Search");
         } catch (error) {
-          if (error instanceof Error && error.message.includes("timeout")) {
+          if (error instanceof Error && /\btimeout\b|timed out/i.test(error.message)) {
             return {
               content: [
                 {
@@ -27630,6 +27995,11 @@ Use this as the \`topicKey\` parameter in \`memorix_store\` to enable upsert beh
           }
           throw error;
         }
+        const activeBoundary = getActiveAutopilotRetrievalBoundary();
+        if (scope !== "global" && activeBoundary && !force && result.entries.length > 0 && result.entries.every((entry) => activeBoundary.coveredObservationIds.has(entry.id))) {
+          const duplicate = blockCoveredAutopilotEvidence("memorix_search", result.entries.map((entry) => entry.id), force);
+          if (duplicate) return duplicate;
+        }
         let text = result.formatted;
         try {
           const { getLastSearchMode: getLastSearchMode2 } = await Promise.resolve().then(() => (init_orama_store(), orama_store_exports));
@@ -27731,6 +28101,7 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
         observations: observations2,
         task,
         refresh: refresh ?? "auto",
+        reader: getObservationReader(),
         enqueueRefresh: () => {
           enqueueCodegraphRefresh2({
             dataDir: projectDir2,
@@ -27742,6 +28113,16 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
         }
       });
       const text = format === "json" ? JSON.stringify({ ...context, brief: buildAutoProjectBrief2(context) }, null, 2) : format === "summary" ? formatAutoProjectContextSummary2(context) : formatAutoProjectContextPrompt2(context);
+      autopilotRetrievalBoundary = {
+        projectId: project.id,
+        issuedAt: Date.now(),
+        coveredObservationIds: /* @__PURE__ */ new Set([
+          ...context.workset.continuation?.memories.map((memory) => memory.id) ?? [],
+          ...context.workset.reliableMemory.map((memory) => memory.id),
+          ...context.workset.cautionMemory.map((memory) => memory.id)
+        ]),
+        readOnly: READ_ONLY_TASK_PATTERN.test(task ?? "")
+      };
       return {
         content: [{ type: "text", text }]
       };
@@ -27781,18 +28162,23 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
     "memorix_context_pack",
     {
       title: "Context Pack",
-      description: "Build a prompt-ready working context pack for a coding task. Combines relevant memories, CodeGraph Memory facts, freshness warnings, suggested reads, and verification hints.",
+      description: "Build a prompt-ready working context pack for a coding task. Combines relevant memories, CodeGraph Memory facts, freshness warnings, suggested reads, and verification hints. After a complete memorix_project_context brief, provide purpose only when deliberately expanding beyond it.",
       inputSchema: {
         task: z2.string().describe("Current coding task or question"),
         limit: z2.preprocess(
           (value) => typeof value === "string" && value.trim() !== "" ? Number(value) : value,
           z2.number().int().positive().max(100)
-        ).optional().describe("Max active memories to inspect before code-ref filtering (default: 20)")
+        ).optional().describe("Max active memories to inspect before code-ref filtering (default: 20)"),
+        purpose: z2.string().optional().describe(
+          "Why this must expand beyond the latest Autopilot brief. Name the missing fact or the user's explicit request."
+        )
       }
     },
-    async ({ task, limit }) => {
+    async ({ task, limit, purpose }) => {
       const unresolved = requireResolvedProject("build a context pack for the current project");
       if (unresolved) return unresolved;
+      const boundary = requireExplicitAutopilotExpansion("memorix_context_pack", purpose);
+      if (boundary) return boundary;
       const [
         { CodeGraphStore: CodeGraphStore2 },
         { assembleContextPackForTask: assembleContextPackForTask2, attachTaskWorkset: attachTaskWorkset2, buildContextPackPrompt: buildContextPackPrompt2 },
@@ -28537,7 +28923,7 @@ ${actions.join("\n")}`
     "memorix_detail",
     {
       title: "Memory Details",
-      description: 'Fetch full observation or mini-skill details \u2014 includes source kind (explicit memory / hook trace / git evidence), value category, and cross-references (~500-1000 tokens each). Always use memorix_search first to find relevant IDs, then fetch only what you need. Accepts typed refs from search results (e.g. "obs:42", "skill:3") via the typedRefs field, or legacy numeric ids / object refs for backward compatibility.',
+      description: 'Fetch full observation or mini-skill details \u2014 includes source kind (explicit memory / hook trace / git evidence), value category, and cross-references (~500-1000 tokens each). Do not re-fetch content already covered by a complete memorix_project_context brief unless a specific fact is still missing or the user asks for deeper history; provide purpose when intentionally expanding. Always use memorix_search first to find relevant IDs, then fetch only what you need. Accepts typed refs from search results (e.g. "obs:42", "skill:3") via the typedRefs field, or legacy numeric ids / object refs for backward compatibility.',
       inputSchema: {
         ids: z2.array(z2.number()).optional().describe("Observation IDs to fetch (legacy, from memorix_search results)"),
         refs: z2.array(
@@ -28546,16 +28932,36 @@ ${actions.join("\n")}`
             projectId: z2.string().optional().describe("Project ID for global-search disambiguation")
           })
         ).optional().describe("Explicit observation refs. Prefer this for global search results."),
-        typedRefs: z2.array(z2.string()).optional().describe('Typed memory refs from search results, e.g. "obs:42", "skill:3", "obs:42@org/proj"')
+        typedRefs: z2.array(z2.string()).optional().describe('Typed memory refs from search results, e.g. "obs:42", "skill:3", "obs:42@org/proj"'),
+        purpose: z2.string().optional().describe(
+          "Why this must expand beyond the latest Autopilot brief. Name the missing fact or the user's explicit request."
+        ),
+        force: z2.boolean().optional().describe(
+          "Use only when the user explicitly asks to read a record already represented in the latest Autopilot brief."
+        )
       }
     },
-    async ({ ids, refs, typedRefs }) => {
+    async ({ ids, refs, typedRefs, purpose, force }) => {
       const safeIds = coerceNumberArray(ids);
       const safeRefs = coerceObservationRefs(refs);
       const safeTypedRefs = coerceStringArray(typedRefs);
+      const hasCrossProjectRef = safeRefs.some((ref) => ref.projectId && ref.projectId !== project.id) || safeTypedRefs.some((ref) => ref.includes("@") && !ref.endsWith(`@${project.id}`));
+      if (!hasCrossProjectRef) {
+        const boundary = requireExplicitAutopilotExpansion("memorix_detail", purpose);
+        if (boundary) return boundary;
+        const requestedObservationIds = [
+          ...safeIds,
+          ...safeRefs.map((ref) => ref.id),
+          ...safeTypedRefs.flatMap((ref) => {
+            const match = /^obs:(\d+)(?:@.+)?$/i.exec(ref.trim());
+            return match ? [Number(match[1])] : [];
+          })
+        ];
+        const duplicate = blockCoveredAutopilotEvidence("memorix_detail", requestedObservationIds, force);
+        if (duplicate) return duplicate;
+      }
       let result;
       try {
-        const hasCrossProjectRef = safeRefs.some((ref) => ref.projectId && ref.projectId !== project.id) || safeTypedRefs.some((ref) => ref.includes("@") && !ref.endsWith(`@${project.id}`));
         const reader = getObservationReader(hasCrossProjectRef ? "global" : "project");
         if (safeTypedRefs.length > 0) {
           result = await compactDetail(safeTypedRefs, { reader });
@@ -30581,6 +30987,7 @@ fi
     if (newCanonicalId === project.id && projectResolved) return false;
     console.error(`[memorix] Switching project: ${project.id} \u2192 ${newCanonicalId}`);
     currentAgentId = void 0;
+    autopilotRetrievalBoundary = null;
     const canonicalProjectDir = newCanonicalId !== newDetected.id ? await getProjectDataDir(newCanonicalId) : newProjectDir;
     projectResolved = true;
     projectResolutionError = null;