@cortexkit/opencode-magic-context 0.20.0 → 0.21.1

package/dist/index.js

@@ -1,3 +1,4 @@
+import { createRequire } from "node:module";
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
@@ -44,6 +45,7 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __promiseAll = (args) => Promise.all(args);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/agents/dreamer.ts
 var DREAMER_AGENT = "dreamer";
@@ -15017,6 +15019,46 @@ var init_magic_context = __esm(() => {
   });
 });
 
+// src/features/magic-context/memory/project-identity.ts
+import { execSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import path from "node:path";
+function getRootCommitHash(directory) {
+  try {
+    const hash2 = execSync("git rev-list --max-parents=0 HEAD", {
+      cwd: directory,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: GIT_TIMEOUT_MS
+    }).trim();
+    const firstLine = hash2.split(`
+`)[0]?.trim();
+    return firstLine && firstLine.length >= 7 ? firstLine : undefined;
+  } catch {
+    return;
+  }
+}
+function directoryFallback(directory) {
+  const canonical = path.resolve(directory);
+  const hash2 = createHash("md5").update(canonical).digest("hex").slice(0, 12);
+  return `dir:${hash2}`;
+}
+function resolveProjectIdentity(directory) {
+  const resolved = path.resolve(directory);
+  const cached2 = resolvedCache.get(resolved);
+  if (cached2 !== undefined) {
+    return cached2;
+  }
+  const rootHash = getRootCommitHash(resolved);
+  const identity = rootHash ? `git:${rootHash}` : directoryFallback(resolved);
+  resolvedCache.set(resolved, identity);
+  return identity;
+}
+var GIT_TIMEOUT_MS = 5000, resolvedCache;
+var init_project_identity = __esm(() => {
+  resolvedCache = new Map;
+});
+
 // src/shared/harness.ts
 function getHarness() {
   return currentHarness;
@@ -15025,41 +15067,41 @@ var currentHarness = "opencode";
 
 // src/shared/data-path.ts
 import * as os from "node:os";
-import * as path from "node:path";
+import * as path2 from "node:path";
 function getDataDir() {
-  return process.env.XDG_DATA_HOME ?? path.join(os.homedir(), ".local", "share");
+  return process.env.XDG_DATA_HOME ?? path2.join(os.homedir(), ".local", "share");
 }
 function getMagicContextTempDir(harness = getHarness()) {
-  return path.join(os.tmpdir(), harness, "magic-context");
+  return path2.join(os.tmpdir(), harness, "magic-context");
 }
 function getMagicContextLogPath(harness = getHarness()) {
-  return path.join(getMagicContextTempDir(harness), "magic-context.log");
+  return path2.join(getMagicContextTempDir(harness), "magic-context.log");
 }
 function getProjectMagicContextDir(directory) {
-  return path.join(directory, ".opencode", "magic-context");
+  return path2.join(directory, ".opencode", "magic-context");
 }
 function getProjectMagicContextHistorianDir(directory) {
-  return path.join(getProjectMagicContextDir(directory), "historian");
+  return path2.join(getProjectMagicContextDir(directory), "historian");
 }
 function getOpenCodeStorageDir() {
-  return path.join(getDataDir(), "opencode", "storage");
+  return path2.join(getDataDir(), "opencode", "storage");
 }
 function getMagicContextStorageDir() {
-  return path.join(getDataDir(), "cortexkit", "magic-context");
+  return path2.join(getDataDir(), "cortexkit", "magic-context");
 }
 function getLegacyOpenCodeMagicContextStorageDir() {
-  return path.join(getOpenCodeStorageDir(), "plugin", "magic-context");
+  return path2.join(getOpenCodeStorageDir(), "plugin", "magic-context");
 }
 function getCacheDir() {
-  return process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), ".cache");
+  return process.env.XDG_CACHE_HOME ?? path2.join(os.homedir(), ".cache");
 }
 var init_data_path = () => {};
 
 // src/shared/logger.ts
 import * as fs from "node:fs";
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 function ensureDir(filePath) {
-  const dir = path2.dirname(filePath);
+  const dir = path3.dirname(filePath);
   if (dir === lastEnsuredDir)
     return;
   try {
@@ -148209,13 +148251,13 @@ function stableStringify(value, seen = new WeakSet) {
 }
 
 // src/features/magic-context/tool-definition-tokens.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 function keyFor(providerID, modelID, agentName) {
   const agent = agentName && agentName.length > 0 ? agentName : "default";
   return `${providerID}/${modelID}/${agent}`;
 }
 function fingerprintFor(description, parameters) {
-  return createHash("sha256").update(description).update("\x00").update(stableStringify(parameters)).digest("hex");
+  return createHash2("sha256").update(description).update("\x00").update(stableStringify(parameters)).digest("hex");
 }
 function setDatabase(db) {
   persistenceDb = db;
@@ -157333,8 +157375,8 @@ async function parseTarGzip(data, opts = {}) {
   const decompressedData = await new Response(stream).arrayBuffer();
   return parseTar(decompressedData, opts);
 }
-function _sanitizePath(path3) {
-  let normalized = path3.replace(/\\/g, "/");
+function _sanitizePath(path4) {
+  let normalized = path4.replace(/\\/g, "/");
   normalized = normalized.replace(/^[a-zA-Z]:\//, "");
   normalized = normalized.replace(/^\/+/, "");
   const hasLeadingDotSlash = normalized.startsWith("./");
@@ -157351,7 +157393,7 @@ function _sanitizePath(path3) {
   if (hasLeadingDotSlash && !result.startsWith("./")) {
     result = "./" + result;
   }
-  if (path3.endsWith("/") && !result.endsWith("/")) {
+  if (path4.endsWith("/") && !result.endsWith("/")) {
     result += "/";
   }
   return result;
@@ -157415,8 +157457,8 @@ __export(exports_native_binding, {
   resolveBetterSqliteNativeBinding: () => resolveBetterSqliteNativeBinding
 });
 import { existsSync as existsSync8, mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "node:fs";
-import { createRequire } from "node:module";
-import * as path3 from "node:path";
+import { createRequire as createRequire2 } from "node:module";
+import * as path4 from "node:path";
 function logInfo(message) {
   log(`${PREFIX} ${message}`);
 }
@@ -157446,9 +157488,9 @@ function probeAbi(binaryPath) {
 function resolveBetterSqlite3OnDisk(requireFn) {
   try {
     const pkgJsonPath = requireFn.resolve("better-sqlite3/package.json");
-    const pkgDir = path3.dirname(pkgJsonPath);
+    const pkgDir = path4.dirname(pkgJsonPath);
     const pkgJson = requireFn(pkgJsonPath);
-    const binaryPath = path3.join(pkgDir, "build", "Release", "better_sqlite3.node");
+    const binaryPath = path4.join(pkgDir, "build", "Release", "better_sqlite3.node");
     return { binaryPath, pkgVersion: pkgJson.version };
   } catch (err) {
     logWarn(`could not resolve better-sqlite3 in node_modules: ${err instanceof Error ? err.message : String(err)}`);
@@ -157456,7 +157498,7 @@ function resolveBetterSqlite3OnDisk(requireFn) {
   }
 }
 function getCachedBinaryPath(pkgVersion, abi) {
-  return path3.join(getCacheDir(), "cortexkit", "native-bindings", "better-sqlite3", `v${pkgVersion}`, `electron-v${abi}-${process.platform}-${process.arch}`, "better_sqlite3.node");
+  return path4.join(getCacheDir(), "cortexkit", "native-bindings", "better-sqlite3", `v${pkgVersion}`, `electron-v${abi}-${process.platform}-${process.arch}`, "better_sqlite3.node");
 }
 async function downloadElectronPrebuild(pkgVersion, abi) {
   const filename = `better-sqlite3-v${pkgVersion}-electron-v${abi}-${process.platform}-${process.arch}.tar.gz`;
@@ -157489,7 +157531,7 @@ async function resolveBetterSqliteNativeBinding() {
   const promise2 = (async () => {
     const expected = process.versions.modules;
     logInfo(`Electron detected (v${process.versions.electron}, NODE_MODULE_VERSION ${expected}); verifying better-sqlite3 binding`);
-    const requireFn = createRequire(import.meta.url);
+    const requireFn = createRequire2(import.meta.url);
     const resolved = resolveBetterSqlite3OnDisk(requireFn);
     if (!resolved) {
       return null;
@@ -157514,7 +157556,7 @@ async function resolveBetterSqliteNativeBinding() {
       }
       logWarn(`cached binary at ${cachedPath} has wrong ABI (${cachedProbe.actual ?? "unknown"} != ${expected}); refetching`);
     }
-    mkdirSync3(path3.dirname(cachedPath), { recursive: true });
+    mkdirSync3(path4.dirname(cachedPath), { recursive: true });
     const nodeFileBytes = await downloadElectronPrebuild(pkgVersion, expected);
     writeFileSync4(cachedPath, nodeFileBytes);
     logInfo(`cached Electron prebuild at ${cachedPath} (${(nodeFileBytes.length / 1024).toFixed(1)} KB)`);
@@ -157574,11 +157616,11 @@ function closeQuietly(db) {
 }
 
 // src/features/magic-context/key-files/project-key-files.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { existsSync as existsSync10, readFileSync as readFileSync9, realpathSync } from "node:fs";
 import { join as join12, resolve as resolve4, sep } from "node:path";
 function sha256(input) {
-  return createHash2("sha256").update(input).digest("hex");
+  return createHash3("sha256").update(input).digest("hex");
 }
 function resolveProjectPath(directory) {
   if (!directory?.trim())
@@ -157721,14 +157763,6 @@ function getLoadAllEmbeddingsStatement(db) {
   }
   return stmt;
 }
-function getStoredModelIdStatement(db) {
-  let stmt = getStoredModelIdStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("SELECT memory_embeddings.model_id AS modelId FROM memory_embeddings INNER JOIN memories ON memories.id = memory_embeddings.memory_id WHERE memories.project_path = ? AND memory_embeddings.model_id IS NOT NULL LIMIT 1");
-    getStoredModelIdStatements.set(db, stmt);
-  }
-  return stmt;
-}
 function getClearAllEmbeddingsStatement(db) {
   let stmt = clearAllEmbeddingsStatements.get(db);
   if (!stmt) {
@@ -157737,6 +157771,14 @@ function getClearAllEmbeddingsStatement(db) {
   }
   return stmt;
 }
+function getDistinctStoredModelIdsStatement(db) {
+  let stmt = getDistinctStoredModelIdsStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT DISTINCT memory_embeddings.model_id AS modelId FROM memory_embeddings INNER JOIN memories ON memories.id = memory_embeddings.memory_id WHERE memories.project_path = ?");
+    getDistinctStoredModelIdsStatements.set(db, stmt);
+  }
+  return stmt;
+}
 function saveEmbedding(db, memoryId, embedding, modelId) {
   const blob = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
   getSaveEmbeddingStatement(db).run(memoryId, blob, modelId);
@@ -157749,20 +157791,21 @@ function loadAllEmbeddings(db, projectPath) {
   }
   return embeddings;
 }
-function getStoredModelId(db, projectPath) {
-  const row = getStoredModelIdStatement(db).get(projectPath);
-  return typeof row?.modelId === "string" ? row.modelId : null;
-}
 function clearEmbeddingsForProject(db, projectPath) {
   getClearAllEmbeddingsStatement(db).run(projectPath);
 }
-var saveEmbeddingStatements, loadAllEmbeddingsStatements, deleteEmbeddingStatements, getStoredModelIdStatements, clearAllEmbeddingsStatements;
+function getDistinctStoredModelIds(db, projectPath) {
+  const rows = getDistinctStoredModelIdsStatement(db).all(projectPath);
+  return new Set(rows.map((row) => typeof row.modelId === "string" ? row.modelId : null));
+}
+var saveEmbeddingStatements, loadAllEmbeddingsStatements, deleteEmbeddingStatements, getStoredModelIdStatements, clearAllEmbeddingsStatements, getDistinctStoredModelIdsStatements;
 var init_storage_memory_embeddings = __esm(() => {
   saveEmbeddingStatements = new WeakMap;
   loadAllEmbeddingsStatements = new WeakMap;
   deleteEmbeddingStatements = new WeakMap;
   getStoredModelIdStatements = new WeakMap;
   clearAllEmbeddingsStatements = new WeakMap;
+  getDistinctStoredModelIdsStatements = new WeakMap;
 });
 
 // src/features/magic-context/memory/embedding-cache.ts
@@ -157807,13 +157850,13 @@ var init_embedding_cache = __esm(() => {
 });
 
 // src/features/magic-context/memory/normalize-hash.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 function normalizeMemoryContent(content) {
   return content.toLowerCase().replace(/\s+/g, " ").trim();
 }
 function computeNormalizedHash(content) {
   const normalized = normalizeMemoryContent(content);
-  return createHash3("md5").update(normalized).digest("hex");
+  return createHash4("md5").update(normalized).digest("hex");
 }
 var init_normalize_hash = () => {};
 
@@ -158444,7 +158487,8 @@ var init_embedding_identity = __esm(() => {
 // src/features/magic-context/memory/embedding-local.ts
 import { mkdirSync as mkdirSync4 } from "node:fs";
 import { open, stat, unlink, writeFile } from "node:fs/promises";
-import { join as join15 } from "node:path";
+import { dirname as dirname7, join as join15 } from "node:path";
+import { pathToFileURL } from "node:url";
 async function acquireModelLoadLock(lockPath) {
   const waitStart = Date.now();
   while (true) {
@@ -158494,6 +158538,33 @@ function startLockHeartbeat(lockPath) {
   timer.unref?.();
   return () => clearInterval(timer);
 }
+async function injectWasmOrtForElectron() {
+  if (typeof process === "undefined" || !process.versions?.electron) {
+    return false;
+  }
+  try {
+    const ortWebSpec = `onnxruntime-${"web"}`;
+    const ortWeb = await import(ortWebSpec);
+    try {
+      const { createRequire: createRequireFn } = await import("node:module");
+      const requireFn = createRequireFn(import.meta.url);
+      const pkgPath = requireFn.resolve("onnxruntime-web/package.json");
+      const distDir = join15(dirname7(pkgPath), "dist");
+      const wasmPathsPrefix = `${pathToFileURL(distDir).href}/`;
+      if (ortWeb.env?.wasm) {
+        ortWeb.env.wasm.wasmPaths = wasmPathsPrefix;
+      }
+    } catch (pathError) {
+      log("[magic-context] could not resolve local onnxruntime-web/dist, falling back to default WASM paths:", pathError instanceof Error ? pathError.message : String(pathError));
+    }
+    globalThis[Symbol.for("onnxruntime")] = ortWeb;
+    log("[magic-context] Electron detected — using onnxruntime-web (WASM) for embeddings (bypasses onnxruntime-node native load)");
+    return true;
+  } catch (error51) {
+    log("[magic-context] failed to inject onnxruntime-web for Electron — letting transformers fall back to native:", error51 instanceof Error ? error51.message : String(error51));
+    return false;
+  }
+}
 async function withQuietConsole(fn) {
   const origWarn = console.warn;
   const origError = console.error;
@@ -158557,11 +158628,18 @@ class LocalEmbeddingProvider {
   model;
   pipeline = null;
   initPromise = null;
+  inFlight = 0;
+  disposing = false;
+  disposePromise = null;
+  inFlightWaiters = [];
   constructor(model = DEFAULT_LOCAL_EMBEDDING_MODEL) {
     this.model = model;
     this.modelId = getEmbeddingProviderIdentity({ provider: "local", model });
   }
   async initialize() {
+    if (this.disposing) {
+      return false;
+    }
     if (this.pipeline) {
       return true;
     }
@@ -158571,7 +158649,11 @@ class LocalEmbeddingProvider {
     }
     this.initPromise = (async () => {
       try {
-        const transformersSpec = `@huggingface/${"transformers"}`;
+        if (this.disposing) {
+          return;
+        }
+        await injectWasmOrtForElectron();
+        const transformersSpec = "@huggingface/transformers";
         const transformersModule = await import(transformersSpec);
         const env = transformersModule.env;
         const LogLevel = transformersModule.LogLevel;
@@ -158594,9 +158676,15 @@ class LocalEmbeddingProvider {
           let lastError;
           for (let attempt = 1;attempt <= MAX_ATTEMPTS; attempt++) {
             try {
-              this.pipeline = await withQuietConsole(() => createPipeline("feature-extraction", this.model, {
+              const pipeline = await withQuietConsole(() => createPipeline("feature-extraction", this.model, {
                 dtype: "fp32"
               }));
+              if (this.disposing) {
+                await pipeline.dispose?.();
+                this.pipeline = null;
+              } else {
+                this.pipeline = pipeline;
+              }
               lastError = undefined;
               break;
             } catch (error51) {
@@ -158611,6 +158699,8 @@ class LocalEmbeddingProvider {
           }
           if (this.pipeline) {
             log(`[magic-context] embedding model loaded: ${this.model}`);
+          } else if (this.disposing) {
+            return;
           } else {
             throw lastError ?? new Error("unknown embedding load failure");
           }
@@ -158628,13 +158718,33 @@ class LocalEmbeddingProvider {
     await this.initPromise;
     return this.pipeline !== null;
   }
+  waitForInFlightToDrain() {
+    if (this.inFlight === 0) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve6) => {
+      this.inFlightWaiters.push(resolve6);
+    });
+  }
+  finishInFlight() {
+    this.inFlight = Math.max(0, this.inFlight - 1);
+    if (this.inFlight !== 0)
+      return;
+    const waiters = this.inFlightWaiters.splice(0);
+    for (const waiter of waiters) {
+      waiter();
+    }
+  }
   async embed(text, signal) {
     if (signal?.aborted)
       return null;
-    if (!await this.initialize()) {
+    if (this.disposing)
       return null;
-    }
+    this.inFlight += 1;
     try {
+      if (!await this.initialize()) {
+        return null;
+      }
       const pipeline = this.pipeline;
       if (!pipeline) {
         return null;
@@ -158647,6 +158757,8 @@ class LocalEmbeddingProvider {
     } catch (error51) {
       log("[magic-context] embedding failed:", error51);
       return null;
+    } finally {
+      this.finishInFlight();
     }
   }
   async embedBatch(texts, signal) {
@@ -158656,10 +158768,14 @@ class LocalEmbeddingProvider {
     if (signal?.aborted) {
       return Array.from({ length: texts.length }, () => null);
     }
-    if (!await this.initialize()) {
+    if (this.disposing) {
       return Array.from({ length: texts.length }, () => null);
     }
+    this.inFlight += 1;
     try {
+      if (!await this.initialize()) {
+        return Array.from({ length: texts.length }, () => null);
+      }
       const pipeline = this.pipeline;
       if (!pipeline) {
         return Array.from({ length: texts.length }, () => null);
@@ -158672,25 +158788,33 @@ class LocalEmbeddingProvider {
     } catch (error51) {
       log("[magic-context] embedding batch failed:", error51);
       return Array.from({ length: texts.length }, () => null);
+    } finally {
+      this.finishInFlight();
     }
   }
   async dispose() {
-    if (this.initPromise) {
-      await this.initPromise;
-    }
-    if (!this.pipeline) {
-      this.pipeline = null;
-      this.initPromise = null;
-      return;
+    if (this.disposePromise) {
+      return this.disposePromise;
     }
-    try {
-      await this.pipeline.dispose?.();
-    } catch (error51) {
-      log("[magic-context] embedding model dispose failed:", error51);
-    } finally {
+    this.disposing = true;
+    this.disposePromise = (async () => {
+      if (this.initPromise) {
+        await this.initPromise;
+      }
+      await this.waitForInFlightToDrain();
+      const pipelineToDispose = this.pipeline;
       this.pipeline = null;
       this.initPromise = null;
-    }
+      if (!pipelineToDispose) {
+        return;
+      }
+      try {
+        await pipelineToDispose.dispose?.();
+      } catch (error51) {
+        log("[magic-context] embedding model dispose failed:", error51);
+      }
+    })();
+    return this.disposePromise;
   }
   isLoaded() {
     return this.pipeline !== null;
@@ -158916,22 +159040,112 @@ var init_embedding_openai = __esm(() => {
   OPEN_DURATION_MS = 5 * 60000;
 });
 
-// src/features/magic-context/memory/embedding.ts
-function isUnembeddedMemoryRow(row) {
-  if (row === null || typeof row !== "object") {
-    return false;
+// src/features/magic-context/git-commits/storage-git-commit-embeddings.ts
+function getSaveStatement(db) {
+  let stmt = saveStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`INSERT INTO git_commit_embeddings (sha, embedding, model_id, created_at)
+             VALUES (?, ?, ?, ?)
+             ON CONFLICT(sha) DO UPDATE SET
+                 embedding = excluded.embedding,
+                 model_id = excluded.model_id,
+                 created_at = excluded.created_at`);
+    saveStatements.set(db, stmt);
   }
-  const candidate = row;
-  return typeof candidate.id === "number" && typeof candidate.content === "string";
+  return stmt;
 }
-function getLoadUnembeddedMemoriesStatement(db) {
-  let stmt = loadUnembeddedMemoriesStatements.get(db);
+function getLoadProjectStatement(db) {
+  let stmt = loadProjectStatements.get(db);
   if (!stmt) {
-    stmt = db.prepare("SELECT m.id AS id, m.content AS content FROM memories m LEFT JOIN memory_embeddings me ON m.id = me.memory_id WHERE m.project_path = ? AND m.status = 'active' AND me.memory_id IS NULL LIMIT ?");
-    loadUnembeddedMemoriesStatements.set(db, stmt);
+    stmt = db.prepare(`SELECT e.sha AS sha, e.embedding AS embedding, e.model_id AS model_id
+             FROM git_commit_embeddings e
+             JOIN git_commits c ON c.sha = e.sha
+             WHERE c.project_path = ?`);
+    loadProjectStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getLoadUnembeddedStatement(db) {
+  let stmt = loadUnembeddedStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`SELECT c.sha AS sha, c.message AS message
+             FROM git_commits c
+             LEFT JOIN git_commit_embeddings e ON c.sha = e.sha
+             WHERE c.project_path = ? AND e.sha IS NULL
+             ORDER BY c.committed_at DESC
+             LIMIT ?`);
+    loadUnembeddedStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getCountEmbeddedStatement(db) {
+  let stmt = countEmbeddedStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`SELECT COUNT(*) AS count FROM git_commit_embeddings e
+             JOIN git_commits c ON c.sha = e.sha WHERE c.project_path = ?`);
+    countEmbeddedStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getClearProjectStatement(db) {
+  let stmt = clearProjectStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`DELETE FROM git_commit_embeddings
+             WHERE sha IN (SELECT sha FROM git_commits WHERE project_path = ?)`);
+    clearProjectStatements.set(db, stmt);
   }
   return stmt;
 }
+function getDistinctModelIdStatement(db) {
+  let stmt = distinctModelIdStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`SELECT DISTINCT e.model_id AS modelId
+             FROM git_commit_embeddings e
+             JOIN git_commits c ON c.sha = e.sha
+             WHERE c.project_path = ?`);
+    distinctModelIdStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function saveCommitEmbedding(db, sha, embedding, modelId) {
+  const bytes = new Uint8Array(embedding.buffer, embedding.byteOffset, embedding.byteLength);
+  getSaveStatement(db).run(sha, bytes, modelId, Date.now());
+}
+function loadProjectCommitEmbeddings(db, projectPath) {
+  const rows = getLoadProjectStatement(db).all(projectPath);
+  const map2 = new Map;
+  for (const row of rows) {
+    const buffer2 = row.embedding.buffer.slice(row.embedding.byteOffset, row.embedding.byteOffset + row.embedding.byteLength);
+    map2.set(row.sha, new Float32Array(buffer2));
+  }
+  return map2;
+}
+function loadUnembeddedCommits(db, projectPath, limit) {
+  return getLoadUnembeddedStatement(db).all(projectPath, limit);
+}
+function countEmbeddedCommits(db, projectPath) {
+  const row = getCountEmbeddedStatement(db).get(projectPath);
+  return row?.count ?? 0;
+}
+function clearProjectCommitEmbeddings(db, projectPath) {
+  return getClearProjectStatement(db).run(projectPath).changes;
+}
+function getDistinctCommitEmbeddingModelIds(db, projectPath) {
+  const rows = getDistinctModelIdStatement(db).all(projectPath);
+  return new Set(rows.map((row) => typeof row.modelId === "string" ? row.modelId : null));
+}
+var saveStatements, loadProjectStatements, loadUnembeddedStatements, countEmbeddedStatements, clearProjectStatements, distinctModelIdStatements;
+var init_storage_git_commit_embeddings = __esm(() => {
+  saveStatements = new WeakMap;
+  loadProjectStatements = new WeakMap;
+  loadUnembeddedStatements = new WeakMap;
+  countEmbeddedStatements = new WeakMap;
+  clearProjectStatements = new WeakMap;
+  distinctModelIdStatements = new WeakMap;
+});
+
+// src/features/magic-context/project-embedding-registry.ts
+import { createHash as createHash5 } from "node:crypto";
 function resolveEmbeddingConfig(config2) {
   if (!config2 || config2.provider === "local") {
     return {
@@ -158950,10 +159164,10 @@ function resolveEmbeddingConfig(config2) {
   }
   return { provider: "off" };
 }
-function resolveProviderIdentity(config2) {
-  return getEmbeddingProviderIdentity(config2);
-}
 function createProvider(config2) {
+  if (testProviderFactory) {
+    return testProviderFactory(config2);
+  }
   if (config2.provider === "off") {
     return null;
   }
@@ -158966,129 +159180,221 @@ function createProvider(config2) {
   }
   return new LocalEmbeddingProvider(config2.model);
 }
-function getOrCreateProvider() {
-  if (provider) {
-    return provider;
+function stableStringify2(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map((entry) => stableStringify2(entry)).join(",")}]`;
   }
-  provider = createProvider(embeddingConfig);
-  return provider;
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
+    return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${stableStringify2(entry)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function sha256Prefix(value, length = 16) {
+  return createHash5("sha256").update(value).digest("hex").slice(0, length);
 }
-function initializeEmbedding(config2) {
-  const nextConfig = resolveEmbeddingConfig(config2);
-  const nextProviderIdentity = resolveProviderIdentity(nextConfig);
-  const previousProvider = provider;
-  const previousProviderIdentity = previousProvider?.modelId ?? resolveProviderIdentity(embeddingConfig);
-  if (previousProviderIdentity === nextProviderIdentity) {
-    embeddingConfig = nextConfig;
+function getRuntimeFingerprint(config2) {
+  if (config2.provider === "off") {
+    return OFF_PROVIDER_IDENTITY;
+  }
+  return `${getEmbeddingProviderIdentity(config2)}:${sha256Prefix(stableStringify2(config2))}`;
+}
+function sameFeatures(a, b) {
+  return a.memoryEnabled === b.memoryEnabled && a.gitCommitEnabled === b.gitCommitEnabled;
+}
+function snapshotFor(registration) {
+  const providerIsOn = registration.providerIdentity !== OFF_PROVIDER_IDENTITY;
+  const enabled = !registration.observationMode && providerIsOn && registration.features.memoryEnabled;
+  const gitCommitEnabled = !registration.observationMode && providerIsOn && registration.features.gitCommitEnabled;
+  return {
+    projectIdentity: registration.projectIdentity,
+    sourceDirectory: registration.sourceDirectory,
+    providerIdentity: registration.providerIdentity,
+    runtimeFingerprint: registration.runtimeFingerprint,
+    generation: registration.generation,
+    features: { ...registration.features },
+    enabled,
+    gitCommitEnabled,
+    modelId: registration.observationMode || !providerIsOn ? "off" : registration.modelId
+  };
+}
+function disposeProvider(provider) {
+  if (!provider)
     return;
+  provider.dispose().catch((error51) => {
+    log("[magic-context] embedding provider dispose failed:", error51);
+  });
+}
+function anyStoredModelIdIsStale(storedIds, currentId) {
+  if (storedIds.size === 0)
+    return false;
+  for (const id of storedIds) {
+    if (id === null || id !== currentId) {
+      return true;
+    }
   }
-  embeddingConfig = nextConfig;
-  provider = null;
-  if (previousProvider) {
-    previousProvider.dispose().catch((error51) => {
-      log("[magic-context] embedding provider dispose failed:", error51);
-    });
+  return false;
+}
+function maybeWipeStaleEmbeddings(db, projectIdentity, currentProviderIdentity, features) {
+  if (currentProviderIdentity === OFF_PROVIDER_IDENTITY) {
+    return false;
   }
+  let wiped = false;
+  db.transaction(() => {
+    if (features.memoryEnabled) {
+      const memoryIds = getDistinctStoredModelIds(db, projectIdentity);
+      if (anyStoredModelIdIsStale(memoryIds, currentProviderIdentity)) {
+        clearEmbeddingsForProject(db, projectIdentity);
+        invalidateProject(projectIdentity);
+        wiped = true;
+      }
+    }
+    if (features.gitCommitEnabled) {
+      const commitIds = getDistinctCommitEmbeddingModelIds(db, projectIdentity);
+      if (anyStoredModelIdIsStale(commitIds, currentProviderIdentity)) {
+        clearProjectCommitEmbeddings(db, projectIdentity);
+        wiped = true;
+      }
+    }
+  })();
+  return wiped;
 }
-function isEmbeddingEnabled() {
-  return embeddingConfig.provider !== "off";
+function registerProjectEmbeddingAndMaybeWipe(db, projectIdentity, config2, features, sourceDirectory) {
+  const resolvedConfig = resolveEmbeddingConfig(config2);
+  const providerIdentity = getEmbeddingProviderIdentity(resolvedConfig);
+  const runtimeFingerprint = getRuntimeFingerprint(resolvedConfig);
+  const prior = projectRegistrations.get(projectIdentity);
+  const canReuseProvider = prior !== undefined && !prior.observationMode && prior.runtimeFingerprint === runtimeFingerprint && prior.providerIdentity === providerIdentity;
+  const wiped = maybeWipeStaleEmbeddings(db, projectIdentity, providerIdentity, features);
+  const generationChanged = prior === undefined || prior.observationMode || prior.runtimeFingerprint !== runtimeFingerprint || !sameFeatures(prior.features, features) || wiped;
+  const generation = generationChanged ? ++globalRegistrationGeneration : prior.generation;
+  const registration = {
+    projectIdentity,
+    sourceDirectory,
+    config: resolvedConfig,
+    providerIdentity,
+    runtimeFingerprint,
+    provider: canReuseProvider ? prior.provider : null,
+    generation,
+    features: { ...features },
+    modelId: providerIdentity === OFF_PROVIDER_IDENTITY ? "off" : providerIdentity,
+    observationMode: false
+  };
+  projectRegistrations.set(projectIdentity, registration);
+  if (!canReuseProvider) {
+    disposeProvider(prior?.provider ?? null);
+  }
+  return snapshotFor(registration);
+}
+function registerProjectInObservationMode(db, projectIdentity, sourceDirectory, failedConfig, failureSummary) {
+  const prior = projectRegistrations.get(projectIdentity);
+  const runtimeFingerprint = `observation:${sha256Prefix(failureSummary)}`;
+  const generation = prior?.runtimeFingerprint === runtimeFingerprint && prior.observationMode ? prior.generation : ++globalRegistrationGeneration;
+  const registration = {
+    projectIdentity,
+    sourceDirectory,
+    config: resolveEmbeddingConfig(failedConfig),
+    providerIdentity: OFF_PROVIDER_IDENTITY,
+    runtimeFingerprint,
+    provider: null,
+    generation,
+    features: { memoryEnabled: false, gitCommitEnabled: false },
+    modelId: "off",
+    observationMode: true
+  };
+  projectRegistrations.set(projectIdentity, registration);
+  disposeProvider(prior?.provider ?? null);
+  return snapshotFor(registration);
 }
-async function embedText(text, signal) {
-  const currentProvider = getOrCreateProvider();
-  if (!currentProvider) {
+function getProjectEmbeddingSnapshot(projectIdentity) {
+  const registration = projectRegistrations.get(projectIdentity);
+  return registration ? snapshotFor(registration) : null;
+}
+function getOrCreateProjectProvider(registration) {
+  if (registration.providerIdentity === OFF_PROVIDER_IDENTITY || registration.observationMode) {
     return null;
   }
-  if (!await currentProvider.initialize()) {
+  if (registration.provider) {
+    return registration.provider;
+  }
+  const provider = createProvider(registration.config);
+  registration.provider = provider;
+  return provider;
+}
+async function embedTextForProject(projectIdentity, text, signal) {
+  const registration = projectRegistrations.get(projectIdentity);
+  if (!registration)
+    return null;
+  const generation = registration.generation;
+  const modelId = registration.modelId;
+  const provider = getOrCreateProjectProvider(registration);
+  if (!provider)
+    return null;
+  const vector = await provider.embed(text, signal);
+  if (!vector)
+    return null;
+  const current = projectRegistrations.get(projectIdentity);
+  if (!current || current.generation !== generation || current.runtimeFingerprint !== registration.runtimeFingerprint) {
     return null;
   }
-  return currentProvider.embed(text, signal);
+  return { vector, modelId, generation };
 }
-async function embedBatch(texts, signal) {
+async function embedBatchForProject(projectIdentity, texts, signal) {
   if (texts.length === 0) {
-    return [];
-  }
-  const currentProvider = getOrCreateProvider();
-  if (!currentProvider) {
-    return Array.from({ length: texts.length }, () => null);
+    const registration2 = projectRegistrations.get(projectIdentity);
+    if (!registration2 || registration2.observationMode)
+      return null;
+    return { vectors: [], modelId: registration2.modelId, generation: registration2.generation };
   }
-  if (!await currentProvider.initialize()) {
-    return Array.from({ length: texts.length }, () => null);
+  const registration = projectRegistrations.get(projectIdentity);
+  if (!registration)
+    return null;
+  const generation = registration.generation;
+  const modelId = registration.modelId;
+  const runtimeFingerprint = registration.runtimeFingerprint;
+  const provider = getOrCreateProjectProvider(registration);
+  if (!provider)
+    return null;
+  const vectors = await provider.embedBatch(texts, signal);
+  const current = projectRegistrations.get(projectIdentity);
+  if (!current || current.generation !== generation || current.runtimeFingerprint !== runtimeFingerprint) {
+    return null;
   }
-  return currentProvider.embedBatch(texts, signal);
+  return { vectors, modelId, generation };
 }
-async function embedAllUnembeddedMemories(db, config2, batchSize = 10) {
-  if (sweepInProgress) {
-    log("[magic-context] embedding sweep already in progress, skipping this tick");
-    return 0;
-  }
-  sweepInProgress = true;
-  const startedAt = Date.now();
-  const deadline = startedAt + SWEEP_MAX_WALL_CLOCK_MS;
-  try {
-    const resolvedConfig = resolveEmbeddingConfig(config2);
-    if (resolvedConfig.provider === "off")
-      return 0;
-    const projects = db.prepare(`SELECT m.project_path, MAX(m.updated_at) AS latest
-                 FROM memories m
-                 WHERE m.status IN ('active', 'permanent')
-                 AND m.id NOT IN (SELECT memory_id FROM memory_embeddings)
-                 GROUP BY m.project_path
-                 ORDER BY latest DESC
-                 LIMIT 20`).all();
-    let total = 0;
-    let consecutiveEmpty = 0;
-    outer:
-      for (const project of projects) {
-        while (Date.now() < deadline) {
-          const count = await embedUnembeddedMemoriesForProject(db, project.project_path, config2, batchSize);
-          if (count === 0) {
-            consecutiveEmpty += 1;
-            if (consecutiveEmpty >= SWEEP_MAX_CONSECUTIVE_EMPTY) {
-              log(`[magic-context] embedding sweep: ${SWEEP_MAX_CONSECUTIVE_EMPTY} consecutive empty batches, stopping (total=${total})`);
-              break outer;
-            }
-            break;
-          }
-          consecutiveEmpty = 0;
-          total += count;
-          if (count < batchSize)
-            break;
-        }
-        if (Date.now() >= deadline) {
-          log(`[magic-context] embedding sweep: wall-clock deadline reached after ${((Date.now() - startedAt) / 1000).toFixed(1)}s (total=${total})`);
-          break;
-        }
-      }
-    return total;
-  } finally {
-    sweepInProgress = false;
+function isUnembeddedMemoryRow(row) {
+  if (row === null || typeof row !== "object")
+    return false;
+  const candidate = row;
+  return typeof candidate.id === "number" && typeof candidate.content === "string";
+}
+function getLoadUnembeddedMemoriesStatement(db) {
+  let stmt = loadUnembeddedMemoriesStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT m.id AS id, m.content AS content FROM memories m LEFT JOIN memory_embeddings me ON m.id = me.memory_id WHERE m.project_path = ? AND m.status = 'active' AND me.memory_id IS NULL LIMIT ?");
+    loadUnembeddedMemoriesStatements.set(db, stmt);
   }
+  return stmt;
 }
-async function embedUnembeddedMemoriesForProject(db, projectPath, config2, batchSize = 10) {
-  const normalizedBatchSize = Math.max(1, Math.floor(batchSize));
-  const resolvedConfig = resolveEmbeddingConfig(config2);
-  if (resolvedConfig.provider === "off") {
+async function embedUnembeddedMemoriesForProject(db, projectIdentity, batchSize = 10) {
+  const snapshot = getProjectEmbeddingSnapshot(projectIdentity);
+  if (!snapshot?.enabled)
     return 0;
-  }
-  initializeEmbedding(resolvedConfig);
-  const memories = getLoadUnembeddedMemoriesStatement(db).all(projectPath, normalizedBatchSize).filter(isUnembeddedMemoryRow);
-  if (memories.length === 0) {
+  const normalizedBatchSize = Math.max(1, Math.floor(batchSize));
+  const memories = getLoadUnembeddedMemoriesStatement(db).all(projectIdentity, normalizedBatchSize).filter(isUnembeddedMemoryRow);
+  if (memories.length === 0)
     return 0;
-  }
   try {
-    const embeddings = await embedBatch(memories.map((memory) => memory.content));
-    const modelId = getEmbeddingModelId();
-    if (modelId === "off") {
+    const result = await embedBatchForProject(projectIdentity, memories.map((memory) => memory.content));
+    if (!result)
       return 0;
-    }
     let embeddedCount = 0;
     db.transaction(() => {
       for (const [index, memory] of memories.entries()) {
-        const embedding = embeddings[index];
-        if (!embedding) {
+        const embedding = result.vectors[index];
+        if (!embedding)
           continue;
-        }
-        saveEmbedding(db, memory.id, embedding, modelId);
+        saveEmbedding(db, memory.id, embedding, result.modelId);
         embeddedCount += 1;
       }
     })();
@@ -159098,10 +159404,56 @@ async function embedUnembeddedMemoriesForProject(db, projectPath, config2, batch
     return 0;
   }
 }
-function getEmbeddingModelId() {
-  return getOrCreateProvider()?.modelId ?? "off";
+var OFF_PROVIDER_IDENTITY = "embedding-provider:off", SWEEP_MAX_WALL_CLOCK_MS, projectRegistrations, loadUnembeddedMemoriesStatements, globalRegistrationGeneration = 0, testProviderFactory = null;
+var init_project_embedding_registry = __esm(() => {
+  init_magic_context();
+  init_logger();
+  init_storage_git_commit_embeddings();
+  init_embedding_cache();
+  init_embedding_identity();
+  init_embedding_local();
+  init_embedding_openai();
+  init_storage_memory_embeddings();
+  SWEEP_MAX_WALL_CLOCK_MS = 10 * 60 * 1000;
+  projectRegistrations = new Map;
+  loadUnembeddedMemoriesStatements = new WeakMap;
+});
+
+// src/features/magic-context/memory/embedding.ts
+function createProvider2(config2) {
+  if (config2.provider === "off") {
+    return null;
+  }
+  if (config2.provider === "openai-compatible") {
+    return new OpenAICompatibleEmbeddingProvider({
+      endpoint: config2.endpoint,
+      model: config2.model,
+      apiKey: config2.api_key
+    });
+  }
+  return new LocalEmbeddingProvider(config2.model);
+}
+function getOrCreateProvider() {
+  if (provider) {
+    return provider;
+  }
+  provider = createProvider2(embeddingConfig);
+  return provider;
+}
+function isEmbeddingEnabled() {
+  return embeddingConfig.provider !== "off";
+}
+async function embedText(text, signal) {
+  const currentProvider = getOrCreateProvider();
+  if (!currentProvider) {
+    return null;
+  }
+  if (!await currentProvider.initialize()) {
+    return null;
+  }
+  return currentProvider.embed(text, signal);
 }
-var DEFAULT_EMBEDDING_CONFIG, embeddingConfig, provider = null, loadUnembeddedMemoriesStatements, SWEEP_MAX_WALL_CLOCK_MS, SWEEP_MAX_CONSECUTIVE_EMPTY = 3, sweepInProgress = false;
+var DEFAULT_EMBEDDING_CONFIG, embeddingConfig, provider = null, loadUnembeddedMemoriesStatements2, SWEEP_MAX_WALL_CLOCK_MS2;
 var init_embedding = __esm(() => {
   init_magic_context();
   init_logger();
@@ -159109,13 +159461,14 @@ var init_embedding = __esm(() => {
   init_embedding_local();
   init_embedding_openai();
   init_storage_memory_embeddings();
+  init_project_embedding_registry();
   DEFAULT_EMBEDDING_CONFIG = {
     provider: "local",
     model: DEFAULT_LOCAL_EMBEDDING_MODEL
   };
   embeddingConfig = DEFAULT_EMBEDDING_CONFIG;
-  loadUnembeddedMemoriesStatements = new WeakMap;
-  SWEEP_MAX_WALL_CLOCK_MS = 10 * 60 * 1000;
+  loadUnembeddedMemoriesStatements2 = new WeakMap;
+  SWEEP_MAX_WALL_CLOCK_MS2 = 10 * 60 * 1000;
 });
 
 // src/features/magic-context/memory/storage-memory-fts.ts
@@ -159152,46 +159505,6 @@ var init_storage_memory_fts = __esm(() => {
   searchStatements = new WeakMap;
 });
 
-// src/features/magic-context/memory/project-identity.ts
-import { execSync } from "node:child_process";
-import { createHash as createHash4 } from "node:crypto";
-import path4 from "node:path";
-function getRootCommitHash(directory) {
-  try {
-    const hash2 = execSync("git rev-list --max-parents=0 HEAD", {
-      cwd: directory,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: GIT_TIMEOUT_MS2
-    }).trim();
-    const firstLine = hash2.split(`
-`)[0]?.trim();
-    return firstLine && firstLine.length >= 7 ? firstLine : undefined;
-  } catch {
-    return;
-  }
-}
-function directoryFallback(directory) {
-  const canonical = path4.resolve(directory);
-  const hash2 = createHash4("md5").update(canonical).digest("hex").slice(0, 12);
-  return `dir:${hash2}`;
-}
-function resolveProjectIdentity(directory) {
-  const resolved = path4.resolve(directory);
-  const cached2 = resolvedCache.get(resolved);
-  if (cached2 !== undefined) {
-    return cached2;
-  }
-  const rootHash = getRootCommitHash(resolved);
-  const identity = rootHash ? `git:${rootHash}` : directoryFallback(resolved);
-  resolvedCache.set(resolved, identity);
-  return identity;
-}
-var GIT_TIMEOUT_MS2 = 5000, resolvedCache;
-var init_project_identity = __esm(() => {
-  resolvedCache = new Map;
-});
-
 // src/features/magic-context/compression-depth-storage.ts
 function getIncrementDepthStatement(db) {
   let stmt = incrementDepthStatements.get(db);
@@ -160550,6 +160863,52 @@ var init_migrations = __esm(async () => {
           db.exec("ALTER TABLE session_meta ADD COLUMN deferred_execute_state TEXT");
         }
       }
+    },
+    {
+      version: 16,
+      description: "Add context-limit cache regression sentinels",
+      up: (db) => {
+        const cols = db.prepare("PRAGMA table_info(session_meta)").all();
+        if (!cols.some((c) => c.name === "observed_safe_input_tokens")) {
+          db.exec("ALTER TABLE session_meta ADD COLUMN observed_safe_input_tokens INTEGER NOT NULL DEFAULT 0");
+        }
+        if (!cols.some((c) => c.name === "cache_alert_sent")) {
+          db.exec("ALTER TABLE session_meta ADD COLUMN cache_alert_sent INTEGER NOT NULL DEFAULT 0");
+        }
+      }
+    },
+    {
+      version: 17,
+      description: "Multi-anchor JSON storage for note-nudge and auto-search-hint persistence",
+      up: (db) => {
+        const cols = db.prepare("PRAGMA table_info(session_meta)").all();
+        if (!cols.some((c) => c.name === "note_nudge_anchors")) {
+          db.exec("ALTER TABLE session_meta ADD COLUMN note_nudge_anchors TEXT NOT NULL DEFAULT '[]'");
+        }
+        if (!cols.some((c) => c.name === "auto_search_hint_decisions")) {
+          db.exec("ALTER TABLE session_meta ADD COLUMN auto_search_hint_decisions TEXT NOT NULL DEFAULT '[]'");
+        }
+        db.exec(`
+                UPDATE session_meta
+                SET note_nudge_anchors = json_array(
+                    json_object(
+                        'messageId', note_nudge_sticky_message_id,
+                        'text', note_nudge_sticky_text
+                    )
+                )
+                WHERE COALESCE(note_nudge_sticky_text, '') != ''
+                  AND COALESCE(note_nudge_sticky_message_id, '') != ''
+                  AND (note_nudge_anchors IS NULL OR note_nudge_anchors = '[]')
+            `);
+        db.exec(`
+                UPDATE session_meta SET note_nudge_anchors = '[]'
+                WHERE note_nudge_anchors IS NULL
+            `);
+        db.exec(`
+                UPDATE session_meta SET auto_search_hint_decisions = '[]'
+                WHERE auto_search_hint_decisions IS NULL
+            `);
+      }
     }
   ];
 });
@@ -161055,6 +161414,8 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       note_nudge_trigger_message_id TEXT DEFAULT '',
       note_nudge_sticky_text TEXT DEFAULT '',
       note_nudge_sticky_message_id TEXT DEFAULT '',
+      note_nudge_anchors TEXT NOT NULL DEFAULT '[]',
+      auto_search_hint_decisions TEXT NOT NULL DEFAULT '[]',
       last_todo_state TEXT DEFAULT '',
       todo_synthetic_call_id TEXT DEFAULT '',
       todo_synthetic_anchor_message_id TEXT DEFAULT '',
@@ -161062,6 +161423,8 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       is_subagent INTEGER DEFAULT 0,
       last_context_percentage REAL DEFAULT 0,
       last_input_tokens INTEGER DEFAULT 0,
+      observed_safe_input_tokens INTEGER NOT NULL DEFAULT 0,
+      cache_alert_sent INTEGER NOT NULL DEFAULT 0,
       times_execute_threshold_reached INTEGER DEFAULT 0,
       compartment_in_progress INTEGER DEFAULT 0,
       historian_failure_count INTEGER DEFAULT 0,
@@ -161133,12 +161496,16 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "session_meta", "note_nudge_trigger_message_id", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "note_nudge_sticky_text", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "note_nudge_sticky_message_id", "TEXT DEFAULT ''");
+  ensureColumn(db, "session_meta", "note_nudge_anchors", "TEXT NOT NULL DEFAULT '[]'");
+  ensureColumn(db, "session_meta", "auto_search_hint_decisions", "TEXT NOT NULL DEFAULT '[]'");
   ensureColumn(db, "session_meta", "last_todo_state", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "todo_synthetic_call_id", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "todo_synthetic_anchor_message_id", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "todo_synthetic_state_json", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "note_last_read_at", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "times_execute_threshold_reached", "INTEGER DEFAULT 0");
+  ensureColumn(db, "session_meta", "observed_safe_input_tokens", "INTEGER NOT NULL DEFAULT 0");
+  ensureColumn(db, "session_meta", "cache_alert_sent", "INTEGER NOT NULL DEFAULT 0");
   ensureColumn(db, "session_meta", "compartment_in_progress", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "historian_failure_count", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "historian_last_error", "TEXT DEFAULT NULL");
@@ -161230,7 +161597,9 @@ function healNullIntegerColumns(db) {
     ["system_prompt_tokens", 0],
     ["conversation_tokens", 0],
     ["tool_call_tokens", 0],
-    ["note_nudge_trigger_pending", 0]
+    ["note_nudge_trigger_pending", 0],
+    ["observed_safe_input_tokens", 0],
+    ["cache_alert_sent", 0]
   ];
   for (const [column, fallback] of columns) {
     try {
@@ -161239,7 +161608,7 @@ function healNullIntegerColumns(db) {
   }
 }
 function ensureColumn(db, table, column, definition) {
-  if (!/^[a-z_]+$/.test(table) || !/^[a-z_]+$/.test(column) || !/^[A-Z0-9_'(),\s]+$/i.test(definition)) {
+  if (!/^[a-z_]+$/.test(table) || !/^[a-z_]+$/.test(column) || !/^[A-Z0-9_'(),[\]\s]+$/i.test(definition)) {
     throw new Error(`Unsafe schema identifier: ${table}.${column} ${definition}`);
   }
   const rows = db.prepare(`PRAGMA table_info(${table})`).all();
@@ -161326,7 +161695,7 @@ function isSessionMetaRow(row) {
   if (row === null || typeof row !== "object")
     return false;
   const r = row;
-  return typeof r.session_id === "string" && typeof r.last_response_time === "number" && isStringOrNull(r.cache_ttl) && typeof r.counter === "number" && typeof r.last_nudge_tokens === "number" && isStringOrNull(r.last_nudge_band) && isStringOrNull(r.last_transform_error) && typeof r.is_subagent === "number" && typeof r.last_context_percentage === "number" && typeof r.last_input_tokens === "number" && isNumberOrNull(r.times_execute_threshold_reached) && isNumberOrNull(r.compartment_in_progress) && (r.system_prompt_hash === null || typeof r.system_prompt_hash === "string" || typeof r.system_prompt_hash === "number") && isNumberOrNull(r.system_prompt_tokens) && isNumberOrNull(r.conversation_tokens) && isNumberOrNull(r.tool_call_tokens) && isNumberOrNull(r.cleared_reasoning_through_tag) && isStringOrNull(r.last_todo_state);
+  return typeof r.session_id === "string" && typeof r.last_response_time === "number" && isStringOrNull(r.cache_ttl) && typeof r.counter === "number" && typeof r.last_nudge_tokens === "number" && isStringOrNull(r.last_nudge_band) && isStringOrNull(r.last_transform_error) && typeof r.is_subagent === "number" && typeof r.last_context_percentage === "number" && typeof r.last_input_tokens === "number" && isNumberOrNull(r.observed_safe_input_tokens) && isNumberOrNull(r.cache_alert_sent) && isNumberOrNull(r.times_execute_threshold_reached) && isNumberOrNull(r.compartment_in_progress) && (r.system_prompt_hash === null || typeof r.system_prompt_hash === "string" || typeof r.system_prompt_hash === "number") && isNumberOrNull(r.system_prompt_tokens) && isNumberOrNull(r.conversation_tokens) && isNumberOrNull(r.tool_call_tokens) && isNumberOrNull(r.cleared_reasoning_through_tag) && isStringOrNull(r.last_todo_state);
 }
 function getDefaultSessionMeta(sessionId) {
   return {
@@ -161340,6 +161709,8 @@ function getDefaultSessionMeta(sessionId) {
     isSubagent: false,
     lastContextPercentage: 0,
     lastInputTokens: 0,
+    observedSafeInputTokens: 0,
+    cacheAlertSent: false,
     timesExecuteThresholdReached: 0,
     compartmentInProgress: false,
     systemPromptHash: "",
@@ -161352,7 +161723,7 @@ function getDefaultSessionMeta(sessionId) {
 }
 function ensureSessionMetaRow(db, sessionId) {
   const defaults = getDefaultSessionMeta(sessionId);
-  db.prepare("INSERT OR IGNORE INTO session_meta (session_id, harness, last_response_time, cache_ttl, counter, last_nudge_tokens, last_nudge_band, last_transform_error, is_subagent, last_context_percentage, last_input_tokens, times_execute_threshold_reached, compartment_in_progress, system_prompt_hash, cleared_reasoning_through_tag) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)").run(sessionId, getHarness(), defaults.lastResponseTime, defaults.cacheTtl, defaults.counter, defaults.lastNudgeTokens, defaults.lastNudgeBand ?? "", defaults.lastTransformError ?? "", defaults.isSubagent ? 1 : 0, defaults.lastContextPercentage, defaults.lastInputTokens, defaults.timesExecuteThresholdReached, defaults.compartmentInProgress ? 1 : 0, defaults.systemPromptHash ?? "", defaults.clearedReasoningThroughTag);
+  db.prepare("INSERT OR IGNORE INTO session_meta (session_id, harness, last_response_time, cache_ttl, counter, last_nudge_tokens, last_nudge_band, last_transform_error, is_subagent, last_context_percentage, last_input_tokens, observed_safe_input_tokens, cache_alert_sent, times_execute_threshold_reached, compartment_in_progress, system_prompt_hash, cleared_reasoning_through_tag) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)").run(sessionId, getHarness(), defaults.lastResponseTime, defaults.cacheTtl, defaults.counter, defaults.lastNudgeTokens, defaults.lastNudgeBand ?? "", defaults.lastTransformError ?? "", defaults.isSubagent ? 1 : 0, defaults.lastContextPercentage, defaults.lastInputTokens, defaults.observedSafeInputTokens, defaults.cacheAlertSent ? 1 : 0, defaults.timesExecuteThresholdReached, defaults.compartmentInProgress ? 1 : 0, defaults.systemPromptHash ?? "", defaults.clearedReasoningThroughTag);
 }
 function toSessionMeta(row) {
   const nudgeBandRaw = typeof row.last_nudge_band === "string" ? row.last_nudge_band : "";
@@ -161372,6 +161743,8 @@ function toSessionMeta(row) {
     isSubagent: row.is_subagent === 1,
     lastContextPercentage: row.last_context_percentage,
     lastInputTokens: row.last_input_tokens,
+    observedSafeInputTokens: numOrZero(row.observed_safe_input_tokens),
+    cacheAlertSent: numOrZero(row.cache_alert_sent) === 1,
     timesExecuteThresholdReached: numOrZero(row.times_execute_threshold_reached),
     compartmentInProgress: row.compartment_in_progress === 1,
     systemPromptHash: String(systemPromptHashRaw),
@@ -161394,6 +161767,8 @@ var init_storage_meta_shared = __esm(() => {
     isSubagent: "is_subagent",
     lastContextPercentage: "last_context_percentage",
     lastInputTokens: "last_input_tokens",
+    observedSafeInputTokens: "observed_safe_input_tokens",
+    cacheAlertSent: "cache_alert_sent",
     timesExecuteThresholdReached: "times_execute_threshold_reached",
     compartmentInProgress: "compartment_in_progress",
     systemPromptHash: "system_prompt_hash",
@@ -161403,7 +161778,7 @@ var init_storage_meta_shared = __esm(() => {
     clearedReasoningThroughTag: "cleared_reasoning_through_tag",
     lastTodoState: "last_todo_state"
   };
-  BOOLEAN_META_KEYS = new Set(["isSubagent", "compartmentInProgress"]);
+  BOOLEAN_META_KEYS = new Set(["isSubagent", "compartmentInProgress", "cacheAlertSent"]);
 });
 
 // src/features/magic-context/storage-meta-persisted.ts
@@ -161437,6 +161812,38 @@ function isPersistedNoteNudgeRow(row) {
   const r = row;
   return typeof r.note_nudge_trigger_pending === "number" && typeof r.note_nudge_trigger_message_id === "string" && typeof r.note_nudge_sticky_text === "string" && typeof r.note_nudge_sticky_message_id === "string";
 }
+function isValidNoteNudgeAnchor(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  const row = value;
+  return typeof row.messageId === "string" && row.messageId.length > 0 && typeof row.text === "string" && row.text.length > 0;
+}
+function isValidAutoSearchHintDecision(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  const row = value;
+  if (typeof row.messageId !== "string" || row.messageId.length === 0)
+    return false;
+  if (row.decision === "hint") {
+    return typeof row.text === "string" && row.text.length > 0;
+  }
+  if (row.decision === "no-hint") {
+    return typeof row.reason === "string" && AUTO_SEARCH_NO_HINT_REASONS.has(row.reason);
+  }
+  return false;
+}
+function parseJsonArray(json2, validator) {
+  if (!json2)
+    return [];
+  try {
+    const parsed = JSON.parse(json2);
+    if (!Array.isArray(parsed))
+      return [];
+    return parsed.filter(validator);
+  } catch {
+    return [];
+  }
+}
 function isPersistedTodoSyntheticAnchorRow(row) {
   if (row === null || typeof row !== "object")
     return false;
@@ -161547,7 +161954,7 @@ function getPersistedNoteNudge(db, sessionId) {
 function setPersistedNoteNudgeTrigger(db, sessionId, triggerMessageId = "") {
   db.transaction(() => {
     ensureSessionMetaRow(db, sessionId);
-    db.prepare("UPDATE session_meta SET note_nudge_trigger_pending = 1, note_nudge_trigger_message_id = ?, note_nudge_sticky_text = '', note_nudge_sticky_message_id = '' WHERE session_id = ?").run(triggerMessageId, sessionId);
+    db.prepare("UPDATE session_meta SET note_nudge_trigger_pending = 1, note_nudge_trigger_message_id = ? WHERE session_id = ?").run(triggerMessageId, sessionId);
   })();
 }
 function setPersistedNoteNudgeTriggerMessageId(db, sessionId, triggerMessageId) {
@@ -161556,14 +161963,126 @@ function setPersistedNoteNudgeTriggerMessageId(db, sessionId, triggerMessageId)
     db.prepare("UPDATE session_meta SET note_nudge_trigger_message_id = ? WHERE session_id = ?").run(triggerMessageId, sessionId);
   })();
 }
-function setPersistedDeliveredNoteNudge(db, sessionId, text, messageId = "") {
-  db.transaction(() => {
+function getNoteNudgeAnchors(db, sessionId) {
+  const row = db.prepare("SELECT note_nudge_anchors FROM session_meta WHERE session_id = ?").get(sessionId);
+  return parseJsonArray(row?.note_nudge_anchors, isValidNoteNudgeAnchor);
+}
+function getAutoSearchHintDecisions(db, sessionId) {
+  const row = db.prepare("SELECT auto_search_hint_decisions FROM session_meta WHERE session_id = ?").get(sessionId);
+  return parseJsonArray(row?.auto_search_hint_decisions, isValidAutoSearchHintDecision);
+}
+function casUpdateJsonArrayColumn(db, sessionId, column, validator, mutate, options) {
+  if (options?.ensureRow === false) {
+    const exists = db.prepare("SELECT 1 FROM session_meta WHERE session_id = ?").get(sessionId);
+    if (!exists)
+      return true;
+  } else {
     ensureSessionMetaRow(db, sessionId);
-    db.prepare("UPDATE session_meta SET note_nudge_trigger_pending = 0, note_nudge_trigger_message_id = '', note_nudge_sticky_text = ?, note_nudge_sticky_message_id = ? WHERE session_id = ?").run(text, messageId, sessionId);
-  })();
+  }
+  for (let attempt = 0;attempt < CAS_RETRY_LIMIT; attempt += 1) {
+    const row = db.prepare(`SELECT ${column} FROM session_meta WHERE session_id = ?`).get(sessionId);
+    const currentBlob = row?.[column] ?? "[]";
+    const current = parseJsonArray(currentBlob, validator);
+    const next = mutate(current);
+    if (next === null)
+      return true;
+    const nextBlob = stableStringify(next);
+    if (nextBlob === currentBlob)
+      return true;
+    const result = db.prepare(`UPDATE session_meta SET ${column} = ? WHERE session_id = ? AND ${column} = ?`).run(nextBlob, sessionId, currentBlob);
+    if (result.changes > 0)
+      return true;
+  }
+  sessionLog(sessionId, `${column} CAS: ${CAS_RETRY_LIMIT} retries exhausted`);
+  return false;
 }
-function clearPersistedNoteNudge(db, sessionId) {
-  db.prepare("UPDATE session_meta SET note_nudge_trigger_pending = 0, note_nudge_trigger_message_id = '', note_nudge_sticky_text = '', note_nudge_sticky_message_id = '' WHERE session_id = ?").run(sessionId);
+function deliverNoteNudgeAtomic(db, sessionId, messageId, text) {
+  let plan = null;
+  const casOk = casUpdateJsonArrayColumn(db, sessionId, "note_nudge_anchors", isValidNoteNudgeAnchor, (current) => {
+    if (current.some((anchor) => anchor.messageId === messageId && anchor.text === text)) {
+      plan = { kind: "already-present" };
+      return null;
+    }
+    if (current.some((anchor) => anchor.messageId === messageId)) {
+      plan = { kind: "conflict" };
+      sessionLog(sessionId, "note-nudge: messageId conflict, refusing append");
+      return null;
+    }
+    plan = { kind: "appended" };
+    return [...current, { messageId, text }];
+  });
+  if (!casOk) {
+    sessionLog(sessionId, `note-nudge: CAS exhausted for ${messageId}; skipping wire append`);
+    return { ok: false, kind: "cas-exhausted" };
+  }
+  const committedPlan = plan;
+  if (!committedPlan) {
+    sessionLog(sessionId, "note-nudge: CAS reported success with no plan staged; treating as failure");
+    return { ok: false, kind: "cas-exhausted" };
+  }
+  if (committedPlan.kind === "conflict") {
+    return { ok: false, kind: "conflict" };
+  }
+  db.prepare("UPDATE session_meta SET note_nudge_trigger_pending = 0, note_nudge_trigger_message_id = '' WHERE session_id = ?").run(sessionId);
+  return { ok: true, kind: committedPlan.kind };
+}
+function appendAutoSearchHintDecision(db, sessionId, entry) {
+  if (!entry.messageId)
+    return { ok: false, kind: "cas-exhausted" };
+  let staged = null;
+  const casOk = casUpdateJsonArrayColumn(db, sessionId, "auto_search_hint_decisions", isValidAutoSearchHintDecision, (current) => {
+    const existing = current.find((decision) => decision.messageId === entry.messageId);
+    if (existing) {
+      staged = { kind: "already-present", decision: existing };
+      return null;
+    }
+    staged = { kind: "appended", decision: entry };
+    return [...current, entry];
+  });
+  if (!casOk)
+    return { ok: false, kind: "cas-exhausted" };
+  const committed = staged;
+  if (!committed) {
+    sessionLog(sessionId, "auto-search: CAS reported success with no staged outcome");
+    return { ok: false, kind: "cas-exhausted" };
+  }
+  return { ok: true, kind: committed.kind, decision: committed.decision };
+}
+function pruneNoteNudgeAnchors(db, sessionId, visibleMessageIds) {
+  let pruned = 0;
+  casUpdateJsonArrayColumn(db, sessionId, "note_nudge_anchors", isValidNoteNudgeAnchor, (current) => {
+    const next = current.filter((anchor) => visibleMessageIds.has(anchor.messageId));
+    pruned = current.length - next.length;
+    return pruned > 0 ? next : null;
+  });
+  return pruned;
+}
+function pruneAutoSearchHintDecisions(db, sessionId, visibleMessageIds) {
+  let pruned = 0;
+  casUpdateJsonArrayColumn(db, sessionId, "auto_search_hint_decisions", isValidAutoSearchHintDecision, (current) => {
+    const next = current.filter((decision) => visibleMessageIds.has(decision.messageId));
+    pruned = current.length - next.length;
+    return pruned > 0 ? next : null;
+  });
+  return pruned;
+}
+function removeNoteNudgeAnchorByMessageId(db, sessionId, messageId) {
+  let removed = false;
+  const ok = casUpdateJsonArrayColumn(db, sessionId, "note_nudge_anchors", isValidNoteNudgeAnchor, (current) => {
+    const next = current.filter((anchor) => anchor.messageId !== messageId);
+    removed = next.length !== current.length;
+    return removed ? next : null;
+  }, { ensureRow: false });
+  return ok && removed;
+}
+function removeAutoSearchHintDecisionByMessageId(db, sessionId, messageId) {
+  let removed = false;
+  const ok = casUpdateJsonArrayColumn(db, sessionId, "auto_search_hint_decisions", isValidAutoSearchHintDecision, (current) => {
+    const next = current.filter((decision) => decision.messageId !== messageId);
+    removed = next.length !== current.length;
+    return removed ? next : null;
+  }, { ensureRow: false });
+  return ok && removed;
 }
 function getPersistedTodoSyntheticAnchor(db, sessionId) {
   const result = db.prepare("SELECT todo_synthetic_call_id, todo_synthetic_anchor_message_id, todo_synthetic_state_json FROM session_meta WHERE session_id = ?").get(sessionId);
@@ -161645,9 +162164,9 @@ function recordOverflowDetected(db, sessionId, reportedLimit) {
   db.transaction(() => {
     ensureSessionMetaRow(db, sessionId);
     if (typeof reportedLimit === "number" && reportedLimit > 0) {
-      db.prepare("UPDATE session_meta SET detected_context_limit = ?, needs_emergency_recovery = 1 WHERE session_id = ?").run(reportedLimit, sessionId);
+      db.prepare("UPDATE session_meta SET detected_context_limit = ?, needs_emergency_recovery = 1, observed_safe_input_tokens = 0, cache_alert_sent = 0 WHERE session_id = ?").run(reportedLimit, sessionId);
     } else {
-      db.prepare("UPDATE session_meta SET needs_emergency_recovery = 1 WHERE session_id = ?").run(sessionId);
+      db.prepare("UPDATE session_meta SET needs_emergency_recovery = 1, observed_safe_input_tokens = 0, cache_alert_sent = 0 WHERE session_id = ?").run(sessionId);
     }
   })();
 }
@@ -161656,7 +162175,7 @@ function recordDetectedContextLimit(db, sessionId, reportedLimit) {
     return;
   db.transaction(() => {
     ensureSessionMetaRow(db, sessionId);
-    db.prepare("UPDATE session_meta SET detected_context_limit = ? WHERE session_id = ?").run(reportedLimit, sessionId);
+    db.prepare("UPDATE session_meta SET detected_context_limit = ?, observed_safe_input_tokens = 0, cache_alert_sent = 0 WHERE session_id = ?").run(reportedLimit, sessionId);
   })();
 }
 function clearEmergencyRecovery(db, sessionId) {
@@ -161771,9 +162290,18 @@ function getSessionsWithPendingMarker(db) {
                AND pending_compaction_marker_state != ''`).all();
   return rows.map((r) => r.session_id);
 }
+var CAS_RETRY_LIMIT = 5, AUTO_SEARCH_NO_HINT_REASONS;
 var init_storage_meta_persisted = __esm(() => {
   init_logger();
   init_storage_meta_shared();
+  AUTO_SEARCH_NO_HINT_REASONS = new Set([
+    "below-threshold",
+    "timeout",
+    "empty",
+    "error",
+    "stacked",
+    "too-short"
+  ]);
 });
 
 // src/features/magic-context/resolve-subagent-fallback.ts
@@ -161797,7 +162325,7 @@ var init_resolve_subagent_fallback = __esm(async () => {
 
 // src/features/magic-context/storage-meta-session.ts
 function getOrCreateSessionMeta(db, sessionId) {
-  const result = db.prepare("SELECT session_id, last_response_time, cache_ttl, counter, last_nudge_tokens, last_nudge_band, last_transform_error, is_subagent, last_context_percentage, last_input_tokens, times_execute_threshold_reached, compartment_in_progress, system_prompt_hash, system_prompt_tokens, conversation_tokens, tool_call_tokens, cleared_reasoning_through_tag, last_todo_state FROM session_meta WHERE session_id = ?").get(sessionId);
+  const result = db.prepare("SELECT session_id, last_response_time, cache_ttl, counter, last_nudge_tokens, last_nudge_band, last_transform_error, is_subagent, last_context_percentage, last_input_tokens, observed_safe_input_tokens, cache_alert_sent, times_execute_threshold_reached, compartment_in_progress, system_prompt_hash, system_prompt_tokens, conversation_tokens, tool_call_tokens, cleared_reasoning_through_tag, last_todo_state FROM session_meta WHERE session_id = ?").get(sessionId);
   if (isSessionMetaRow(result)) {
     return toSessionMeta(result);
   }
@@ -162298,12 +162826,12 @@ var init_storage = __esm(async () => {
 });
 
 // src/shared/models-dev-cache.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 import { existsSync as existsSync14, readFileSync as readFileSync11 } from "node:fs";
 import { homedir as homedir9, platform as platform3 } from "node:os";
 import { join as join19 } from "node:path";
 function hashFast(input) {
-  return createHash5("sha1").update(input).digest("hex");
+  return createHash7("sha1").update(input).digest("hex");
 }
 function getModelsJsonPath() {
   const explicit = process.env.OPENCODE_MODELS_PATH?.trim();
@@ -162410,17 +162938,9 @@ async function refreshModelLimitsFromApi(client) {
     apiCache = map2;
     apiLoadedAt = Date.now();
     if (previousSize === null) {
-      recentlySeenApiSizes.add(map2.size);
       sessionLog("global", `models-dev-cache: API layer loaded ${map2.size} model metadata entries`);
     } else if (previousSize !== map2.size) {
-      const sizeAlreadySeen = recentlySeenApiSizes.has(map2.size);
-      recentlySeenApiSizes.add(map2.size);
-      if (!sizeAlreadySeen) {
-        sessionLog("global", `models-dev-cache: API layer loaded ${map2.size} model metadata entries (was ${previousSize})`);
-      } else if (!oscillationLogged) {
-        oscillationLogged = true;
-        sessionLog("global", `models-dev-cache: API count oscillating between ${[...recentlySeenApiSizes].sort((a, b) => a - b).join(" ↔ ")} — likely upstream provider plugin returning slightly different model sets between calls (e.g. github-copilot's /models endpoint toggling model_picker_enabled). Suppressing further size-change logs.`);
-      }
+      sessionLog("global", `models-dev-cache: API layer loaded ${map2.size} model metadata entries (was ${previousSize})`);
     }
   } catch (error51) {
     sessionLog("global", "models-dev-cache: API refresh failed:", error51 instanceof Error ? error51.message : String(error51));
@@ -162440,13 +162960,12 @@ function getModelsDevContextLimit(providerID, modelID) {
   }
   return fileCache.get(key)?.limit;
 }
-var RELOAD_INTERVAL_MS, apiCache = null, apiLoadedAt = 0, recentlySeenApiSizes, oscillationLogged = false, fileCache = null, fileLastAttempt = 0;
+var RELOAD_INTERVAL_MS, apiCache = null, apiLoadedAt = 0, fileCache = null, fileLastAttempt = 0;
 var init_models_dev_cache = __esm(() => {
   init_data_path();
   init_jsonc_parser();
   init_logger();
   RELOAD_INTERVAL_MS = 5 * 60 * 1000;
-  recentlySeenApiSizes = new Set;
 });
 
 // src/shared/rpc-notifications.ts
@@ -164340,7 +164859,7 @@ function peekNoteNudgeText(db, sessionId, currentUserMessageId, projectIdentity,
   const deliveredAt = getPersistedNoteNudgeDeliveredAt(db, sessionId);
   if (deliveredAt > 0 && Date.now() - deliveredAt < NOTE_NUDGE_COOLDOWN_MS) {
     sessionLog(sessionId, `note-nudge: suppressing — last delivered ${Math.round((Date.now() - deliveredAt) / 1000)}s ago (cooldown ${NOTE_NUDGE_COOLDOWN_MS / 60000}m)`);
-    clearPersistedNoteNudge(db, sessionId);
+    clearNoteNudgeTriggerOnly(db, sessionId);
     return null;
   }
   const notes = getSessionNotes(db, sessionId);
@@ -164348,7 +164867,7 @@ function peekNoteNudgeText(db, sessionId, currentUserMessageId, projectIdentity,
   const totalCount = notes.length + readySmartNotes.length;
   if (totalCount === 0) {
     sessionLog(sessionId, "note-nudge: triggerPending but no notes found, skipping");
-    clearPersistedNoteNudge(db, sessionId);
+    clearNoteNudgeTriggerOnly(db, sessionId);
     return null;
   }
   const lastReadAt = getNoteLastReadAt(db, sessionId);
@@ -164356,7 +164875,7 @@ function peekNoteNudgeText(db, sessionId, currentUserMessageId, projectIdentity,
     const mostRecentNoteActivity = maxNoteActivityTime([...notes, ...readySmartNotes]);
     if (mostRecentNoteActivity > 0 && lastReadAt > mostRecentNoteActivity) {
       sessionLog(sessionId, `note-nudge: suppressing — agent ran ctx_note(read) at ${new Date(lastReadAt).toISOString()} and the read is still visible; no new notes since ${new Date(mostRecentNoteActivity).toISOString()}`);
-      clearPersistedNoteNudge(db, sessionId);
+      clearNoteNudgeTriggerOnly(db, sessionId);
       return null;
     }
   }
@@ -164381,22 +164900,28 @@ function maxNoteActivityTime(notes) {
   return max;
 }
 function markNoteNudgeDelivered(db, sessionId, text, messageId) {
-  setPersistedDeliveredNoteNudge(db, sessionId, messageId ? text : "", messageId ?? "");
-  recordNoteNudgeDeliveryTime(sessionId);
-  sessionLog(sessionId, messageId ? `note-nudge: marked delivered, sticky anchor=${messageId}` : "note-nudge: marked delivered without anchor");
+  if (!messageId) {
+    clearNoteNudgeTriggerAndCooldown(db, sessionId);
+    sessionLog(sessionId, "note-nudge: marked delivered without anchor");
+    return { ok: true, kind: "already-present" };
+  }
+  const outcome = deliverNoteNudgeAtomic(db, sessionId, messageId, text);
+  if (outcome.ok) {
+    recordNoteNudgeDeliveryTime(sessionId);
+  }
+  sessionLog(sessionId, outcome.ok ? `note-nudge: marked delivered, sticky anchor=${messageId} (${outcome.kind})` : `note-nudge: delivery not persisted for anchor=${messageId} (${outcome.kind})`);
+  return outcome;
 }
-function getStickyNoteNudge(db, sessionId) {
-  const state = getPersistedNoteNudge(db, sessionId);
-  if (!state.stickyText || !state.stickyMessageId)
-    return null;
-  return { text: state.stickyText, messageId: state.stickyMessageId };
+function clearNoteNudgeTriggerAndCooldown(db, sessionId) {
+  db.prepare("UPDATE session_meta SET note_nudge_trigger_pending = 0, note_nudge_trigger_message_id = '' WHERE session_id = ?").run(sessionId);
+  lastDeliveredAt.delete(sessionId);
 }
-function clearNoteNudgeState(db, sessionId, options) {
-  if (options?.persist !== false) {
-    clearPersistedNoteNudge(db, sessionId);
-  }
+function resetNoteNudgeCooldownOnly(sessionId) {
   lastDeliveredAt.delete(sessionId);
 }
+function clearNoteNudgeTriggerOnly(db, sessionId) {
+  db.prepare("UPDATE session_meta SET note_nudge_trigger_pending = 0, note_nudge_trigger_message_id = '' WHERE session_id = ?").run(sessionId);
+}
 var NOTE_NUDGE_COOLDOWN_MS, lastDeliveredAt;
 var init_note_nudger = __esm(() => {
   init_storage_meta_persisted();
@@ -164668,7 +165193,8 @@ var init_historian_state_file = __esm(() => {
 
 // src/features/magic-context/memory/embedding-backfill.ts
 async function ensureMemoryEmbeddings(args) {
-  if (!isEmbeddingEnabled()) {
+  const snapshot = getProjectEmbeddingSnapshot(args.projectIdentity);
+  if (!snapshot?.enabled) {
     return args.existingEmbeddings;
   }
   const missingMemories = args.memories.filter((memory) => !args.existingEmbeddings.has(memory.id));
@@ -164676,19 +165202,25 @@ async function ensureMemoryEmbeddings(args) {
     return args.existingEmbeddings;
   }
   try {
-    const embeddings = await embedBatch(missingMemories.map((memory) => memory.content));
-    const modelId = getEmbeddingModelId();
+    const result = await embedBatchForProject(args.projectIdentity, missingMemories.map((memory) => memory.content));
+    if (!result) {
+      return args.existingEmbeddings;
+    }
     const staged = new Map;
     args.db.transaction(() => {
       for (const [index, memory] of missingMemories.entries()) {
-        const embedding = embeddings[index];
+        const embedding = result.vectors[index];
         if (!embedding) {
           continue;
         }
-        saveEmbedding(args.db, memory.id, embedding, modelId);
+        saveEmbedding(args.db, memory.id, embedding, result.modelId);
         staged.set(memory.id, embedding);
       }
     })();
+    const currentSnapshot = getProjectEmbeddingSnapshot(args.projectIdentity);
+    if (!currentSnapshot || currentSnapshot.generation !== result.generation) {
+      return args.existingEmbeddings;
+    }
     for (const [id, embedding] of staged) {
       args.existingEmbeddings.set(id, embedding);
     }
@@ -164732,17 +165264,17 @@ function promoteSessionFactsToMemory(db, sessionId, projectPath, facts) {
         expiresAt: resolveExpiresAt(fact.category)
       };
       const memory = insertMemory(db, memoryInput);
-      embedAndStoreMemory(db, sessionId, memory.id, memory.content);
+      embedAndStoreMemory(db, sessionId, projectPath, memory.id, memory.content);
     } catch (error51) {
       sessionLog(sessionId, `memory promotion failed for fact "${fact.content.slice(0, 60)}":`, error51);
     }
   }
 }
-async function embedAndStoreMemory(db, sessionId, memoryId, content) {
+async function embedAndStoreMemory(db, sessionId, projectPath, memoryId, content) {
   try {
-    const embedding = await embedText(content);
-    if (embedding) {
-      saveEmbedding(db, memoryId, embedding, getEmbeddingModelId());
+    const result = await embedTextForProject(projectPath, content);
+    if (result) {
+      saveEmbedding(db, memoryId, result.vector, result.modelId);
     }
   } catch (error51) {
     sessionLog(sessionId, `memory embedding failed for memory ${memoryId}:`, error51);
@@ -165344,6 +165876,7 @@ No new compartments or facts were written. Check the historian model/output and
     }
     deps.onCompartmentStatePublished?.(sessionId);
     if (deps.directory && deps.memoryEnabled !== false && deps.autoPromote !== false) {
+      await deps.ensureProjectRegistered?.(deps.directory, db);
       promoteSessionFactsToMemory(db, sessionId, resolveProjectIdentity(deps.directory), validatedPass.facts ?? []);
     }
     queueDropsForCompartmentalizedMessages(db, sessionId, lastCompartmentEnd);
@@ -165446,7 +165979,33 @@ async function executeContextRecompInternal(deps) {
   let currentStateFilePath;
   updateSessionMeta(db, sessionId, { compartmentInProgress: true });
   try {
-    let promoteAndFinalize = function(reason) {
+    const protectedTailStart = getProtectedTailStartOrdinal(sessionId);
+    if (protectedTailStart <= 1) {
+      return `## Magic Recomp
+
+No eligible raw history exists before the protected tail, so nothing was rebuilt.`;
+    }
+    const rawMessageCount = getRawSessionMessageCount(sessionId);
+    const parentSessionResponse = await client.session.get({ path: { id: sessionId } }).catch(() => null);
+    const parentSession = normalizeSDKResponse(parentSessionResponse, null, { preferResponseOnMissingData: true });
+    const sessionDirectory = parentSession?.directory ?? directory;
+    const projectPath = directory ? resolveProjectIdentity(directory) : undefined;
+    const memories = projectPath ? getMemoriesByProject(db, projectPath, ["active", "permanent"]) : [];
+    const memoryBlock = renderMemoryBlock(memories) ?? undefined;
+    const existingStaging = getRecompStaging(db, sessionId);
+    let candidateCompartments = existingStaging?.compartments ?? [];
+    let candidateFacts = existingStaging?.facts ?? [];
+    let offset = existingStaging ? existingStaging.lastEndMessage + 1 : 1;
+    let passCount = existingStaging?.passCount ?? 0;
+    let currentTokenBudget = historianChunkTokens;
+    let passAttempt = 1;
+    const resumed = existingStaging !== null;
+    if (resumed) {
+      await sendIgnoredMessage(client, sessionId, `## Magic Recomp — Resumed
+
+Found ${existingStaging.compartments.length} staged compartment(s) from ${existingStaging.passCount} previous pass(es), covering messages 1-${existingStaging.lastEndMessage}. Resuming from message ${offset}.`, notifParams());
+    }
+    async function promoteAndFinalize(reason) {
       if (passCount === 0 || candidateCompartments.length === 0)
         return null;
       const mergedError = validateStoredCompartments(candidateCompartments);
@@ -165462,6 +166021,7 @@ async function executeContextRecompInternal(deps) {
       }
       deps.onCompartmentStatePublished?.(sessionId);
       if (deps.directory && deps.memoryEnabled !== false && deps.autoPromote !== false) {
+        await deps.ensureProjectRegistered?.(deps.directory, db);
         promoteSessionFactsToMemory(db, sessionId, resolveProjectIdentity(deps.directory), promoted2.facts);
       }
       const lastCompartmentEnd2 = promoted2.compartments[promoted2.compartments.length - 1]?.endMessage ?? 0;
@@ -165481,37 +166041,11 @@ async function executeContextRecompInternal(deps) {
         `Remaining messages ${lastCompartmentEnd2 + 1}-${protectedTailStart - 1} were not rebuilt (${reason}).`
       ].join(`
 `);
-    };
-    const protectedTailStart = getProtectedTailStartOrdinal(sessionId);
-    if (protectedTailStart <= 1) {
-      return `## Magic Recomp
-
-No eligible raw history exists before the protected tail, so nothing was rebuilt.`;
-    }
-    const rawMessageCount = getRawSessionMessageCount(sessionId);
-    const parentSessionResponse = await client.session.get({ path: { id: sessionId } }).catch(() => null);
-    const parentSession = normalizeSDKResponse(parentSessionResponse, null, { preferResponseOnMissingData: true });
-    const sessionDirectory = parentSession?.directory ?? directory;
-    const projectPath = directory ? resolveProjectIdentity(directory) : undefined;
-    const memories = projectPath ? getMemoriesByProject(db, projectPath, ["active", "permanent"]) : [];
-    const memoryBlock = renderMemoryBlock(memories) ?? undefined;
-    const existingStaging = getRecompStaging(db, sessionId);
-    let candidateCompartments = existingStaging?.compartments ?? [];
-    let candidateFacts = existingStaging?.facts ?? [];
-    let offset = existingStaging ? existingStaging.lastEndMessage + 1 : 1;
-    let passCount = existingStaging?.passCount ?? 0;
-    let currentTokenBudget = historianChunkTokens;
-    let passAttempt = 1;
-    const resumed = existingStaging !== null;
-    if (resumed) {
-      await sendIgnoredMessage(client, sessionId, `## Magic Recomp — Resumed
-
-Found ${existingStaging.compartments.length} staged compartment(s) from ${existingStaging.passCount} previous pass(es), covering messages 1-${existingStaging.lastEndMessage}. Resuming from message ${offset}.`, notifParams());
     }
     while (offset < protectedTailStart) {
       const chunk = readSessionChunk(sessionId, currentTokenBudget, offset, protectedTailStart);
       if (!chunk.text || chunk.messageCount === 0 || chunk.endIndex < offset) {
-        const promoted2 = promoteAndFinalize(`remaining messages ${offset}-${protectedTailStart - 1} were too few or all noise to form a historian chunk`);
+        const promoted2 = await promoteAndFinalize(`remaining messages ${offset}-${protectedTailStart - 1} were too few or all noise to form a historian chunk`);
         if (promoted2) {
           return `## Magic Recomp — Complete
 
@@ -165523,7 +166057,7 @@ Recomp stopped because raw history ${offset}-${protectedTailStart - 1} could not
       }
       const chunkCoverageError = validateChunkCoverage(chunk);
       if (chunkCoverageError) {
-        const partial2 = promoteAndFinalize(`chunk could not be represented safely: ${chunkCoverageError}`);
+        const partial2 = await promoteAndFinalize(`chunk could not be represented safely: ${chunkCoverageError}`);
         if (partial2) {
           return `## Magic Recomp — Partial
 
@@ -165584,7 +166118,7 @@ Validator result: ${validatedPass.error}`, notifParams());
             continue;
           }
         }
-        const partial2 = promoteAndFinalize(`historian failed to validate messages ${chunk.startIndex}-${chunk.endIndex}: ${validatedPass.error}`);
+        const partial2 = await promoteAndFinalize(`historian failed to validate messages ${chunk.startIndex}-${chunk.endIndex}: ${validatedPass.error}`);
         if (partial2) {
           return `## Magic Recomp — Partial
 
@@ -165607,7 +166141,7 @@ Nothing was written.`;
       saveRecompStagingPass(db, sessionId, passCount, candidateCompartments, candidateFacts);
       const nextOffset = (validatedPass.compartments?.[validatedPass.compartments.length - 1]?.endMessage ?? chunk.endIndex) + 1;
       if (nextOffset <= offset) {
-        const partial2 = promoteAndFinalize(`historian made no forward progress after messages ${chunk.startIndex}-${chunk.endIndex}`);
+        const partial2 = await promoteAndFinalize(`historian made no forward progress after messages ${chunk.startIndex}-${chunk.endIndex}`);
         if (partial2) {
           return `## Magic Recomp — Partial
 
@@ -165806,7 +166340,7 @@ __export(exports_tui_config, {
   ensureTuiPluginEntry: () => ensureTuiPluginEntry
 });
 import { existsSync as existsSync16, mkdirSync as mkdirSync9, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname8, join as join27 } from "node:path";
+import { dirname as dirname9, join as join27 } from "node:path";
 function isMagicContextEntry(entry) {
   if (!entry)
     return false;
@@ -165852,7 +166386,7 @@ function ensureTuiPluginEntry() {
       plugins.push(PLUGIN_ENTRY);
     }
     config2.plugin = plugins;
-    mkdirSync9(dirname8(configPath), { recursive: true });
+    mkdirSync9(dirname9(configPath), { recursive: true });
     writeFileSync8(configPath, `${import_comment_json4.stringify(config2, null, 2)}
 `);
     log(`[magic-context] updated TUI plugin entry in ${configPath}`);
@@ -165963,6 +166497,42 @@ function loadConfigFile(configPath) {
     return null;
   }
 }
+function loadConfigFileDetailed(configPath, source) {
+  if (!existsSync3(configPath)) {
+    return null;
+  }
+  let rawText;
+  try {
+    rawText = readFileSync3(configPath, "utf-8");
+  } catch (error51) {
+    return {
+      config: {},
+      warnings: [
+        `${configPath}: failed to read config: ${error51 instanceof Error ? error51.message : String(error51)}`
+      ],
+      outcome: "project-file-io-error",
+      source
+    };
+  }
+  try {
+    const substituted = substituteConfigVariables({ text: rawText, configPath });
+    return {
+      config: parseJsonc(substituted.text),
+      warnings: substituted.warnings.map((w) => `${configPath}: ${w}`),
+      outcome: substituted.warnings.length > 0 ? "substitution-failure" : "ok",
+      source
+    };
+  } catch (error51) {
+    return {
+      config: {},
+      warnings: [
+        `${configPath}: failed to load config: ${error51 instanceof Error ? error51.message : String(error51)}`
+      ],
+      outcome: "project-file-parse-error",
+      source
+    };
+  }
+}
 function deepMergeRawConfig(base, override) {
   const result = { ...base };
   for (const key of Object.keys(override)) {
@@ -166057,7 +166627,7 @@ function migrateLegacyExperimental(rawConfig, warnings) {
   patched.dreamer = dreamer;
   return patched;
 }
-function parsePluginConfig(rawConfig) {
+function parsePluginConfig(rawConfig, recoveredTopLevelKeys = []) {
   const preMigrationWarnings = [];
   const migrated = migrateLegacyExperimental(rawConfig, preMigrationWarnings);
   const parsed = MagicContextConfigSchema.safeParse(migrated);
@@ -166082,6 +166652,7 @@ function parsePluginConfig(rawConfig) {
   }
   const patched = { ...rawConfig };
   for (const key of errorPaths) {
+    recoveredTopLevelKeys.push(key);
     const isAgentConfig = key === "historian" || key === "dreamer" || key === "sidekick";
     if (isAgentConfig) {
       delete patched[key];
@@ -166152,6 +166723,102 @@ function loadPluginConfig(directory) {
   }
   return config2;
 }
+function collectEmptyStringPaths(value, prefix = "") {
+  if (typeof value === "string") {
+    return value === "" && prefix ? [prefix] : [];
+  }
+  if (Array.isArray(value) || value === null || typeof value !== "object") {
+    return [];
+  }
+  const paths = [];
+  for (const [key, child] of Object.entries(value)) {
+    const nextPrefix = prefix ? `${prefix}.${key}` : key;
+    paths.push(...collectEmptyStringPaths(child, nextPrefix));
+  }
+  return paths;
+}
+function bindSubstitutionFailures(loaded) {
+  if (!loaded || loaded.warnings.length === 0 || loaded.outcome !== "substitution-failure") {
+    return [];
+  }
+  const emptyPaths = collectEmptyStringPaths(loaded.config);
+  return loaded.warnings.map((message) => {
+    const matchedPath = emptyPaths.find((path) => {
+      const tail = path.split(".").at(-1) ?? path;
+      return message.includes(path) || message.toLowerCase().includes(tail.toLowerCase());
+    });
+    return { keyPath: matchedPath ?? "<unknown>", source: loaded.source, message };
+  });
+}
+function combinedOutcome(args) {
+  const sourceOutcomes = Object.values(args.sources);
+  if (sourceOutcomes.includes("project-file-parse-error"))
+    return "project-file-parse-error";
+  if (sourceOutcomes.includes("project-file-io-error"))
+    return "project-file-io-error";
+  if (args.recoveredTopLevelKeys.length > 0)
+    return "schema-recovery";
+  if (args.substitutionFailures.length > 0)
+    return "substitution-failure";
+  return "ok";
+}
+function loadPluginConfigDetailed(directory) {
+  const userDetected = detectConfigFile(getUserConfigBasePath());
+  const rootDetected = detectConfigFile(join(directory, CONFIG_FILE_BASENAME));
+  const dotOpenCodeDetected = detectConfigFile(getProjectConfigBasePath(directory));
+  const projectDetected = rootDetected.format !== "none" ? rootDetected : dotOpenCodeDetected;
+  const userLoaded = userDetected.format === "none" ? null : loadConfigFileDetailed(userDetected.path, "user");
+  const projectLoaded = projectDetected.format === "none" ? null : loadConfigFileDetailed(projectDetected.path, "project");
+  const allWarnings = [];
+  let mergedRaw = {};
+  if (userLoaded) {
+    allWarnings.push(...userLoaded.warnings.map((w) => `[user config] ${w}`));
+    mergedRaw = deepMergeRawConfig(mergedRaw, userLoaded.config);
+  }
+  if (projectLoaded) {
+    allWarnings.push(...projectLoaded.warnings.map((w) => `[project config] ${w}`));
+    const projectRaw = { ...projectLoaded.config };
+    const strippedUserOnlyFields = getProjectUserOnlyFields(projectRaw);
+    if (strippedUserOnlyFields.length > 0) {
+      for (const key of strippedUserOnlyFields) {
+        delete projectRaw[key];
+      }
+      allWarnings.push(`[project config] Ignoring ${strippedUserOnlyFields.join(", ")} from project config (security: these settings only honor user-level config)`);
+    }
+    mergedRaw = deepMergeRawConfig(mergedRaw, projectRaw);
+  }
+  const recoveredTopLevelKeys = [];
+  const config2 = parsePluginConfig(mergedRaw, recoveredTopLevelKeys);
+  if (config2.configWarnings?.length) {
+    allWarnings.push(...config2.configWarnings.map((w) => {
+      if (userLoaded && projectLoaded)
+        return `[config] ${w}`;
+      if (userLoaded)
+        return `[user config] ${w}`;
+      return `[project config] ${w}`;
+    }));
+  }
+  if (allWarnings.length > 0) {
+    config2.configWarnings = allWarnings;
+  } else if ("configWarnings" in config2) {
+    config2.configWarnings = undefined;
+  }
+  const substitutionFailures = [
+    ...bindSubstitutionFailures(userLoaded),
+    ...bindSubstitutionFailures(projectLoaded)
+  ];
+  const sources = {
+    userConfig: userLoaded?.outcome ?? "ok",
+    projectConfig: projectLoaded?.outcome ?? "ok"
+  };
+  return {
+    config: config2,
+    loadOutcome: combinedOutcome({ sources, substitutionFailures, recoveredTopLevelKeys }),
+    sources,
+    substitutionFailures,
+    recoveredTopLevelKeys
+  };
+}
 
 // src/features/builtin-commands/commands.ts
 function getMagicContextBuiltinCommands() {
@@ -166545,6 +167212,9 @@ function buildDreamTaskPrompt(task, args) {
   }
 }
 
+// src/index.ts
+init_project_identity();
+
 // src/features/magic-context/sidekick/agent.ts
 init_shared();
 init_assistant_message_extractor();
@@ -167425,10 +168095,10 @@ import { existsSync as existsSync9, readFileSync as readFileSync8 } from "node:f
 import { homedir as homedir8 } from "node:os";
 import { join as join11 } from "node:path";
 var overrideAvailability = null;
-function parseConfig(path4) {
-  if (!existsSync9(path4))
+function parseConfig(path5) {
+  if (!existsSync9(path5))
     return null;
-  return import_comment_json3.parse(readFileSync8(path4, "utf-8"));
+  return import_comment_json3.parse(readFileSync8(path5, "utf-8"));
 }
 function entryMatchesAft(entry) {
   const value = Array.isArray(entry) ? entry[0] : entry;
@@ -167456,9 +168126,9 @@ function getAftAvailability() {
   const piPaths = [join11(home, ".pi", "agent", "settings.json")];
   const checkedPaths = [...opencodePaths, ...piPaths];
   let opencode = false;
-  for (const path4 of opencodePaths) {
+  for (const path5 of opencodePaths) {
     try {
-      const config2 = parseConfig(path4);
+      const config2 = parseConfig(path5);
       if (hasAftAtKeys(config2, ["plugin", "plugins", "mcp", "mcp_servers"])) {
         opencode = true;
         break;
@@ -167466,9 +168136,9 @@ function getAftAvailability() {
     } catch {}
   }
   let pi = false;
-  for (const path4 of piPaths) {
+  for (const path5 of piPaths) {
     try {
-      const config2 = parseConfig(path4);
+      const config2 = parseConfig(path5);
       if (hasAftAtKeys(config2, ["packages", "extensions"])) {
         pi = true;
         break;
@@ -168866,7 +169536,7 @@ init_logger();
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 var execFileAsync = promisify(execFile);
-var GIT_TIMEOUT_MS = 1e4;
+var GIT_TIMEOUT_MS2 = 1e4;
 var DEFAULT_MAX_COMMITS = 5000;
 var RECORD_SEPARATOR = "\x1E";
 var FIELD_SEPARATOR = "\x1F";
@@ -168886,7 +169556,7 @@ async function readGitCommits(directory, options = {}) {
   try {
     const result = await execFileAsync("git", args, {
       cwd: directory,
-      timeout: GIT_TIMEOUT_MS,
+      timeout: GIT_TIMEOUT_MS2,
       maxBuffer: 32 * 1024 * 1024,
       encoding: "utf8"
     });
@@ -168944,79 +169614,7 @@ ${body}` : subject;
 // src/features/magic-context/git-commits/indexer.ts
 init_logger();
 init_embedding();
-
-// src/features/magic-context/git-commits/storage-git-commit-embeddings.ts
-var saveStatements = new WeakMap;
-var loadProjectStatements = new WeakMap;
-var loadUnembeddedStatements = new WeakMap;
-var countEmbeddedStatements = new WeakMap;
-var clearProjectStatements = new WeakMap;
-function getSaveStatement(db) {
-  let stmt = saveStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare(`INSERT INTO git_commit_embeddings (sha, embedding, model_id, created_at)
-             VALUES (?, ?, ?, ?)
-             ON CONFLICT(sha) DO UPDATE SET
-                 embedding = excluded.embedding,
-                 model_id = excluded.model_id,
-                 created_at = excluded.created_at`);
-    saveStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getLoadProjectStatement(db) {
-  let stmt = loadProjectStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare(`SELECT e.sha AS sha, e.embedding AS embedding, e.model_id AS model_id
-             FROM git_commit_embeddings e
-             JOIN git_commits c ON c.sha = e.sha
-             WHERE c.project_path = ?`);
-    loadProjectStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getLoadUnembeddedStatement(db) {
-  let stmt = loadUnembeddedStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare(`SELECT c.sha AS sha, c.message AS message
-             FROM git_commits c
-             LEFT JOIN git_commit_embeddings e ON c.sha = e.sha
-             WHERE c.project_path = ? AND e.sha IS NULL
-             ORDER BY c.committed_at DESC
-             LIMIT ?`);
-    loadUnembeddedStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getCountEmbeddedStatement(db) {
-  let stmt = countEmbeddedStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare(`SELECT COUNT(*) AS count FROM git_commit_embeddings e
-             JOIN git_commits c ON c.sha = e.sha WHERE c.project_path = ?`);
-    countEmbeddedStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function saveCommitEmbedding(db, sha, embedding, modelId) {
-  const bytes = new Uint8Array(embedding.buffer, embedding.byteOffset, embedding.byteLength);
-  getSaveStatement(db).run(sha, bytes, modelId, Date.now());
-}
-function loadProjectCommitEmbeddings(db, projectPath) {
-  const rows = getLoadProjectStatement(db).all(projectPath);
-  const map2 = new Map;
-  for (const row of rows) {
-    const buffer2 = row.embedding.buffer.slice(row.embedding.byteOffset, row.embedding.byteOffset + row.embedding.byteLength);
-    map2.set(row.sha, new Float32Array(buffer2));
-  }
-  return map2;
-}
-function loadUnembeddedCommits(db, projectPath, limit) {
-  return getLoadUnembeddedStatement(db).all(projectPath, limit);
-}
-function countEmbeddedCommits(db, projectPath) {
-  const row = getCountEmbeddedStatement(db).get(projectPath);
-  return row?.count ?? 0;
-}
+init_storage_git_commit_embeddings();
 
 // src/features/magic-context/git-commits/storage-git-commits.ts
 init_logger();
@@ -169143,7 +169741,7 @@ var EMBED_MAX_PER_SWEEP = 500;
 var EMBED_SWEEP_MAX_WALL_CLOCK_MS = 5 * 60 * 1000;
 var indexInProgress = new Set;
 var embedInProgress = new Set;
-async function indexCommitsForProject(db, projectPath, directory, embeddingConfig2, options) {
+async function indexCommitsForProject(db, projectPath, directory, options) {
   const result = {
     scanned: 0,
     inserted: 0,
@@ -169174,22 +169772,24 @@ async function indexCommitsForProject(db, projectPath, directory, embeddingConfi
     result.inserted = upsert.inserted;
     result.updated = upsert.updated;
     result.evicted = enforceProjectCap(db, projectPath, options.maxCommits);
-    if (options.skipEmbed || !isEmbeddingEnabled()) {
-      log(`[git-commits] indexed ${projectPath}: scanned=${result.scanned} inserted=${result.inserted} updated=${result.updated} evicted=${result.evicted} embedded=0 (embedding skipped: skipEmbed=${options.skipEmbed === true} embeddingEnabled=${isEmbeddingEnabled()})`);
+    const snapshot = getProjectEmbeddingSnapshot(projectPath);
+    if (options.skipEmbed || !snapshot?.gitCommitEnabled) {
+      log(`[git-commits] indexed ${projectPath}: scanned=${result.scanned} inserted=${result.inserted} updated=${result.updated} evicted=${result.evicted} embedded=0 (embedding skipped: skipEmbed=${options.skipEmbed === true} gitCommitEnabled=${snapshot?.gitCommitEnabled === true})`);
       return result;
     }
-    result.embedded = await embedUnembeddedCommits(db, projectPath, embeddingConfig2);
+    result.embedded = await embedUnembeddedCommits(db, projectPath);
     log(`[git-commits] indexed ${projectPath}: scanned=${result.scanned} inserted=${result.inserted} updated=${result.updated} evicted=${result.evicted} embedded=${result.embedded}`);
     return result;
   } finally {
     indexInProgress.delete(projectPath);
   }
 }
-async function embedUnembeddedCommits(db, projectPath, _config) {
+async function embedUnembeddedCommits(db, projectPath) {
   if (embedInProgress.has(projectPath)) {
     return 0;
   }
-  if (!isEmbeddingEnabled()) {
+  const snapshot = getProjectEmbeddingSnapshot(projectPath);
+  if (!snapshot?.gitCommitEnabled) {
     return 0;
   }
   embedInProgress.add(projectPath);
@@ -169203,16 +169803,15 @@ async function embedUnembeddedCommits(db, projectPath, _config) {
         break;
       let embeddedThisBatch = 0;
       try {
-        const embeddings = await embedBatch(rows.map((row) => row.message));
-        const modelId = getEmbeddingModelId();
-        if (modelId === "off")
+        const result = await embedBatchForProject(projectPath, rows.map((row) => row.message));
+        if (!result)
           break;
         db.transaction(() => {
           for (const [index, row] of rows.entries()) {
-            const embedding = embeddings[index];
+            const embedding = result.vectors[index];
             if (!embedding)
               continue;
-            saveCommitEmbedding(db, row.sha, embedding, modelId);
+            saveCommitEmbedding(db, row.sha, embedding, result.modelId);
             embeddedThisBatch += 1;
           }
         })();
@@ -169238,6 +169837,7 @@ async function embedUnembeddedCommits(db, projectPath, _config) {
 // src/features/magic-context/git-commits/search-git-commits.ts
 init_logger();
 init_storage_memory_fts();
+init_storage_git_commit_embeddings();
 var ftsStatements = new WeakMap;
 var ftsPlainStatements = new WeakMap;
 var getBySHAStatements = new WeakMap;
@@ -169368,19 +169968,25 @@ function searchGitCommitsSync(db, projectPath, query, options) {
   });
   return results.slice(0, options.limit);
 }
+
+// src/features/magic-context/git-commits/index.ts
+init_storage_git_commit_embeddings();
+
 // src/plugin/dream-timer.ts
 init_embedding();
-init_project_identity();
 init_logger();
 init_resolve_fallbacks();
 await init_storage();
 var DREAM_TIMER_INTERVAL_MS = 15 * 60 * 1000;
 var activeTimer = null;
 var registeredProjects = new Map;
-function startDreamScheduleTimer(args) {
+async function startDreamScheduleTimer(args) {
+  const db = openDatabase();
+  await args.ensureRegistered(args.directory, db);
+  const snapshot = getProjectEmbeddingSnapshot(args.projectIdentity);
   const dreamingEnabled = Boolean(args.dreamerConfig?.enabled && args.dreamerConfig.schedule?.trim());
-  const embeddingSweepEnabled = args.memoryEnabled && args.embeddingConfig.provider !== "off";
-  const commitIndexingEnabled = args.gitCommitIndexing?.enabled === true;
+  const embeddingSweepEnabled = snapshot?.enabled ?? false;
+  const commitIndexingEnabled = snapshot?.gitCommitEnabled ?? false;
   if (!dreamingEnabled && !embeddingSweepEnabled && !commitIndexingEnabled) {
     return;
   }
@@ -169412,45 +170018,43 @@ function startDreamScheduleTimer(args) {
 }
 function runTick(origin) {
   log(`[dreamer] timer tick (${origin}) — projects=${registeredProjects.size}`);
-  try {
-    const anyEmbeddingEnabled = Array.from(registeredProjects.values()).some((r) => r.memoryEnabled && r.embeddingConfig.provider !== "off");
-    if (anyEmbeddingEnabled) {
-      const first = registeredProjects.values().next().value;
-      if (first) {
-        embedAllUnembeddedMemories(openDatabase(), first.embeddingConfig).then((embeddedCount) => {
+  (async () => {
+    try {
+      const db = openDatabase();
+      for (const reg of registeredProjects.values()) {
+        await reg.ensureRegistered(reg.directory, db);
+        const memorySnapshot = getProjectEmbeddingSnapshot(reg.projectIdentity);
+        if (memorySnapshot?.enabled) {
+          const embeddedCount = await embedUnembeddedMemoriesForProject(db, reg.projectIdentity);
           if (embeddedCount > 0) {
-            log(`[magic-context] proactively embedded ${embeddedCount} ${embeddedCount === 1 ? "memory" : "memories"} across all projects`);
+            log(`[magic-context] proactively embedded ${embeddedCount} ${embeddedCount === 1 ? "memory" : "memories"} for project ${reg.projectIdentity}`);
           }
-        }).catch((error51) => {
-          log("[magic-context] periodic memory embedding sweep failed:", error51);
-        });
+        }
+        await reg.ensureRegistered(reg.directory, db);
+        const gitSnapshot = getProjectEmbeddingSnapshot(reg.projectIdentity);
+        await sweepProject(reg, origin, db, gitSnapshot?.gitCommitEnabled === true);
       }
+    } catch (error51) {
+      log("[magic-context] timer-triggered maintenance check failed:", error51);
     }
-    for (const reg of registeredProjects.values()) {
-      sweepProject(reg, origin);
-    }
-  } catch (error51) {
-    log("[magic-context] timer-triggered maintenance check failed:", error51);
-  }
+  })();
 }
-async function sweepProject(reg, origin) {
+async function sweepProject(reg, origin, db = openDatabase(), gitCommitEnabled = getProjectEmbeddingSnapshot(reg.projectIdentity)?.gitCommitEnabled === true) {
   const dreamingEnabled = Boolean(reg.dreamerConfig?.enabled && reg.dreamerConfig.schedule?.trim());
-  const commitIndexingEnabled = reg.gitCommitIndexing?.enabled === true;
-  if (commitIndexingEnabled && reg.gitCommitIndexing) {
+  if (gitCommitEnabled && reg.gitCommitIndexing) {
     await sweepGitCommits({
       directory: reg.directory,
       gitCommitIndexing: reg.gitCommitIndexing,
-      embeddingConfig: reg.embeddingConfig
+      projectIdentity: reg.projectIdentity,
+      db
     });
   }
   if (!dreamingEnabled || !reg.dreamerConfig?.schedule?.trim()) {
     return;
   }
   try {
-    const db = openDatabase();
     log(`[dreamer] timer tick (${origin}) ${reg.directory} — checking schedule window "${reg.dreamerConfig.schedule}"`);
-    const registrationIdentity = resolveProjectIdentity(reg.directory);
-    checkScheduleAndEnqueue(db, reg.dreamerConfig.schedule, registrationIdentity);
+    checkScheduleAndEnqueue(db, reg.dreamerConfig.schedule, reg.projectIdentity);
     await processDreamQueue({
       db,
       client: reg.client,
@@ -169459,7 +170063,7 @@ async function sweepProject(reg, origin) {
       maxRuntimeMinutes: reg.dreamerConfig.max_runtime_minutes,
       experimentalUserMemories: reg.experimentalUserMemories,
       experimentalPinKeyFiles: reg.experimentalPinKeyFiles,
-      projectIdentity: registrationIdentity,
+      projectIdentity: reg.projectIdentity,
       fallbackModels: resolveFallbackChain(DREAMER_AGENT, reg.dreamerConfig.fallback_models)
     });
   } catch (error51) {
@@ -169467,28 +170071,124 @@ async function sweepProject(reg, origin) {
   }
 }
 async function sweepGitCommits(args) {
-  const { directory, gitCommitIndexing, embeddingConfig: embeddingConfig2 } = args;
+  const { directory, projectIdentity, db, gitCommitIndexing } = args;
   const startedAt = Date.now();
-  log(`[git-commits] sweep starting for ${directory} (sinceDays=${gitCommitIndexing.since_days} maxCommits=${gitCommitIndexing.max_commits} embedding=${embeddingConfig2.provider})`);
+  log(`[git-commits] sweep starting for ${directory} (sinceDays=${gitCommitIndexing.since_days} maxCommits=${gitCommitIndexing.max_commits})`);
   try {
-    const db = openDatabase();
-    const projectPath = resolveProjectIdentity(directory);
-    const result = await indexCommitsForProject(db, projectPath, directory, embeddingConfig2, {
+    const result = await indexCommitsForProject(db, projectIdentity, directory, {
       sinceDays: gitCommitIndexing.since_days,
       maxCommits: gitCommitIndexing.max_commits
     });
     let drainedEmbeddings = 0;
-    if (embeddingConfig2.provider !== "off" && result.embedded > 0) {
-      drainedEmbeddings = await embedUnembeddedCommits(db, projectPath, embeddingConfig2);
+    if (result.embedded > 0) {
+      drainedEmbeddings = await embedUnembeddedCommits(db, projectIdentity);
     }
     const elapsedMs = Date.now() - startedAt;
-    log(`[git-commits] sweep finished for ${projectPath} in ${elapsedMs}ms: scanned=${result.scanned} inserted=${result.inserted} updated=${result.updated} evicted=${result.evicted} embedded=${result.embedded} drained=${drainedEmbeddings}`);
+    log(`[git-commits] sweep finished for ${projectIdentity} in ${elapsedMs}ms: scanned=${result.scanned} inserted=${result.inserted} updated=${result.updated} evicted=${result.evicted} embedded=${result.embedded} drained=${drainedEmbeddings}`);
   } catch (error51) {
     const elapsedMs = Date.now() - startedAt;
     log(`[git-commits] sweep failed for ${directory} after ${elapsedMs}ms: ${error51 instanceof Error ? error51.message : String(error51)}`);
   }
 }
 
+// src/plugin/embedding-bootstrap.ts
+init_embedding();
+init_embedding_cache();
+init_project_identity();
+
+// src/plugin/embedding-bootstrap-helpers.ts
+init_embedding();
+init_logger();
+import { createHash as createHash6 } from "node:crypto";
+var EMBEDDING_AFFECTING_KEYS = new Set([
+  "embedding.api_key",
+  "embedding.endpoint",
+  "embedding.model",
+  "embedding.provider"
+]);
+var EMBEDDING_AFFECTING_TOP_LEVEL_KEYS = new Set(["embedding", "memory", "experimental"]);
+var EMBEDDING_WARNING_TERMS = ["api_key", "endpoint", "model", "provider", "embedding"];
+var loggedFailureSignatures = new Map;
+function sha256Prefix2(value, length = 16) {
+  return createHash6("sha256").update(value).digest("hex").slice(0, length);
+}
+function warningLooksEmbeddingRelated(message) {
+  const lower = message.toLowerCase();
+  return EMBEDDING_WARNING_TERMS.some((term) => lower.includes(term));
+}
+function isConfigLoadUntrusted(detailed) {
+  if (detailed.sources.userConfig === "project-file-parse-error" || detailed.sources.userConfig === "project-file-io-error" || detailed.sources.projectConfig === "project-file-parse-error" || detailed.sources.projectConfig === "project-file-io-error") {
+    return true;
+  }
+  for (const failure of detailed.substitutionFailures) {
+    if (EMBEDDING_AFFECTING_KEYS.has(failure.keyPath)) {
+      return true;
+    }
+    if (failure.keyPath === "<unknown>" && warningLooksEmbeddingRelated(failure.message)) {
+      return true;
+    }
+  }
+  for (const recoveredKey of detailed.recoveredTopLevelKeys) {
+    if (EMBEDDING_AFFECTING_TOP_LEVEL_KEYS.has(recoveredKey)) {
+      return true;
+    }
+  }
+  return false;
+}
+function describeFailure(detailed) {
+  const parts = [];
+  for (const [source, outcome] of Object.entries(detailed.sources)) {
+    if (outcome !== "ok") {
+      parts.push(`${source}=${outcome}`);
+    }
+  }
+  if (detailed.substitutionFailures.length > 0) {
+    parts.push(`substitution=${detailed.substitutionFailures.map((failure) => `${failure.source}:${failure.keyPath}`).join(",")}`);
+  }
+  if (detailed.recoveredTopLevelKeys.length > 0) {
+    parts.push(`recovered=${detailed.recoveredTopLevelKeys.join(",")}`);
+  }
+  return parts.length > 0 ? parts.join("; ") : detailed.loadOutcome;
+}
+function logConfigFailureOnce(projectIdentity, detailed) {
+  const signature = sha256Prefix2(JSON.stringify({
+    outcomes: detailed.sources,
+    substitutions: detailed.substitutionFailures.map((failure) => `${failure.source}:${failure.keyPath}:${failure.message}`).sort(),
+    recoveredTopLevelKeys: [...detailed.recoveredTopLevelKeys].sort()
+  }));
+  const existing = loggedFailureSignatures.get(projectIdentity) ?? new Set;
+  if (existing.has(signature))
+    return;
+  existing.add(signature);
+  loggedFailureSignatures.set(projectIdentity, existing);
+  log(`[mc][embedding] config load untrusted, preserving last-known-good for ${projectIdentity} — ${describeFailure(detailed)}`);
+}
+function handleUntrustedLoad(db, projectIdentity, directory, detailed) {
+  const prior = getProjectEmbeddingSnapshot(projectIdentity);
+  if (prior && !prior.runtimeFingerprint.startsWith("observation:")) {
+    logConfigFailureOnce(projectIdentity, detailed);
+    return true;
+  }
+  registerProjectInObservationMode(db, projectIdentity, directory, detailed.config.embedding, describeFailure(detailed));
+  return true;
+}
+
+// src/plugin/embedding-bootstrap.ts
+async function ensureProjectRegisteredFromOpenCodeDirectory(directory, db) {
+  const projectIdentity = resolveProjectIdentity(directory);
+  invalidateProject(projectIdentity);
+  const detailed = loadPluginConfigDetailed(directory);
+  if (isConfigLoadUntrusted(detailed)) {
+    handleUntrustedLoad(db, projectIdentity, directory, detailed);
+    return;
+  }
+  const features = {
+    memoryEnabled: detailed.config.memory.enabled,
+    gitCommitEnabled: detailed.config.experimental.git_commit_indexing.enabled
+  };
+  registerProjectEmbeddingAndMaybeWipe(db, projectIdentity, detailed.config.embedding, features, directory);
+}
+
 // src/plugin/event.ts
 function createEventHandler(args) {
   return async (input) => {
@@ -169987,9 +170687,9 @@ function createTagger() {
 // src/hooks/magic-context/hook.ts
 init_magic_context();
 init_project_identity();
+await init_storage();
 init_logger();
 init_resolve_fallbacks();
-await init_storage();
 
 // src/hooks/magic-context/command-handler.ts
 init_shared();
@@ -170770,6 +171470,7 @@ function clearSessionTracking(sessionId) {
 init_overflow_detection();
 init_storage_meta_persisted();
 init_logger();
+init_models_dev_cache();
 await __promiseAll([
   init_storage(),
   init_compaction_marker_manager()
@@ -170872,6 +171573,7 @@ function getMessageRemovedInfo(properties) {
 
 // src/hooks/magic-context/event-handler.ts
 init_note_nudger();
+init_send_session_notification();
 await init_read_session_chunk();
 
 // src/hooks/magic-context/transform.ts
@@ -171728,6 +172430,7 @@ async function runCompartmentPhase(args) {
         fallbackModels: args.fallbackModels,
         directory: args.compartmentDirectory,
         fallbackModelId: args.fallbackModelId,
+        ensureProjectRegistered: args.ensureProjectRegistered,
         getNotificationParams: args.getNotificationParams,
         experimentalCompactionMarkers: args.experimentalCompactionMarkers,
         experimentalUserMemories: args.experimentalUserMemories,
@@ -171757,6 +172460,7 @@ async function runCompartmentPhase(args) {
         fallbackModels: args.fallbackModels,
         directory: args.compartmentDirectory,
         fallbackModelId: args.fallbackModelId,
+        ensureProjectRegistered: args.ensureProjectRegistered,
         getNotificationParams: args.getNotificationParams,
         experimentalCompactionMarkers: args.experimentalCompactionMarkers,
         experimentalUserMemories: args.experimentalUserMemories,
@@ -172627,6 +173331,9 @@ function applyContextNudge(messages, nudge, nudgePlacements, sessionId) {
   }
 }
 
+// src/hooks/magic-context/auto-search-runner.ts
+init_embedding();
+
 // src/features/magic-context/search.ts
 init_logger();
 init_memory();
@@ -172687,6 +173394,7 @@ async function getSemanticScores(args) {
   const cachedEmbeddings = getProjectEmbeddings(args.db, args.projectPath);
   const embeddings = await ensureMemoryEmbeddings({
     db: args.db,
+    projectIdentity: args.projectPath,
     memories: args.memories,
     existingEmbeddings: cachedEmbeddings
   });
@@ -172962,6 +173670,7 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
 }
 
 // src/hooks/magic-context/auto-search-runner.ts
+init_storage_meta_persisted();
 init_logger();
 
 // src/hooks/magic-context/auto-search-hint.ts
@@ -173043,7 +173752,6 @@ ${trimmedBody}…
 }
 
 // src/hooks/magic-context/auto-search-runner.ts
-var autoSearchByTurn = new Map;
 var AUTO_SEARCH_TIMEOUT_MS = 3000;
 async function unifiedSearchWithTimeout(db, sessionId, projectPath, prompt, options, timeoutMs) {
   const controller = new AbortController;
@@ -173135,66 +173843,101 @@ async function runAutoSearchHint(args) {
   if (!userMsg || typeof userMsg.info.id !== "string")
     return;
   const userMsgId = userMsg.info.id;
-  const cached2 = autoSearchByTurn.get(sessionId);
-  if (cached2 && cached2.messageId === userMsgId) {
-    appendReminderToUserMessageById(messages, userMsgId, cached2.hint);
+  const existing = getAutoSearchHintDecisions(db, sessionId);
+  const existingForMessage = existing.find((decision) => decision.messageId === userMsgId);
+  if (existingForMessage) {
+    if (existingForMessage.decision === "hint") {
+      appendReminderToUserMessageById(messages, userMsgId, existingForMessage.text);
+    }
     return;
   }
+  const writeNoHintAndReconcile = (reason) => {
+    const outcome2 = appendAutoSearchHintDecision(db, sessionId, {
+      messageId: userMsgId,
+      decision: "no-hint",
+      reason
+    });
+    if (!outcome2.ok)
+      return;
+    if (outcome2.kind === "already-present" && outcome2.decision.decision === "hint") {
+      appendReminderToUserMessageById(messages, userMsgId, outcome2.decision.text);
+    }
+  };
   const rawPartsText = collectUserPromptParts(userMsg);
   if (hasStackedAugmentation(rawPartsText)) {
     sessionLog(sessionId, "auto-search: skipping — user message already carries augmentation/hint");
-    autoSearchByTurn.set(sessionId, { messageId: userMsgId, hint: "" });
+    writeNoHintAndReconcile("stacked");
     return;
   }
   const rawPrompt = extractUserPromptText(userMsg);
   if (rawPrompt.length < options.minPromptChars) {
-    autoSearchByTurn.set(sessionId, { messageId: userMsgId, hint: "" });
+    writeNoHintAndReconcile("too-short");
     return;
   }
   let results;
   try {
+    if (options.directory) {
+      await options.ensureProjectRegistered?.(options.directory, db);
+    }
+    const embeddingSnapshot = getProjectEmbeddingSnapshot(options.projectPath);
+    const memoryEnabled = embeddingSnapshot?.features.memoryEnabled ?? options.memoryEnabled;
+    const embeddingEnabled = embeddingSnapshot ? embeddingSnapshot.enabled || embeddingSnapshot.gitCommitEnabled : options.embeddingEnabled;
+    const gitCommitsEnabled = embeddingSnapshot?.gitCommitEnabled ?? options.gitCommitsEnabled ?? false;
     const searchOptions = {
       limit: 10,
-      memoryEnabled: options.memoryEnabled,
-      embeddingEnabled: options.embeddingEnabled,
-      gitCommitsEnabled: options.gitCommitsEnabled,
+      memoryEnabled,
+      embeddingEnabled,
+      gitCommitsEnabled,
+      embedQuery: async (text, signal) => {
+        const result = await embedTextForProject(options.projectPath, text, signal);
+        return result?.vector ?? null;
+      },
+      isEmbeddingRuntimeEnabled: () => embeddingEnabled === true,
       visibleMemoryIds: options.visibleMemoryIds ?? null
     };
     results = await unifiedSearchWithTimeout(db, sessionId, options.projectPath, rawPrompt, searchOptions, AUTO_SEARCH_TIMEOUT_MS);
   } catch (error51) {
     log(`[auto-search] unified search failed for session ${sessionId}: ${error51 instanceof Error ? error51.message : String(error51)}`);
-    autoSearchByTurn.set(sessionId, { messageId: userMsgId, hint: "" });
+    writeNoHintAndReconcile("error");
     return;
   }
   if (results === null) {
     sessionLog(sessionId, `auto-search: timed out after ${AUTO_SEARCH_TIMEOUT_MS}ms, skipping hint for this turn`);
-    autoSearchByTurn.set(sessionId, { messageId: userMsgId, hint: "" });
+    writeNoHintAndReconcile("timeout");
     return;
   }
   if (results.length === 0) {
-    autoSearchByTurn.set(sessionId, { messageId: userMsgId, hint: "" });
+    writeNoHintAndReconcile("empty");
     return;
   }
   if (results[0].score < options.scoreThreshold) {
     sessionLog(sessionId, `auto-search: top score ${results[0].score.toFixed(3)} below threshold ${options.scoreThreshold}`);
-    autoSearchByTurn.set(sessionId, { messageId: userMsgId, hint: "" });
+    writeNoHintAndReconcile("below-threshold");
     return;
   }
   const hintText = buildAutoSearchHint(results);
   if (!hintText) {
-    autoSearchByTurn.set(sessionId, { messageId: userMsgId, hint: "" });
+    writeNoHintAndReconcile("empty");
     return;
   }
   const payload = `
 
 ${hintText}`;
-  autoSearchByTurn.set(sessionId, { messageId: userMsgId, hint: payload });
-  appendReminderToUserMessageById(messages, userMsgId, payload);
+  const outcome = appendAutoSearchHintDecision(db, sessionId, {
+    messageId: userMsgId,
+    decision: "hint",
+    text: payload
+  });
+  if (!outcome.ok) {
+    sessionLog(sessionId, `auto-search: CAS exhausted for ${userMsgId}; skipping wire append`);
+    return;
+  }
+  if (outcome.decision.decision === "hint") {
+    appendReminderToUserMessageById(messages, userMsgId, outcome.decision.text);
+  }
   sessionLog(sessionId, `auto-search: attached hint to ${userMsgId} (${results.length} fragments, top score ${results[0].score.toFixed(3)})`);
 }
-function clearAutoSearchForSession(sessionId) {
-  autoSearchByTurn.delete(sessionId);
-}
+function clearAutoSearchForSession(_sessionId) {}
 
 // src/hooks/magic-context/transform-postprocess-phase.ts
 await __promiseAll([
@@ -173474,7 +174217,7 @@ function isVisibleNoteReadPart(part) {
 }
 
 // src/hooks/magic-context/todo-view.ts
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 var TERMINAL_STATUSES = new Set(["completed", "cancelled"]);
 var TITLE_DONE_STATUSES = new Set(["completed"]);
 var SYNTHETIC_CALL_ID_PREFIX = "mc_synthetic_todo_";
@@ -173519,7 +174262,7 @@ function buildSyntheticTodoPart(stateJson) {
   };
 }
 function computeSyntheticCallId(stateJson) {
-  const hash2 = createHash6("sha256").update(stateJson).digest("hex").slice(0, 16);
+  const hash2 = createHash8("sha256").update(stateJson).digest("hex").slice(0, 16);
   return `${SYNTHETIC_CALL_ID_PREFIX}${hash2}`;
 }
 function parseTodoState(stateJson) {
@@ -173793,15 +174536,13 @@ async function runPostTransformPhase(args) {
   } else {
     args.nudgePlacements.clear(args.sessionId);
   }
-  const stickyNoteNudge = args.fullFeatureMode ? getStickyNoteNudge(args.db, args.sessionId) : null;
-  if (stickyNoteNudge) {
-    const reinjected = appendReminderToUserMessageById(args.messages, stickyNoteNudge.messageId, stickyNoteNudge.text);
-    if (!reinjected) {
-      if (isCacheBustingPass) {
-        clearNoteNudgeState(args.db, args.sessionId);
-        sessionLog(args.sessionId, `sticky note nudge cleared — anchor ${stickyNoteNudge.messageId} gone (compacted/deleted)`);
-      } else {
-        sessionLog(args.sessionId, `preserving sticky note nudge anchor to avoid cache bust: messageId=${stickyNoteNudge.messageId}`);
+  if (args.fullFeatureMode) {
+    for (const anchor of getNoteNudgeAnchors(args.db, args.sessionId)) {
+      appendReminderToUserMessageById(args.messages, anchor.messageId, anchor.text);
+    }
+    for (const decision of getAutoSearchHintDecisions(args.db, args.sessionId)) {
+      if (decision.decision === "hint") {
+        appendReminderToUserMessageById(args.messages, decision.messageId, decision.text);
       }
     }
   }
@@ -173811,8 +174552,13 @@ async function runPostTransformPhase(args) {
     const noteInstruction = `
 
 <instruction name="deferred_notes">${deferredNoteText}</instruction>`;
-    const anchoredMessageId = appendReminderToLatestUserMessage(args.messages, noteInstruction);
-    markNoteNudgeDelivered(args.db, args.sessionId, noteInstruction, anchoredMessageId);
+    const anchoredMessageId = findLastUserMessageId(args.messages);
+    const outcome = markNoteNudgeDelivered(args.db, args.sessionId, noteInstruction, anchoredMessageId);
+    if (anchoredMessageId && outcome.ok) {
+      appendReminderToUserMessageById(args.messages, anchoredMessageId, noteInstruction);
+    } else if (anchoredMessageId && !outcome.ok) {
+      sessionLog(args.sessionId, `note-nudge delivery skipped wire append: ${outcome.kind}`);
+    }
   }
   if (args.fullFeatureMode) {
     const persistedAnchor = getPersistedTodoSyntheticAnchor(args.db, args.sessionId);
@@ -173903,10 +174649,9 @@ async function runPostTransformPhase(args) {
           enabled: true,
           scoreThreshold: args.autoSearch.scoreThreshold,
           minPromptChars: args.autoSearch.minPromptChars,
+          directory: args.autoSearch.directory ?? args.sessionDirectory,
           projectPath: args.projectPath,
-          memoryEnabled: args.autoSearch.memoryEnabled,
-          embeddingEnabled: args.autoSearch.embeddingEnabled,
-          gitCommitsEnabled: args.autoSearch.gitCommitsEnabled,
+          ensureProjectRegistered: args.autoSearch.ensureProjectRegistered,
           visibleMemoryIds
         }
       });
@@ -173914,6 +174659,19 @@ async function runPostTransformPhase(args) {
       sessionLog(args.sessionId, "auto-search runner failed:", error51);
     }
   }
+  if (args.fullFeatureMode && isCacheBustingPass) {
+    const visibleIds = new Set;
+    for (const message of args.messages) {
+      if (typeof message.info?.id === "string") {
+        visibleIds.add(message.info.id);
+      }
+    }
+    const prunedAnchors = pruneNoteNudgeAnchors(args.db, args.sessionId, visibleIds);
+    const prunedDecisions = pruneAutoSearchHintDecisions(args.db, args.sessionId, visibleIds);
+    if (prunedAnchors > 0 || prunedDecisions > 0) {
+      sessionLog(args.sessionId, `sticky-injection GC: pruned ${prunedAnchors} note-nudge anchor(s), ${prunedDecisions} auto-search decision(s)`);
+    }
+  }
   return { explicitMaterializedSuccessfully, deferredMaterializedSuccessfully };
 }
 
@@ -174047,6 +174805,8 @@ function createTransform(deps) {
           updateSessionMeta(db, sessionId, {
             lastContextPercentage: 0,
             lastInputTokens: 0,
+            observedSafeInputTokens: 0,
+            cacheAlertSent: false,
             clearedReasoningThroughTag: 0
           });
           clearHistorianFailureState(db, sessionId);
@@ -174058,7 +174818,9 @@ function createTransform(deps) {
             ...sessionMeta,
             lastContextPercentage: 0,
             lastInputTokens: 0,
-            clearedReasoningThroughTag: 0
+            clearedReasoningThroughTag: 0,
+            observedSafeInputTokens: 0,
+            cacheAlertSent: false
           };
         }
       }
@@ -174169,6 +174931,7 @@ function createTransform(deps) {
         compressorMaxMergeDepth: deps.compressorMaxMergeDepth,
         memoryEnabled: deps.memoryConfig?.enabled,
         autoPromote: deps.memoryConfig?.autoPromote,
+        ensureProjectRegistered: deps.ensureProjectRegistered,
         preserveInjectionCacheUntilConsumed: true,
         onCompartmentStatePublished: (sid) => {
           deferredHistoryRefreshSessions.add(sid);
@@ -174353,6 +175116,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
       compressorCooldownMs: deps.compressorCooldownMs,
       memoryEnabled: deps.memoryConfig?.enabled,
       autoPromote: deps.memoryConfig?.autoPromote,
+      ensureProjectRegistered: deps.ensureProjectRegistered,
       onCompartmentStatePublished: (sid) => {
         deferredHistoryRefreshSessions.add(sid);
         deferredMaterializationSessions.add(sid);
@@ -174567,6 +175331,9 @@ function truncateHistorianEmergencyError(error51) {
 
 // src/hooks/magic-context/event-handler.ts
 var CONTEXT_USAGE_TTL_MS = 60 * 60 * 1000;
+function formatTokens(value) {
+  return value.toLocaleString();
+}
 function evictExpiredUsageEntries(contextUsageMap) {
   const now = Date.now();
   for (const [sessionId, entry] of contextUsageMap) {
@@ -174587,12 +175354,16 @@ function cleanupRemovedMessageState(deps, sessionId, messageId) {
       clearPersistedNudgePlacement(deps.db, sessionId);
     }
     sessionLog(sessionId, clearedNudgePlacement ? `event message.removed: cleared nudge anchor for ${messageId}` : `event message.removed: nudge anchor unchanged for ${messageId}`);
+    const removedNoteNudgeAnchor = removeNoteNudgeAnchorByMessageId(deps.db, sessionId, messageId);
+    const removedAutoSearchDecision = removeAutoSearchHintDecisionByMessageId(deps.db, sessionId, messageId);
     const persistedNoteNudge = getPersistedNoteNudge(deps.db, sessionId);
-    const clearedNoteNudge = persistedNoteNudge.triggerMessageId === messageId || persistedNoteNudge.stickyMessageId === messageId;
-    if (clearedNoteNudge) {
-      clearPersistedNoteNudge(deps.db, sessionId);
+    const clearedNoteNudgeTrigger = persistedNoteNudge.triggerMessageId === messageId;
+    if (clearedNoteNudgeTrigger) {
+      clearNoteNudgeTriggerOnly(deps.db, sessionId);
     }
-    sessionLog(sessionId, clearedNoteNudge ? `event message.removed: cleared note nudge state for ${messageId}` : `event message.removed: note nudge state unchanged for ${messageId}`);
+    const clearedNoteNudge = removedNoteNudgeAnchor || clearedNoteNudgeTrigger;
+    sessionLog(sessionId, clearedNoteNudge ? `event message.removed: pruned note nudge state for ${messageId}` : `event message.removed: note nudge state unchanged for ${messageId}`);
+    sessionLog(sessionId, removedAutoSearchDecision ? `event message.removed: pruned auto-search decision for ${messageId}` : `event message.removed: auto-search decision unchanged for ${messageId}`);
     const persistedStickyTurnReminder = getPersistedStickyTurnReminder(deps.db, sessionId);
     const clearedStickyTurnReminder = persistedStickyTurnReminder?.messageId === messageId;
     if (clearedStickyTurnReminder) {
@@ -174678,9 +175449,11 @@ function createEventHandler2(deps) {
       } else {
         clearMessageTokensCache(info.sessionID);
       }
+      let messageHadOverflowError = false;
       if (info.error !== undefined && info.error !== null) {
         const detection = detectOverflow(info.error);
         if (detection.isOverflow) {
+          messageHadOverflowError = true;
           try {
             const metaForOverflow = getOrCreateSessionMeta(deps.db, info.sessionID);
             if (metaForOverflow.isSubagent) {
@@ -174723,12 +175496,33 @@ function createEventHandler2(deps) {
         }
         if (hasUsageTokens) {
           const totalInputTokens = (info.tokens?.input ?? 0) + (info.tokens?.cache?.read ?? 0) + (info.tokens?.cache?.write ?? 0);
-          const contextLimit = resolveContextLimit(info.providerID, info.modelID, {
+          let contextLimit = resolveContextLimit(info.providerID, info.modelID, {
             db: deps.db,
             sessionID: info.sessionID
           });
-          const percentage = contextLimit > 0 ? totalInputTokens / contextLimit * 100 : 0;
+          let percentage = contextLimit > 0 ? totalInputTokens / contextLimit * 100 : 0;
           sessionLog(info.sessionID, `event message.updated: totalInputTokens=${totalInputTokens} contextLimit=${contextLimit} percentage=${percentage.toFixed(1)}%`);
+          const sessionMeta = getOrCreateSessionMeta(deps.db, info.sessionID);
+          const observedSafeInputTokens = sessionMeta.observedSafeInputTokens ?? 0;
+          if (percentage > 100 && observedSafeInputTokens > 0 && totalInputTokens <= observedSafeInputTokens * 2) {
+            const oldLimit = contextLimit;
+            if (deps.client) {
+              await refreshModelLimitsFromApi(deps.client);
+              contextLimit = resolveContextLimit(info.providerID, info.modelID, {
+                db: deps.db,
+                sessionID: info.sessionID
+              });
+              if (contextLimit >= totalInputTokens) {
+                percentage = totalInputTokens / contextLimit * 100;
+                sessionLog(info.sessionID, `models-dev-cache: regression recovered for ${info.providerID}/${info.modelID} via refresh (was=${oldLimit}, now=${contextLimit})`);
+              }
+            }
+            if (contextLimit < totalInputTokens && !sessionMeta.cacheAlertSent) {
+              updates.cacheAlertSent = true;
+              const safeTokens = Math.max(observedSafeInputTokens, totalInputTokens);
+              await sendIgnoredMessage(deps.client, info.sessionID, `⚠️ Magic Context: OpenCode reports a context limit of ${formatTokens(contextLimit)} tokens for ${info.providerID}/${info.modelID} but you've successfully sent ${formatTokens(safeTokens)} tokens in this session — the cached limit looks wrong. Restart OpenCode if you suspect this is incorrect.`, deps.getNotificationParams?.(info.sessionID) ?? {});
+            }
+          }
           deps.contextUsageMap.set(info.sessionID, {
             usage: {
               percentage,
@@ -174739,12 +175533,14 @@ function createEventHandler2(deps) {
           });
           updates.lastContextPercentage = percentage;
           updates.lastInputTokens = totalInputTokens;
+          if (!messageHadOverflowError) {
+            updates.observedSafeInputTokens = Math.max(observedSafeInputTokens, totalInputTokens);
+          }
           const historianFailureState = getHistorianFailureState(deps.db, info.sessionID);
           if (historianFailureState.failureCount > 0 && percentage < 90) {
             clearHistorianFailureState(deps.db, info.sessionID);
             sessionLog(info.sessionID, `event message.updated: cleared historian failure state at ${percentage.toFixed(1)}%`);
           }
-          const sessionMeta = getOrCreateSessionMeta(deps.db, info.sessionID);
           const previousPercentage = sessionMeta.lastContextPercentage;
           if (!sessionMeta.isSubagent) {
             const effectiveExecuteThreshold = resolveExecuteThreshold(deps.config.execute_threshold_percentage ?? 65, modelKey, 65, {
@@ -174789,10 +175585,6 @@ function createEventHandler2(deps) {
           deps.nudgePlacements.clear(info.sessionID, { persist: false });
           sessionLog(info.sessionID, "event message.removed: cleared in-memory nudge placement cache");
         }
-        if (cleanup.clearedNoteNudge) {
-          clearNoteNudgeState(deps.db, info.sessionID, { persist: false });
-          sessionLog(info.sessionID, "event message.removed: cleared in-memory note nudge state");
-        }
         const markerState = getPersistedCompactionMarkerState(deps.db, info.sessionID);
         if (markerState && (markerState.boundaryMessageId === info.messageID || markerState.summaryMessageId === info.messageID)) {
           removeCompactionMarkerForSession(deps.db, info.sessionID);
@@ -175017,10 +175809,11 @@ function estimateProjectedPercentage(db, sessionId, contextUsage, preloadedTags)
 await init_read_session_db();
 
 // src/hooks/magic-context/text-complete.ts
-var TAG_PREFIX_REGEX2 = /^(\u00a7\d+\u00a7\s*)+/;
+var LEADING_TAG_PREFIX_REGEX = /^(\u00a7\d+\u00a7\s*)+/;
+var SECTION_CHAR_REGEX = /\u00a7/g;
 function createTextCompleteHandler() {
   return async (_input, output) => {
-    output.text = output.text.replace(TAG_PREFIX_REGEX2, "");
+    output.text = output.text.replace(LEADING_TAG_PREFIX_REGEX, "").replace(SECTION_CHAR_REGEX, "");
   };
 }
 
@@ -175155,7 +175948,9 @@ function createEventHook(args) {
           clearHistorianFailureState(args.db, assistantInfo.sessionID);
           clearPersistedReasoningWatermark(args.db, assistantInfo.sessionID);
           updateSessionMeta(args.db, assistantInfo.sessionID, {
-            clearedReasoningThroughTag: 0
+            clearedReasoningThroughTag: 0,
+            observedSafeInputTokens: 0,
+            cacheAlertSent: false
           });
         }
       }
@@ -175181,7 +175976,7 @@ function createEventHook(args) {
       args.deferredMaterializationSessions.delete(sessionId);
       args.lastHeuristicsTurnId.delete(sessionId);
       args.commitSeenLastPass?.delete(sessionId);
-      clearNoteNudgeState(args.db, sessionId);
+      resetNoteNudgeCooldownOnly(sessionId);
       clearAutoSearchForSession(sessionId);
       clearSidebarSnapshotCache(sessionId);
       clearSessionTracking(sessionId);
@@ -175229,7 +176024,7 @@ function createToolExecuteAfterHook(args) {
       }
     }
     if (typedInput.tool === "ctx_note") {
-      clearNoteNudgeState(args.db, typedInput.sessionID);
+      clearNoteNudgeTriggerAndCooldown(args.db, typedInput.sessionID);
     }
     args.toolUsageSinceUserTurn.set(typedInput.sessionID, turnUsage + 1);
   };
@@ -175239,7 +176034,7 @@ function createToolExecuteAfterHook(args) {
 init_send_session_notification();
 
 // src/hooks/magic-context/system-prompt-hash.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 import { existsSync as existsSync15, readFileSync as readFileSync13 } from "node:fs";
 import { join as join25 } from "node:path";
 
@@ -175331,6 +176126,7 @@ Prefer many small targeted operations over one large blanket operation. Compress
 }
 
 // src/hooks/magic-context/system-prompt-hash.ts
+init_compartment_storage();
 init_logger();
 await init_storage();
 
@@ -175487,7 +176283,7 @@ function readProjectDocs(directory) {
         const content = readFileSync13(filePath, "utf-8").trim();
         if (content.length > 0) {
           sections.push(`<${filename}>
-${content}
+${escapeXmlContent(content)}
 </${filename}>`);
         }
       }
@@ -175564,7 +176360,7 @@ function createSystemPromptHashHandler(deps) {
       if (!hasCachedProfile || isCacheBusting) {
         const memories = getActiveUserMemories(deps.db);
         if (memories.length > 0) {
-          const items = memories.map((m) => `- ${m.content}`).join(`
+          const items = memories.map((m) => `- ${escapeXmlContent(m.content)}`).join(`
 `);
           cachedUserProfileBySession.set(sessionId, `${USER_PROFILE_MARKER}
 ${items}
@@ -175620,7 +176416,7 @@ ${items}
 `);
     if (systemContent.length === 0)
       return;
-    const currentHash = createHash7("md5").update(systemContent).digest("hex");
+    const currentHash = createHash9("md5").update(systemContent).digest("hex");
     if (!sessionMetaEarly) {
       return;
     }
@@ -175772,6 +176568,7 @@ function createMagicContextHook(deps) {
       injectionBudgetTokens: deps.config.memory.injection_budget_tokens,
       autoPromote: deps.config.memory.auto_promote ?? true
     } : undefined,
+    ensureProjectRegistered: ensureProjectRegisteredFromOpenCodeDirectory,
     getHistorianChunkTokens,
     historyBudgetPercentage: deps.config.history_budget_percentage,
     executeThresholdPercentage: deps.config.execute_threshold_percentage,
@@ -175801,9 +176598,8 @@ function createMagicContextHook(deps) {
       enabled: true,
       scoreThreshold: deps.config.experimental.auto_search.score_threshold,
       minPromptChars: deps.config.experimental.auto_search.min_prompt_chars,
-      memoryEnabled: deps.config.memory?.enabled !== false,
-      embeddingEnabled: deps.config.embedding?.provider !== "off",
-      gitCommitsEnabled: deps.config.experimental?.git_commit_indexing?.enabled === true
+      directory: deps.directory,
+      ensureProjectRegistered: ensureProjectRegisteredFromOpenCodeDirectory
     } : undefined,
     cavemanTextCompression: ctxReduceEnabled === false && deps.config.experimental?.caveman_text_compression?.enabled === true ? {
       enabled: true,
@@ -175816,6 +176612,8 @@ function createMagicContextHook(deps) {
     config: deps.config,
     tagger: deps.tagger,
     db,
+    client: deps.client,
+    getNotificationParams: (sessionId) => getLiveNotificationParams(sessionId, liveModelBySession, variantBySession, agentBySession),
     nudgePlacements,
     onSessionCacheInvalidated: (sessionId) => {
       clearInjectionCache(sessionId);
@@ -175901,6 +176699,7 @@ function createMagicContextHook(deps) {
       historianTwoPass: deps.config.historian?.two_pass === true,
       memoryEnabled: deps.config.memory?.enabled,
       autoPromote: deps.config.memory?.auto_promote ?? true,
+      ensureProjectRegistered: ensureProjectRegisteredFromOpenCodeDirectory,
       onCompartmentStatePublished: (sid) => {
         historyRefreshSessions.add(sid);
         pendingMaterializationSessions.add(sid);
@@ -176333,6 +177132,7 @@ function buildSidebarSnapshot(db, sessionId, directory, liveSessionState, inject
     sessionId,
     usagePercentage: 0,
     inputTokens: 0,
+    contextLimit: 0,
     systemPromptTokens: 0,
     compartmentCount: 0,
     factCount: 0,
@@ -176469,6 +177269,7 @@ ${c.content}
         measuredToolDefTokens = getMeasuredToolDefinitionTokens(model.providerID, model.modelID, agent) ?? 0;
       }
     }
+    const contextLimit = activeProviderID && activeModelID ? resolveContextLimit(activeProviderID, activeModelID, { db, sessionID: sessionId }) : 0;
     const calibration = resolveModelCalibration(activeProviderID, activeModelID);
     const calibrated = calibrateBuckets({
       inputTokens,
@@ -176485,6 +177286,7 @@ ${c.content}
       sessionId,
       usagePercentage,
       inputTokens,
+      contextLimit,
       systemPromptTokens: calibrated.systemTokens,
       compartmentCount,
       factCount,
@@ -176562,7 +177364,7 @@ function buildStatusDetail(db, sessionId, directory, modelKey, config2, liveSess
       const ops = db.prepare("SELECT tag_id, operation FROM pending_ops WHERE session_id = ?").all(sessionId);
       detail.pendingOps = ops.map((o) => ({ tagId: o.tag_id, operation: o.operation }));
     } catch {}
-    const contextLimitForTokens = base.usagePercentage > 0 ? Math.round(base.inputTokens / (base.usagePercentage / 100)) : 0;
+    const contextLimitForTokens = base.contextLimit > 0 ? base.contextLimit : base.usagePercentage > 0 ? Math.round(base.inputTokens / (base.usagePercentage / 100)) : 0;
     if (config2) {
       const pctCfg = config2.execute_threshold_percentage;
       const tokensCfg = config2.execute_threshold_tokens;
@@ -176588,7 +177390,9 @@ function buildStatusDetail(db, sessionId, directory, modelKey, config2, liveSess
         detail.historyBudgetPercentage = config2.history_budget_percentage;
       }
     }
-    if (base.usagePercentage > 0) {
+    if (base.contextLimit > 0) {
+      detail.contextLimit = base.contextLimit;
+    } else if (base.usagePercentage > 0) {
       detail.contextLimit = Math.round(base.inputTokens / (base.usagePercentage / 100));
     }
     detail.cacheTtlMs = parseTtlString(detail.cacheTtl);
@@ -176688,9 +177492,6 @@ function registerRpcHandlers(rpcServer, args) {
 }
 
 // src/plugin/tool-registry.ts
-init_magic_context();
-init_memory();
-init_embedding();
 init_project_identity();
 await init_storage();
 
@@ -176838,21 +177639,17 @@ function filterByCategory(memories, category) {
   return memories.filter((memory) => memory.category === category);
 }
 function queueMemoryEmbedding(args) {
-  if (!args.deps.embeddingEnabled) {
+  const snapshot = getProjectEmbeddingSnapshot(args.projectPath);
+  if (!snapshot?.enabled) {
     return;
   }
   (async () => {
-    const embedding2 = await embedText(args.content);
-    if (!embedding2) {
+    const result = await embedTextForProject(args.projectPath, args.content);
+    if (!result) {
       sessionLog(args.sessionId, `memory embedding skipped for memory ${args.memoryId}: provider unavailable or embedding generation failed.`);
       return;
     }
-    const modelId = getEmbeddingModelId();
-    if (modelId === "off") {
-      sessionLog(args.sessionId, `memory embedding skipped for memory ${args.memoryId}: embedding provider is off.`);
-      return;
-    }
-    saveEmbedding(args.deps.db, args.memoryId, embedding2, modelId);
+    saveEmbedding(args.deps.db, args.memoryId, result.vector, result.modelId);
     sessionLog(args.sessionId, `proactively embedded memory ${args.memoryId}.`);
   })().catch((error51) => {
     sessionLog(args.sessionId, `memory embedding failed for memory ${args.memoryId}:`, error51);
@@ -176888,13 +177685,15 @@ function createCtxMemoryTool(deps) {
       reason: tool2.schema.string().optional().describe("Archive reason (optional for archive)")
     },
     async execute(args, toolContext) {
-      if (!deps.memoryEnabled) {
-        return getDisabledMessage();
-      }
       if (toolContext.agent !== DREAMER_AGENT && !allowedActions.includes(args.action)) {
         return `Error: Action '${args.action}' is not allowed in this context.`;
       }
       const projectPath = deps.resolveProjectPath(toolContext.directory);
+      await deps.ensureProjectRegistered?.(toolContext.directory, deps.db);
+      const embeddingSnapshot = getProjectEmbeddingSnapshot(projectPath);
+      if (embeddingSnapshot ? !embeddingSnapshot.features.memoryEnabled : deps.memoryEnabled === false) {
+        return getDisabledMessage();
+      }
       if (args.action === "write") {
         const content = args.content?.trim();
         if (!content) {
@@ -176923,6 +177722,7 @@ function createCtxMemoryTool(deps) {
         queueMemoryEmbedding({
           deps,
           sessionId: toolContext.sessionID,
+          projectPath,
           memoryId: memory.id,
           content
         });
@@ -176968,6 +177768,7 @@ function createCtxMemoryTool(deps) {
         queueMemoryEmbedding({
           deps,
           sessionId: toolContext.sessionID,
+          projectPath,
           memoryId: memory.id,
           content
         });
@@ -177041,6 +177842,7 @@ function createCtxMemoryTool(deps) {
         queueMemoryEmbedding({
           deps,
           sessionId: toolContext.sessionID,
+          projectPath,
           memoryId: canonicalMemory.id,
           content
         });
@@ -177416,6 +178218,7 @@ var CTX_SEARCH_DESCRIPTION = [
 var DEFAULT_CTX_SEARCH_LIMIT = 10;
 // src/tools/ctx-search/tools.ts
 init_compartment_storage();
+init_embedding();
 import { tool as tool5 } from "@opencode-ai/plugin";
 await init_inject_compartments();
 var VALID_SOURCES = new Set(["memory", "message", "git_commit"]);
@@ -177514,13 +178317,23 @@ function createCtxSearchTool(deps) {
       const lastCompartmentEnd = getLastCompartmentEndMessage(deps.db, toolContext.sessionID);
       const visibleMemoryIds = getVisibleMemoryIds(deps.db, toolContext.sessionID);
       const projectPath = deps.resolveProjectPath(toolContext.directory);
+      await deps.ensureProjectRegistered?.(toolContext.directory, deps.db);
+      const embeddingSnapshot = getProjectEmbeddingSnapshot(projectPath);
+      const memoryEnabled = embeddingSnapshot?.features.memoryEnabled ?? deps.memoryEnabled;
+      const embeddingEnabled = embeddingSnapshot ? embeddingSnapshot.enabled || embeddingSnapshot.gitCommitEnabled : deps.embeddingEnabled;
+      const gitCommitsEnabled = embeddingSnapshot?.gitCommitEnabled ?? deps.gitCommitsEnabled ?? false;
       const results = await unifiedSearch(deps.db, toolContext.sessionID, projectPath, query, {
         limit: normalizeLimit3(args.limit),
-        memoryEnabled: deps.memoryEnabled,
-        embeddingEnabled: deps.embeddingEnabled,
+        memoryEnabled,
+        embeddingEnabled,
+        embedQuery: async (text, signal) => {
+          const result = await embedTextForProject(projectPath, text, signal);
+          return result?.vector ?? null;
+        },
+        isEmbeddingRuntimeEnabled: () => embeddingEnabled === true,
         readMessages: deps.readMessages,
         maxMessageOrdinal: lastCompartmentEnd >= 0 ? lastCompartmentEnd : undefined,
-        gitCommitsEnabled: deps.gitCommitsEnabled ?? false,
+        gitCommitsEnabled,
         sources: normalizeSources(args.sources),
         visibleMemoryIds
       });
@@ -177563,10 +178376,6 @@ function normalizeToolArgSchemas(toolDefinition) {
 // src/plugin/tool-registry.ts
 function createToolRegistry(args) {
   const { ctx, pluginConfig } = args;
-  const embeddingConfig2 = pluginConfig.embedding ?? {
-    provider: "local",
-    model: DEFAULT_LOCAL_EMBEDDING_MODEL
-  };
   if (pluginConfig.enabled !== true) {
     return {};
   }
@@ -177583,18 +178392,7 @@ function createToolRegistry(args) {
     console.warn(`[magic-context] persistent storage unavailable; disabling magic-context tools${reason ? `: ${reason}` : ""}`);
     return {};
   }
-  const memoryEnabled = pluginConfig.memory?.enabled === true;
-  initializeEmbedding(embeddingConfig2);
-  const launchProjectPath = resolveProjectIdentity(ctx.directory);
-  if (memoryEnabled) {
-    const currentModelId = getEmbeddingModelId();
-    const storedModelId = getStoredModelId(db, launchProjectPath);
-    const hasEmbeddings = db.prepare("SELECT 1 FROM memory_embeddings me JOIN memories m ON me.memory_id = m.id WHERE m.project_path = ? LIMIT 1").get(launchProjectPath) !== null;
-    if (hasEmbeddings && storedModelId !== currentModelId) {
-      clearEmbeddingsForProject(db, launchProjectPath);
-      console.warn(`[magic-context] embedding model changed from ${storedModelId} to ${currentModelId}; cleared embeddings for project ${launchProjectPath}`);
-    }
-  }
+  ensureProjectRegisteredFromOpenCodeDirectory(ctx.directory, db);
   const resolveProjectPath2 = (directory) => resolveProjectIdentity(directory);
   const ctxReduceEnabled = pluginConfig.ctx_reduce_enabled !== false;
   const allTools = {
@@ -177611,19 +178409,14 @@ function createToolRegistry(args) {
     ...createCtxSearchTools({
       db,
       resolveProjectPath: resolveProjectPath2,
-      memoryEnabled,
-      embeddingEnabled: embeddingConfig2.provider !== "off",
-      gitCommitsEnabled: pluginConfig.experimental?.git_commit_indexing?.enabled === true
+      ensureProjectRegistered: ensureProjectRegisteredFromOpenCodeDirectory
     }),
-    ...memoryEnabled ? {
-      ...createCtxMemoryTools({
-        db,
-        resolveProjectPath: resolveProjectPath2,
-        memoryEnabled: true,
-        embeddingEnabled: embeddingConfig2.provider !== "off",
-        allowedActions: ["write", "delete"]
-      })
-    } : {}
+    ...createCtxMemoryTools({
+      db,
+      resolveProjectPath: resolveProjectPath2,
+      ensureProjectRegistered: ensureProjectRegisteredFromOpenCodeDirectory,
+      allowedActions: ["write", "delete"]
+    })
   };
   for (const toolDefinition of Object.values(allTools)) {
     normalizeToolArgSchemas(toolDefinition);
@@ -177649,14 +178442,14 @@ import {
   writeFileSync as writeFileSync7
 } from "node:fs";
 import { createServer } from "node:http";
-import { dirname as dirname7 } from "node:path";
+import { dirname as dirname8 } from "node:path";
 
 // src/shared/rpc-utils.ts
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 import { join as join26 } from "node:path";
 function projectHash(directory) {
   const normalized = directory.replace(/\/+$/, "");
-  return createHash8("sha256").update(normalized).digest("hex").slice(0, 16);
+  return createHash10("sha256").update(normalized).digest("hex").slice(0, 16);
 }
 function rpcPortDir(storageDir, directory) {
   return join26(storageDir, "rpc", projectHash(directory));
@@ -177736,7 +178529,7 @@ class MagicContextRpcServer {
         this.server = server;
         try {
           this.warnIfOtherLiveInstance();
-          const dir = dirname7(this.portFilePath);
+          const dir = dirname8(this.portFilePath);
           mkdirSync8(dir, { recursive: true });
           const tmpPath = `${this.portFilePath}.tmp`;
           writeFileSync7(tmpPath, JSON.stringify({
@@ -177884,8 +178677,9 @@ var plugin = async (ctx) => {
   });
   const storageDir = getMagicContextStorageDir();
   if (pluginConfig.enabled) {
-    startDreamScheduleTimer({
+    const timerRegistration = {
       directory: ctx.directory,
+      projectIdentity: resolveProjectIdentity(ctx.directory),
       client: ctx.client,
       dreamerConfig: pluginConfig.dreamer,
       embeddingConfig: pluginConfig.embedding,
@@ -177903,8 +178697,10 @@ var plugin = async (ctx) => {
         enabled: true,
         since_days: pluginConfig.experimental.git_commit_indexing.since_days,
         max_commits: pluginConfig.experimental.git_commit_indexing.max_commits
-      } : undefined
-    });
+      } : undefined,
+      ensureRegistered: ensureProjectRegisteredFromOpenCodeDirectory
+    };
+    await startDreamScheduleTimer(timerRegistration);
     const rpcServer = new MagicContextRpcServer(storageDir, ctx.directory);
     registerRpcHandlers(rpcServer, {
       directory: ctx.directory,
@@ -177916,9 +178712,6 @@ var plugin = async (ctx) => {
       log(`[magic-context] RPC server failed to start: ${err}`);
     });
     refreshModelLimitsFromApi(ctx.client);
-    setInterval(() => {
-      refreshModelLimitsFromApi(ctx.client);
-    }, 60 * 60 * 1000);
   }
   if (conflictResult?.hasConflict) {
     sendConflictWarning(ctx.client, ctx.directory, conflictResult);