@cortexkit/opencode-magic-context 0.13.2 → 0.14.0

package/dist/index.js

@@ -14101,7 +14101,16 @@ var init_magic_context = __esm(() => {
     max_runtime_minutes: exports_external.number().min(10).default(120),
     tasks: exports_external.array(DreamingTaskSchema).default(DEFAULT_DREAMER_TASKS),
     task_timeout_minutes: exports_external.number().min(5).default(20),
-    inject_docs: exports_external.boolean().default(true)
+    inject_docs: exports_external.boolean().default(true),
+    user_memories: exports_external.object({
+      enabled: exports_external.boolean().default(true),
+      promotion_threshold: exports_external.number().min(2).max(20).default(3)
+    }).default({ enabled: true, promotion_threshold: 3 }),
+    pin_key_files: exports_external.object({
+      enabled: exports_external.boolean().default(false),
+      token_budget: exports_external.number().min(2000).max(30000).default(1e4),
+      min_reads: exports_external.number().min(2).max(20).default(4)
+    }).default({ enabled: false, token_budget: 1e4, min_reads: 4 })
   }));
   SidekickConfigSchema = AgentOverrideConfigSchema.extend({
     enabled: exports_external.boolean().default(false),
@@ -14196,20 +14205,21 @@ var init_magic_context = __esm(() => {
       model: DEFAULT_LOCAL_EMBEDDING_MODEL
     }),
     experimental: exports_external.object({
-      user_memories: exports_external.object({
+      temporal_awareness: exports_external.boolean().default(false),
+      git_commit_indexing: exports_external.object({
         enabled: exports_external.boolean().default(false),
-        promotion_threshold: exports_external.number().min(2).max(20).default(3)
-      }).default({ enabled: false, promotion_threshold: 3 }),
-      pin_key_files: exports_external.object({
+        since_days: exports_external.number().min(7).max(3650).default(365),
+        max_commits: exports_external.number().min(100).max(20000).default(2000)
+      }).default({ enabled: false, since_days: 365, max_commits: 2000 }),
+      auto_search: exports_external.object({
         enabled: exports_external.boolean().default(false),
-        token_budget: exports_external.number().min(2000).max(30000).default(1e4),
-        min_reads: exports_external.number().min(2).max(20).default(4)
-      }).default({ enabled: false, token_budget: 1e4, min_reads: 4 }),
-      temporal_awareness: exports_external.boolean().default(false)
+        score_threshold: exports_external.number().min(0.3).max(0.95).default(0.55),
+        min_prompt_chars: exports_external.number().min(5).max(500).default(20)
+      }).default({ enabled: false, score_threshold: 0.55, min_prompt_chars: 20 })
     }).default({
-      user_memories: { enabled: false, promotion_threshold: 3 },
-      pin_key_files: { enabled: false, token_budget: 1e4, min_reads: 4 },
-      temporal_awareness: false
+      temporal_awareness: false,
+      git_commit_indexing: { enabled: false, since_days: 365, max_commits: 2000 },
+      auto_search: { enabled: false, score_threshold: 0.55, min_prompt_chars: 20 }
     }),
     memory: exports_external.object({
       enabled: exports_external.boolean().default(true),
@@ -14603,7 +14613,7 @@ function replaceSessionFacts(db, sessionId, facts) {
   db.transaction(() => {
     db.prepare("DELETE FROM session_facts WHERE session_id = ?").run(sessionId);
     insertFactRows(db, sessionId, facts, now);
-    db.prepare("UPDATE session_meta SET memory_block_cache = '' WHERE session_id = ?").run(sessionId);
+    db.prepare("UPDATE session_meta SET memory_block_cache = '', memory_block_ids = '' WHERE session_id = ?").run(sessionId);
   })();
 }
 function getSessionFacts(db, sessionId) {
@@ -14617,7 +14627,7 @@ function replaceAllCompartmentState(db, sessionId, compartments, facts) {
     db.prepare("DELETE FROM session_facts WHERE session_id = ?").run(sessionId);
     insertCompartmentRows(db, sessionId, compartments, now);
     insertFactRows(db, sessionId, facts, now);
-    db.prepare("UPDATE session_meta SET memory_block_cache = '' WHERE session_id = ?").run(sessionId);
+    db.prepare("UPDATE session_meta SET memory_block_cache = '', memory_block_ids = '' WHERE session_id = ?").run(sessionId);
   })();
 }
 function buildCompartmentBlock(compartments, facts, memoryBlock, dateRanges) {
@@ -14705,7 +14715,7 @@ function promoteRecompStaging(db, sessionId) {
 }
 function invalidateAllMemoryBlockCaches(db) {
   try {
-    db.prepare("UPDATE session_meta SET memory_block_cache = '' WHERE memory_block_cache != ''").run();
+    db.prepare("UPDATE session_meta SET memory_block_cache = '', memory_block_ids = '' WHERE memory_block_cache != '' OR memory_block_ids != ''").run();
   } catch {}
 }
 function clearRecompStaging(db, sessionId) {
@@ -16612,7 +16622,9 @@ class LocalEmbeddingProvider {
     await this.initPromise;
     return this.pipeline !== null;
   }
-  async embed(text) {
+  async embed(text, signal) {
+    if (signal?.aborted)
+      return null;
     if (!await this.initialize()) {
       return null;
     }
@@ -16631,10 +16643,13 @@ class LocalEmbeddingProvider {
       return null;
     }
   }
-  async embedBatch(texts) {
+  async embedBatch(texts, signal) {
     if (texts.length === 0) {
       return [];
     }
+    if (signal?.aborted) {
+      return Array.from({ length: texts.length }, () => null);
+    }
     if (!await this.initialize()) {
       return Array.from({ length: texts.length }, () => null);
     }
@@ -16695,6 +16710,10 @@ class OpenAICompatibleEmbeddingProvider {
   model;
   apiKey;
   initialized = false;
+  failureTimes = [];
+  circuitOpenUntil = 0;
+  openLogged = false;
+  halfOpenProbeInFlight = false;
   constructor(options) {
     this.endpoint = normalizeEndpoint(options.endpoint);
     this.model = options.model?.trim() ?? "";
@@ -16712,18 +16731,36 @@ class OpenAICompatibleEmbeddingProvider {
     this.initialized = true;
     return true;
   }
-  async embed(text) {
-    const [embedding] = await this.embedBatch([text]);
+  async embed(text, signal) {
+    const [embedding] = await this.embedBatch([text], signal);
     return embedding ?? null;
   }
-  async embedBatch(texts) {
+  async embedBatch(texts, signal) {
     if (texts.length === 0) {
       return [];
     }
     if (!await this.initialize()) {
       return Array.from({ length: texts.length }, () => null);
     }
+    if (signal?.aborted) {
+      return Array.from({ length: texts.length }, () => null);
+    }
+    let isProbe = false;
+    let internalController;
+    let timeoutHandle;
+    let onOuterAbort;
     try {
+      const claim = this.claimProbeOrShortCircuit();
+      if (claim === "short_circuit") {
+        return Array.from({ length: texts.length }, () => null);
+      }
+      isProbe = claim === "probe";
+      internalController = new AbortController;
+      timeoutHandle = setTimeout(() => internalController?.abort(), FETCH_TIMEOUT_MS);
+      onOuterAbort = () => internalController?.abort();
+      if (signal) {
+        signal.addEventListener("abort", onOuterAbort, { once: true });
+      }
       const response = await fetch(`${this.endpoint}/embeddings`, {
         method: "POST",
         headers: {
@@ -16733,21 +16770,48 @@ class OpenAICompatibleEmbeddingProvider {
         body: JSON.stringify({
           model: this.model,
           input: texts
-        })
+        }),
+        signal: internalController.signal
       });
       if (!response.ok) {
         log(`[magic-context] openai-compatible embedding request failed: ${response.status} ${response.statusText}`);
+        this.recordFailure(isProbe);
         return Array.from({ length: texts.length }, () => null);
       }
       const body = await response.json();
       const items = Array.isArray(body.data) ? body.data : [];
-      return Array.from({ length: texts.length }, (_, index) => {
+      const results = Array.from({ length: texts.length }, (_, index) => {
         const embedding = items[index]?.embedding;
         return Array.isArray(embedding) ? Float32Array.from(embedding) : null;
       });
+      if (results.every((r) => r === null)) {
+        this.recordFailure(isProbe);
+      } else {
+        this.recordSuccess();
+      }
+      return results;
     } catch (error48) {
-      log("[magic-context] openai-compatible embedding request failed:", error48);
+      const isAbort = error48 instanceof Error && (error48.name === "AbortError" || error48.message.includes("aborted"));
+      if (isAbort) {
+        if (signal?.aborted) {} else {
+          log(`[magic-context] openai-compatible embedding request timed out after ${FETCH_TIMEOUT_MS}ms`);
+          this.recordFailure(isProbe);
+        }
+      } else {
+        log("[magic-context] openai-compatible embedding request failed:", error48);
+        this.recordFailure(isProbe);
+      }
       return Array.from({ length: texts.length }, () => null);
+    } finally {
+      if (timeoutHandle !== undefined) {
+        clearTimeout(timeoutHandle);
+      }
+      if (signal && onOuterAbort) {
+        signal.removeEventListener("abort", onOuterAbort);
+      }
+      if (isProbe) {
+        this.halfOpenProbeInFlight = false;
+      }
     }
   }
   async dispose() {
@@ -16756,9 +16820,73 @@ class OpenAICompatibleEmbeddingProvider {
   isLoaded() {
     return this.initialized;
   }
+  claimProbeOrShortCircuit() {
+    if (this.circuitOpenUntil === 0) {
+      return "allow";
+    }
+    if (Date.now() < this.circuitOpenUntil) {
+      return "short_circuit";
+    }
+    if (this.halfOpenProbeInFlight) {
+      return "short_circuit";
+    }
+    this.halfOpenProbeInFlight = true;
+    log("[magic-context] openai-compatible embedding: circuit half-open, probing endpoint");
+    return "probe";
+  }
+  recordFailure(isProbe) {
+    if (isProbe) {
+      this.circuitOpenUntil = Date.now() + OPEN_DURATION_MS;
+      if (!this.openLogged) {
+        log(`[magic-context] openai-compatible embedding: probe failed, re-opening circuit for ${OPEN_DURATION_MS / 60000}min`);
+        this.openLogged = true;
+      }
+      this.failureTimes = [];
+      return;
+    }
+    const now = Date.now();
+    const cutoff = now - FAILURE_WINDOW_MS;
+    this.failureTimes = this.failureTimes.filter((t) => t > cutoff);
+    this.failureTimes.push(now);
+    if (this.failureTimes.length >= FAILURE_THRESHOLD) {
+      this.circuitOpenUntil = now + OPEN_DURATION_MS;
+      if (!this.openLogged) {
+        log(`[magic-context] openai-compatible embedding: opening circuit for ${OPEN_DURATION_MS / 60000}min after ${this.failureTimes.length} failures in ${FAILURE_WINDOW_MS / 1000}s`);
+        this.openLogged = true;
+      }
+      this.failureTimes = [];
+    }
+  }
+  recordSuccess() {
+    if (this.failureTimes.length > 0 || this.circuitOpenUntil > 0 || this.openLogged) {
+      log("[magic-context] openai-compatible embedding: endpoint recovered, circuit closed");
+    }
+    this.failureTimes = [];
+    this.circuitOpenUntil = 0;
+    this.openLogged = false;
+  }
+  _getCircuitState() {
+    if (this.circuitOpenUntil === 0)
+      return "closed";
+    if (Date.now() < this.circuitOpenUntil) {
+      return this.halfOpenProbeInFlight ? "half_open" : "open";
+    }
+    return "half_open";
+  }
+  _getFailureCount() {
+    return this.failureTimes.length;
+  }
+  _resetCircuit() {
+    this.failureTimes = [];
+    this.circuitOpenUntil = 0;
+    this.openLogged = false;
+    this.halfOpenProbeInFlight = false;
+  }
 }
+var FAILURE_THRESHOLD = 3, FAILURE_WINDOW_MS = 60000, OPEN_DURATION_MS, FETCH_TIMEOUT_MS = 30000;
 var init_embedding_openai = __esm(() => {
   init_logger();
+  OPEN_DURATION_MS = 5 * 60000;
 });
 
 // src/features/magic-context/memory/embedding.ts
@@ -16847,7 +16975,7 @@ function initializeEmbedding(config2) {
 function isEmbeddingEnabled() {
   return embeddingConfig.provider !== "off";
 }
-async function embedText(text) {
+async function embedText(text, signal) {
   const currentProvider = getOrCreateProvider();
   if (!currentProvider) {
     return null;
@@ -16855,9 +16983,9 @@ async function embedText(text) {
   if (!await currentProvider.initialize()) {
     return null;
   }
-  return currentProvider.embed(text);
+  return currentProvider.embed(text, signal);
 }
-async function embedBatch(texts) {
+async function embedBatch(texts, signal) {
   if (texts.length === 0) {
     return [];
   }
@@ -16868,7 +16996,7 @@ async function embedBatch(texts) {
   if (!await currentProvider.initialize()) {
     return Array.from({ length: texts.length }, () => null);
   }
-  return currentProvider.embedBatch(texts);
+  return currentProvider.embedBatch(texts, signal);
 }
 async function embedAllUnembeddedMemories(db, config2, batchSize = 10) {
   if (sweepInProgress) {
@@ -16971,6 +17099,79 @@ var init_embedding = __esm(() => {
   SWEEP_MAX_WALL_CLOCK_MS = 10 * 60 * 1000;
 });
 
+// src/features/magic-context/memory/storage-memory-fts.ts
+function getSearchStatement(db) {
+  let stmt = searchStatements.get(db);
+  if (!stmt) {
+    const selectColumns = Object.entries(COLUMN_MAP).map(([property, column]) => `memories.${column} AS ${property}`).join(", ");
+    stmt = db.prepare(`SELECT ${selectColumns} FROM memories_fts INNER JOIN memories ON memories.id = memories_fts.rowid WHERE memories.project_path = ? AND memories.status IN ('active', 'permanent') AND (memories.expires_at IS NULL OR memories.expires_at > ?) AND memories_fts MATCH ? ORDER BY bm25(memories_fts), memories.updated_at DESC, memories.id ASC LIMIT ?`);
+    searchStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function sanitizeFtsQuery(query) {
+  const tokens = query.split(/\s+/).filter((token) => token.length > 0);
+  if (tokens.length === 0)
+    return "";
+  return tokens.map((token) => `"${token.replace(/"/g, '""')}"`).join(" ");
+}
+function searchMemoriesFTS(db, projectPath, query, limit = DEFAULT_SEARCH_LIMIT) {
+  const trimmedQuery = query.trim();
+  if (trimmedQuery.length === 0 || limit <= 0) {
+    return [];
+  }
+  const sanitized = sanitizeFtsQuery(trimmedQuery);
+  if (sanitized.length === 0) {
+    return [];
+  }
+  const rows = getSearchStatement(db).all(projectPath, Date.now(), sanitized, limit).filter(isMemoryRow);
+  return rows.map(toMemory);
+}
+var DEFAULT_SEARCH_LIMIT = 10, searchStatements;
+var init_storage_memory_fts = __esm(() => {
+  init_storage_memory();
+  searchStatements = new WeakMap;
+});
+
+// src/features/magic-context/memory/project-identity.ts
+import { execSync } from "child_process";
+import path3 from "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 = path3.resolve(directory);
+  const hash2 = Bun.hash(canonical).toString(16).slice(0, 12);
+  return `dir:${hash2}`;
+}
+function resolveProjectIdentity(directory) {
+  const resolved = path3.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);
@@ -150227,6 +150428,62 @@ var init_migrations = __esm(() => {
                 CREATE INDEX IF NOT EXISTS idx_um_status ON user_memories(status);
             `);
       }
+    },
+    {
+      version: 4,
+      description: "Add git_commits + git_commit_embeddings + git_commits_fts tables",
+      up: (db) => {
+        db.exec(`
+                CREATE TABLE IF NOT EXISTS git_commits (
+                    sha TEXT PRIMARY KEY,
+                    project_path TEXT NOT NULL,
+                    short_sha TEXT NOT NULL,
+                    message TEXT NOT NULL,
+                    author TEXT,
+                    committed_at INTEGER NOT NULL,
+                    indexed_at INTEGER NOT NULL
+                );
+                CREATE INDEX IF NOT EXISTS idx_git_commits_project_time
+                    ON git_commits(project_path, committed_at DESC);
+
+                CREATE TABLE IF NOT EXISTS git_commit_embeddings (
+                    sha TEXT PRIMARY KEY,
+                    embedding BLOB NOT NULL,
+                    model_id TEXT NOT NULL,
+                    created_at INTEGER NOT NULL,
+                    FOREIGN KEY(sha) REFERENCES git_commits(sha) ON DELETE CASCADE
+                );
+
+                CREATE VIRTUAL TABLE IF NOT EXISTS git_commits_fts USING fts5(
+                    sha UNINDEXED,
+                    project_path UNINDEXED,
+                    message,
+                    tokenize = 'porter unicode61'
+                );
+
+                -- Mirror writes into FTS. We intentionally rebuild FTS rows on
+                -- every INSERT OR REPLACE so amended commits or re-indexed
+                -- messages update cleanly.
+                CREATE TRIGGER IF NOT EXISTS git_commits_fts_insert
+                AFTER INSERT ON git_commits BEGIN
+                    DELETE FROM git_commits_fts WHERE sha = NEW.sha;
+                    INSERT INTO git_commits_fts(sha, project_path, message)
+                    VALUES (NEW.sha, NEW.project_path, NEW.message);
+                END;
+
+                CREATE TRIGGER IF NOT EXISTS git_commits_fts_delete
+                AFTER DELETE ON git_commits BEGIN
+                    DELETE FROM git_commits_fts WHERE sha = OLD.sha;
+                END;
+
+                CREATE TRIGGER IF NOT EXISTS git_commits_fts_update
+                AFTER UPDATE OF message, project_path ON git_commits BEGIN
+                    DELETE FROM git_commits_fts WHERE sha = OLD.sha;
+                    INSERT INTO git_commits_fts(sha, project_path, message)
+                    VALUES (NEW.sha, NEW.project_path, NEW.message);
+                END;
+            `);
+      }
     }
   ];
 });
@@ -150449,7 +150706,8 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       historian_last_failure_at INTEGER DEFAULT NULL,
       system_prompt_hash TEXT DEFAULT '',
       memory_block_cache TEXT DEFAULT '',
-      memory_block_count INTEGER DEFAULT 0
+      memory_block_count INTEGER DEFAULT 0,
+      memory_block_ids TEXT DEFAULT ''
     );
 
     CREATE INDEX IF NOT EXISTS idx_tags_session_tag_number ON tags(session_id, tag_number);
@@ -150500,6 +150758,7 @@ 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_last_read_at", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "times_execute_threshold_reached", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "compartment_in_progress", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "historian_failure_count", "INTEGER DEFAULT 0");
@@ -150513,6 +150772,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "memory_embeddings", "model_id", "TEXT");
   ensureColumn(db, "session_meta", "memory_block_cache", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "memory_block_count", "INTEGER DEFAULT 0");
+  ensureColumn(db, "session_meta", "memory_block_ids", "TEXT DEFAULT ''");
   ensureColumn(db, "dream_queue", "retry_count", "INTEGER DEFAULT 0");
   ensureColumn(db, "tags", "reasoning_byte_size", "INTEGER DEFAULT 0");
   ensureColumn(db, "tags", "drop_mode", "TEXT DEFAULT 'full'");
@@ -150525,8 +150785,16 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "session_meta", "tool_call_tokens", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "recomp_partial_range_start", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "recomp_partial_range_end", "INTEGER DEFAULT 0");
+  ensureColumn(db, "session_meta", "detected_context_limit", "INTEGER DEFAULT 0");
+  ensureColumn(db, "session_meta", "needs_emergency_recovery", "INTEGER DEFAULT 0");
   healNullTextColumns(db);
   healNullIntegerColumns(db);
+  healMissingMemoryBlockIds(db);
+}
+function healMissingMemoryBlockIds(db) {
+  try {
+    db.prepare("UPDATE session_meta SET memory_block_cache = '' WHERE memory_block_cache != '' AND (memory_block_ids IS NULL OR memory_block_ids = '') AND memory_block_count > 0").run();
+  } catch {}
 }
 function healNullTextColumns(db) {
   const columns = [
@@ -150543,6 +150811,7 @@ function healNullTextColumns(db) {
     ["system_prompt_hash", ""],
     ["stripped_placeholder_ids", ""],
     ["memory_block_cache", ""],
+    ["memory_block_ids", ""],
     ["compaction_marker_state", ""],
     ["key_files", ""]
   ];
@@ -150802,6 +151071,9 @@ function setPersistedReasoningWatermark(db, sessionId, tagNumber) {
   ensureSessionMetaRow(db, sessionId);
   db.prepare("UPDATE session_meta SET cleared_reasoning_through_tag = ? WHERE session_id = ?").run(tagNumber, sessionId);
 }
+function clearPersistedReasoningWatermark(db, sessionId) {
+  setPersistedReasoningWatermark(db, sessionId, 0);
+}
 function getPersistedNudgePlacement(db, sessionId) {
   const result = db.prepare("SELECT nudge_anchor_message_id, nudge_anchor_text FROM session_meta WHERE session_id = ?").get(sessionId);
   if (!isPersistedNudgePlacementRow(result)) {
@@ -150879,6 +151151,23 @@ function setPersistedDeliveredNoteNudge(db, sessionId, text, messageId = "") {
 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 getNoteLastReadAt(db, sessionId) {
+  try {
+    const result = db.prepare("SELECT note_last_read_at FROM session_meta WHERE session_id = ?").get(sessionId);
+    if (!result || typeof result !== "object")
+      return 0;
+    const value = result.note_last_read_at;
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+  } catch {
+    return 0;
+  }
+}
+function setNoteLastReadAt(db, sessionId, at = Date.now()) {
+  db.transaction(() => {
+    ensureSessionMetaRow(db, sessionId);
+    db.prepare("UPDATE session_meta SET note_last_read_at = ? WHERE session_id = ?").run(at, sessionId);
+  })();
+}
 function getHistorianFailureState(db, sessionId) {
   const result = db.prepare("SELECT historian_failure_count, historian_last_error, historian_last_failure_at FROM session_meta WHERE session_id = ?").get(sessionId);
   if (!isPersistedHistorianFailureRow(result)) {
@@ -150903,6 +151192,37 @@ function clearHistorianFailureState(db, sessionId) {
     db.prepare("UPDATE session_meta SET historian_failure_count = 0, historian_last_error = NULL, historian_last_failure_at = NULL WHERE session_id = ?").run(sessionId);
   })();
 }
+function getOverflowState(db, sessionId) {
+  const result = db.prepare("SELECT detected_context_limit, needs_emergency_recovery FROM session_meta WHERE session_id = ?").get(sessionId);
+  if (!result) {
+    return { detectedContextLimit: 0, needsEmergencyRecovery: false };
+  }
+  const limit = typeof result.detected_context_limit === "number" && result.detected_context_limit > 0 ? result.detected_context_limit : 0;
+  const needs = typeof result.needs_emergency_recovery === "number" && result.needs_emergency_recovery > 0;
+  return { detectedContextLimit: limit, needsEmergencyRecovery: needs };
+}
+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);
+    } else {
+      db.prepare("UPDATE session_meta SET needs_emergency_recovery = 1 WHERE session_id = ?").run(sessionId);
+    }
+  })();
+}
+function clearEmergencyRecovery(db, sessionId) {
+  db.transaction(() => {
+    ensureSessionMetaRow(db, sessionId);
+    db.prepare("UPDATE session_meta SET needs_emergency_recovery = 0 WHERE session_id = ?").run(sessionId);
+  })();
+}
+function clearDetectedContextLimit(db, sessionId) {
+  db.transaction(() => {
+    ensureSessionMetaRow(db, sessionId);
+    db.prepare("UPDATE session_meta SET detected_context_limit = 0 WHERE session_id = ?").run(sessionId);
+  })();
+}
 function getPersistedCompactionMarkerState(db, sessionId) {
   const row = db.prepare("SELECT compaction_marker_state FROM session_meta WHERE session_id = ?").get(sessionId);
   const raw = row?.compaction_marker_state;
@@ -151308,8 +151628,33 @@ function resolveLimit(limit) {
     return limit.context;
   return;
 }
-function loadModelsDevLimitsFromFile() {
-  const limits = new Map;
+function resolveInterleavedField(interleaved) {
+  if (interleaved && typeof interleaved === "object" && typeof interleaved.field === "string" && interleaved.field.length > 0) {
+    return interleaved.field;
+  }
+  return;
+}
+function setCachedModelMetadata(cache, key, model) {
+  const limit = resolveLimit(model?.limit);
+  const interleavedField = resolveInterleavedField(model?.capabilities?.interleaved) ?? resolveInterleavedField(model?.interleaved);
+  if (limit === undefined && interleavedField === undefined) {
+    return;
+  }
+  const value = {};
+  if (limit !== undefined)
+    value.limit = limit;
+  if (interleavedField !== undefined)
+    value.interleavedField = interleavedField;
+  cache.set(key, value);
+  const modes = model?.experimental?.modes;
+  if (modes && typeof modes === "object") {
+    for (const mode of Object.keys(modes)) {
+      cache.set(`${key}-${mode}`, value);
+    }
+  }
+}
+function loadModelsDevMetadataFromFile() {
+  const metadata = new Map;
   const modelsJsonPath = getModelsJsonPath();
   let fileFound = false;
   try {
@@ -151321,16 +151666,7 @@ function loadModelsDevLimitsFromFile() {
         if (!provider2?.models || typeof provider2.models !== "object")
           continue;
         for (const [modelId, model] of Object.entries(provider2.models)) {
-          const effective = resolveLimit(model?.limit);
-          if (typeof effective === "number" && effective > 0) {
-            limits.set(`${providerId}/${modelId}`, effective);
-            const modes = model?.experimental?.modes;
-            if (modes && typeof modes === "object") {
-              for (const mode of Object.keys(modes)) {
-                limits.set(`${providerId}/${modelId}-${mode}`, effective);
-              }
-            }
-          }
+          setCachedModelMetadata(metadata, `${providerId}/${modelId}`, model);
         }
       }
     }
@@ -151348,10 +151684,7 @@ function loadModelsDevLimitsFromFile() {
           if (!provider2?.models || typeof provider2.models !== "object")
             continue;
           for (const [modelId, model] of Object.entries(provider2.models)) {
-            const effective = resolveLimit(model?.limit);
-            if (typeof effective === "number" && effective > 0) {
-              limits.set(`${providerId}/${modelId}`, effective);
-            }
+            setCachedModelMetadata(metadata, `${providerId}/${modelId}`, model);
           }
         }
       }
@@ -151359,8 +151692,8 @@ function loadModelsDevLimitsFromFile() {
   } catch (error48) {
     sessionLog("global", "models-dev-cache: failed to read opencode config for custom models:", error48 instanceof Error ? error48.message : String(error48));
   }
-  sessionLog("global", `models-dev-cache: file-layer loaded ${limits.size} model limits (modelsJsonPath=${modelsJsonPath}, found=${fileFound})`);
-  return limits;
+  sessionLog("global", `models-dev-cache: file-layer loaded ${metadata.size} model metadata entries (modelsJsonPath=${modelsJsonPath}, found=${fileFound})`);
+  return metadata;
 }
 async function refreshModelLimitsFromApi(client) {
   try {
@@ -151377,17 +151710,14 @@ async function refreshModelLimitsFromApi(client) {
       if (!p?.id || !p.models || typeof p.models !== "object")
         continue;
       for (const [modelId, model] of Object.entries(p.models)) {
-        const effective = resolveLimit(model?.limit);
-        if (typeof effective === "number" && effective > 0) {
-          map2.set(`${p.id}/${modelId}`, effective);
-        }
+        setCachedModelMetadata(map2, `${p.id}/${modelId}`, model);
       }
     }
     const previousSize = apiCache?.size ?? null;
     apiCache = map2;
     apiLoadedAt = Date.now();
     if (previousSize === null || previousSize !== map2.size) {
-      sessionLog("global", `models-dev-cache: API layer loaded ${map2.size} model limits${previousSize !== null ? ` (was ${previousSize})` : ""}`);
+      sessionLog("global", `models-dev-cache: API layer loaded ${map2.size} model metadata entries${previousSize !== null ? ` (was ${previousSize})` : ""}`);
     }
   } catch (error48) {
     sessionLog("global", "models-dev-cache: API refresh failed:", error48 instanceof Error ? error48.message : String(error48));
@@ -151396,16 +151726,32 @@ async function refreshModelLimitsFromApi(client) {
 function getModelsDevContextLimit(providerID, modelID) {
   const key = `${providerID}/${modelID}`;
   if (apiCache) {
-    const fromApi = apiCache.get(key);
+    const fromApi = apiCache.get(key)?.limit;
     if (typeof fromApi === "number")
       return fromApi;
   }
   const now = Date.now();
   if (!fileCache || now - fileLastAttempt > RELOAD_INTERVAL_MS) {
     fileLastAttempt = now;
-    fileCache = loadModelsDevLimitsFromFile();
+    fileCache = loadModelsDevMetadataFromFile();
   }
-  return fileCache.get(key);
+  return fileCache.get(key)?.limit;
+}
+function getModelsDevInterleavedField(providerID, modelID) {
+  const key = `${providerID}/${modelID}`;
+  if (apiCache) {
+    const fromApi = apiCache.get(key)?.interleavedField;
+    if (typeof fromApi === "string" && fromApi.length > 0) {
+      return fromApi;
+    }
+  }
+  const now = Date.now();
+  if (!fileCache || now - fileLastAttempt > RELOAD_INTERVAL_MS) {
+    fileLastAttempt = now;
+    fileCache = loadModelsDevMetadataFromFile();
+  }
+  const fromFile = fileCache.get(key)?.interleavedField;
+  return typeof fromFile === "string" && fromFile.length > 0 ? fromFile : undefined;
 }
 var RELOAD_INTERVAL_MS, apiCache = null, apiLoadedAt = 0, fileCache = null, fileLastAttempt = 0;
 var init_models_dev_cache = __esm(() => {
@@ -151413,45 +151759,6 @@ var init_models_dev_cache = __esm(() => {
   RELOAD_INTERVAL_MS = 5 * 60 * 1000;
 });
 
-// src/features/magic-context/memory/project-identity.ts
-import { execSync } from "child_process";
-import path3 from "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 = path3.resolve(directory);
-  const hash2 = Bun.hash(canonical).toString(16).slice(0, 12);
-  return `dir:${hash2}`;
-}
-function resolveProjectIdentity(directory) {
-  const resolved = path3.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/rpc-notifications.ts
 var exports_rpc_notifications = {};
 __export(exports_rpc_notifications, {
@@ -152141,6 +152448,25 @@ var init_temporal_awareness = __esm(() => {
 function clearInjectionCache(sessionId) {
   injectionCache.delete(sessionId);
 }
+function getVisibleMemoryIds(db, sessionId) {
+  try {
+    const row = db.prepare("SELECT memory_block_ids FROM session_meta WHERE session_id = ?").get(sessionId);
+    if (!row?.memory_block_ids)
+      return null;
+    const parsed = JSON.parse(row.memory_block_ids);
+    if (!Array.isArray(parsed))
+      return null;
+    const ids = new Set;
+    for (const value of parsed) {
+      if (typeof value === "number" && Number.isFinite(value)) {
+        ids.add(value);
+      }
+    }
+    return ids.size > 0 ? ids : null;
+  } catch {
+    return null;
+  }
+}
 function renderMemoryBlock(memories) {
   const byCategory = new Map;
   for (const m of memories) {
@@ -152236,8 +152562,9 @@ function prepareCompartmentInjection(db, sessionId, messages, isCacheBusting, pr
       }
       memoryCount = memories.length;
       memoryBlock = renderMemoryBlock(memories) ?? undefined;
+      const renderedIds = memories.map((m) => m.id);
       try {
-        db.prepare("UPDATE session_meta SET memory_block_cache = ?, memory_block_count = ? WHERE session_id = ?").run(memoryBlock ?? "", memoryCount, sessionId);
+        db.prepare("UPDATE session_meta SET memory_block_cache = ?, memory_block_count = ?, memory_block_ids = ? WHERE session_id = ?").run(memoryBlock ?? "", memoryCount, JSON.stringify(renderedIds), sessionId);
       } catch (error48) {
         const code = error48?.code;
         if (code === "SQLITE_BUSY") {
@@ -153084,23 +153411,42 @@ function peekNoteNudgeText(db, sessionId, currentUserMessageId, projectIdentity)
     return null;
   }
   const notes = getSessionNotes(db, sessionId);
-  const readySmartCount = projectIdentity ? getReadySmartNotes(db, projectIdentity).length : 0;
-  const totalCount = notes.length + readySmartCount;
+  const readySmartNotes = projectIdentity ? getReadySmartNotes(db, projectIdentity) : [];
+  const totalCount = notes.length + readySmartNotes.length;
   if (totalCount === 0) {
     sessionLog(sessionId, "note-nudge: triggerPending but no notes found, skipping");
     clearPersistedNoteNudge(db, sessionId);
     return null;
   }
+  const lastReadAt = getNoteLastReadAt(db, sessionId);
+  if (lastReadAt > 0) {
+    const mostRecentNoteActivity = maxNoteActivityTime([...notes, ...readySmartNotes]);
+    if (mostRecentNoteActivity > 0 && lastReadAt > mostRecentNoteActivity) {
+      sessionLog(sessionId, `note-nudge: suppressing \u2014 agent already ran ctx_note(read) at ${new Date(lastReadAt).toISOString()}, no new notes since ${new Date(mostRecentNoteActivity).toISOString()}`);
+      clearPersistedNoteNudge(db, sessionId);
+      return null;
+    }
+  }
   const parts = [];
   if (notes.length > 0) {
     parts.push(`${notes.length} deferred note${notes.length === 1 ? "" : "s"}`);
   }
-  if (readySmartCount > 0) {
-    parts.push(`${readySmartCount} ready smart note${readySmartCount === 1 ? "" : "s"}`);
+  if (readySmartNotes.length > 0) {
+    parts.push(`${readySmartNotes.length} ready smart note${readySmartNotes.length === 1 ? "" : "s"}`);
   }
   sessionLog(sessionId, `note-nudge: delivering nudge for ${parts.join(" and ")}`);
   return `You have ${parts.join(" and ")}. Review with ctx_note read \u2014 some may be actionable now.`;
 }
+function maxNoteActivityTime(notes) {
+  let max = 0;
+  for (const note of notes) {
+    if (note.updatedAt > max)
+      max = note.updatedAt;
+    if (note.readyAt !== null && note.readyAt > max)
+      max = note.readyAt;
+  }
+  return max;
+}
 function markNoteNudgeDelivered(db, sessionId, text, messageId) {
   setPersistedDeliveredNoteNudge(db, sessionId, messageId ? text : "", messageId ?? "");
   recordNoteNudgeDeliveryTime(sessionId);
@@ -153216,40 +153562,6 @@ var init_promotion = __esm(() => {
   init_storage_memory();
   init_storage_memory_embeddings();
 });
-
-// src/features/magic-context/memory/storage-memory-fts.ts
-function getSearchStatement(db) {
-  let stmt = searchStatements.get(db);
-  if (!stmt) {
-    const selectColumns = Object.entries(COLUMN_MAP).map(([property, column]) => `memories.${column} AS ${property}`).join(", ");
-    stmt = db.prepare(`SELECT ${selectColumns} FROM memories_fts INNER JOIN memories ON memories.id = memories_fts.rowid WHERE memories.project_path = ? AND memories.status IN ('active', 'permanent') AND (memories.expires_at IS NULL OR memories.expires_at > ?) AND memories_fts MATCH ? ORDER BY bm25(memories_fts), memories.updated_at DESC, memories.id ASC LIMIT ?`);
-    searchStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function sanitizeFtsQuery(query) {
-  const tokens = query.split(/\s+/).filter((token) => token.length > 0);
-  if (tokens.length === 0)
-    return "";
-  return tokens.map((token) => `"${token.replace(/"/g, '""')}"`).join(" ");
-}
-function searchMemoriesFTS(db, projectPath, query, limit = DEFAULT_SEARCH_LIMIT) {
-  const trimmedQuery = query.trim();
-  if (trimmedQuery.length === 0 || limit <= 0) {
-    return [];
-  }
-  const sanitized = sanitizeFtsQuery(trimmedQuery);
-  if (sanitized.length === 0) {
-    return [];
-  }
-  const rows = getSearchStatement(db).all(projectPath, Date.now(), sanitized, limit).filter(isMemoryRow);
-  return rows.map(toMemory);
-}
-var DEFAULT_SEARCH_LIMIT = 10, searchStatements;
-var init_storage_memory_fts = __esm(() => {
-  init_storage_memory();
-  searchStatements = new WeakMap;
-});
 // src/features/magic-context/memory/index.ts
 var init_memory = __esm(() => {
   init_project_identity();
@@ -154024,6 +154336,7 @@ No new compartments or facts were written. Check the historian model/output and
       appendCompartments(db, sessionId, newCompartments);
       replaceSessionFacts(db, sessionId, validatedPass.facts ?? []);
       clearHistorianFailureState(db, sessionId);
+      clearEmergencyRecovery(db, sessionId);
     })();
     clearInjectionCache(sessionId);
     if (deps.directory) {
@@ -162379,15 +162692,75 @@ function redactConfigValue(value) {
   }
   return typeof value;
 }
+function migrateLegacyExperimental(rawConfig, warnings) {
+  const experimental = rawConfig.experimental;
+  if (typeof experimental !== "object" || experimental === null) {
+    return rawConfig;
+  }
+  const exp = experimental;
+  const hasUM = "user_memories" in exp;
+  const hasPKF = "pin_key_files" in exp;
+  if (!hasUM && !hasPKF) {
+    return rawConfig;
+  }
+  const patched = { ...rawConfig };
+  const dreamer = typeof patched.dreamer === "object" && patched.dreamer !== null ? { ...patched.dreamer } : {};
+  const newExperimental = { ...exp };
+  const coerceToObject = (value) => {
+    if (typeof value === "boolean") {
+      return { enabled: value };
+    }
+    if (typeof value === "object" && value !== null) {
+      return { ...value };
+    }
+    return;
+  };
+  if (hasUM) {
+    const oldUM = coerceToObject(exp.user_memories);
+    if (oldUM !== undefined) {
+      if (dreamer.user_memories === undefined) {
+        dreamer.user_memories = oldUM;
+        warnings.push('Migrated "experimental.user_memories" \u2192 "dreamer.user_memories" in-memory (run `doctor` to persist).');
+      } else if (typeof dreamer.user_memories === "object" && dreamer.user_memories !== null) {
+        dreamer.user_memories = {
+          ...oldUM,
+          ...dreamer.user_memories
+        };
+      }
+    }
+    delete newExperimental.user_memories;
+  }
+  if (hasPKF) {
+    const oldPKF = coerceToObject(exp.pin_key_files);
+    if (oldPKF !== undefined) {
+      if (dreamer.pin_key_files === undefined) {
+        dreamer.pin_key_files = oldPKF;
+        warnings.push('Migrated "experimental.pin_key_files" \u2192 "dreamer.pin_key_files" in-memory (run `doctor` to persist).');
+      } else if (typeof dreamer.pin_key_files === "object" && dreamer.pin_key_files !== null) {
+        dreamer.pin_key_files = {
+          ...oldPKF,
+          ...dreamer.pin_key_files
+        };
+      }
+    }
+    delete newExperimental.pin_key_files;
+  }
+  patched.experimental = newExperimental;
+  patched.dreamer = dreamer;
+  return patched;
+}
 function parsePluginConfig(rawConfig) {
-  const parsed = MagicContextConfigSchema.safeParse(rawConfig);
+  const preMigrationWarnings = [];
+  const migrated = migrateLegacyExperimental(rawConfig, preMigrationWarnings);
+  const parsed = MagicContextConfigSchema.safeParse(migrated);
   const disabledHooks = Array.isArray(rawConfig.disabled_hooks) ? rawConfig.disabled_hooks.filter((value) => typeof value === "string") : undefined;
   const command = typeof rawConfig.command === "object" && rawConfig.command !== null ? rawConfig.command : undefined;
   if (parsed.success) {
     return {
       ...parsed.data,
       disabled_hooks: disabledHooks,
-      command
+      command,
+      ...preMigrationWarnings.length > 0 ? { configWarnings: preMigrationWarnings } : {}
     };
   }
   const defaults = MagicContextConfigSchema.parse({});
@@ -162411,17 +162784,23 @@ function parsePluginConfig(rawConfig) {
       warnings.push(`"${key}": invalid value (${redactConfigValue(rawConfig[key])}), using default ${JSON.stringify(defaultVal)}.`);
     }
   }
-  const retryParsed = MagicContextConfigSchema.safeParse(patched);
+  const retryMigrated = migrateLegacyExperimental(patched, preMigrationWarnings);
+  const retryParsed = MagicContextConfigSchema.safeParse(retryMigrated);
   if (retryParsed.success) {
     return {
       ...retryParsed.data,
       disabled_hooks: disabledHooks,
       command,
-      configWarnings: warnings
+      configWarnings: [...preMigrationWarnings, ...warnings]
     };
   }
   warnings.push("Config recovery failed, using all defaults.");
-  return { ...defaults, disabled_hooks: disabledHooks, command, configWarnings: warnings };
+  return {
+    ...defaults,
+    disabled_hooks: disabledHooks,
+    command,
+    configWarnings: [...preMigrationWarnings, ...warnings]
+  };
 }
 function loadPluginConfig(directory) {
   const userDetected = detectConfigFile(getUserConfigBasePath());
@@ -164199,36 +164578,562 @@ function checkScheduleAndEnqueue(db, schedule) {
   }
   return enqueued;
 }
+// src/features/magic-context/git-commits/git-log-reader.ts
+init_logger();
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var GIT_TIMEOUT_MS = 1e4;
+var DEFAULT_MAX_COMMITS = 5000;
+var RECORD_SEPARATOR = "\x1E";
+var FIELD_SEPARATOR = "\x1F";
+async function readGitCommits(directory, options = {}) {
+  const args = [
+    "log",
+    options.branch ?? "HEAD",
+    "--no-merges",
+    `--max-count=${options.maxCommits ?? DEFAULT_MAX_COMMITS}`,
+    `--format=%H${FIELD_SEPARATOR}%s${FIELD_SEPARATOR}%ae${FIELD_SEPARATOR}%ct${FIELD_SEPARATOR}%b${RECORD_SEPARATOR}`
+  ];
+  if (options.sinceMs !== undefined && options.sinceMs > 0) {
+    const iso = new Date(options.sinceMs).toISOString();
+    args.push(`--since=${iso}`);
+  }
+  let stdout;
+  try {
+    const result = await execFileAsync("git", args, {
+      cwd: directory,
+      timeout: GIT_TIMEOUT_MS,
+      maxBuffer: 32 * 1024 * 1024,
+      encoding: "utf8"
+    });
+    stdout = result.stdout;
+  } catch (error48) {
+    const message = error48 instanceof Error ? error48.message : String(error48);
+    log(`[git-commits] readGitCommits failed at cwd=${directory}: ${message.slice(0, 500)}`);
+    return [];
+  }
+  if (stdout.trim().length === 0) {
+    log(`[git-commits] readGitCommits returned empty stdout at cwd=${directory} (sinceMs=${options.sinceMs ?? "none"} args=${args.slice(0, 4).join(" ")})`);
+  }
+  return parseGitLogOutput(stdout);
+}
+function parseGitLogOutput(stdout) {
+  const commits = [];
+  const records = stdout.split(RECORD_SEPARATOR);
+  for (const rawRecord of records) {
+    const record2 = rawRecord.replace(/^\s+/, "");
+    if (!record2)
+      continue;
+    const fields = [];
+    let remaining = record2;
+    for (let i = 0;i < 4; i++) {
+      const idx = remaining.indexOf(FIELD_SEPARATOR);
+      if (idx < 0)
+        break;
+      fields.push(remaining.slice(0, idx));
+      remaining = remaining.slice(idx + FIELD_SEPARATOR.length);
+    }
+    fields.push(remaining);
+    if (fields.length < 5)
+      continue;
+    const sha = fields[0].trim();
+    const subject = fields[1].trim();
+    const author = fields[2].trim();
+    const timeSec = Number.parseInt(fields[3].trim(), 10);
+    const body = fields[4].trim();
+    if (sha.length !== 40 || !Number.isFinite(timeSec) || timeSec <= 0) {
+      continue;
+    }
+    const message = body.length > 0 ? `${subject}
+
+${body}` : subject;
+    commits.push({
+      sha,
+      shortSha: sha.slice(0, 7),
+      message,
+      author: author.length > 0 ? author : null,
+      committedAtMs: timeSec * 1000
+    });
+  }
+  return commits;
+}
+// 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;
+}
+
+// src/features/magic-context/git-commits/storage-git-commits.ts
+init_logger();
+var insertStatements = new WeakMap;
+var existingShasStatements = new WeakMap;
+var projectCountStatements = new WeakMap;
+var evictStatements = new WeakMap;
+var latestCommitTimeStatements = new WeakMap;
+function getInsertStatement(db) {
+  let stmt = insertStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`INSERT INTO git_commits (sha, project_path, short_sha, message, author, committed_at, indexed_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?)
+             ON CONFLICT(sha) DO UPDATE SET
+                 project_path = excluded.project_path,
+                 short_sha = excluded.short_sha,
+                 message = excluded.message,
+                 author = excluded.author,
+                 committed_at = excluded.committed_at,
+                 indexed_at = excluded.indexed_at
+             WHERE git_commits.message != excluded.message`);
+    insertStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getExistingShasStatement(db) {
+  let stmt = existingShasStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT sha FROM git_commits WHERE project_path = ?");
+    existingShasStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getProjectCountStatement(db) {
+  let stmt = projectCountStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT COUNT(*) AS count FROM git_commits WHERE project_path = ?");
+    projectCountStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getLatestCommitTimeStatement(db) {
+  let stmt = latestCommitTimeStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT MAX(committed_at) AS latest FROM git_commits WHERE project_path = ?");
+    latestCommitTimeStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getEvictStatement(db) {
+  let stmt = evictStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`DELETE FROM git_commits
+             WHERE sha IN (
+                 SELECT sha FROM git_commits
+                 WHERE project_path = ?
+                 ORDER BY committed_at ASC
+                 LIMIT ?
+             )`);
+    evictStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function upsertCommits(db, projectPath, commits) {
+  if (commits.length === 0)
+    return { inserted: 0, updated: 0 };
+  const existing = new Set;
+  for (const row of getExistingShasStatement(db).all(projectPath)) {
+    existing.add(row.sha);
+  }
+  let inserted = 0;
+  let updated = 0;
+  const now = Date.now();
+  const insertStmt = getInsertStatement(db);
+  db.transaction(() => {
+    for (const commit of commits) {
+      const result = insertStmt.run(commit.sha, projectPath, commit.shortSha, commit.message, commit.author, commit.committedAtMs, now);
+      if (result.changes > 0) {
+        if (existing.has(commit.sha)) {
+          updated++;
+        } else {
+          inserted++;
+          existing.add(commit.sha);
+        }
+      }
+    }
+  })();
+  return { inserted, updated };
+}
+function getCommitCount(db, projectPath) {
+  const row = getProjectCountStatement(db).get(projectPath);
+  return row?.count ?? 0;
+}
+function getLatestIndexedCommitTimeMs(db, projectPath) {
+  const row = getLatestCommitTimeStatement(db).get(projectPath);
+  return row?.latest ?? null;
+}
+function evictOldestCommits(db, projectPath, excess) {
+  if (excess <= 0)
+    return 0;
+  const before = getCommitCount(db, projectPath);
+  getEvictStatement(db).run(projectPath, excess);
+  const after = getCommitCount(db, projectPath);
+  return Math.max(0, before - after);
+}
+function enforceProjectCap(db, projectPath, maxCommits) {
+  if (maxCommits <= 0)
+    return 0;
+  const count = getCommitCount(db, projectPath);
+  if (count <= maxCommits)
+    return 0;
+  const excess = count - maxCommits;
+  const evicted = evictOldestCommits(db, projectPath, excess);
+  if (evicted > 0) {
+    log(`[git-commits] evicted ${evicted} oldest commits for project ${projectPath} (cap=${maxCommits}, was=${count})`);
+  }
+  return evicted;
+}
+
+// src/features/magic-context/git-commits/indexer.ts
+var MS_PER_DAY = 24 * 60 * 60 * 1000;
+var EMBED_BATCH_SIZE = 16;
+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) {
+  const result = {
+    scanned: 0,
+    inserted: 0,
+    updated: 0,
+    evicted: 0,
+    embedded: 0
+  };
+  if (indexInProgress.has(projectPath)) {
+    log(`[git-commits] index already in progress for ${projectPath}, skipping`);
+    return result;
+  }
+  indexInProgress.add(projectPath);
+  try {
+    const latestIndexed = getLatestIndexedCommitTimeMs(db, projectPath);
+    const sinceMs = latestIndexed !== null ? Math.max(latestIndexed - 60000, Date.now() - options.sinceDays * MS_PER_DAY) : Date.now() - options.sinceDays * MS_PER_DAY;
+    const commits = await readGitCommits(directory, {
+      sinceMs,
+      maxCommits: options.maxCommits
+    });
+    result.scanned = commits.length;
+    if (commits.length === 0) {
+      result.evicted = enforceProjectCap(db, projectPath, options.maxCommits);
+      log(`[git-commits] no new commits for ${projectPath} (sinceMs=${sinceMs} latestIndexed=${latestIndexed ?? "none"} evicted=${result.evicted})`);
+      return result;
+    }
+    log(`[git-commits] read ${commits.length} commits for ${projectPath} (sinceMs=${sinceMs} latestIndexed=${latestIndexed ?? "none"})`);
+    const upsert = upsertCommits(db, projectPath, commits);
+    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()})`);
+      return result;
+    }
+    result.embedded = await embedUnembeddedCommits(db, projectPath, embeddingConfig2);
+    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) {
+  if (embedInProgress.has(projectPath)) {
+    return 0;
+  }
+  if (!isEmbeddingEnabled()) {
+    return 0;
+  }
+  embedInProgress.add(projectPath);
+  const startedAt = Date.now();
+  const deadline = startedAt + EMBED_SWEEP_MAX_WALL_CLOCK_MS;
+  let total = 0;
+  try {
+    while (Date.now() < deadline && total < EMBED_MAX_PER_SWEEP) {
+      const rows = loadUnembeddedCommits(db, projectPath, EMBED_BATCH_SIZE);
+      if (rows.length === 0)
+        break;
+      let embeddedThisBatch = 0;
+      try {
+        const embeddings = await embedBatch(rows.map((row) => row.message));
+        const modelId = getEmbeddingModelId();
+        if (modelId === "off")
+          break;
+        db.transaction(() => {
+          for (const [index, row] of rows.entries()) {
+            const embedding = embeddings[index];
+            if (!embedding)
+              continue;
+            saveCommitEmbedding(db, row.sha, embedding, modelId);
+            embeddedThisBatch += 1;
+          }
+        })();
+      } catch (error48) {
+        log(`[git-commits] embed batch failed for ${projectPath}: ${error48 instanceof Error ? error48.message : String(error48)}`);
+        break;
+      }
+      if (embeddedThisBatch === 0)
+        break;
+      total += embeddedThisBatch;
+      if (embeddedThisBatch < rows.length)
+        break;
+    }
+    if (total > 0) {
+      const totalEmbedded = countEmbeddedCommits(db, projectPath);
+      log(`[git-commits] embedded ${total} commits for ${projectPath} (total embedded: ${totalEmbedded})`);
+    }
+    return total;
+  } finally {
+    embedInProgress.delete(projectPath);
+  }
+}
+// src/features/magic-context/git-commits/search-git-commits.ts
+init_logger();
+init_storage_memory_fts();
+var ftsStatements = new WeakMap;
+var ftsPlainStatements = new WeakMap;
+var getBySHAStatements = new WeakMap;
+function rowToCommit(row) {
+  return {
+    sha: row.sha,
+    shortSha: row.short_sha,
+    projectPath: row.project_path,
+    message: row.message,
+    author: row.author,
+    committedAtMs: row.committed_at,
+    indexedAtMs: row.indexed_at
+  };
+}
+function getFtsStatement(db) {
+  let stmt = ftsStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`SELECT c.sha AS sha, c.project_path AS project_path, c.short_sha AS short_sha,
+                    c.message AS message, c.author AS author,
+                    c.committed_at AS committed_at, c.indexed_at AS indexed_at
+             FROM git_commits_fts
+             INNER JOIN git_commits c ON c.sha = git_commits_fts.sha
+             WHERE c.project_path = ? AND git_commits_fts MATCH ?
+             ORDER BY bm25(git_commits_fts) LIMIT ?`);
+    ftsStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getLikeFallbackStatement(db) {
+  let stmt = ftsPlainStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`SELECT sha, project_path, short_sha, message, author, committed_at, indexed_at
+             FROM git_commits
+             WHERE project_path = ? AND lower(message) LIKE '%' || lower(?) || '%'
+             ORDER BY committed_at DESC LIMIT ?`);
+    ftsPlainStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getBySHAStatement(db) {
+  let stmt = getBySHAStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`SELECT sha, project_path, short_sha, message, author, committed_at, indexed_at
+             FROM git_commits WHERE sha = ?`);
+    getBySHAStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function clamp01(value) {
+  if (!Number.isFinite(value))
+    return 0;
+  return Math.min(1, Math.max(0, value));
+}
+function searchGitCommitsSync(db, projectPath, query, options) {
+  const trimmed = query.trim();
+  if (trimmed.length === 0 || options.limit <= 0)
+    return [];
+  const semanticWeight = options.semanticWeight ?? 0.7;
+  const ftsWeight = options.ftsWeight ?? 0.3;
+  const singleSourcePenalty = options.singleSourcePenalty ?? 0.8;
+  const fetchLimit = Math.max(options.limit * 3, 30);
+  const ftsCandidates = [];
+  const sanitized = sanitizeFtsQuery(trimmed);
+  if (sanitized.length > 0) {
+    try {
+      for (const row of getFtsStatement(db).all(projectPath, sanitized, fetchLimit)) {
+        ftsCandidates.push(rowToCommit(row));
+      }
+    } catch (error48) {
+      log(`[git-commits] FTS query failed for "${trimmed}": ${error48 instanceof Error ? error48.message : String(error48)}`);
+    }
+  }
+  if (ftsCandidates.length === 0) {
+    for (const row of getLikeFallbackStatement(db).all(projectPath, trimmed, fetchLimit)) {
+      ftsCandidates.push(rowToCommit(row));
+    }
+  }
+  const ftsScores = new Map;
+  ftsCandidates.forEach((commit, rank) => {
+    ftsScores.set(commit.sha, 1 / (rank + 1));
+  });
+  const semanticScores = new Map;
+  if (options.queryEmbedding) {
+    const embeddings = loadProjectCommitEmbeddings(db, projectPath);
+    for (const [sha, embedding] of embeddings.entries()) {
+      const similarity = clamp01(cosineSimilarity(options.queryEmbedding, embedding));
+      if (similarity > 0) {
+        semanticScores.set(sha, similarity);
+      }
+    }
+  }
+  const bySha = new Map;
+  for (const commit of ftsCandidates)
+    bySha.set(commit.sha, commit);
+  const getCommitStmt = getBySHAStatement(db);
+  for (const sha of semanticScores.keys()) {
+    if (bySha.has(sha))
+      continue;
+    const row = getCommitStmt.get(sha);
+    if (row && row.project_path === projectPath) {
+      bySha.set(sha, rowToCommit(row));
+    }
+  }
+  const results = [];
+  for (const [sha, commit] of bySha.entries()) {
+    const sem = semanticScores.get(sha);
+    const fts = ftsScores.get(sha);
+    let score = 0;
+    let matchType = "fts";
+    if (sem !== undefined && fts !== undefined) {
+      score = semanticWeight * sem + ftsWeight * fts;
+      matchType = "hybrid";
+    } else if (sem !== undefined) {
+      score = sem * singleSourcePenalty;
+      matchType = "semantic";
+    } else if (fts !== undefined) {
+      score = fts * singleSourcePenalty;
+      matchType = "fts";
+    }
+    if (score <= 0)
+      continue;
+    results.push({ commit, score, matchType });
+  }
+  results.sort((left, right) => {
+    if (right.score !== left.score)
+      return right.score - left.score;
+    return right.commit.committedAtMs - left.commit.committedAtMs;
+  });
+  return results.slice(0, options.limit);
+}
 // src/plugin/dream-timer.ts
 init_embedding();
+init_project_identity();
 init_storage();
 init_logger();
 var DREAM_TIMER_INTERVAL_MS = 15 * 60 * 1000;
 var activeTimer = null;
-var activeCleanup = null;
+var registeredProjects = new Map;
 function startDreamScheduleTimer(args) {
-  if (activeTimer) {
-    log("[dreamer] schedule timer already running, skipping duplicate start");
-    return activeCleanup ?? undefined;
-  }
-  const {
-    client,
-    dreamerConfig,
-    embeddingConfig: embeddingConfig2,
-    memoryEnabled,
-    experimentalUserMemories,
-    experimentalPinKeyFiles
-  } = args;
-  const dreamingEnabled = Boolean(dreamerConfig?.enabled && dreamerConfig.schedule?.trim());
-  const embeddingSweepEnabled = memoryEnabled && embeddingConfig2.provider !== "off";
-  if (!dreamingEnabled && !embeddingSweepEnabled) {
+  const dreamingEnabled = Boolean(args.dreamerConfig?.enabled && args.dreamerConfig.schedule?.trim());
+  const embeddingSweepEnabled = args.memoryEnabled && args.embeddingConfig.provider !== "off";
+  const commitIndexingEnabled = args.gitCommitIndexing?.enabled === true;
+  if (!dreamingEnabled && !embeddingSweepEnabled && !commitIndexingEnabled) {
     return;
   }
-  const timer = setInterval(() => {
-    log("[dreamer] timer tick \u2014 checking schedule and embeddings");
-    try {
-      if (embeddingSweepEnabled) {
-        embedAllUnembeddedMemories(openDatabase(), embeddingConfig2).then((embeddedCount) => {
+  const isNewRegistration = !registeredProjects.has(args.directory);
+  registeredProjects.set(args.directory, args);
+  if (isNewRegistration) {
+    log(`[dreamer] registered project ${args.directory} (dreaming=${dreamingEnabled} embeddings=${embeddingSweepEnabled} commits=${commitIndexingEnabled}; total=${registeredProjects.size})`);
+  }
+  if (!activeTimer) {
+    log(`[dreamer] started independent schedule timer (every ${DREAM_TIMER_INTERVAL_MS / 60000}m)`);
+    runTick("startup");
+    const timer = setInterval(() => runTick("interval"), DREAM_TIMER_INTERVAL_MS);
+    if (typeof timer === "object" && "unref" in timer) {
+      timer.unref();
+    }
+    activeTimer = timer;
+  } else if (isNewRegistration) {
+    sweepProject(args, "startup");
+  }
+  return () => {
+    registeredProjects.delete(args.directory);
+    log(`[dreamer] unregistered project ${args.directory} (remaining=${registeredProjects.size})`);
+    if (registeredProjects.size === 0 && activeTimer) {
+      clearInterval(activeTimer);
+      activeTimer = null;
+      log("[dreamer] stopped dream schedule timer (no projects left)");
+    }
+  };
+}
+function runTick(origin) {
+  log(`[dreamer] timer tick (${origin}) \u2014 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) => {
           if (embeddedCount > 0) {
             log(`[magic-context] proactively embedded ${embeddedCount} ${embeddedCount === 1 ? "memory" : "memories"} across all projects`);
           }
@@ -164236,41 +165141,65 @@ function startDreamScheduleTimer(args) {
           log("[magic-context] periodic memory embedding sweep failed:", error48);
         });
       }
-      if (!dreamingEnabled || !dreamerConfig?.schedule?.trim()) {
-        log("[dreamer] timer tick \u2014 dreaming disabled, skipping schedule check");
-        return;
-      }
-      const db = openDatabase();
-      log(`[dreamer] timer tick \u2014 checking schedule window "${dreamerConfig.schedule}"`);
-      checkScheduleAndEnqueue(db, dreamerConfig.schedule);
-      processDreamQueue({
-        db,
-        client,
-        tasks: dreamerConfig.tasks,
-        taskTimeoutMinutes: dreamerConfig.task_timeout_minutes,
-        maxRuntimeMinutes: dreamerConfig.max_runtime_minutes,
-        experimentalUserMemories,
-        experimentalPinKeyFiles
-      }).catch((error48) => {
-        log("[dreamer] timer-triggered queue processing failed:", error48);
-      });
-    } catch (error48) {
-      log("[magic-context] timer-triggered maintenance check failed:", error48);
     }
-  }, DREAM_TIMER_INTERVAL_MS);
-  if (typeof timer === "object" && "unref" in timer) {
-    timer.unref();
+    for (const reg of registeredProjects.values()) {
+      sweepProject(reg, origin);
+    }
+  } catch (error48) {
+    log("[magic-context] timer-triggered maintenance check failed:", error48);
+  }
+}
+async function sweepProject(reg, origin) {
+  const dreamingEnabled = Boolean(reg.dreamerConfig?.enabled && reg.dreamerConfig.schedule?.trim());
+  const commitIndexingEnabled = reg.gitCommitIndexing?.enabled === true;
+  if (commitIndexingEnabled && reg.gitCommitIndexing) {
+    await sweepGitCommits({
+      directory: reg.directory,
+      gitCommitIndexing: reg.gitCommitIndexing,
+      embeddingConfig: reg.embeddingConfig
+    });
+  }
+  if (!dreamingEnabled || !reg.dreamerConfig?.schedule?.trim()) {
+    return;
+  }
+  try {
+    const db = openDatabase();
+    log(`[dreamer] timer tick (${origin}) ${reg.directory} \u2014 checking schedule window "${reg.dreamerConfig.schedule}"`);
+    checkScheduleAndEnqueue(db, reg.dreamerConfig.schedule);
+    await processDreamQueue({
+      db,
+      client: reg.client,
+      tasks: reg.dreamerConfig.tasks,
+      taskTimeoutMinutes: reg.dreamerConfig.task_timeout_minutes,
+      maxRuntimeMinutes: reg.dreamerConfig.max_runtime_minutes,
+      experimentalUserMemories: reg.experimentalUserMemories,
+      experimentalPinKeyFiles: reg.experimentalPinKeyFiles
+    });
+  } catch (error48) {
+    log(`[dreamer] timer-triggered queue processing failed for ${reg.directory}:`, error48);
+  }
+}
+async function sweepGitCommits(args) {
+  const { directory, gitCommitIndexing, embeddingConfig: embeddingConfig2 } = args;
+  const startedAt = Date.now();
+  log(`[git-commits] sweep starting for ${directory} (sinceDays=${gitCommitIndexing.since_days} maxCommits=${gitCommitIndexing.max_commits} embedding=${embeddingConfig2.provider})`);
+  try {
+    const db = openDatabase();
+    const projectPath = resolveProjectIdentity(directory);
+    const result = await indexCommitsForProject(db, projectPath, directory, embeddingConfig2, {
+      sinceDays: gitCommitIndexing.since_days,
+      maxCommits: gitCommitIndexing.max_commits
+    });
+    let drainedEmbeddings = 0;
+    if (embeddingConfig2.provider !== "off" && result.embedded > 0) {
+      drainedEmbeddings = await embedUnembeddedCommits(db, projectPath, embeddingConfig2);
+    }
+    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}`);
+  } catch (error48) {
+    const elapsedMs = Date.now() - startedAt;
+    log(`[git-commits] sweep failed for ${directory} after ${elapsedMs}ms: ${error48 instanceof Error ? error48.message : String(error48)}`);
   }
-  const cleanup = () => {
-    clearInterval(timer);
-    activeTimer = null;
-    activeCleanup = null;
-    log("[dreamer] stopped dream schedule timer");
-  };
-  activeTimer = timer;
-  activeCleanup = cleanup;
-  log(`[dreamer] started independent schedule timer (every ${DREAM_TIMER_INTERVAL_MS / 60000}m)`);
-  return cleanup;
 }
 
 // src/plugin/event.ts
@@ -164297,21 +165226,23 @@ function createCompactionHandler() {
   };
 }
 // src/hooks/magic-context/event-resolvers.ts
+init_storage_meta_persisted();
 init_logger();
 init_models_dev_cache();
 var DEFAULT_CONTEXT_LIMIT = 128000;
 var MAX_EXECUTE_THRESHOLD = 80;
-function resolveContextLimit(providerID, modelID) {
-  if (!providerID) {
-    return DEFAULT_CONTEXT_LIMIT;
-  }
-  if (modelID) {
-    const modelsDevLimit = getModelsDevContextLimit(providerID, modelID);
-    if (modelsDevLimit !== undefined) {
-      return modelsDevLimit;
-    }
+function resolveContextLimit(providerID, modelID, ctx) {
+  const fromModelsDev = providerID && modelID ? getModelsDevContextLimit(providerID, modelID) : undefined;
+  const baseline = fromModelsDev ?? DEFAULT_CONTEXT_LIMIT;
+  if (ctx?.db && ctx.sessionID) {
+    try {
+      const overflow = getOverflowState(ctx.db, ctx.sessionID);
+      if (overflow.detectedContextLimit > 0 && overflow.detectedContextLimit < baseline) {
+        return overflow.detectedContextLimit;
+      }
+    } catch {}
   }
-  return DEFAULT_CONTEXT_LIMIT;
+  return baseline;
 }
 function resolveCacheTtl(cacheTtl, modelKey) {
   if (typeof cacheTtl === "string") {
@@ -165251,6 +166182,112 @@ ${snap.error}`;
 // src/hooks/magic-context/hook.ts
 init_derive_budgets();
 
+// src/features/magic-context/overflow-detection.ts
+var OVERFLOW_PATTERNS = [
+  /prompt is too long/i,
+  /input is too long for requested model/i,
+  /exceeds the context window/i,
+  /input token count.*exceeds the maximum/i,
+  /maximum prompt length is \d+/i,
+  /reduce the length of the messages/i,
+  /maximum context length is \d+ tokens/i,
+  /exceeds the limit of \d+/i,
+  /exceeds the available context size/i,
+  /greater than the context length/i,
+  /context window exceeds limit/i,
+  /exceeded model token limit/i,
+  /context[_ ]length[_ ]exceeded/i,
+  /request entity too large/i,
+  /context length is only \d+ tokens/i,
+  /input length.*exceeds.*context length/i,
+  /prompt too long; exceeded (?:max )?context length/i,
+  /too large for model with \d+ maximum context length/i,
+  /model_context_window_exceeded/i,
+  /context size has been exceeded/i
+];
+var LIMIT_EXTRACTION_PATTERNS = [
+  /maximum prompt length is (\d+)/i,
+  /maximum context length is (\d+) tokens?/i,
+  /context length is only (\d+) tokens?/i,
+  /exceeds the limit of (\d+)/i,
+  /too large for model with (\d+) maximum context length/i,
+  /context size.*(\d+) tokens?/i,
+  /exceeds? the context length of (\d+)/i,
+  /max(?:imum)?.*context.*?(\d+)/i
+];
+var MIN_PLAUSIBLE_LIMIT = 1024;
+var MAX_PLAUSIBLE_LIMIT = 1e7;
+function extractErrorMessage(error48) {
+  if (!error48)
+    return "";
+  if (typeof error48 === "string")
+    return error48;
+  if (typeof error48 === "object") {
+    const obj = error48;
+    const nested = obj.error;
+    if (nested && typeof nested.message === "string" && nested.message.length > 0) {
+      return nested.message;
+    }
+  }
+  if (error48 instanceof Error)
+    return error48.message;
+  if (typeof error48 === "object") {
+    const obj = error48;
+    if (typeof obj.message === "string")
+      return obj.message;
+    if (typeof obj.responseBody === "string")
+      return obj.responseBody;
+    try {
+      return JSON.stringify(error48);
+    } catch {
+      return String(error48);
+    }
+  }
+  return String(error48);
+}
+function detectOverflow(error48) {
+  const message = extractErrorMessage(error48);
+  if (!message) {
+    return { isOverflow: false };
+  }
+  const hasStatus413 = /\b413\b/.test(message) && /(entity|payload|context|prompt)/i.test(message);
+  let matched;
+  for (const pattern of OVERFLOW_PATTERNS) {
+    if (pattern.test(message)) {
+      matched = pattern;
+      break;
+    }
+  }
+  if (!matched && !hasStatus413) {
+    return { isOverflow: false };
+  }
+  const reportedLimit = parseReportedLimit(message);
+  return {
+    isOverflow: true,
+    reportedLimit,
+    matchedPattern: matched?.source
+  };
+}
+function parseReportedLimit(message) {
+  if (!message)
+    return;
+  for (const pattern of LIMIT_EXTRACTION_PATTERNS) {
+    const match = message.match(pattern);
+    if (!match)
+      continue;
+    const raw = match[1];
+    if (!raw)
+      continue;
+    const value = Number.parseInt(raw, 10);
+    if (!Number.isFinite(value))
+      continue;
+    if (value < MIN_PLAUSIBLE_LIMIT || value > MAX_PLAUSIBLE_LIMIT)
+      continue;
+    return value;
+  }
+  return;
+}
+
 // src/hooks/magic-context/event-handler.ts
 init_storage();
 init_storage_meta_persisted();
@@ -165309,9 +166346,18 @@ function getMessageUpdatedAssistantInfo(properties) {
         read: typeof cache?.read === "number" ? cache.read : undefined,
         write: typeof cache?.write === "number" ? cache.write : undefined
       }
-    }
+    },
+    error: info.error !== undefined ? info.error : undefined
   };
 }
+function getSessionErrorInfo(properties) {
+  if (!isRecord(properties))
+    return null;
+  const sessionID = properties.sessionID;
+  if (typeof sessionID !== "string" || sessionID.length === 0)
+    return null;
+  return { sessionID, error: properties.error };
+}
 function getMessageRemovedInfo(properties) {
   if (!isRecord(properties)) {
     return null;
@@ -165490,6 +166536,18 @@ init_inject_compartments();
 init_note_nudger();
 init_read_session_chunk();
 init_read_session_formatting();
+
+// src/hooks/magic-context/reasoning-capability.ts
+init_models_dev_cache();
+function modelRequiresInterleavedReasoning(model) {
+  if (!model?.providerID || !model?.modelID) {
+    return false;
+  }
+  const field = getModelsDevInterleavedField(model.providerID, model.modelID);
+  return typeof field === "string" && field.length > 0;
+}
+
+// src/hooks/magic-context/transform.ts
 init_send_session_notification();
 
 // src/hooks/magic-context/strip-content.ts
@@ -165614,7 +166672,9 @@ function stripDroppedPlaceholderMessages(messages) {
   }
   return stripped;
 }
-function replayClearedReasoning(messages, reasoningByMessage, messageTagNumbers, persistedWatermark) {
+function replayClearedReasoning(messages, reasoningByMessage, messageTagNumbers, persistedWatermark, skipTypedReasoningCleanup = false) {
+  if (skipTypedReasoningCleanup)
+    return 0;
   if (persistedWatermark <= 0)
     return 0;
   let cleared = 0;
@@ -165660,7 +166720,9 @@ function replayStrippedInlineThinking(messages, messageTagNumbers, persistedWate
   }
   return stripped;
 }
-function clearOldReasoning(messages, reasoningByMessage, messageTagNumbers, clearReasoningAge) {
+function clearOldReasoning(messages, reasoningByMessage, messageTagNumbers, clearReasoningAge, skipTypedReasoningCleanup = false) {
+  if (skipTypedReasoningCleanup)
+    return 0;
   const maxTag = findMaxTag(messageTagNumbers);
   if (maxTag === 0)
     return 0;
@@ -165695,7 +166757,9 @@ function findMaxTag(messageTagNumbers) {
   return max;
 }
 var CLEARED_REASONING_TYPES = new Set(["thinking", "reasoning"]);
-function stripClearedReasoning(messages) {
+function stripClearedReasoning(messages, skipTypedReasoningCleanup = false) {
+  if (skipTypedReasoningCleanup)
+    return 0;
   let stripped = 0;
   for (const message of messages) {
     if (message.info.role !== "assistant")
@@ -166924,6 +167988,571 @@ function applyContextNudge(messages, nudge, nudgePlacements, sessionId) {
   }
 }
 
+// src/features/magic-context/search.ts
+init_read_session_chunk();
+init_logger();
+init_memory();
+init_embedding();
+init_storage_memory_fts();
+init_message_index();
+var DEFAULT_UNIFIED_SEARCH_LIMIT = 10;
+var FTS_SEMANTIC_CANDIDATE_LIMIT = 50;
+var SEMANTIC_WEIGHT = 0.7;
+var FTS_WEIGHT = 0.3;
+var SINGLE_SOURCE_PENALTY = 0.8;
+var RESULT_PREVIEW_LIMIT = 220;
+var MEMORY_SOURCE_BOOST = 1.3;
+var MESSAGE_SOURCE_BOOST = 1.15;
+var GIT_COMMIT_SOURCE_BOOST = 1.2;
+var messageSearchStatements = new WeakMap;
+function normalizeLimit(limit) {
+  if (typeof limit !== "number" || !Number.isFinite(limit)) {
+    return DEFAULT_UNIFIED_SEARCH_LIMIT;
+  }
+  return Math.max(1, Math.floor(limit));
+}
+function normalizeCosineScore(score) {
+  if (!Number.isFinite(score)) {
+    return 0;
+  }
+  return Math.min(1, Math.max(0, score));
+}
+function previewText(text) {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  if (normalized.length <= RESULT_PREVIEW_LIMIT) {
+    return normalized;
+  }
+  return `${normalized.slice(0, RESULT_PREVIEW_LIMIT - 1).trimEnd()}\u2026`;
+}
+function getMessageSearchStatement(db) {
+  let stmt = messageSearchStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT message_ordinal AS messageOrdinal, message_id AS messageId, role, content FROM message_history_fts WHERE session_id = ? AND message_history_fts MATCH ? ORDER BY bm25(message_history_fts), CAST(message_ordinal AS INTEGER) ASC LIMIT ?");
+    messageSearchStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getMessageOrdinal(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+async function getSemanticScores(args) {
+  const semanticScores = new Map;
+  if (!args.embeddingEnabled || !args.isEmbeddingRuntimeEnabled() || args.memories.length === 0) {
+    return semanticScores;
+  }
+  const queryEmbedding = await args.embedQuery(args.query, args.signal);
+  if (!queryEmbedding) {
+    return semanticScores;
+  }
+  const cachedEmbeddings = getProjectEmbeddings(args.db, args.projectPath);
+  const embeddings = await ensureMemoryEmbeddings({
+    db: args.db,
+    memories: args.memories,
+    existingEmbeddings: cachedEmbeddings
+  });
+  for (const memory of args.memories) {
+    const memoryEmbedding = embeddings.get(memory.id);
+    if (!memoryEmbedding) {
+      continue;
+    }
+    semanticScores.set(memory.id, normalizeCosineScore(cosineSimilarity(queryEmbedding, memoryEmbedding)));
+  }
+  return semanticScores;
+}
+function getFtsMatches(args) {
+  try {
+    return searchMemoriesFTS(args.db, args.projectPath, args.query, args.limit);
+  } catch (error48) {
+    log(`[search] FTS query failed for "${args.query}": ${error48 instanceof Error ? error48.message : String(error48)}`);
+    return [];
+  }
+}
+function getFtsScores(matches) {
+  return new Map(matches.map((memory, rank) => [memory.id, 1 / (rank + 1)]));
+}
+function selectSemanticCandidates(args) {
+  if (args.ftsMatches.length === 0) {
+    return args.memories;
+  }
+  const candidateIds = new Set(args.ftsMatches.map((memory) => memory.id));
+  const cachedEmbeddings = peekProjectEmbeddings(args.projectPath);
+  if (cachedEmbeddings) {
+    for (const memoryId of cachedEmbeddings.keys()) {
+      candidateIds.add(memoryId);
+    }
+  }
+  return args.memories.filter((memory) => candidateIds.has(memory.id));
+}
+function mergeMemoryResults(args) {
+  const memoryById = new Map(args.memories.map((memory) => [memory.id, memory]));
+  const candidateIds = new Set([...args.semanticScores.keys(), ...args.ftsScores.keys()]);
+  const results = [];
+  for (const id of candidateIds) {
+    if (args.visibleMemoryIds?.has(id)) {
+      continue;
+    }
+    const memory = memoryById.get(id);
+    if (!memory) {
+      continue;
+    }
+    const semanticScore = args.semanticScores.get(id);
+    const ftsScore = args.ftsScores.get(id);
+    let score = 0;
+    let matchType = "fts";
+    if (semanticScore !== undefined && ftsScore !== undefined) {
+      score = SEMANTIC_WEIGHT * semanticScore + FTS_WEIGHT * ftsScore;
+      matchType = "hybrid";
+    } else if (semanticScore !== undefined) {
+      score = semanticScore * SINGLE_SOURCE_PENALTY;
+      matchType = "semantic";
+    } else if (ftsScore !== undefined) {
+      score = ftsScore * SINGLE_SOURCE_PENALTY;
+      matchType = "fts";
+    }
+    if (score <= 0) {
+      continue;
+    }
+    results.push({
+      source: "memory",
+      content: previewText(memory.content),
+      score,
+      memoryId: memory.id,
+      category: memory.category,
+      matchType
+    });
+  }
+  return results.sort((left, right) => {
+    if (right.score !== left.score) {
+      return right.score - left.score;
+    }
+    return left.memoryId - right.memoryId;
+  }).slice(0, args.limit);
+}
+async function searchMemories(args) {
+  if (!args.memoryEnabled) {
+    return [];
+  }
+  const memories = getMemoriesByProject(args.db, args.projectPath);
+  if (memories.length === 0) {
+    return [];
+  }
+  const ftsMatches = getFtsMatches({
+    db: args.db,
+    projectPath: args.projectPath,
+    query: args.query,
+    limit: FTS_SEMANTIC_CANDIDATE_LIMIT
+  });
+  const ftsScores = getFtsScores(ftsMatches);
+  const semanticCandidates = selectSemanticCandidates({
+    memories,
+    projectPath: args.projectPath,
+    ftsMatches
+  });
+  const semanticScores = await getSemanticScores({
+    db: args.db,
+    projectPath: args.projectPath,
+    query: args.query,
+    memories: semanticCandidates,
+    embeddingEnabled: args.embeddingEnabled,
+    embedQuery: args.embedQuery,
+    isEmbeddingRuntimeEnabled: args.isEmbeddingRuntimeEnabled,
+    signal: args.signal
+  });
+  return mergeMemoryResults({
+    memories,
+    semanticScores,
+    ftsScores,
+    limit: args.limit,
+    visibleMemoryIds: args.visibleMemoryIds
+  });
+}
+function linearDecayScore(rank, total) {
+  if (total <= 0)
+    return 0;
+  return Math.max(0, 1 - rank / total);
+}
+function searchMessages(args) {
+  ensureMessagesIndexed(args.db, args.sessionId, args.readMessages);
+  const sanitizedQuery = sanitizeFtsQuery(args.query.trim());
+  if (sanitizedQuery.length === 0) {
+    return [];
+  }
+  const fetchLimit = args.maxOrdinal != null && args.maxOrdinal >= 0 ? args.limit * 3 : args.limit;
+  const rows = getMessageSearchStatement(args.db).all(args.sessionId, sanitizedQuery, fetchLimit).map((row) => row);
+  const cutoff = args.maxOrdinal != null && args.maxOrdinal >= 0 ? args.maxOrdinal : null;
+  const filtered = rows.map((row) => {
+    const messageOrdinal = getMessageOrdinal(row.messageOrdinal);
+    if (messageOrdinal === null || typeof row.messageId !== "string" || typeof row.role !== "string" || typeof row.content !== "string") {
+      return null;
+    }
+    if (cutoff !== null && messageOrdinal > cutoff) {
+      return null;
+    }
+    return {
+      messageOrdinal,
+      messageId: row.messageId,
+      role: row.role,
+      content: row.content
+    };
+  }).filter((result) => result !== null).slice(0, args.limit);
+  return filtered.map((row, rank) => ({
+    source: "message",
+    content: previewText(row.content),
+    score: linearDecayScore(rank, filtered.length),
+    messageOrdinal: row.messageOrdinal,
+    messageId: row.messageId,
+    role: row.role
+  }));
+}
+function getSourceBoost(result) {
+  switch (result.source) {
+    case "memory":
+      return MEMORY_SOURCE_BOOST;
+    case "message":
+      return MESSAGE_SOURCE_BOOST;
+    case "git_commit":
+      return GIT_COMMIT_SOURCE_BOOST;
+  }
+}
+function compareUnifiedResults(left, right) {
+  const leftEffective = left.score * getSourceBoost(left);
+  const rightEffective = right.score * getSourceBoost(right);
+  if (rightEffective !== leftEffective) {
+    return rightEffective - leftEffective;
+  }
+  if (left.source === "memory" && right.source === "memory") {
+    return left.memoryId - right.memoryId;
+  }
+  if (left.source === "message" && right.source === "message") {
+    return left.messageOrdinal - right.messageOrdinal;
+  }
+  if (left.source === "git_commit" && right.source === "git_commit") {
+    return right.committedAtMs - left.committedAtMs;
+  }
+  return 0;
+}
+function toGitCommitResult(hit) {
+  return {
+    source: "git_commit",
+    content: previewText(hit.commit.message),
+    score: hit.score,
+    sha: hit.commit.sha,
+    shortSha: hit.commit.shortSha,
+    author: hit.commit.author,
+    committedAtMs: hit.commit.committedAtMs,
+    matchType: hit.matchType
+  };
+}
+async function searchGitCommitsAsync(args) {
+  if (args.limit <= 0)
+    return [];
+  let queryEmbedding = null;
+  if (args.embeddingEnabled && args.isEmbeddingRuntimeEnabled()) {
+    try {
+      queryEmbedding = await args.embedQuery(args.query, args.signal);
+    } catch (error48) {
+      log(`[search] git commit query embedding failed: ${error48 instanceof Error ? error48.message : String(error48)}`);
+    }
+  }
+  const hits = searchGitCommitsSync(args.db, args.projectPath, args.query, {
+    limit: args.limit,
+    queryEmbedding
+  });
+  return hits.map(toGitCommitResult);
+}
+function resolveSources(sources) {
+  if (sources === undefined) {
+    return new Set(["memory", "message", "git_commit"]);
+  }
+  const set2 = new Set;
+  for (const source of sources) {
+    if (source === "memory" || source === "message" || source === "git_commit") {
+      set2.add(source);
+    }
+  }
+  return set2;
+}
+async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
+  const trimmedQuery = query.trim();
+  if (trimmedQuery.length === 0) {
+    return [];
+  }
+  const limit = normalizeLimit(options.limit);
+  const tierLimit = Math.max(limit * 3, DEFAULT_UNIFIED_SEARCH_LIMIT);
+  const embeddingEnabled = options.embeddingEnabled ?? true;
+  const embedQuery = options.embedQuery ?? embedText;
+  const isEmbeddingRuntimeEnabled = options.isEmbeddingRuntimeEnabled ?? isEmbeddingEnabled;
+  const gitCommitsEnabled = options.gitCommitsEnabled ?? false;
+  const activeSources = resolveSources(options.sources);
+  const runMemory = activeSources.has("memory") && (options.memoryEnabled ?? true);
+  const runMessages = activeSources.has("message");
+  const runGitCommits = activeSources.has("git_commit") && gitCommitsEnabled;
+  const [memoryResults, messageResults, gitCommitResults] = await Promise.all([
+    runMemory ? searchMemories({
+      db,
+      projectPath,
+      query: trimmedQuery,
+      limit: tierLimit,
+      memoryEnabled: true,
+      embeddingEnabled,
+      embedQuery,
+      isEmbeddingRuntimeEnabled,
+      visibleMemoryIds: options.visibleMemoryIds,
+      signal: options.signal
+    }) : Promise.resolve([]),
+    runMessages ? Promise.resolve(searchMessages({
+      db,
+      sessionId,
+      query: trimmedQuery,
+      limit: tierLimit,
+      readMessages: options.readMessages ?? readRawSessionMessages,
+      maxOrdinal: options.maxMessageOrdinal
+    })) : Promise.resolve([]),
+    runGitCommits ? searchGitCommitsAsync({
+      db,
+      projectPath,
+      query: trimmedQuery,
+      limit: tierLimit,
+      embeddingEnabled,
+      embedQuery,
+      isEmbeddingRuntimeEnabled,
+      signal: options.signal
+    }) : Promise.resolve([])
+  ]);
+  const results = [...memoryResults, ...messageResults, ...gitCommitResults].sort(compareUnifiedResults).slice(0, limit);
+  const countRetrievals = options.countRetrievals ?? true;
+  if (countRetrievals) {
+    const memoryIds = results.filter((result) => result.source === "memory").map((result) => result.memoryId);
+    if (memoryIds.length > 0) {
+      db.transaction(() => {
+        for (const memoryId of memoryIds) {
+          updateMemoryRetrievalCount(db, memoryId);
+        }
+      })();
+    }
+  }
+  return results;
+}
+
+// src/hooks/magic-context/auto-search-runner.ts
+init_logger();
+
+// src/hooks/magic-context/auto-search-hint.ts
+init_caveman();
+var MAX_FRAGMENTS = 3;
+var FRAGMENT_CHAR_CAP = 80;
+var MAX_HINT_CHARS = 800;
+var MS_PER_DAY2 = 24 * 60 * 60 * 1000;
+function truncate(text, limit) {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  if (normalized.length <= limit)
+    return normalized;
+  return `${normalized.slice(0, Math.max(0, limit - 1)).trimEnd()}\u2026`;
+}
+function formatAge(committedAtMs) {
+  const delta = Date.now() - committedAtMs;
+  if (delta < 0)
+    return "future";
+  const days = Math.floor(delta / MS_PER_DAY2);
+  if (days <= 0)
+    return "today";
+  if (days === 1)
+    return "1d ago";
+  if (days < 30)
+    return `${days}d ago`;
+  const months = Math.floor(days / 30);
+  if (months === 1)
+    return "1mo ago";
+  if (months < 12)
+    return `${months}mo ago`;
+  const years = Math.floor(days / 365);
+  return years === 1 ? "1y ago" : `${years}y ago`;
+}
+function renderFragment(result, charCap) {
+  switch (result.source) {
+    case "memory": {
+      const compressed = cavemanCompress(result.content, "ultra");
+      return truncate(compressed, charCap);
+    }
+    case "git_commit": {
+      const subject = result.content.split(/\r?\n/)[0] ?? result.content;
+      const body = truncate(subject, Math.max(10, charCap - 20));
+      return `commit ${result.shortSha} ${formatAge(result.committedAtMs)}: ${body}`;
+    }
+    case "message": {
+      const compressed = cavemanCompress(result.content, "ultra");
+      return truncate(compressed, charCap);
+    }
+  }
+}
+function buildAutoSearchHint(results, options = {}) {
+  const maxFragments = Math.max(1, options.maxFragments ?? MAX_FRAGMENTS);
+  const fragmentCharCap = Math.max(20, options.fragmentCharCap ?? FRAGMENT_CHAR_CAP);
+  const picks = results.slice(0, maxFragments);
+  const lines = [];
+  for (const result of picks) {
+    const fragment = renderFragment(result, fragmentCharCap);
+    if (fragment.length === 0)
+      continue;
+    lines.push(`- ${fragment}`);
+  }
+  if (lines.length === 0)
+    return null;
+  const header = lines.length === 1 ? "Your memory may contain 1 related fragment:" : `Your memory may contain ${lines.length} related fragments:`;
+  const footer = "Run ctx_search to retrieve full context if relevant.";
+  const body = [header, ...lines, footer].join(`
+`);
+  const wrapped = `<ctx-search-hint>
+${body}
+</ctx-search-hint>`;
+  if (wrapped.length > MAX_HINT_CHARS) {
+    const overflow = wrapped.length - MAX_HINT_CHARS;
+    const trimmedBody = body.slice(0, Math.max(0, body.length - overflow - 1)).trimEnd();
+    return `<ctx-search-hint>
+${trimmedBody}\u2026
+</ctx-search-hint>`;
+  }
+  return wrapped;
+}
+
+// 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;
+  let timer;
+  const timeoutPromise = new Promise((resolve3) => {
+    timer = setTimeout(() => {
+      controller.abort();
+      resolve3(null);
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([
+      unifiedSearch(db, sessionId, projectPath, prompt, {
+        ...options,
+        signal: controller.signal,
+        countRetrievals: false
+      }),
+      timeoutPromise
+    ]);
+  } finally {
+    if (timer !== undefined)
+      clearTimeout(timer);
+  }
+}
+function collectUserPromptParts(message) {
+  let collected = "";
+  for (const part of message.parts) {
+    const p = part;
+    if (p.type === "text" && typeof p.text === "string") {
+      collected += (collected.length > 0 ? `
+` : "") + p.text;
+    }
+  }
+  return collected;
+}
+function hasStackedAugmentation(rawText) {
+  return rawText.includes("<sidekick-augmentation>") || rawText.includes("<ctx-search-hint>") || rawText.includes("<ctx-search-auto>");
+}
+function extractUserPromptText(message) {
+  return collectUserPromptParts(message).replace(/\u00A7\d+\u00A7\s*/g, "").replace(/<!--\s*\+[\d\s.hmdw]+\s*-->/g, "").replace(/<!--\s*OMO_INTERNAL_INITIATOR[\s\S]*?-->/g, "").replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "").replace(/<ctx-search-hint>[\s\S]*?<\/ctx-search-hint>/g, "").replace(/<ctx-search-auto>[\s\S]*?<\/ctx-search-auto>/g, "").replace(/<instruction[^>]*>[\s\S]*?<\/instruction>/g, "").replace(/<sidekick-augmentation>[\s\S]*?<\/sidekick-augmentation>/g, "").replace(/[ \t]+\n/g, `
+`).replace(/\n{3,}/g, `
+
+`).trim();
+}
+function findLatestMeaningfulUserMessage(messages) {
+  for (let i = messages.length - 1;i >= 0; i -= 1) {
+    const msg = messages[i];
+    if (msg.info.role !== "user")
+      continue;
+    if (typeof msg.info.id !== "string")
+      continue;
+    for (const part of msg.parts) {
+      const p = part;
+      if (p.type === "text" && typeof p.text === "string" && p.text.trim().length > 0) {
+        return msg;
+      }
+    }
+  }
+  return null;
+}
+async function runAutoSearchHint(args) {
+  const { sessionId, db, messages, options } = args;
+  if (!options.enabled)
+    return;
+  const userMsg = findLatestMeaningfulUserMessage(messages);
+  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);
+    return;
+  }
+  const rawPartsText = collectUserPromptParts(userMsg);
+  if (hasStackedAugmentation(rawPartsText)) {
+    sessionLog(sessionId, "auto-search: skipping \u2014 user message already carries augmentation/hint");
+    autoSearchByTurn.set(sessionId, { messageId: userMsgId, hint: "" });
+    return;
+  }
+  const rawPrompt = extractUserPromptText(userMsg);
+  if (rawPrompt.length < options.minPromptChars) {
+    autoSearchByTurn.set(sessionId, { messageId: userMsgId, hint: "" });
+    return;
+  }
+  let results;
+  try {
+    const searchOptions = {
+      limit: 10,
+      memoryEnabled: options.memoryEnabled,
+      embeddingEnabled: options.embeddingEnabled,
+      gitCommitsEnabled: options.gitCommitsEnabled,
+      visibleMemoryIds: options.visibleMemoryIds ?? null
+    };
+    results = await unifiedSearchWithTimeout(db, sessionId, options.projectPath, rawPrompt, searchOptions, AUTO_SEARCH_TIMEOUT_MS);
+  } catch (error48) {
+    log(`[auto-search] unified search failed for session ${sessionId}: ${error48 instanceof Error ? error48.message : String(error48)}`);
+    autoSearchByTurn.set(sessionId, { messageId: userMsgId, hint: "" });
+    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: "" });
+    return;
+  }
+  if (results.length === 0) {
+    autoSearchByTurn.set(sessionId, { messageId: userMsgId, hint: "" });
+    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: "" });
+    return;
+  }
+  const hintText = buildAutoSearchHint(results);
+  if (!hintText) {
+    autoSearchByTurn.set(sessionId, { messageId: userMsgId, hint: "" });
+    return;
+  }
+  const payload = `
+
+${hintText}`;
+  autoSearchByTurn.set(sessionId, { messageId: userMsgId, hint: payload });
+  appendReminderToUserMessageById(messages, userMsgId, payload);
+  sessionLog(sessionId, `auto-search: attached hint to ${userMsgId} (${results.length} fragments, top score ${results[0].score.toFixed(3)})`);
+}
+function clearAutoSearchForSession(sessionId) {
+  autoSearchByTurn.delete(sessionId);
+}
+
 // src/hooks/magic-context/transform-postprocess-phase.ts
 init_compartment_runner();
 
@@ -167151,7 +168780,7 @@ function logTransformTiming(sessionId, stage, startMs, extra) {
 }
 
 // src/hooks/magic-context/transform-postprocess-phase.ts
-function runPostTransformPhase(args) {
+async function runPostTransformPhase(args) {
   let didMutateFromPendingOperations = false;
   const isExplicitFlush = args.flushedSessions.has(args.sessionId);
   const alreadyRanThisTurn = args.currentTurnId !== null && args.lastHeuristicsTurnId.get(args.sessionId) === args.currentTurnId;
@@ -167211,8 +168840,8 @@ function runPostTransformPhase(args) {
         logTransformTiming(args.sessionId, "watermarkCleanup", t6);
       }
       const t7 = performance.now();
-      const clearedReasoning = clearOldReasoning(args.messages, args.reasoningByMessage, args.messageTagNumbers, args.clearReasoningAge);
-      stripClearedReasoning(args.messages);
+      const clearedReasoning = clearOldReasoning(args.messages, args.reasoningByMessage, args.messageTagNumbers, args.clearReasoningAge, args.skipTypedReasoningCleanup);
+      stripClearedReasoning(args.messages, args.skipTypedReasoningCleanup);
       const strippedInline = stripInlineThinking(args.messages, args.messageTagNumbers, args.clearReasoningAge);
       if (clearedReasoning > 0 || strippedInline > 0) {
         let maxTag = 0;
@@ -167226,6 +168855,7 @@ function runPostTransformPhase(args) {
           updateSessionMeta(args.db, args.sessionId, {
             clearedReasoningThroughTag: newWatermark
           });
+          args.sessionMeta.clearedReasoningThroughTag = newWatermark;
           sessionLog(args.sessionId, `reasoning cleanup: cleared=${clearedReasoning} inlineStripped=${strippedInline} watermark=${currentWatermark}\u2192${newWatermark}`);
         } else {
           sessionLog(args.sessionId, `reasoning cleanup: cleared=${clearedReasoning} inlineStripped=${strippedInline} watermark=${currentWatermark} (unchanged)`);
@@ -167392,6 +169022,28 @@ function runPostTransformPhase(args) {
     const anchoredMessageId = appendReminderToLatestUserMessage(args.messages, noteInstruction);
     markNoteNudgeDelivered(args.db, args.sessionId, noteInstruction, anchoredMessageId);
   }
+  if (args.fullFeatureMode && args.autoSearch?.enabled && args.projectPath) {
+    const visibleMemoryIds = getVisibleMemoryIds(args.db, args.sessionId) ?? undefined;
+    try {
+      await runAutoSearchHint({
+        sessionId: args.sessionId,
+        db: args.db,
+        messages: args.messages,
+        options: {
+          enabled: true,
+          scoreThreshold: args.autoSearch.scoreThreshold,
+          minPromptChars: args.autoSearch.minPromptChars,
+          projectPath: args.projectPath,
+          memoryEnabled: args.autoSearch.memoryEnabled,
+          embeddingEnabled: args.autoSearch.embeddingEnabled,
+          gitCommitsEnabled: args.autoSearch.gitCommitsEnabled,
+          visibleMemoryIds
+        }
+      });
+    } catch (error48) {
+      sessionLog(args.sessionId, "auto-search runner failed:", error48);
+    }
+  }
 }
 
 // src/hooks/magic-context/nudge-placement-store.ts
@@ -167503,10 +169155,20 @@ function createTransform(deps) {
           deps.liveModelBySession.set(sessionId, lastAssistantModel);
           updateSessionMeta(db, sessionId, {
             lastContextPercentage: 0,
-            lastInputTokens: 0
+            lastInputTokens: 0,
+            clearedReasoningThroughTag: 0
           });
           clearHistorianFailureState(db, sessionId);
+          clearPersistedReasoningWatermark(db, sessionId);
+          clearDetectedContextLimit(db, sessionId);
+          clearEmergencyRecovery(db, sessionId);
           deps.contextUsageMap.delete(sessionId);
+          sessionMeta = {
+            ...sessionMeta,
+            lastContextPercentage: 0,
+            lastInputTokens: 0,
+            clearedReasoningThroughTag: 0
+          };
         }
       }
     }
@@ -167528,7 +169190,21 @@ function createTransform(deps) {
         sessionMeta = { ...sessionMeta, lastContextPercentage: 0, lastInputTokens: 0 };
       }
     }
-    const contextUsageEarly = loadContextUsage(deps.contextUsageMap, db, sessionId);
+    let contextUsageEarly = loadContextUsage(deps.contextUsageMap, db, sessionId);
+    if (fullFeatureMode) {
+      try {
+        const overflowState = getOverflowState(db, sessionId);
+        if (overflowState.needsEmergencyRecovery && contextUsageEarly.percentage < 95) {
+          sessionLog(sessionId, `transform: bumping percentage to 95% due to overflow recovery flag (was ${contextUsageEarly.percentage.toFixed(1)}%, detectedLimit=${overflowState.detectedContextLimit || "unknown"})`);
+          contextUsageEarly = {
+            ...contextUsageEarly,
+            percentage: 95
+          };
+        }
+      } catch (error48) {
+        sessionLog(sessionId, "transform: overflow recovery state read failed:", getErrorMessage(error48));
+      }
+    }
     const historyBudgetTokens = resolveHistoryBudgetTokens(deps.historyBudgetPercentage, contextUsageEarly, deps.executeThresholdPercentage, deps.getModelKey?.(sessionId), deps.executeThresholdTokens);
     const schedulerDecisionEarly = resolveSchedulerDecision(deps.scheduler, sessionMeta, contextUsageEarly, sessionId, deps.getModelKey?.(sessionId));
     const isCacheBusting = deps.flushedSessions.has(sessionId);
@@ -167657,10 +169333,12 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
     const t3 = performance.now();
     const strippedStructuralNoise = stripStructuralNoise(messages);
     logTransformTiming(sessionId, "stripStructuralNoise", t3, `strippedParts=${strippedStructuralNoise}`);
+    const currentSessionModel = deps.liveModelBySession?.get(sessionId) ?? findLastAssistantModel(messages) ?? undefined;
+    const skipTypedReasoningCleanup = modelRequiresInterleavedReasoning(currentSessionModel);
     const persistedReasoningWatermark = sessionMeta?.clearedReasoningThroughTag ?? 0;
     if (persistedReasoningWatermark > 0) {
       const tReplay = performance.now();
-      const replayed = replayClearedReasoning(messages, reasoningByMessage, messageTagNumbers, persistedReasoningWatermark);
+      const replayed = replayClearedReasoning(messages, reasoningByMessage, messageTagNumbers, persistedReasoningWatermark, skipTypedReasoningCleanup);
       const replayedInline = replayStrippedInlineThinking(messages, messageTagNumbers, persistedReasoningWatermark);
       if (replayed > 0 || replayedInline > 0) {
         sessionLog(sessionId, `reasoning replay: cleared=${replayed} inlineStripped=${replayedInline} (watermark=${persistedReasoningWatermark})`);
@@ -167668,10 +169346,10 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
       logTransformTiming(sessionId, "replayReasoningClearing", tReplay);
     }
     const t4 = performance.now();
-    const strippedClearedReasoning = stripClearedReasoning(messages);
+    const strippedClearedReasoning = stripClearedReasoning(messages, skipTypedReasoningCleanup);
     logTransformTiming(sessionId, "stripClearedReasoning", t4, `strippedParts=${strippedClearedReasoning}`);
     const tMergeStrip = performance.now();
-    const strippedMergedReasoning = stripReasoningFromMergedAssistants(messages);
+    const strippedMergedReasoning = skipTypedReasoningCleanup ? 0 : stripReasoningFromMergedAssistants(messages);
     if (strippedMergedReasoning > 0) {
       sessionLog(sessionId, `stripped ${strippedMergedReasoning} reasoning parts from merged assistants (anthropic groupIntoBlocks workaround)`);
     }
@@ -167721,7 +169399,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
     sessionMeta = { ...sessionMeta, compartmentInProgress };
     logTransformTiming(sessionId, "compartmentPhase", tCompartmentPhase);
     const tPostProcess = performance.now();
-    runPostTransformPhase({
+    await runPostTransformPhase({
       sessionId,
       db,
       messages,
@@ -167751,7 +169429,9 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
       watermark,
       forceMaterializationPercentage: FORCE_MATERIALIZE_PERCENTAGE,
       hasRecentReduceCall,
-      projectPath: deps.projectPath
+      skipTypedReasoningCleanup,
+      projectPath: deps.projectPath,
+      autoSearch: deps.autoSearch
     });
     logTransformTiming(sessionId, "postTransformPhase", tPostProcess);
     const msgTokens = getMessageTokensCache(sessionId);
@@ -167971,6 +169651,25 @@ function createEventHandler2(deps) {
       }
       return;
     }
+    if (input.event.type === "session.error") {
+      const errInfo = getSessionErrorInfo(input.event.properties);
+      if (!errInfo) {
+        return;
+      }
+      try {
+        const detection = detectOverflow(errInfo.error);
+        if (!detection.isOverflow) {
+          return;
+        }
+        const existing = getOverflowState(deps.db, errInfo.sessionID);
+        recordOverflowDetected(deps.db, errInfo.sessionID, detection.reportedLimit);
+        sessionLog(errInfo.sessionID, `overflow detected via session.error: reportedLimit=${detection.reportedLimit ?? "unknown"} pattern=${detection.matchedPattern ?? "n/a"} (previousRecovery=${existing.needsEmergencyRecovery})`);
+        deps.onSessionCacheInvalidated?.(errInfo.sessionID);
+      } catch (error48) {
+        sessionLog(errInfo.sessionID, "event session.error handling failed:", error48);
+      }
+      return;
+    }
     if (input.event.type === "message.updated") {
       const info = getMessageUpdatedAssistantInfo(input.event.properties);
       if (!info) {
@@ -167987,6 +169686,18 @@ function createEventHandler2(deps) {
       } else {
         clearMessageTokensCache(info.sessionID);
       }
+      if (info.error !== undefined && info.error !== null) {
+        const detection = detectOverflow(info.error);
+        if (detection.isOverflow) {
+          try {
+            recordOverflowDetected(deps.db, info.sessionID, detection.reportedLimit);
+            sessionLog(info.sessionID, `overflow detected via message.updated: reportedLimit=${detection.reportedLimit ?? "unknown"} pattern=${detection.matchedPattern ?? "n/a"}`);
+            deps.onSessionCacheInvalidated?.(info.sessionID);
+          } catch (error48) {
+            sessionLog(info.sessionID, "event message.updated overflow persistence failed:", error48);
+          }
+        }
+      }
       const now = Date.now();
       const usageTokens = [
         info.tokens?.input,
@@ -168012,7 +169723,10 @@ 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);
+          const contextLimit = resolveContextLimit(info.providerID, info.modelID, {
+            db: deps.db,
+            sessionID: info.sessionID
+          });
           const percentage = contextLimit > 0 ? totalInputTokens / contextLimit * 100 : 0;
           sessionLog(info.sessionID, `event message.updated: totalInputTokens=${totalInputTokens} contextLimit=${contextLimit} percentage=${percentage.toFixed(1)}%`);
           deps.contextUsageMap.set(info.sessionID, {
@@ -168349,6 +170063,12 @@ function createChatMessageHook(args) {
     const sessionId = input.sessionID;
     if (!sessionId)
       return;
+    if (input.model?.providerID && input.model.modelID) {
+      args.liveModelBySession.set(sessionId, {
+        providerID: input.model.providerID,
+        modelID: input.model.modelID
+      });
+    }
     if (args.ctxReduceEnabled !== false) {
       const sessionMeta = getOrCreateSessionMeta(args.db, sessionId);
       const turnUsage = args.toolUsageSinceUserTurn.get(sessionId);
@@ -168382,8 +170102,12 @@ function createEventHook(args) {
           modelID: assistantInfo.modelID
         });
         if (previous && (previous.providerID !== assistantInfo.providerID || previous.modelID !== assistantInfo.modelID)) {
-          sessionLog(assistantInfo.sessionID, `model changed (${previous.providerID}/${previous.modelID} -> ${assistantInfo.providerID}/${assistantInfo.modelID}), clearing historian failure state`);
+          sessionLog(assistantInfo.sessionID, `model changed (${previous.providerID}/${previous.modelID} -> ${assistantInfo.providerID}/${assistantInfo.modelID}), clearing historian failure state and reasoning watermark`);
           clearHistorianFailureState(args.db, assistantInfo.sessionID);
+          clearPersistedReasoningWatermark(args.db, assistantInfo.sessionID);
+          updateSessionMeta(args.db, assistantInfo.sessionID, {
+            clearedReasoningThroughTag: 0
+          });
         }
       }
     }
@@ -168402,6 +170126,7 @@ function createEventHook(args) {
       args.lastHeuristicsTurnId.delete(sessionId);
       args.commitSeenLastPass?.delete(sessionId);
       clearNoteNudgeState(args.db, sessionId);
+      clearAutoSearchForSession(sessionId);
     }
     if (input.event.type === "message.removed") {
       return;
@@ -169012,13 +170737,21 @@ function createMagicContextHook(deps) {
     },
     projectPath,
     experimentalCompactionMarkers: deps.config.compaction_markers,
-    experimentalUserMemories: deps.config.experimental?.user_memories?.enabled,
+    experimentalUserMemories: deps.config.dreamer?.user_memories?.enabled,
     experimentalTemporalAwareness: deps.config.experimental?.temporal_awareness === true,
     historianTwoPass: deps.config.historian?.two_pass === true,
     compressorMinCompartmentRatio: deps.config.compressor?.enabled === false ? undefined : deps.config.compressor?.min_compartment_ratio,
     compressorMaxMergeDepth: deps.config.compressor?.enabled === false ? undefined : deps.config.compressor?.max_merge_depth,
     compressorCooldownMs: deps.config.compressor?.enabled === false ? undefined : deps.config.compressor?.cooldown_ms,
-    liveModelBySession
+    liveModelBySession,
+    autoSearch: deps.config.experimental?.auto_search?.enabled ? {
+      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
+    } : undefined
   });
   const eventHandler = createEventHandler2({
     contextUsageMap,
@@ -169054,14 +170787,14 @@ function createMagicContextHook(deps) {
       tasks: dreaming.tasks,
       taskTimeoutMinutes: dreaming.task_timeout_minutes,
       maxRuntimeMinutes: dreaming.max_runtime_minutes,
-      experimentalUserMemories: deps.config.experimental?.user_memories?.enabled ? {
+      experimentalUserMemories: deps.config.dreamer?.user_memories?.enabled ? {
         enabled: true,
-        promotionThreshold: deps.config.experimental.user_memories?.promotion_threshold
+        promotionThreshold: deps.config.dreamer.user_memories.promotion_threshold
       } : undefined,
-      experimentalPinKeyFiles: deps.config.experimental?.pin_key_files?.enabled ? {
+      experimentalPinKeyFiles: deps.config.dreamer?.pin_key_files?.enabled ? {
         enabled: true,
-        token_budget: deps.config.experimental.pin_key_files?.token_budget,
-        min_reads: deps.config.experimental.pin_key_files?.min_reads
+        token_budget: deps.config.dreamer.pin_key_files.token_budget,
+        min_reads: deps.config.dreamer.pin_key_files.min_reads
       } : undefined
     }).catch((error48) => {
       log("[dreamer] scheduled queue processing failed:", error48);
@@ -169117,14 +170850,14 @@ function createMagicContextHook(deps) {
       projectPath,
       client: deps.client,
       directory: deps.directory,
-      experimentalUserMemories: deps.config.experimental?.user_memories?.enabled ? {
+      experimentalUserMemories: deps.config.dreamer?.user_memories?.enabled ? {
         enabled: true,
-        promotionThreshold: deps.config.experimental.user_memories?.promotion_threshold
+        promotionThreshold: deps.config.dreamer.user_memories.promotion_threshold
       } : undefined,
-      experimentalPinKeyFiles: deps.config.experimental?.pin_key_files?.enabled ? {
+      experimentalPinKeyFiles: deps.config.dreamer?.pin_key_files?.enabled ? {
         enabled: true,
-        token_budget: deps.config.experimental.pin_key_files?.token_budget,
-        min_reads: deps.config.experimental.pin_key_files?.min_reads
+        token_budget: deps.config.dreamer.pin_key_files.token_budget,
+        min_reads: deps.config.dreamer.pin_key_files.min_reads
       } : undefined
     } : undefined
   });
@@ -169139,9 +170872,9 @@ function createMagicContextHook(deps) {
     directory: deps.directory,
     flushedSessions,
     lastHeuristicsTurnId,
-    experimentalUserMemories: deps.config.experimental?.user_memories?.enabled,
-    experimentalPinKeyFiles: deps.config.experimental?.pin_key_files?.enabled ?? false,
-    experimentalPinKeyFilesTokenBudget: deps.config.experimental?.pin_key_files?.token_budget,
+    experimentalUserMemories: deps.config.dreamer?.user_memories?.enabled,
+    experimentalPinKeyFiles: deps.config.dreamer?.pin_key_files?.enabled ?? false,
+    experimentalPinKeyFilesTokenBudget: deps.config.dreamer?.pin_key_files?.token_budget,
     experimentalTemporalAwareness: deps.config.experimental?.temporal_awareness === true
   });
   const eventHook = createEventHook({
@@ -169169,6 +170902,7 @@ function createMagicContextHook(deps) {
       db,
       toolUsageSinceUserTurn,
       recentReduceBySession,
+      liveModelBySession,
       variantBySession,
       agentBySession,
       flushedSessions,
@@ -169226,6 +170960,8 @@ function createSessionHooks(args) {
         memory: pluginConfig.memory,
         sidekick: pluginConfig.sidekick,
         dreamer: pluginConfig.dreamer,
+        commit_cluster_trigger: pluginConfig.commit_cluster_trigger,
+        compaction_markers: pluginConfig.compaction_markers,
         compressor: pluginConfig.compressor,
         experimental: pluginConfig.experimental
       }
@@ -169720,7 +171456,7 @@ var MEMORY_CATEGORIES = new Set(CATEGORY_PRIORITY);
 function isMemoryCategory2(value) {
   return MEMORY_CATEGORIES.has(value);
 }
-function normalizeLimit(limit) {
+function normalizeLimit2(limit) {
   if (typeof limit !== "number" || !Number.isFinite(limit)) {
     return DEFAULT_SEARCH_LIMIT2;
   }
@@ -169895,7 +171631,7 @@ function createCtxMemoryTool(deps) {
         return `Archived memory [ID: ${args.id}].`;
       }
       if (args.action === "list") {
-        const limit = normalizeLimit(args.limit);
+        const limit = normalizeLimit2(args.limit);
         const category = normalizeCategory(args.category);
         const memories = filterByCategory(getMemoriesByProject(deps.db, deps.projectPath), category).slice(0, limit);
         return formatMemoryList(memories);
@@ -170184,6 +171920,9 @@ ${parts.join(`
         projectIdentity: deps.projectIdentity,
         sessionId
       });
+      try {
+        setNoteLastReadAt(deps.db, sessionId);
+      } catch {}
       if (sections.length === 0) {
         return `## Notes
 
@@ -170342,336 +172081,73 @@ function createCtxReduceTools(deps) {
 }
 // src/tools/ctx-search/constants.ts
 var CTX_SEARCH_TOOL_NAME = "ctx_search";
-var CTX_SEARCH_DESCRIPTION = "Search across project memories, session facts, and conversation history. Returns ranked results from all sources. Use message ordinals with ctx_expand to retrieve full conversation context around a result.";
+var CTX_SEARCH_DESCRIPTION = [
+  "Search across project memories, indexed git commits, and raw conversation history.",
+  "",
+  "Sources:",
+  "- memory: curated cross-session knowledge (highest-signal; already-visible ones are filtered out)",
+  "- message: raw user/assistant messages from older compartmentalized history",
+  "- git_commit: HEAD git commits (enabled when experimental.git_commit_indexing is on)",
+  "",
+  "Narrow via the `sources` param when the question maps to a specific channel:",
+  '- "was this working before / when did this break" \u2192 ["git_commit", "message"]',
+  '- "when did we change this" \u2192 ["git_commit"]',
+  '- "what is our naming convention" \u2192 ["memory"]',
+  '- "did we discuss this earlier" \u2192 ["message"]',
+  "Omit sources for a broad search across all enabled channels.",
+  "",
+  "Memories already rendered in <session-history> are hard-filtered from results \u2014 the agent already sees them in context.",
+  "Session facts are NOT a search source; they're always visible in <session-history>.",
+  "Message results include ordinals the agent can pass to ctx_expand for full context."
+].join(`
+`);
 var DEFAULT_CTX_SEARCH_LIMIT = 10;
 // src/tools/ctx-search/tools.ts
 init_compartment_storage();
 import { tool as tool5 } from "@opencode-ai/plugin";
-
-// src/features/magic-context/search.ts
-init_read_session_chunk();
-init_logger();
-init_memory();
-init_embedding();
-init_storage_memory_fts();
-init_message_index();
-init_storage();
-var DEFAULT_UNIFIED_SEARCH_LIMIT = 10;
-var FTS_SEMANTIC_CANDIDATE_LIMIT = 50;
-var SEMANTIC_WEIGHT = 0.7;
-var FTS_WEIGHT = 0.3;
-var SINGLE_SOURCE_PENALTY = 0.8;
-var RESULT_PREVIEW_LIMIT = 220;
-var MEMORY_SOURCE_BOOST = 1.3;
-var FACT_SOURCE_BOOST = 1.15;
-var MESSAGE_SOURCE_BOOST = 1;
-var messageSearchStatements = new WeakMap;
-function normalizeLimit2(limit) {
-  if (typeof limit !== "number" || !Number.isFinite(limit)) {
-    return DEFAULT_UNIFIED_SEARCH_LIMIT;
-  }
-  return Math.max(1, Math.floor(limit));
-}
-function normalizeCosineScore(score) {
-  if (!Number.isFinite(score)) {
-    return 0;
-  }
-  return Math.min(1, Math.max(0, score));
-}
-function previewText(text) {
-  const normalized = text.replace(/\s+/g, " ").trim();
-  if (normalized.length <= RESULT_PREVIEW_LIMIT) {
-    return normalized;
-  }
-  return `${normalized.slice(0, RESULT_PREVIEW_LIMIT - 1).trimEnd()}\u2026`;
-}
-function tokenizeQuery(query) {
-  return Array.from(new Set(query.toLowerCase().split(/\s+/).map((token) => token.trim()).filter((token) => token.length > 0)));
-}
-function scoreTextMatch(content, query, extraText = "") {
-  const tokens = tokenizeQuery(query);
-  if (tokens.length === 0) {
-    return 0;
-  }
-  const haystack = `${content} ${extraText}`.toLowerCase();
-  const queryLower = query.trim().toLowerCase();
-  let matchedTokens = 0;
-  for (const token of tokens) {
-    if (haystack.includes(token)) {
-      matchedTokens++;
-    }
-  }
-  if (matchedTokens === 0) {
-    return 0;
-  }
-  let score = matchedTokens / tokens.length;
-  if (queryLower.length > 0 && haystack.includes(queryLower)) {
-    score += 0.35;
-  }
-  return Math.min(1, score);
-}
-function getMessageSearchStatement(db) {
-  let stmt = messageSearchStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("SELECT message_ordinal AS messageOrdinal, message_id AS messageId, role, content FROM message_history_fts WHERE session_id = ? AND message_history_fts MATCH ? ORDER BY bm25(message_history_fts), CAST(message_ordinal AS INTEGER) ASC LIMIT ?");
-    messageSearchStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getMessageOrdinal(value) {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return value;
-  }
-  if (typeof value === "string" && value.trim().length > 0) {
-    const parsed = Number.parseInt(value, 10);
-    return Number.isFinite(parsed) ? parsed : null;
-  }
-  return null;
-}
-async function getSemanticScores(args) {
-  const semanticScores = new Map;
-  if (!args.embeddingEnabled || !args.isEmbeddingRuntimeEnabled() || args.memories.length === 0) {
-    return semanticScores;
-  }
-  const queryEmbedding = await args.embedQuery(args.query);
-  if (!queryEmbedding) {
-    return semanticScores;
-  }
-  const cachedEmbeddings = getProjectEmbeddings(args.db, args.projectPath);
-  const embeddings = await ensureMemoryEmbeddings({
-    db: args.db,
-    memories: args.memories,
-    existingEmbeddings: cachedEmbeddings
-  });
-  for (const memory of args.memories) {
-    const memoryEmbedding = embeddings.get(memory.id);
-    if (!memoryEmbedding) {
-      continue;
-    }
-    semanticScores.set(memory.id, normalizeCosineScore(cosineSimilarity(queryEmbedding, memoryEmbedding)));
-  }
-  return semanticScores;
-}
-function getFtsMatches(args) {
-  try {
-    return searchMemoriesFTS(args.db, args.projectPath, args.query, args.limit);
-  } catch (error48) {
-    log(`[search] FTS query failed for "${args.query}": ${error48 instanceof Error ? error48.message : String(error48)}`);
-    return [];
-  }
-}
-function getFtsScores(matches) {
-  return new Map(matches.map((memory, rank) => [memory.id, 1 / (rank + 1)]));
-}
-function selectSemanticCandidates(args) {
-  if (args.ftsMatches.length === 0) {
-    return args.memories;
-  }
-  const candidateIds = new Set(args.ftsMatches.map((memory) => memory.id));
-  const cachedEmbeddings = peekProjectEmbeddings(args.projectPath);
-  if (cachedEmbeddings) {
-    for (const memoryId of cachedEmbeddings.keys()) {
-      candidateIds.add(memoryId);
-    }
-  }
-  return args.memories.filter((memory) => candidateIds.has(memory.id));
-}
-function mergeMemoryResults(args) {
-  const memoryById = new Map(args.memories.map((memory) => [memory.id, memory]));
-  const candidateIds = new Set([...args.semanticScores.keys(), ...args.ftsScores.keys()]);
-  const results = [];
-  for (const id of candidateIds) {
-    const memory = memoryById.get(id);
-    if (!memory) {
-      continue;
-    }
-    const semanticScore = args.semanticScores.get(id);
-    const ftsScore = args.ftsScores.get(id);
-    let score = 0;
-    let matchType = "fts";
-    if (semanticScore !== undefined && ftsScore !== undefined) {
-      score = SEMANTIC_WEIGHT * semanticScore + FTS_WEIGHT * ftsScore;
-      matchType = "hybrid";
-    } else if (semanticScore !== undefined) {
-      score = semanticScore * SINGLE_SOURCE_PENALTY;
-      matchType = "semantic";
-    } else if (ftsScore !== undefined) {
-      score = ftsScore * SINGLE_SOURCE_PENALTY;
-      matchType = "fts";
-    }
-    if (score <= 0) {
-      continue;
-    }
-    results.push({
-      source: "memory",
-      content: previewText(memory.content),
-      score,
-      memoryId: memory.id,
-      category: memory.category,
-      matchType
-    });
-  }
-  return results.sort((left, right) => {
-    if (right.score !== left.score) {
-      return right.score - left.score;
-    }
-    return left.memoryId - right.memoryId;
-  }).slice(0, args.limit);
-}
-async function searchMemories(args) {
-  if (!args.memoryEnabled) {
-    return [];
-  }
-  const memories = getMemoriesByProject(args.db, args.projectPath);
-  if (memories.length === 0) {
-    return [];
-  }
-  const ftsMatches = getFtsMatches({
-    db: args.db,
-    projectPath: args.projectPath,
-    query: args.query,
-    limit: FTS_SEMANTIC_CANDIDATE_LIMIT
-  });
-  const ftsScores = getFtsScores(ftsMatches);
-  const semanticCandidates = selectSemanticCandidates({
-    memories,
-    projectPath: args.projectPath,
-    ftsMatches
-  });
-  const semanticScores = await getSemanticScores({
-    db: args.db,
-    projectPath: args.projectPath,
-    query: args.query,
-    memories: semanticCandidates,
-    embeddingEnabled: args.embeddingEnabled,
-    embedQuery: args.embedQuery,
-    isEmbeddingRuntimeEnabled: args.isEmbeddingRuntimeEnabled
-  });
-  return mergeMemoryResults({
-    memories,
-    semanticScores,
-    ftsScores,
-    limit: args.limit
-  });
-}
-function searchFacts(args) {
-  return getSessionFacts(args.db, args.sessionId).map((fact) => ({
-    fact,
-    score: scoreTextMatch(fact.content, args.query, fact.category)
-  })).filter((candidate) => candidate.score > 0).sort((left, right) => {
-    if (right.score !== left.score) {
-      return right.score - left.score;
-    }
-    return left.fact.id - right.fact.id;
-  }).slice(0, args.limit).map(({ fact, score }) => ({
-    source: "fact",
-    content: previewText(fact.content),
-    score,
-    factId: fact.id,
-    factCategory: fact.category
-  }));
-}
-function searchMessages(args) {
-  ensureMessagesIndexed(args.db, args.sessionId, args.readMessages);
-  const sanitizedQuery = sanitizeFtsQuery(args.query.trim());
-  if (sanitizedQuery.length === 0) {
-    return [];
-  }
-  const fetchLimit = args.maxOrdinal != null && args.maxOrdinal >= 0 ? args.limit * 3 : args.limit;
-  const rows = getMessageSearchStatement(args.db).all(args.sessionId, sanitizedQuery, fetchLimit).map((row) => row);
-  const cutoff = args.maxOrdinal != null && args.maxOrdinal >= 0 ? args.maxOrdinal : null;
-  return rows.map((row, rank) => {
-    const messageOrdinal = getMessageOrdinal(row.messageOrdinal);
-    if (messageOrdinal === null || typeof row.messageId !== "string" || typeof row.role !== "string" || typeof row.content !== "string") {
-      return null;
-    }
-    if (cutoff !== null && messageOrdinal > cutoff) {
-      return null;
-    }
-    return {
-      source: "message",
-      content: previewText(row.content),
-      score: 1 / (rank + 1),
-      messageOrdinal,
-      messageId: row.messageId,
-      role: row.role
-    };
-  }).filter((result) => result !== null).slice(0, args.limit);
-}
-function getSourceBoost(result) {
-  switch (result.source) {
-    case "memory":
-      return MEMORY_SOURCE_BOOST;
-    case "fact":
-      return FACT_SOURCE_BOOST;
-    case "message":
-      return MESSAGE_SOURCE_BOOST;
-  }
-}
-function compareUnifiedResults(left, right) {
-  const leftEffective = left.score * getSourceBoost(left);
-  const rightEffective = right.score * getSourceBoost(right);
-  if (rightEffective !== leftEffective) {
-    return rightEffective - leftEffective;
-  }
-  if (left.source === "memory" && right.source === "memory") {
-    return left.memoryId - right.memoryId;
-  }
-  if (left.source === "fact" && right.source === "fact") {
-    return left.factId - right.factId;
-  }
-  if (left.source === "message" && right.source === "message") {
-    return left.messageOrdinal - right.messageOrdinal;
-  }
-  return 0;
-}
-async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
-  const trimmedQuery = query.trim();
-  if (trimmedQuery.length === 0) {
-    return [];
-  }
-  const limit = normalizeLimit2(options.limit);
-  const tierLimit = Math.max(limit * 3, DEFAULT_UNIFIED_SEARCH_LIMIT);
-  const [memoryResults, factResults, messageResults] = await Promise.all([
-    searchMemories({
-      db,
-      projectPath,
-      query: trimmedQuery,
-      limit: tierLimit,
-      memoryEnabled: options.memoryEnabled ?? true,
-      embeddingEnabled: options.embeddingEnabled ?? true,
-      embedQuery: options.embedQuery ?? embedText,
-      isEmbeddingRuntimeEnabled: options.isEmbeddingRuntimeEnabled ?? isEmbeddingEnabled
-    }),
-    Promise.resolve(searchFacts({ db, sessionId, query: trimmedQuery, limit: tierLimit })),
-    Promise.resolve(searchMessages({
-      db,
-      sessionId,
-      query: trimmedQuery,
-      limit: tierLimit,
-      readMessages: options.readMessages ?? readRawSessionMessages,
-      maxOrdinal: options.maxMessageOrdinal
-    }))
-  ]);
-  const results = [...memoryResults, ...factResults, ...messageResults].sort(compareUnifiedResults).slice(0, limit);
-  const memoryIds = results.filter((result) => result.source === "memory").map((result) => result.memoryId);
-  if (memoryIds.length > 0) {
-    db.transaction(() => {
-      for (const memoryId of memoryIds) {
-        updateMemoryRetrievalCount(db, memoryId);
-      }
-    })();
-  }
-  return results;
-}
-
-// src/tools/ctx-search/tools.ts
+init_inject_compartments();
+var VALID_SOURCES = new Set(["memory", "message", "git_commit"]);
 function normalizeLimit3(limit) {
   if (typeof limit !== "number" || !Number.isFinite(limit)) {
     return DEFAULT_CTX_SEARCH_LIMIT;
   }
   return Math.max(1, Math.floor(limit));
 }
+function normalizeSources(sources) {
+  if (!sources || sources.length === 0)
+    return;
+  const result = [];
+  const seen = new Set;
+  for (const source of sources) {
+    if (VALID_SOURCES.has(source)) {
+      const typed = source;
+      if (!seen.has(typed)) {
+        seen.add(typed);
+        result.push(typed);
+      }
+    }
+  }
+  return result.length > 0 ? result : undefined;
+}
+function formatAge2(committedAtMs) {
+  const ageMs = Date.now() - committedAtMs;
+  if (ageMs < 0)
+    return "future";
+  const days = Math.floor(ageMs / (24 * 60 * 60 * 1000));
+  if (days <= 0)
+    return "today";
+  if (days === 1)
+    return "1d ago";
+  if (days < 30)
+    return `${days}d ago`;
+  const months = Math.floor(days / 30);
+  if (months === 1)
+    return "1mo ago";
+  if (months < 12)
+    return `${months}mo ago`;
+  const years = Math.floor(days / 365);
+  return years === 1 ? "1y ago" : `${years}y ago`;
+}
 function formatResult(result, index) {
   if (result.source === "memory") {
     return [
@@ -170680,9 +172156,9 @@ function formatResult(result, index) {
     ].join(`
 `);
   }
-  if (result.source === "fact") {
+  if (result.source === "git_commit") {
     return [
-      `[${index}] [fact] score=${result.score.toFixed(2)} category=${result.factCategory} id=${result.factId}`,
+      `[${index}] [git_commit] score=${result.score.toFixed(2)} sha=${result.shortSha} ${formatAge2(result.committedAtMs)} match=${result.matchType}`,
       result.content
     ].join(`
 `);
@@ -170698,7 +172174,7 @@ function formatResult(result, index) {
 }
 function formatSearchResults(query, results) {
   if (results.length === 0) {
-    return `No results found for "${query}" across memories, session facts, or message history.`;
+    return `No results found for "${query}" across memories, git commits, or message history.`;
   }
   const body = results.map((result, index) => formatResult(result, index + 1)).join(`
 
@@ -170711,8 +172187,9 @@ function createCtxSearchTool(deps) {
   return tool5({
     description: CTX_SEARCH_DESCRIPTION,
     args: {
-      query: tool5.schema.string().describe("Search query across memories, facts, and conversation history."),
-      limit: tool5.schema.number().optional().describe("Maximum results to return (default: 10)")
+      query: tool5.schema.string().describe("Search query. Matches against memory content, git commit messages, and raw user/assistant message text."),
+      limit: tool5.schema.number().optional().describe("Maximum results to return (default: 10)"),
+      sources: tool5.schema.array(tool5.schema.enum(["memory", "message", "git_commit"])).optional().describe('Optional. Restrict to specific sources. Examples: ["git_commit"] for "when did we change X", ["memory"] for naming conventions, ["message"] for "did we discuss this earlier", ["git_commit","message"] for regression hunts. Omit for a broad search across all enabled sources.')
     },
     async execute(args, toolContext) {
       const query = args.query?.trim();
@@ -170720,12 +172197,16 @@ function createCtxSearchTool(deps) {
         return "Error: 'query' is required.";
       }
       const lastCompartmentEnd = getLastCompartmentEndMessage(deps.db, toolContext.sessionID);
+      const visibleMemoryIds = getVisibleMemoryIds(deps.db, toolContext.sessionID);
       const results = await unifiedSearch(deps.db, toolContext.sessionID, deps.projectPath, query, {
         limit: normalizeLimit3(args.limit),
         memoryEnabled: deps.memoryEnabled,
         embeddingEnabled: deps.embeddingEnabled,
         readMessages: deps.readMessages,
-        maxMessageOrdinal: lastCompartmentEnd >= 0 ? lastCompartmentEnd : undefined
+        maxMessageOrdinal: lastCompartmentEnd >= 0 ? lastCompartmentEnd : undefined,
+        gitCommitsEnabled: deps.gitCommitsEnabled ?? false,
+        sources: normalizeSources(args.sources),
+        visibleMemoryIds
       });
       return formatSearchResults(query, results);
     }
@@ -170807,7 +172288,8 @@ function createToolRegistry(args) {
       db,
       projectPath,
       memoryEnabled,
-      embeddingEnabled: embeddingConfig2.provider !== "off"
+      embeddingEnabled: embeddingConfig2.provider !== "off",
+      gitCommitsEnabled: pluginConfig.experimental?.git_commit_indexing?.enabled === true
     }),
     ...memoryEnabled ? {
       ...createCtxMemoryTools({
@@ -170972,8 +172454,10 @@ var plugin = async (ctx) => {
     setTimeout(async () => {
       try {
         const { sendIgnoredMessage: sendIgnoredMessage2 } = await Promise.resolve().then(() => (init_send_session_notification(), exports_send_session_notification));
-        const sessions = await Promise.resolve(ctx.client.session?.list?.()).catch(() => null);
-        const sessionId = sessions?.data?.[0]?.id ?? sessions?.[0]?.id;
+        const clientWithSessions = ctx.client;
+        const sessions = await Promise.resolve(clientWithSessions.session?.list?.()).catch(() => null);
+        const sessionList = Array.isArray(sessions) ? sessions : sessions?.data;
+        const sessionId = sessionList?.[0]?.id;
         if (sessionId) {
           await sendIgnoredMessage2(ctx.client, sessionId, warningText, {});
         }
@@ -171007,14 +172491,19 @@ var plugin = async (ctx) => {
       dreamerConfig: pluginConfig.dreamer,
       embeddingConfig: pluginConfig.embedding,
       memoryEnabled: pluginConfig.memory?.enabled === true,
-      experimentalUserMemories: pluginConfig.experimental?.user_memories?.enabled ? {
+      experimentalUserMemories: pluginConfig.dreamer?.user_memories?.enabled ? {
+        enabled: true,
+        promotionThreshold: pluginConfig.dreamer.user_memories.promotion_threshold
+      } : undefined,
+      experimentalPinKeyFiles: pluginConfig.dreamer?.pin_key_files?.enabled ? {
         enabled: true,
-        promotionThreshold: pluginConfig.experimental.user_memories?.promotion_threshold
+        token_budget: pluginConfig.dreamer.pin_key_files.token_budget,
+        min_reads: pluginConfig.dreamer.pin_key_files.min_reads
       } : undefined,
-      experimentalPinKeyFiles: pluginConfig.experimental?.pin_key_files?.enabled ? {
+      gitCommitIndexing: pluginConfig.experimental?.git_commit_indexing?.enabled ? {
         enabled: true,
-        token_budget: pluginConfig.experimental.pin_key_files?.token_budget,
-        min_reads: pluginConfig.experimental.pin_key_files?.min_reads
+        since_days: pluginConfig.experimental.git_commit_indexing.since_days,
+        max_commits: pluginConfig.experimental.git_commit_indexing.max_commits
       } : undefined
     });
     const storageDir = `${getOpenCodeStorageDir()}/plugin/magic-context`;
@@ -171114,7 +172603,7 @@ var plugin = async (ctx) => {
       config2.agent = {
         ...config2.agent ?? {},
         [DREAMER_AGENT]: buildHiddenAgentConfig(DREAMER_AGENT, DREAMER_SYSTEM_PROMPT, dreamerAgentOverrides),
-        [HISTORIAN_AGENT]: buildHiddenAgentConfig(HISTORIAN_AGENT, pluginConfig.experimental?.user_memories?.enabled ? COMPARTMENT_AGENT_SYSTEM_PROMPT + USER_OBSERVATIONS_APPENDIX : COMPARTMENT_AGENT_SYSTEM_PROMPT, historianAgentOverrides),
+        [HISTORIAN_AGENT]: buildHiddenAgentConfig(HISTORIAN_AGENT, pluginConfig.dreamer?.user_memories?.enabled ? COMPARTMENT_AGENT_SYSTEM_PROMPT + USER_OBSERVATIONS_APPENDIX : COMPARTMENT_AGENT_SYSTEM_PROMPT, historianAgentOverrides),
         [HISTORIAN_EDITOR_AGENT]: buildHiddenAgentConfig(HISTORIAN_EDITOR_AGENT, HISTORIAN_EDITOR_SYSTEM_PROMPT, historianAgentOverrides),
         [SIDEKICK_AGENT]: buildHiddenAgentConfig(SIDEKICK_AGENT, SIDEKICK_SYSTEM_PROMPT, sidekickAgentOverrides)
       };