@cortexkit/pi-magic-context 0.32.0 → 0.32.1

package/dist/index.js

@@ -14951,7 +14951,9 @@ __export(exports_rpc_notifications, {
   registerNotificationSink: () => registerNotificationSink,
   pushNotification: () => pushNotification,
   isTuiConnected: () => isTuiConnected,
-  drainNotifications: () => drainNotifications
+  drainNotifications: () => drainNotifications,
+  acknowledgeNotifications: () => acknowledgeNotifications,
+  __resetNotificationStateForTests: () => __resetNotificationStateForTests
 });
 function registerNotificationSink(sink) {
   sinks.add(sink);
@@ -14960,7 +14962,11 @@ function registerNotificationSink(sink) {
   };
 }
 function notificationMatchesSink(notification, sink) {
-  return notification.sessionId === undefined || sink.sessionId === undefined || notification.sessionId === sink.sessionId;
+  if (notification.sessionId === undefined)
+    return true;
+  if (sink.sessionId !== undefined)
+    return notification.sessionId === sink.sessionId;
+  return sink.protocol !== 2;
 }
 function pushNotification(type, payload, sessionId) {
   const notification = { id: nextNotificationId++, type, payload, sessionId };
@@ -14973,23 +14979,31 @@ function pushNotification(type, payload, sessionId) {
     } catch {}
   }
   if (queue.length > 100) {
-    const newestPerSession = new Map;
-    for (const n of queue) {
-      const prev = newestPerSession.get(n.sessionId);
-      if (prev === undefined || n.id > prev) {
-        newestPerSession.set(n.sessionId, n.id);
-      }
-    }
-    const mustKeep = new Set(newestPerSession.values());
-    const byNewest = [...queue].sort((a, b) => b.id - a.id);
-    const kept = [];
-    for (const n of byNewest) {
-      if (kept.length < 50 || mustKeep.has(n.id))
-        kept.push(n);
+    const reservedIds = new Set;
+    const reservedScopes = new Set;
+    for (let i = queue.length - 1;i >= 0 && reservedScopes.size < 25; i -= 1) {
+      const candidate = queue[i];
+      const scope = candidate.sessionId ?? "\x00global";
+      if (reservedScopes.has(scope))
+        continue;
+      reservedScopes.add(scope);
+      reservedIds.add(candidate.id);
     }
-    queue = kept.sort((a, b) => a.id - b.id);
+    const evictionIndex = queue.findIndex((candidate) => !reservedIds.has(candidate.id));
+    queue.splice(evictionIndex >= 0 ? evictionIndex : 0, 1);
   }
 }
+function acknowledgeNotifications(ids) {
+  const acknowledged = new Set(ids.filter((id) => Number.isSafeInteger(id) && id > 0));
+  if (acknowledged.size === 0)
+    return;
+  queue = queue.filter((notification) => !acknowledged.has(notification.id));
+}
+function __resetNotificationStateForTests() {
+  queue = [];
+  nextNotificationId = 1;
+  sinks.clear();
+}
 function cursor(value) {
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
 }
@@ -15032,7 +15046,9 @@ function isTuiConnected(sessionId) {
   if (sessionId === undefined)
     return true;
   for (const sink of sinks) {
-    if (sink.sessionId === undefined || sink.sessionId === sessionId)
+    if (sink.sessionId === sessionId)
+      return true;
+    if (sink.sessionId === undefined && sink.protocol !== 2)
       return true;
   }
   return false;
@@ -16088,11 +16104,11 @@ function buildNodeSqliteDatabaseClass(DatabaseSync) {
     }
     transaction(fn) {
       const self2 = this;
-      const wrapped = function(...args) {
+      const execute = (mode, receiver, args) => {
         const nested = self2.isTransaction === true;
-        self2.exec(nested ? `SAVEPOINT ${SAVEPOINT}` : "BEGIN");
+        self2.exec(nested ? `SAVEPOINT ${SAVEPOINT}` : `BEGIN${mode ? ` ${mode}` : ""}`);
         try {
-          const result = fn.apply(this, args);
+          const result = fn.apply(receiver, args);
           self2.exec(nested ? `RELEASE ${SAVEPOINT}` : "COMMIT");
           return result;
         } catch (error) {
@@ -16105,6 +16121,21 @@ function buildNodeSqliteDatabaseClass(DatabaseSync) {
           throw error;
         }
       };
+      const wrapped = function(...args) {
+        return execute("", this, args);
+      };
+      wrapped.default = function(...args) {
+        return execute("", this, args);
+      };
+      wrapped.deferred = function(...args) {
+        return execute("DEFERRED", this, args);
+      };
+      wrapped.immediate = function(...args) {
+        return execute("IMMEDIATE", this, args);
+      };
+      wrapped.exclusive = function(...args) {
+        return execute("EXCLUSIVE", this, args);
+      };
       return wrapped;
     }
   }
@@ -148826,6 +148857,66 @@ function readRawSessionMessagesFromDb(db, sessionId) {
     };
   });
 }
+function readRawSessionMessagePageFromDb(db, sessionId, afterOrdinal, limit, finalWatermark = Number.MAX_SAFE_INTEGER) {
+  const remaining = Math.max(0, Math.floor(finalWatermark) - Math.floor(afterOrdinal));
+  const pageSize = Math.min(Math.max(1, Math.floor(limit)), remaining);
+  if (pageSize === 0)
+    return [];
+  const messageRows = db.prepare(`SELECT id, data, time_created, time_updated
+             FROM message
+             WHERE session_id = ?
+               AND NOT (
+                   CASE WHEN json_valid(data) = 1
+                        THEN COALESCE(json_extract(data, '$.summary'), 0)
+                        ELSE 0 END = 1
+                   AND CASE WHEN json_valid(data) = 1
+                            THEN COALESCE(json_extract(data, '$.finish'), '')
+                            ELSE '' END = 'stop'
+               )
+             ORDER BY time_created ASC, id ASC
+             LIMIT ? OFFSET ?`).all(sessionId, pageSize, Math.max(0, Math.floor(afterOrdinal))).filter(isRawMessageRow).map((row, index) => ({
+    ...row,
+    ordinal: Math.floor(afterOrdinal) + index + 1
+  }));
+  if (messageRows.length === 0)
+    return [];
+  const placeholders = messageRows.map(() => "?").join(", ");
+  const partRows = db.prepare(`SELECT message_id, data, time_updated
+             FROM part
+             WHERE session_id = ? AND message_id IN (${placeholders})
+             ORDER BY time_created ASC, id ASC`).all(sessionId, ...messageRows.map((row) => row.id)).filter(isRawPartRow);
+  const partsByMessageId = new Map;
+  for (const part of partRows) {
+    const list = partsByMessageId.get(part.message_id) ?? [];
+    list.push(attachRawPartVersion(parseJsonUnknown(part.data), part.time_updated));
+    partsByMessageId.set(part.message_id, list);
+  }
+  return messageRows.map((row) => {
+    const info = parseJsonRecord(row.data);
+    return {
+      ordinal: row.ordinal,
+      id: row.id,
+      role: typeof info?.role === "string" ? info.role : "unknown",
+      parts: partsByMessageId.get(row.id) ?? [],
+      createdAt: row.time_created ?? null,
+      version: row.time_updated ?? null
+    };
+  });
+}
+function countRawSessionMessageOrdinalsFromDb(db, sessionId) {
+  const row = db.prepare(`SELECT COUNT(*) AS count
+             FROM message
+             WHERE session_id = ?
+               AND NOT (
+                   CASE WHEN json_valid(data) = 1
+                        THEN COALESCE(json_extract(data, '$.summary'), 0)
+                        ELSE 0 END = 1
+                   AND CASE WHEN json_valid(data) = 1
+                            THEN COALESCE(json_extract(data, '$.finish'), '')
+                            ELSE '' END = 'stop'
+               )`).get(sessionId);
+  return typeof row?.count === "number" ? row.count : 0;
+}
 function isAnchorRow(row) {
   return row !== null && typeof row === "object" && typeof row.time_created === "number" && typeof row.id === "string";
 }
@@ -149133,6 +149224,31 @@ function readRawSessionMessages(sessionId) {
   }
   return readRawSessionMessagesFromSource(sessionId);
 }
+function readRawSessionMessagePage(sessionId, afterOrdinal, limit, finalWatermark) {
+  const provider = sessionProviders.get(sessionId);
+  if (provider?.readMessagePage) {
+    return provider.readMessagePage(afterOrdinal, limit, finalWatermark);
+  }
+  if (provider) {
+    return provider.readMessages().filter((message) => message.ordinal > afterOrdinal && message.ordinal <= finalWatermark).slice(0, limit);
+  }
+  if (!openCodeDbExists())
+    return [];
+  return withReadOnlySessionDb((db) => readRawSessionMessagePageFromDb(db, sessionId, afterOrdinal, limit, finalWatermark));
+}
+function getRawSessionMessageOrdinalCount(sessionId) {
+  const provider = sessionProviders.get(sessionId);
+  if (provider) {
+    if (provider.getMessageCount)
+      return provider.getMessageCount();
+    return provider.readMessages().length;
+  }
+  if (!openCodeDbExists())
+    return 0;
+  return withReadOnlySessionDb((db) => countRawSessionMessageOrdinalsFromDb(db, sessionId));
+}
+readRawSessionMessages.readPage = readRawSessionMessagePage;
+readRawSessionMessages.getCount = getRawSessionMessageOrdinalCount;
 function primeTailRawMessageCache(args) {
   const { sessionId, lastCompartmentEnd, anchorMessageId } = args;
   if (!activeRawMessageCache)
@@ -149413,11 +149529,10 @@ function clearCompressionDepthRange(db, sessionId, startOrdinal, endOrdinal) {
 // ../plugin/src/features/magic-context/message-index.ts
 var lastIndexedStatements = new WeakMap;
 var insertMessageStatements = new WeakMap;
-var upsertIndexStatements = new WeakMap;
-var upsertCleanIndexStatements = new WeakMap;
+var upsertProgressStatements = new WeakMap;
 var upsertDirtyFloorStatements = new WeakMap;
 var deleteFtsStatements = new WeakMap;
-var deleteFtsFromOrdinalStatements = new WeakMap;
+var deleteFtsRangeStatements = new WeakMap;
 var deleteIndexStatements = new WeakMap;
 var countIndexedMessageStatements = new WeakMap;
 function normalizeIndexText(text) {
@@ -149439,19 +149554,11 @@ function getInsertMessageStatement(db) {
   }
   return stmt;
 }
-function getUpsertIndexStatement(db) {
-  let stmt = upsertIndexStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("INSERT INTO message_history_index (session_id, last_indexed_ordinal, updated_at, harness) VALUES (?, ?, ?, ?) ON CONFLICT(session_id) DO UPDATE SET last_indexed_ordinal = excluded.last_indexed_ordinal, updated_at = excluded.updated_at");
-    upsertIndexStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getUpsertCleanIndexStatement(db) {
-  let stmt = upsertCleanIndexStatements.get(db);
+function getUpsertProgressStatement(db) {
+  let stmt = upsertProgressStatements.get(db);
   if (!stmt) {
-    stmt = db.prepare("INSERT INTO message_history_index (session_id, last_indexed_ordinal, dirty_floor_ordinal, updated_at, harness) VALUES (?, ?, 0, ?, ?) ON CONFLICT(session_id) DO UPDATE SET last_indexed_ordinal = excluded.last_indexed_ordinal, dirty_floor_ordinal = 0, updated_at = excluded.updated_at");
-    upsertCleanIndexStatements.set(db, stmt);
+    stmt = db.prepare("INSERT INTO message_history_index (session_id, last_indexed_ordinal, dirty_floor_ordinal, updated_at, harness) VALUES (?, ?, ?, ?, ?) ON CONFLICT(session_id) DO UPDATE SET last_indexed_ordinal = excluded.last_indexed_ordinal, dirty_floor_ordinal = excluded.dirty_floor_ordinal, updated_at = excluded.updated_at");
+    upsertProgressStatements.set(db, stmt);
   }
   return stmt;
 }
@@ -149463,27 +149570,11 @@ function getUpsertDirtyFloorStatement(db) {
   }
   return stmt;
 }
-function getDeleteFtsStatement(db) {
-  let stmt = deleteFtsStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("DELETE FROM message_history_fts WHERE session_id = ?");
-    deleteFtsStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getDeleteFtsFromOrdinalStatement(db) {
-  let stmt = deleteFtsFromOrdinalStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("DELETE FROM message_history_fts WHERE session_id = ? AND CAST(message_ordinal AS INTEGER) >= ?");
-    deleteFtsFromOrdinalStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getDeleteIndexStatement(db) {
-  let stmt = deleteIndexStatements.get(db);
+function getDeleteFtsRangeStatement(db) {
+  let stmt = deleteFtsRangeStatements.get(db);
   if (!stmt) {
-    stmt = db.prepare("DELETE FROM message_history_index WHERE session_id = ?");
-    deleteIndexStatements.set(db, stmt);
+    stmt = db.prepare("DELETE FROM message_history_fts WHERE session_id = ? AND CAST(message_ordinal AS INTEGER) BETWEEN ? AND ?");
+    deleteFtsRangeStatements.set(db, stmt);
   }
   return stmt;
 }
@@ -149511,16 +149602,17 @@ function isMessageAlreadyIndexed(db, sessionId, messageId) {
   const row = getCountIndexedMessageStatement(db).get(sessionId, messageId);
   return (typeof row?.count === "number" ? row.count : 0) > 0;
 }
-function advanceIndexWatermark(db, sessionId, ordinal, now) {
-  const current = getLastIndexedOrdinal(db, sessionId);
-  getUpsertIndexStatement(db).run(sessionId, Math.max(current, ordinal), now, getHarness());
+function setIndexProgress(db, sessionId, watermark, dirtyFloor, now) {
+  getUpsertProgressStatement(db).run(sessionId, Math.max(0, Math.floor(watermark)), dirtyFloor ?? 0, now, getHarness());
 }
-function clearIndexedMessages(db, sessionId) {
-  db.transaction(() => {
-    getDeleteFtsStatement(db).run(sessionId);
-    getDeleteIndexStatement(db).run(sessionId);
-    clearCompressionDepth(db, sessionId);
-  })();
+function getMessageIndexReconciliationStartOrdinal(db, sessionId) {
+  const watermark = getLastIndexedOrdinal(db, sessionId);
+  const dirtyFloor = getDirtyIndexFloor(db, sessionId);
+  return dirtyFloor === null ? watermark : Math.min(watermark, dirtyFloor - 1);
+}
+function isMessageIndexReconciledThrough(db, sessionId, finalWatermark) {
+  const dirtyFloor = getDirtyIndexFloor(db, sessionId);
+  return getLastIndexedOrdinal(db, sessionId) >= finalWatermark && dirtyFloor === null;
 }
 function getIndexableContent(role, parts) {
   if (role === "user") {
@@ -149535,22 +149627,21 @@ function getIndexableContent(role, parts) {
   return "";
 }
 function indexSingleMessageInTransaction(db, sessionId, message, now) {
-  if (message.role !== "user" && message.role !== "assistant") {
-    advanceIndexWatermark(db, sessionId, message.ordinal, now);
-    return false;
-  }
-  const content = getIndexableContent(message.role, message.parts);
-  if (content.length === 0) {
-    advanceIndexWatermark(db, sessionId, message.ordinal, now);
+  const currentWatermark = getLastIndexedOrdinal(db, sessionId);
+  const dirtyFloor = getDirtyIndexFloor(db, sessionId);
+  if (message.ordinal !== currentWatermark + 1 || dirtyFloor !== null && dirtyFloor !== message.ordinal) {
     return false;
   }
-  if (isMessageAlreadyIndexed(db, sessionId, message.id)) {
-    advanceIndexWatermark(db, sessionId, message.ordinal, now);
-    return false;
+  let inserted = false;
+  if (message.role === "user" || message.role === "assistant") {
+    const content = getIndexableContent(message.role, message.parts);
+    if (content.length > 0 && !isMessageAlreadyIndexed(db, sessionId, message.id)) {
+      getInsertMessageStatement(db).run(sessionId, message.ordinal, message.id, message.role, content);
+      inserted = true;
+    }
   }
-  getInsertMessageStatement(db).run(sessionId, message.ordinal, message.id, message.role, content);
-  advanceIndexWatermark(db, sessionId, message.ordinal, now);
-  return true;
+  setIndexProgress(db, sessionId, message.ordinal, null, now);
+  return inserted;
 }
 function indexSingleMessage(db, sessionId, message) {
   db.exec("BEGIN IMMEDIATE");
@@ -149568,38 +149659,44 @@ function indexSingleMessage(db, sessionId, message) {
     }
   }
 }
-function indexMessagesAfterOrdinal(db, sessionId, messages, lastIndexedOrdinal, finalWatermark = messages.length) {
+function indexMessagesAfterOrdinal(db, sessionId, messages, _lastIndexedOrdinal, finalWatermark = messages.length) {
   const now = Date.now();
   let inserted = 0;
   db.exec("BEGIN IMMEDIATE");
   let committed = false;
   try {
-    let effectiveWatermark = Math.max(lastIndexedOrdinal, getLastIndexedOrdinal(db, sessionId));
+    const currentWatermark = getLastIndexedOrdinal(db, sessionId);
     const dirtyFloor = getDirtyIndexFloor(db, sessionId);
-    if (dirtyFloor !== null) {
-      const rewindOrdinal = Math.max(1, Math.min(dirtyFloor, finalWatermark + 1));
-      if (rewindOrdinal <= finalWatermark) {
-        getDeleteFtsFromOrdinalStatement(db).run(sessionId, rewindOrdinal);
-      }
-      effectiveWatermark = Math.min(effectiveWatermark, rewindOrdinal - 1);
+    const effectiveWatermark = dirtyFloor === null ? currentWatermark : Math.min(currentWatermark, Math.max(0, dirtyFloor - 1));
+    if (dirtyFloor !== null && dirtyFloor <= finalWatermark) {
+      getDeleteFtsRangeStatement(db).run(sessionId, dirtyFloor, finalWatermark);
     }
-    const insertMessage = getInsertMessageStatement(db);
+    const messagesByOrdinal = new Map;
     for (const message of messages) {
-      if (message.ordinal <= effectiveWatermark) {
-        continue;
+      if (message.ordinal > effectiveWatermark && message.ordinal <= finalWatermark) {
+        messagesByOrdinal.set(message.ordinal, message);
       }
-      if (message.role !== "user" && message.role !== "assistant") {
+    }
+    let coveredWatermark = effectiveWatermark;
+    while (coveredWatermark < finalWatermark && messagesByOrdinal.has(coveredWatermark + 1)) {
+      coveredWatermark += 1;
+    }
+    for (let ordinal = effectiveWatermark + 1;ordinal <= coveredWatermark; ordinal++) {
+      const message = messagesByOrdinal.get(ordinal);
+      if (!message || message.role !== "user" && message.role !== "assistant") {
         continue;
       }
       const content = getIndexableContent(message.role, message.parts);
-      if (content.length === 0) {
+      if (content.length === 0 || isMessageAlreadyIndexed(db, sessionId, message.id)) {
         continue;
       }
-      insertMessage.run(sessionId, message.ordinal, message.id, message.role, content);
-      inserted++;
+      getInsertMessageStatement(db).run(sessionId, message.ordinal, message.id, message.role, content);
+      inserted += 1;
     }
-    const newWatermark = Math.max(effectiveWatermark, finalWatermark);
-    getUpsertCleanIndexStatement(db).run(sessionId, newWatermark, now, getHarness());
+    const missingFloor = coveredWatermark < finalWatermark ? coveredWatermark + 1 : null;
+    const preservedFloor = dirtyFloor !== null && dirtyFloor > finalWatermark ? dirtyFloor : null;
+    const nextDirtyFloor = missingFloor === null ? preservedFloor : preservedFloor === null ? missingFloor : Math.min(missingFloor, preservedFloor);
+    setIndexProgress(db, sessionId, coveredWatermark, nextDirtyFloor, now);
     db.exec("COMMIT");
     committed = true;
   } finally {
@@ -149630,6 +149727,7 @@ function isDatabaseLockedError(error) {
   return false;
 }
 var INCREMENTAL_DEBOUNCE_MS = 100;
+var RECONCILIATION_BATCH_SIZE = 100;
 var reconciledSessions = new Set;
 var reconciliationScheduledSessions = new Set;
 var sessionLocks = new Map;
@@ -149644,6 +149742,9 @@ function defer(fn) {
   }
   setTimeout(fn, 0);
 }
+function yieldToEventLoop() {
+  return new Promise((resolve) => defer(resolve));
+}
 function runWithSessionLock(sessionId, operation) {
   const previous = sessionLocks.get(sessionId) ?? Promise.resolve();
   const run = previous.catch(() => {
@@ -149670,24 +149771,27 @@ function logIndexingError(sessionId, action, error) {
   log(`[message-index-async] ${action} failed for ${sessionId}:`, error);
 }
 async function reconcileSessionIndex(db, sessionId, readMessages) {
-  await runWithSessionLock(sessionId, () => {
-    if (reconciledSessions.has(sessionId)) {
+  await runWithSessionLock(sessionId, async () => {
+    if (reconciledSessions.has(sessionId))
       return;
+    let fallbackSnapshot = null;
+    const finalWatermark = readMessages.getCount ? readMessages.getCount(sessionId) : (fallbackSnapshot = readMessages(sessionId)).length;
+    let cursor = getMessageIndexReconciliationStartOrdinal(db, sessionId);
+    while (cursor < finalWatermark) {
+      const pageEnd = Math.min(finalWatermark, cursor + RECONCILIATION_BATCH_SIZE);
+      const messages = readMessages.readPage ? readMessages.readPage(sessionId, cursor, RECONCILIATION_BATCH_SIZE, finalWatermark) : (fallbackSnapshot ?? []).filter((message) => message.ordinal > cursor && message.ordinal <= pageEnd);
+      indexMessagesAfterOrdinal(db, sessionId, messages, cursor, pageEnd);
+      const nextCursor = getMessageIndexReconciliationStartOrdinal(db, sessionId);
+      if (nextCursor <= cursor)
+        break;
+      cursor = nextCursor;
+      if (cursor < finalWatermark) {
+        await yieldToEventLoop();
+      }
     }
-    const messages = readMessages(sessionId);
-    if (messages.length === 0) {
-      clearIndexedMessages(db, sessionId);
+    if (isMessageIndexReconciledThrough(db, sessionId, finalWatermark)) {
       reconciledSessions.add(sessionId);
-      return;
-    }
-    let lastIndexedOrdinal = getLastIndexedOrdinal(db, sessionId);
-    if (lastIndexedOrdinal > messages.length) {
-      clearIndexedMessages(db, sessionId);
-      lastIndexedOrdinal = 0;
     }
-    const watermark = Math.min(lastIndexedOrdinal, messages.length);
-    indexMessagesAfterOrdinal(db, sessionId, messages, watermark, messages.length);
-    reconciledSessions.add(sessionId);
   });
 }
 function scheduleReconciliation(db, sessionId, readMessages) {
@@ -149711,16 +149815,23 @@ function scheduleIncrementalIndex(db, sessionId, messageId, messageSource) {
   const timer = setTimeout(() => {
     incrementalTimers.delete(key);
     pendingIncrementalKeys.add(key);
-    let attemptedOrdinal = null;
     runWithSessionLock(sessionId, () => {
       const message = typeof messageSource === "function" ? messageSource(sessionId, messageId) : messageSource;
       if (!message)
         return;
-      attemptedOrdinal = message.ordinal;
+      const currentWatermark = getLastIndexedOrdinal(db, sessionId);
+      if (message.ordinal <= currentWatermark && isMessageIndexReconciledThrough(db, sessionId, currentWatermark)) {
+        completedIncrementalKeys.add(key);
+        return;
+      }
+      const wasReconciled = reconciledSessions.delete(sessionId);
+      markMessageIndexDirty(db, sessionId, Math.min(message.ordinal, getLastIndexedOrdinal(db, sessionId) + 1));
       indexSingleMessage(db, sessionId, message);
+      if (wasReconciled && isMessageIndexReconciledThrough(db, sessionId, message.ordinal)) {
+        reconciledSessions.add(sessionId);
+      }
       completedIncrementalKeys.add(key);
     }).catch((error) => {
-      markMessageIndexDirty(db, sessionId, attemptedOrdinal ?? getLastIndexedOrdinal(db, sessionId) + 1);
       reconciledSessions.delete(sessionId);
       logIndexingError(sessionId, `incremental index for ${messageId}`, error);
     }).finally(() => {
@@ -149860,9 +149971,11 @@ function parseReportedLimit(message) {
 
 // ../plugin/src/features/magic-context/session-project-backfill.ts
 init_logger();
+import { randomUUID } from "node:crypto";
 import { existsSync as existsSync5 } from "node:fs";
 
 // ../plugin/src/features/magic-context/session-project-storage.ts
+var SESSION_CHUNK_REPAIR_BATCH_SIZE = 100;
 var upsertSessionProjectStatements = new WeakMap;
 var repairSessionChunkProjectStatements = new WeakMap;
 var repairProjectChunkProjectStatements = new WeakMap;
@@ -149884,9 +149997,14 @@ function getRepairSessionChunkProjectStatement(db) {
   if (!stmt) {
     stmt = db.prepare(`UPDATE compartment_chunk_embeddings
              SET project_path = ?
-             WHERE session_id = ?
-               AND harness = ?
-               AND project_path <> ?`);
+             WHERE id IN (
+                 SELECT id
+                 FROM compartment_chunk_embeddings
+                 WHERE session_id = ?
+                   AND harness = ?
+                   AND project_path <> ?
+                 LIMIT ?
+             )`);
     repairSessionChunkProjectStatements.set(db, stmt);
   }
   return stmt;
@@ -149924,7 +150042,7 @@ function recordSessionProjectIdentity(db, sessionId, projectPath) {
   const now = Date.now();
   db.transaction(() => {
     getUpsertSessionProjectStatement(db).run(sessionId, harness, projectPath, now);
-    getRepairSessionChunkProjectStatement(db).run(projectPath, sessionId, harness, projectPath);
+    getRepairSessionChunkProjectStatement(db).run(projectPath, sessionId, harness, projectPath, SESSION_CHUNK_REPAIR_BATCH_SIZE);
   })();
 }
 function repairMisScopedCompartmentChunkEmbeddingsForProject(db, projectPath) {
@@ -149935,18 +150053,30 @@ function repairMisScopedCompartmentChunkEmbeddingsForProject(db, projectPath) {
 
 // ../plugin/src/features/magic-context/session-project-backfill.ts
 var LEASE_TTL_MS = 10 * 60 * 1000;
+var SESSION_PAGE_SIZE = 100;
 var SESSION_QUERY_CHUNK_SIZE = 250;
-var YIELD_EVERY_NEW_DIRECTORIES = 10;
+var YIELD_EVERY_PROCESSED_SESSIONS = 25;
+var YIELD_EVERY_IDENTITY_RESOLUTIONS = 2;
 function ensureBackfillStateTable(db) {
   db.exec(`
         CREATE TABLE IF NOT EXISTS session_project_backfill_state (
             harness TEXT PRIMARY KEY,
             status TEXT NOT NULL CHECK (status IN ('running', 'completed')),
+            holder_id TEXT,
             started_at INTEGER,
             lease_expires_at INTEGER,
             completed_at INTEGER
         );
     `);
+  const columns = db.prepare("PRAGMA table_info(session_project_backfill_state)").all();
+  if (!columns.some((column) => column.name === "holder_id")) {
+    try {
+      db.exec("ALTER TABLE session_project_backfill_state ADD COLUMN holder_id TEXT");
+    } catch (error) {
+      if (!/duplicate column name/i.test(String(error)))
+        throw error;
+    }
+  }
 }
 function withImmediateTransaction(db, fn) {
   db.exec("BEGIN IMMEDIATE");
@@ -149964,54 +150094,52 @@ function withImmediateTransaction(db, fn) {
 function defaultYieldFn() {
   return new Promise((resolve) => setTimeout(resolve, 0));
 }
-function acquireBackfillLease(db, harness, now) {
+function acquireBackfillLease(db, harness, holderId, now) {
   ensureBackfillStateTable(db);
   return withImmediateTransaction(db, () => {
-    const current = db.prepare(`SELECT harness, status, started_at, lease_expires_at, completed_at
+    const current = db.prepare(`SELECT harness, status, holder_id, started_at, lease_expires_at, completed_at
                  FROM session_project_backfill_state
                  WHERE harness = ?`).get(harness);
-    if (current?.status === "completed") {
+    if (current?.status === "completed")
       return "already_completed";
-    }
     if (current?.status === "running" && current.lease_expires_at !== null && current.lease_expires_at > now) {
       return "blocked_by_lease";
     }
     db.prepare(`INSERT INTO session_project_backfill_state(
                 harness,
                 status,
+                holder_id,
                 started_at,
                 lease_expires_at,
                 completed_at
             )
-             VALUES (?, 'running', ?, ?, NULL)
+             VALUES (?, 'running', ?, ?, ?, NULL)
              ON CONFLICT(harness) DO UPDATE SET
                 status = 'running',
+                holder_id = excluded.holder_id,
                 started_at = excluded.started_at,
                 lease_expires_at = excluded.lease_expires_at,
-                completed_at = NULL`).run(harness, now, now + LEASE_TTL_MS);
-    return "completed";
+                completed_at = NULL`).run(harness, holderId, now, now + LEASE_TTL_MS);
+    return "acquired";
   });
 }
-function renewBackfillLease(db, harness, now) {
+function renewBackfillLease(db, harness, holderId, now) {
   ensureBackfillStateTable(db);
-  db.prepare(`UPDATE session_project_backfill_state
-         SET lease_expires_at = ?
-         WHERE harness = ? AND status = 'running'`).run(now + LEASE_TTL_MS, harness);
+  return db.prepare(`UPDATE session_project_backfill_state
+                 SET lease_expires_at = ?
+                 WHERE harness = ? AND status = 'running' AND holder_id = ?`).run(now + LEASE_TTL_MS, harness, holderId).changes === 1;
+}
+function markBackfillCompleted(db, harness, holderId, now) {
+  ensureBackfillStateTable(db);
+  return db.prepare(`UPDATE session_project_backfill_state
+                 SET status = 'completed', lease_expires_at = NULL, completed_at = ?
+                 WHERE harness = ? AND status = 'running' AND holder_id = ?`).run(now, harness, holderId).changes === 1;
 }
-function markBackfillCompleted(db, harness, now) {
+function markBackfillRetryPending(db, harness, holderId, now) {
   ensureBackfillStateTable(db);
-  db.prepare(`INSERT INTO session_project_backfill_state(
-            harness,
-            status,
-            started_at,
-            lease_expires_at,
-            completed_at
-        )
-         VALUES (?, 'completed', ?, NULL, ?)
-         ON CONFLICT(harness) DO UPDATE SET
-            status = 'completed',
-            lease_expires_at = NULL,
-            completed_at = excluded.completed_at`).run(harness, now, now);
+  return db.prepare(`UPDATE session_project_backfill_state
+                 SET lease_expires_at = ?
+                 WHERE harness = ? AND status = 'running' AND holder_id = ?`).run(now, harness, holderId).changes === 1;
 }
 function dedupeSessions(sessions) {
   const sessionsById = new Map;
@@ -150019,14 +150147,7 @@ function dedupeSessions(sessions) {
     if (!session.sessionId)
       continue;
     const existing = sessionsById.get(session.sessionId);
-    if (!existing) {
-      sessionsById.set(session.sessionId, {
-        sessionId: session.sessionId,
-        directory: session.directory
-      });
-      continue;
-    }
-    if (!existing.directory && session.directory) {
+    if (!existing || !existing.directory && session.directory) {
       sessionsById.set(session.sessionId, {
         sessionId: session.sessionId,
         directory: session.directory
@@ -150046,22 +150167,34 @@ function getMappedSessionIds(db, harness, sessions) {
                  FROM session_projects
                  WHERE harness = ?
                    AND session_id IN (${placeholders})`).all(harness, ...chunk.map((session) => session.sessionId));
-    for (const row of rows) {
+    for (const row of rows)
       mapped.add(row.session_id);
-    }
   }
   return mapped;
 }
-async function runSessionProjectBackfill(db, sessions, options = {}) {
+function createPageReader(source) {
+  if (typeof source === "function") {
+    return async (afterSessionId, limit) => source(afterSessionId, limit);
+  }
+  const sessions = dedupeSessions(source);
+  let offset = 0;
+  return async (_afterSessionId, limit) => {
+    const page = sessions.slice(offset, offset + limit);
+    offset += page.length;
+    return page;
+  };
+}
+async function runSessionProjectBackfill(db, source, options = {}) {
   const startedAt = performance.now();
   const harness = getHarness();
   const now = options.now ?? Date.now;
   const resolveIdentity = options.resolveIdentity ?? resolveProjectIdentity;
   const yieldFn = options.yieldFn ?? defaultYieldFn;
-  const dedupedSessions = dedupeSessions(sessions);
+  const holderId = options.holderId ?? randomUUID();
+  const readPage = createPageReader(source);
   const result = {
     status: "completed",
-    totalSessions: dedupedSessions.length,
+    totalSessions: 0,
     alreadyMappedSessions: 0,
     unmappedSessions: 0,
     backfilledSessions: 0,
@@ -150069,47 +150202,95 @@ async function runSessionProjectBackfill(db, sessions, options = {}) {
     skippedEmptyDirectories: 0,
     durationMs: 0
   };
-  const leaseStatus = acquireBackfillLease(db, harness, now());
-  if (leaseStatus !== "completed") {
+  const leaseStatus = acquireBackfillLease(db, harness, holderId, now());
+  if (leaseStatus !== "acquired") {
     result.status = leaseStatus;
     result.durationMs = performance.now() - startedAt;
     return result;
   }
-  const mappedSessionIds = getMappedSessionIds(db, harness, dedupedSessions);
-  result.alreadyMappedSessions = mappedSessionIds.size;
+  const finishWithLostLease = () => {
+    result.status = "lost_lease";
+    result.durationMs = performance.now() - startedAt;
+    return result;
+  };
+  const yieldAndRenew = async () => {
+    if (!renewBackfillLease(db, harness, holderId, now()))
+      return false;
+    await yieldFn();
+    return renewBackfillLease(db, harness, holderId, now());
+  };
   const existenceCache = new Map;
   const identityCache2 = new Map;
-  let newDirectoryResolutions = 0;
-  for (const session of dedupedSessions) {
-    if (mappedSessionIds.has(session.sessionId)) {
-      continue;
-    }
-    result.unmappedSessions += 1;
-    if (!session.directory) {
-      result.skippedEmptyDirectories += 1;
-      continue;
-    }
-    const stillExists = existenceCache.get(session.directory) ?? existsSync5(session.directory);
-    existenceCache.set(session.directory, stillExists);
-    if (!stillExists) {
-      result.skippedDeadDirectories += 1;
-      continue;
-    }
-    let identity = identityCache2.get(session.directory);
-    if (!identity) {
-      identity = resolveIdentity(session.directory);
-      identityCache2.set(session.directory, identity);
-      newDirectoryResolutions += 1;
-      if (newDirectoryResolutions % YIELD_EVERY_NEW_DIRECTORIES === 0) {
-        renewBackfillLease(db, harness, now());
-        await yieldFn();
-        renewBackfillLease(db, harness, now());
+  const seenSessionIds = new Set;
+  let processedSinceYield = 0;
+  let identityResolutionsSinceYield = 0;
+  let afterSessionId = null;
+  for (;; ) {
+    const sourcePage = await readPage(afterSessionId, SESSION_PAGE_SIZE);
+    if (sourcePage.length === 0)
+      break;
+    afterSessionId = sourcePage.at(-1)?.sessionId ?? afterSessionId;
+    const page = dedupeSessions(sourcePage).filter((session) => {
+      if (seenSessionIds.has(session.sessionId))
+        return false;
+      seenSessionIds.add(session.sessionId);
+      return true;
+    });
+    const mappedSessionIds = getMappedSessionIds(db, harness, page);
+    for (const session of page) {
+      result.totalSessions += 1;
+      processedSinceYield += 1;
+      if (mappedSessionIds.has(session.sessionId)) {
+        result.alreadyMappedSessions += 1;
+      } else {
+        result.unmappedSessions += 1;
+        if (!session.directory) {
+          result.skippedEmptyDirectories += 1;
+        } else {
+          const stillExists = existenceCache.get(session.directory) ?? existsSync5(session.directory);
+          existenceCache.set(session.directory, stillExists);
+          if (!stillExists) {
+            result.skippedDeadDirectories += 1;
+          } else {
+            let identity = identityCache2.get(session.directory);
+            if (!identity) {
+              if (identityResolutionsSinceYield >= YIELD_EVERY_IDENTITY_RESOLUTIONS) {
+                if (!await yieldAndRenew())
+                  return finishWithLostLease();
+                processedSinceYield = 0;
+                identityResolutionsSinceYield = 0;
+              }
+              identity = await resolveIdentity(session.directory);
+              identityResolutionsSinceYield += 1;
+              if (!renewBackfillLease(db, harness, holderId, now())) {
+                return finishWithLostLease();
+              }
+              identityCache2.set(session.directory, identity);
+            }
+            recordSessionProjectIdentity(db, session.sessionId, identity);
+            result.backfilledSessions += 1;
+          }
+        }
       }
+      if (processedSinceYield >= YIELD_EVERY_PROCESSED_SESSIONS) {
+        if (!await yieldAndRenew())
+          return finishWithLostLease();
+        processedSinceYield = 0;
+        identityResolutionsSinceYield = 0;
+      }
+    }
+    if (sourcePage.length < SESSION_PAGE_SIZE)
+      break;
+  }
+  const hasSkippedSessions = result.skippedDeadDirectories > 0 || result.skippedEmptyDirectories > 0;
+  if (hasSkippedSessions) {
+    if (!markBackfillRetryPending(db, harness, holderId, now())) {
+      return finishWithLostLease();
     }
-    recordSessionProjectIdentity(db, session.sessionId, identity);
-    result.backfilledSessions += 1;
+    result.status = "retry_pending";
+  } else if (!markBackfillCompleted(db, harness, holderId, now())) {
+    return finishWithLostLease();
   }
-  markBackfillCompleted(db, harness, now());
   result.durationMs = performance.now() - startedAt;
   log(`[session-projects] backfilled ${result.backfilledSessions} of ${result.unmappedSessions} unmapped sessions (skipped ${result.skippedDeadDirectories} dead dirs) in ${Math.round(result.durationMs)}ms`);
   return result;
@@ -150667,10 +150848,16 @@ function healAllNullColumns(db) {
   healNullIntegerColumns(db);
   healMissingMemoryBlockIds(db);
 }
+function getSessionMetaColumns(db) {
+  const rows = db.prepare("PRAGMA table_info(session_meta)").all();
+  return new Set(rows.flatMap((row) => typeof row.name === "string" ? [row.name] : []));
+}
 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 {}
+  const columns = getSessionMetaColumns(db);
+  if (!columns.has("memory_block_cache") || !columns.has("memory_block_ids") || !columns.has("memory_block_count")) {
+    return;
+  }
+  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();
 }
 function healNullTextColumns(db) {
   const columns = [
@@ -150699,10 +150886,11 @@ function healNullTextColumns(db) {
     ["compaction_marker_state", ""],
     ["key_files", ""]
   ];
+  const existingColumns = getSessionMetaColumns(db);
   for (const [column, fallback] of columns) {
-    try {
-      db.prepare(`UPDATE session_meta SET ${column} = ? WHERE ${column} IS NULL`).run(fallback);
-    } catch (_error) {}
+    if (!existingColumns.has(column))
+      continue;
+    db.prepare(`UPDATE session_meta SET ${column} = ? WHERE ${column} IS NULL`).run(fallback);
   }
 }
 function healNullIntegerColumns(db) {
@@ -150733,10 +150921,11 @@ function healNullIntegerColumns(db) {
     ["emergency_drain_active", 0],
     ["historian_drain_failure_at", 0]
   ];
+  const existingColumns = getSessionMetaColumns(db);
   for (const [column, fallback] of columns) {
-    try {
-      db.prepare(`UPDATE session_meta SET ${column} = ? WHERE ${column} IS NULL`).run(fallback);
-    } catch (_error) {}
+    if (!existingColumns.has(column))
+      continue;
+    db.prepare(`UPDATE session_meta SET ${column} = ? WHERE ${column} IS NULL`).run(fallback);
   }
 }
 
@@ -152384,6 +152573,34 @@ var MIGRATIONS = [
         ensureColumn(db, "session_meta", "wrapup_in_progress_state", "TEXT");
       }
     }
+  },
+  {
+    version: 51,
+    description: "version tool-owner backfill state and repair legacy NULL session metadata",
+    up(db) {
+      db.exec(`
+                CREATE TABLE IF NOT EXISTS tool_owner_backfill_state (
+                    session_id TEXT PRIMARY KEY,
+                    status TEXT NOT NULL CHECK (status IN ('pending', 'running', 'completed', 'skipped')),
+                    started_at INTEGER,
+                    lease_expires_at INTEGER,
+                    completed_at INTEGER,
+                    last_error TEXT
+                );
+                CREATE INDEX IF NOT EXISTS idx_tool_owner_backfill_state_status
+                    ON tool_owner_backfill_state(status);
+            `);
+      healAllNullColumns(db);
+    }
+  },
+  {
+    version: 52,
+    description: "persist emergency recovery origin",
+    up(db) {
+      if (tableExists2(db, "session_meta")) {
+        ensureColumn(db, "session_meta", "emergency_recovery_origin", "TEXT DEFAULT ''");
+      }
+    }
   }
 ];
 var LATEST_MIGRATION_VERSION = MIGRATIONS.reduce((max, m) => Math.max(max, m.version), 0);
@@ -152413,40 +152630,45 @@ function isSiblingMigrationConflict(db, error, version) {
 }
 function runMigrations(db) {
   ensureMigrationsTable(db);
-  let currentVersion = getCurrentVersion(db);
-  let pendingMigrations = MIGRATIONS.filter((m) => m.version > currentVersion);
-  if (pendingMigrations.length === 0) {
-    return;
-  }
-  log(`[migrations] current schema version: ${currentVersion}, applying ${pendingMigrations.length} migration(s)`);
-  let migrationIndex = 0;
-  while (migrationIndex < pendingMigrations.length) {
-    const migration = pendingMigrations[migrationIndex];
+  let loggedPlan = false;
+  while (true) {
+    let migration;
+    let currentVersion = 0;
     try {
-      db.transaction(() => {
+      const applied = db.transaction(() => {
+        currentVersion = getCurrentVersion(db);
+        migration = MIGRATIONS.find((candidate) => candidate.version > currentVersion);
+        if (!migration)
+          return false;
+        if (!loggedPlan) {
+          const pendingCount = MIGRATIONS.filter((candidate) => candidate.version > currentVersion).length;
+          log(`[migrations] current schema version: ${currentVersion}, applying ${pendingCount} migration(s)`);
+          loggedPlan = true;
+        }
         migration.up(db);
         db.prepare("INSERT INTO schema_migrations (version, description, applied_at) VALUES (?, ?, ?)").run(migration.version, migration.description, Date.now());
-      })();
+        return true;
+      }).immediate();
+      if (!applied || !migration)
+        break;
       log(`[migrations] applied v${migration.version}: ${migration.description}`);
-      migrationIndex += 1;
     } catch (error) {
-      if (isSiblingMigrationConflict(db, error, migration.version)) {
+      if (migration && isSiblingMigrationConflict(db, error, migration.version)) {
         log(`[migrations] v${migration.version} already applied by sibling instance — resuming with re-read version`);
         const reReadVersion = getCurrentVersion(db);
-        if (reReadVersion <= currentVersion) {
-          log(`[migrations] FAILED v${migration.version}: sibling-conflict shape but version not advanced (${reReadVersion} <= ${currentVersion}) — failing closed`);
-          throw new Error(`Migration v${migration.version} failed: sibling conflict reported but version did not advance. Database may need manual repair.`);
-        }
-        currentVersion = reReadVersion;
-        pendingMigrations = MIGRATIONS.filter((m) => m.version > currentVersion);
-        migrationIndex = 0;
-        continue;
+        if (reReadVersion > currentVersion)
+          continue;
+        throw new Error(`Migration v${migration.version} failed: sibling conflict reported but version did not advance. Database may need manual repair.`);
       }
-      log(`[migrations] FAILED v${migration.version}: ${migration.description} — ${error instanceof Error ? error.message : String(error)}`);
-      throw new Error(`Migration v${migration.version} failed: ${error instanceof Error ? error.message : String(error)}. Database may need manual repair.`);
+      const version = migration?.version ?? currentVersion + 1;
+      const description = migration?.description ?? "acquire migration write lock";
+      log(`[migrations] FAILED v${version}: ${description} — ${error instanceof Error ? error.message : String(error)}`);
+      throw new Error(`Migration v${version} failed: ${error instanceof Error ? error.message : String(error)}. Database may need manual repair.`);
     }
   }
-  log(`[migrations] schema version now: ${MIGRATIONS[MIGRATIONS.length - 1].version}`);
+  if (loggedPlan) {
+    log(`[migrations] schema version now: ${MIGRATIONS[MIGRATIONS.length - 1].version}`);
+  }
 }
 // ../plugin/src/features/magic-context/project-docs-hash.ts
 import { createHash as createHash3 } from "node:crypto";
@@ -152959,7 +153181,8 @@ function countSessionsByStatus(db, status) {
 function acquireSessionLease(db, sessionId, now) {
   const expiresAt = now + LEASE_DURATION_MS;
   const result = db.prepare(`INSERT INTO tool_owner_backfill_state(session_id, status, started_at, lease_expires_at)
-             VALUES (?, 'running', ?, ?)
+             SELECT ?, 'running', ?, ?
+             WHERE EXISTS (SELECT 1 FROM tags WHERE session_id = ?)
              ON CONFLICT(session_id) DO UPDATE SET
                  status = 'running',
                  started_at = excluded.started_at,
@@ -152967,7 +153190,7 @@ function acquireSessionLease(db, sessionId, now) {
                  last_error = NULL
              WHERE tool_owner_backfill_state.status IN ('pending', 'skipped')
                 OR (tool_owner_backfill_state.status = 'running'
-                    AND tool_owner_backfill_state.lease_expires_at < ?)`).run(sessionId, now, expiresAt, now);
+                    AND tool_owner_backfill_state.lease_expires_at < ?)`).run(sessionId, now, expiresAt, sessionId, now);
   return (result.changes ?? 0) === 1;
 }
 function renewSessionLease(db, sessionId, now) {
@@ -152987,13 +153210,9 @@ function markSessionPendingRetry(db, sessionId) {
          WHERE session_id = ?`).run(sessionId);
 }
 function markSessionSkipped(db, sessionId, now, reason) {
-  db.prepare(`INSERT INTO tool_owner_backfill_state(session_id, status, completed_at, last_error)
-         VALUES (?, 'skipped', ?, ?)
-         ON CONFLICT(session_id) DO UPDATE SET
-             status = 'skipped',
-             completed_at = excluded.completed_at,
-             last_error = excluded.last_error,
-             lease_expires_at = NULL`).run(sessionId, now, reason);
+  db.prepare(`UPDATE tool_owner_backfill_state
+         SET status = 'skipped', completed_at = ?, last_error = ?, lease_expires_at = NULL
+         WHERE session_id = ? AND status = 'running'`).run(now, reason, sessionId);
 }
 function markSessionErrored(db, sessionId, error) {
   const message = error instanceof Error ? error.message : String(error);
@@ -153077,7 +153296,7 @@ function applyOwnersForSession(db, sessionId, ownersByCallId) {
       const result = updateRowStmt.run(ownerId, orphan.id);
       rowsUpdated += result.changes ?? 0;
     }
-  })();
+  }).immediate();
   const rowsLeftNull = db.prepare(`SELECT COUNT(*) AS c FROM tags
                  WHERE session_id = ? AND type = 'tool'
                    AND tool_owner_message_id IS NULL`).get(sessionId).c;
@@ -153127,7 +153346,7 @@ var persistenceByDatabase = new WeakMap;
 var persistenceErrorByDatabase = new WeakMap;
 var pathByDatabase = new WeakMap;
 var lastSchemaFenceRejection = null;
-var LATEST_SUPPORTED_VERSION = 50;
+var LATEST_SUPPORTED_VERSION = 52;
 var PERMISSIONS_ENFORCEABLE = process.platform !== "win32";
 function ensureSecureStorageDir(dir) {
   mkdirSync4(dir, { recursive: true, mode: 448 });
@@ -153820,6 +154039,17 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       pi_stable_id_scheme INTEGER
     );
 
+    CREATE TABLE IF NOT EXISTS tool_owner_backfill_state (
+      session_id TEXT PRIMARY KEY,
+      status TEXT NOT NULL CHECK (status IN ('pending', 'running', 'completed', 'skipped')),
+      started_at INTEGER,
+      lease_expires_at INTEGER,
+      completed_at INTEGER,
+      last_error TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_tool_owner_backfill_state_status
+      ON tool_owner_backfill_state(status);
+
     CREATE TABLE IF NOT EXISTS subagent_invocations (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       session_id TEXT NOT NULL,
@@ -154053,6 +154283,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "session_meta", "detected_context_limit", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "detected_context_limit_model_key", "TEXT");
   ensureColumn(db, "session_meta", "needs_emergency_recovery", "INTEGER DEFAULT 0");
+  ensureColumn(db, "session_meta", "emergency_recovery_origin", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "pending_compaction_marker_state", "TEXT");
   ensureColumn(db, "session_meta", "pending_pi_compaction_marker_state", "TEXT");
   ensureColumn(db, "session_meta", "new_work_tokens", "INTEGER NOT NULL DEFAULT 0");
@@ -155120,13 +155351,17 @@ function clearHistorianFailureState(db, sessionId) {
 function normalizeDetectedLimitModelKey(modelKey) {
   return typeof modelKey === "string" && modelKey.length > 0 ? modelKey : null;
 }
+function normalizeEmergencyRecoveryOrigin(value) {
+  return value === "provider_overflow" || value === "proactive_model_shrink" ? value : null;
+}
 function getOverflowState(db, sessionId, modelKey) {
-  const result = db.prepare("SELECT detected_context_limit, detected_context_limit_model_key, needs_emergency_recovery FROM session_meta WHERE session_id = ?").get(sessionId);
+  const result = db.prepare("SELECT detected_context_limit, detected_context_limit_model_key, needs_emergency_recovery, emergency_recovery_origin FROM session_meta WHERE session_id = ?").get(sessionId);
   if (!result) {
     return {
       detectedContextLimit: 0,
       detectedContextLimitModelKey: null,
-      needsEmergencyRecovery: false
+      needsEmergencyRecovery: false,
+      emergencyRecoveryOrigin: null
     };
   }
   const storedModelKey = normalizeDetectedLimitModelKey(result.detected_context_limit_model_key);
@@ -155134,19 +155369,22 @@ function getOverflowState(db, sessionId, modelKey) {
   const limit = typeof result.detected_context_limit === "number" && result.detected_context_limit > 0 ? result.detected_context_limit : 0;
   const modelMatches = limit > 0 && requestedModelKey && storedModelKey ? requestedModelKey === storedModelKey : true;
   const needs = typeof result.needs_emergency_recovery === "number" && result.needs_emergency_recovery > 0;
+  const persistedOrigin = normalizeEmergencyRecoveryOrigin(result.emergency_recovery_origin);
+  const recoveryOrigin = needs ? persistedOrigin ?? (limit > 0 ? "provider_overflow" : null) : null;
   return {
     detectedContextLimit: modelMatches ? limit : 0,
     detectedContextLimitModelKey: storedModelKey,
-    needsEmergencyRecovery: needs
+    needsEmergencyRecovery: needs,
+    emergencyRecoveryOrigin: recoveryOrigin
   };
 }
-function recordOverflowDetected(db, sessionId, reportedLimit, modelKey) {
+function recordOverflowDetected(db, sessionId, reportedLimit, modelKey, origin = "provider_overflow") {
   db.transaction(() => {
     ensureSessionMetaRow(db, sessionId);
     if (typeof reportedLimit === "number" && reportedLimit > 0) {
-      db.prepare("UPDATE session_meta SET detected_context_limit = ?, detected_context_limit_model_key = ?, needs_emergency_recovery = 1, observed_safe_input_tokens = 0, cache_alert_sent = 0 WHERE session_id = ?").run(reportedLimit, normalizeDetectedLimitModelKey(modelKey), sessionId);
+      db.prepare("UPDATE session_meta SET detected_context_limit = ?, detected_context_limit_model_key = ?, needs_emergency_recovery = 1, emergency_recovery_origin = ?, observed_safe_input_tokens = 0, cache_alert_sent = 0 WHERE session_id = ?").run(reportedLimit, normalizeDetectedLimitModelKey(modelKey), origin, sessionId);
     } else {
-      db.prepare("UPDATE session_meta SET needs_emergency_recovery = 1, observed_safe_input_tokens = 0, cache_alert_sent = 0 WHERE session_id = ?").run(sessionId);
+      db.prepare("UPDATE session_meta SET needs_emergency_recovery = 1, emergency_recovery_origin = ?, observed_safe_input_tokens = 0, cache_alert_sent = 0 WHERE session_id = ?").run(origin, sessionId);
     }
   })();
 }
@@ -155154,9 +155392,9 @@ function clearEmergencyRecovery(db, sessionId) {
   db.transaction(() => {
     ensureSessionMetaRow(db, sessionId);
     try {
-      db.prepare("UPDATE session_meta SET needs_emergency_recovery = 0, recovery_no_eligible_head_count = 0 WHERE session_id = ?").run(sessionId);
+      db.prepare("UPDATE session_meta SET needs_emergency_recovery = 0, emergency_recovery_origin = '', recovery_no_eligible_head_count = 0 WHERE session_id = ?").run(sessionId);
     } catch {
-      db.prepare("UPDATE session_meta SET needs_emergency_recovery = 0 WHERE session_id = ?").run(sessionId);
+      db.prepare("UPDATE session_meta SET needs_emergency_recovery = 0, emergency_recovery_origin = '' WHERE session_id = ?").run(sessionId);
     }
   })();
 }
@@ -156785,12 +157023,12 @@ async function runDeferredV22Backfill(db, options = {}) {
     };
   }
   const resolveIdentity = options.resolveIdentity ?? resolveBackfillIdentity;
-  const yieldToEventLoop = options.yieldToEventLoop ?? defaultYieldToEventLoop;
+  const yieldToEventLoop2 = options.yieldToEventLoop ?? defaultYieldToEventLoop;
   let lastCursor = parseCursor(readMeta(db, BACKFILL_CURSOR_META_KEY));
   let processedRows = 0;
   let changedRows = 0;
   let failedRows = 0;
-  await yieldToEventLoop();
+  await yieldToEventLoop2();
   while (true) {
     const batch = db.prepare(`SELECT id, project_path, category, normalized_hash, seen_count
                  FROM memories
@@ -156812,7 +157050,7 @@ async function runDeferredV22Backfill(db, options = {}) {
         failedBatchRows.push({ ...row, ...classified });
       }
       if ((index + 1) % YIELD_EVERY_N_ROWS === 0 && index + 1 < batch.length) {
-        await yieldToEventLoop();
+        await yieldToEventLoop2();
       }
     }
     await options.onBatchResolved?.(batch);
@@ -156871,10 +157109,10 @@ async function runDeferredV22Backfill(db, options = {}) {
         bumpProjectMemoryEpochInTransaction(db, identity, now);
       }
       writeMeta(db, BACKFILL_CURSOR_META_KEY, String(finalCursor));
-    })();
+    }).immediate();
     processedRows += batch.length;
     lastCursor = finalCursor;
-    await yieldToEventLoop();
+    await yieldToEventLoop2();
   }
   const status = updateFinalBackfillStatus(db);
   const failureCount = countFailures(db);
@@ -156916,9 +157154,15 @@ function loadPersistedApiCacheOnce() {
     const raw = readFileSync4(persistFilePath(), "utf-8");
     const obj = JSON.parse(raw);
     const map = new Map;
-    for (const [key, limit] of Object.entries(obj)) {
-      if (isSaneLimit(limit))
-        map.set(key, { limit });
+    for (const [key, persisted] of Object.entries(obj)) {
+      const limit = typeof persisted === "number" ? persisted : persisted.limit;
+      const inputLimit = typeof persisted === "number" ? undefined : persisted.inputLimit;
+      if (isSaneLimit(limit)) {
+        map.set(key, {
+          limit,
+          inputLimit: isSaneLimit(inputLimit) ? inputLimit : undefined
+        });
+      }
     }
     if (map.size > 0) {
       apiCache = map;
@@ -173968,10 +174212,10 @@ function civilMinuteKey(date5) {
   const p = (n, w = 2) => String(n).padStart(w, "0");
   return `${p(date5.getFullYear(), 4)}-${p(date5.getMonth() + 1)}-${p(date5.getDate())} ${p(date5.getHours())}:${p(date5.getMinutes())}`;
 }
-function nextOccurrence(cron, after, excludeCivilMinute) {
+function nextOccurrence(cron, after, excludeCivilMinute, maxSearchMs = MAX_SEARCH_MS) {
   const afterMs = after.getTime();
   let cursorMs = Math.floor(afterMs / MINUTE_MS) * MINUTE_MS + MINUTE_MS;
-  const capMs = afterMs + MAX_SEARCH_MS;
+  const capMs = afterMs + Math.max(0, Math.min(MAX_SEARCH_MS, maxSearchMs));
   while (cursorMs <= capMs) {
     const candidate = new Date(cursorMs);
     if (matchesCron(cron, candidate)) {
@@ -173983,14 +174227,14 @@ function nextOccurrence(cron, after, excludeCivilMinute) {
   }
   return null;
 }
-function nextDueAtMs(expression, afterMs, consumedScheduledAtMs) {
+function nextDueAtMs(expression, afterMs, consumedScheduledAtMs, maxSearchMs = MAX_SEARCH_MS) {
   if (expression.trim().length === 0)
     return null;
   const parsed = parseCron(expression);
   if (!parsed.ok)
     return null;
   const exclude = consumedScheduledAtMs !== undefined ? civilMinuteKey(new Date(consumedScheduledAtMs)) : undefined;
-  const next = nextOccurrence(parsed.cron, new Date(afterMs), exclude);
+  const next = nextOccurrence(parsed.cron, new Date(afterMs), exclude, maxSearchMs);
   return next ? next.getTime() : null;
 }
 
@@ -174385,22 +174629,6 @@ function getInsertEmbeddingStatement(db) {
   }
   return stmt;
 }
-function getClearProjectStatement(db) {
-  let stmt = clearProjectStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("DELETE FROM compartment_chunk_embeddings WHERE project_path = ?");
-    clearProjectStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getClearProjectModelStatement(db) {
-  let stmt = clearProjectModelStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("DELETE FROM compartment_chunk_embeddings WHERE project_path = ? AND model_id = ?");
-    clearProjectModelStatements.set(db, stmt);
-  }
-  return stmt;
-}
 function getSearchRowsStatement(db, withModel) {
   const map2 = withModel ? searchRowsByModelStatements : searchRowsStatements;
   let stmt = map2.get(db);
@@ -174704,12 +174932,6 @@ function replaceCompartmentChunkEmbeddings(db, rows) {
     }
   })();
 }
-function clearChunkEmbeddingsForProject(db, projectPath, modelId) {
-  if (modelId) {
-    return getClearProjectModelStatement(db).run(projectPath, modelId).changes;
-  }
-  return getClearProjectStatement(db).run(projectPath).changes;
-}
 function loadCompartmentChunkEmbeddingsForSearch(db, sessionId, projectPath, modelId) {
   if (!modelId) {
     throw new Error("loadCompartmentChunkEmbeddingsForSearch requires a current model id");
@@ -175634,22 +175856,6 @@ function getLoadAllEmbeddingsStatement(db) {
   }
   return stmt;
 }
-function getClearAllEmbeddingsStatement(db) {
-  let stmt = clearAllEmbeddingsStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("DELETE FROM memory_embeddings WHERE memory_id IN (SELECT id FROM memories WHERE project_path = ?)");
-    clearAllEmbeddingsStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getClearModelEmbeddingsStatement(db) {
-  let stmt = clearModelEmbeddingsStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("DELETE FROM memory_embeddings WHERE model_id = ? AND memory_id IN (SELECT id FROM memories WHERE project_path = ?)");
-    clearModelEmbeddingsStatements.set(db, stmt);
-  }
-  return stmt;
-}
 function saveEmbedding(db, memoryId, embedding, modelId) {
   const blob = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
   getSaveEmbeddingStatement(db).run(memoryId, blob, modelId);
@@ -175669,12 +175875,6 @@ function loadAllEmbeddings(db, projectPath, modelId) {
   }
   return embeddings;
 }
-function clearEmbeddingsForProject(db, projectPath, modelId) {
-  if (modelId) {
-    return getClearModelEmbeddingsStatement(db).run(modelId, projectPath).changes;
-  }
-  return getClearAllEmbeddingsStatement(db).run(projectPath).changes;
-}
 function getMemoryEmbedCoverage(db, projectPath, modelId) {
   const row = db.prepare(`SELECT
                COUNT(*) AS total,
@@ -175691,7 +175891,7 @@ function getMemoryEmbedCoverage(db, projectPath, modelId) {
 }
 
 // ../plugin/src/features/magic-context/project-embedding-registry.ts
-import { createHash as createHash8, randomUUID } from "node:crypto";
+import { createHash as createHash8, randomUUID as randomUUID2 } from "node:crypto";
 init_logger();
 
 // ../plugin/src/features/magic-context/git-commits/storage-git-commit-embeddings.ts
@@ -175747,24 +175947,6 @@ function getCountEmbeddedStatement(db) {
   }
   return stmt;
 }
-function getClearProjectStatement2(db) {
-  let stmt = clearProjectStatements2.get(db);
-  if (!stmt) {
-    stmt = db.prepare(`DELETE FROM git_commit_embeddings
-             WHERE sha IN (SELECT sha FROM git_commits WHERE project_path = ?)`);
-    clearProjectStatements2.set(db, stmt);
-  }
-  return stmt;
-}
-function getClearProjectModelStatement2(db) {
-  let stmt = clearProjectModelStatements2.get(db);
-  if (!stmt) {
-    stmt = db.prepare(`DELETE FROM git_commit_embeddings
-             WHERE model_id = ? AND sha IN (SELECT sha FROM git_commits WHERE project_path = ?)`);
-    clearProjectModelStatements2.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());
@@ -175785,12 +175967,6 @@ function countEmbeddedCommits(db, projectPath, modelId) {
   const row = getCountEmbeddedStatement(db).get(projectPath, modelId);
   return row?.count ?? 0;
 }
-function clearProjectCommitEmbeddings(db, projectPath, modelId) {
-  if (modelId) {
-    return getClearProjectModelStatement2(db).run(modelId, projectPath).changes;
-  }
-  return getClearProjectStatement2(db).run(projectPath).changes;
-}
 
 // ../plugin/src/features/magic-context/git-commits/storage-git-commits.ts
 init_logger();
@@ -176098,6 +176274,7 @@ var COMMIT_DRAIN_BATCH_SIZE = 16;
 var COMMIT_DRAIN_MAX_PER_SWEEP = 500;
 var CHUNK_DRAIN_BATCH_SIZE = 8;
 var EMBEDDING_IDENTITY_GC_GRACE_MS = 14 * 24 * 60 * 60 * 1000;
+var STALE_EMBEDDING_GC_BATCH_SIZE = 250;
 var MAX_WINDOWS_PER_EMBED_CALL = 2;
 var SESSION_EMBED_LEASE_RENEWAL_MS = 60 * 1000;
 var EMBED_SLICE_RETRY_ATTEMPTS = 3;
@@ -176326,6 +176503,55 @@ function staleModelsForScope(db, projectIdentity, scope, currentModelId, cutoff)
   const rows = getStaleIdentityStatement(db, scope).all(projectIdentity, scope, currentModelId, cutoff);
   return rows.map((row) => row.modelId).filter((modelId) => typeof modelId === "string");
 }
+function deleteStaleEmbeddingBatch(db, scope, projectIdentity, modelId, limit) {
+  if (scope === "memory") {
+    return db.prepare(`DELETE FROM memory_embeddings
+                 WHERE rowid IN (
+                     SELECT me.rowid
+                     FROM memory_embeddings me
+                     JOIN memories m ON m.id = me.memory_id
+                     WHERE m.project_path = ? AND me.model_id = ?
+                     LIMIT ?
+                 )`).run(projectIdentity, modelId, limit).changes;
+  }
+  if (scope === "commit") {
+    return db.prepare(`DELETE FROM git_commit_embeddings
+                 WHERE rowid IN (
+                     SELECT gce.rowid
+                     FROM git_commit_embeddings gce
+                     JOIN git_commits gc ON gc.sha = gce.sha
+                     WHERE gc.project_path = ? AND gce.model_id = ?
+                     LIMIT ?
+                 )`).run(projectIdentity, modelId, limit).changes;
+  }
+  return db.prepare(`DELETE FROM compartment_chunk_embeddings
+             WHERE id IN (
+                 SELECT id
+                 FROM compartment_chunk_embeddings
+                 WHERE project_path = ? AND model_id = ?
+                 LIMIT ?
+             )`).run(projectIdentity, modelId, limit).changes;
+}
+function hasStaleEmbeddingRows(db, scope, projectIdentity, modelId) {
+  if (scope === "memory") {
+    return Boolean(db.prepare(`SELECT 1
+                     FROM memory_embeddings me
+                     JOIN memories m ON m.id = me.memory_id
+                     WHERE m.project_path = ? AND me.model_id = ?
+                     LIMIT 1`).get(projectIdentity, modelId));
+  }
+  if (scope === "commit") {
+    return Boolean(db.prepare(`SELECT 1
+                     FROM git_commit_embeddings gce
+                     JOIN git_commits gc ON gc.sha = gce.sha
+                     WHERE gc.project_path = ? AND gce.model_id = ?
+                     LIMIT 1`).get(projectIdentity, modelId));
+  }
+  return Boolean(db.prepare(`SELECT 1
+                 FROM compartment_chunk_embeddings
+                 WHERE project_path = ? AND model_id = ?
+                 LIMIT 1`).get(projectIdentity, modelId));
+}
 function sweepStaleEmbeddingIdentitiesForProject(db, projectIdentity, now = Date.now()) {
   const snapshot = getProjectEmbeddingSnapshot(projectIdentity);
   const result = {
@@ -176340,24 +176566,45 @@ function sweepStaleEmbeddingIdentitiesForProject(db, projectIdentity, now = Date
     return result;
   const cutoff = now - EMBEDDING_IDENTITY_GC_GRACE_MS;
   const deleteTracking = getDeleteActiveIdentityStatement(db);
+  const scopes = [
+    {
+      scope: "memory",
+      enabled: snapshot.enabled && snapshot.modelId !== "off",
+      currentModelId: snapshot.modelId
+    },
+    {
+      scope: "commit",
+      enabled: snapshot.gitCommitEnabled && snapshot.modelId !== "off",
+      currentModelId: snapshot.modelId
+    },
+    {
+      scope: "chunk",
+      enabled: snapshot.enabled && snapshot.chunkModelId !== "off",
+      currentModelId: snapshot.chunkModelId
+    }
+  ];
+  let remainingBudget = STALE_EMBEDDING_GC_BATCH_SIZE;
   db.exec("BEGIN IMMEDIATE");
   try {
-    if (snapshot.enabled && snapshot.modelId !== "off") {
-      for (const modelId of staleModelsForScope(db, projectIdentity, "memory", snapshot.modelId, cutoff)) {
-        result.memoryRowsDeleted += clearEmbeddingsForProject(db, projectIdentity, modelId);
-        result.trackingRowsDeleted += deleteTracking.run(projectIdentity, "memory", modelId).changes;
-      }
-    }
-    if (snapshot.gitCommitEnabled && snapshot.modelId !== "off") {
-      for (const modelId of staleModelsForScope(db, projectIdentity, "commit", snapshot.modelId, cutoff)) {
-        result.commitRowsDeleted += clearProjectCommitEmbeddings(db, projectIdentity, modelId);
-        result.trackingRowsDeleted += deleteTracking.run(projectIdentity, "commit", modelId).changes;
-      }
-    }
-    if (snapshot.enabled && snapshot.chunkModelId !== "off") {
-      for (const modelId of staleModelsForScope(db, projectIdentity, "chunk", snapshot.chunkModelId, cutoff)) {
-        result.chunkRowsDeleted += clearChunkEmbeddingsForProject(db, projectIdentity, modelId);
-        result.trackingRowsDeleted += deleteTracking.run(projectIdentity, "chunk", modelId).changes;
+    for (const { scope, enabled, currentModelId } of scopes) {
+      if (!enabled || remainingBudget === 0)
+        continue;
+      for (const modelId of staleModelsForScope(db, projectIdentity, scope, currentModelId, cutoff)) {
+        if (remainingBudget === 0)
+          break;
+        const deleted = deleteStaleEmbeddingBatch(db, scope, projectIdentity, modelId, remainingBudget);
+        remainingBudget -= deleted;
+        if (scope === "memory")
+          result.memoryRowsDeleted += deleted;
+        else if (scope === "commit")
+          result.commitRowsDeleted += deleted;
+        else
+          result.chunkRowsDeleted += deleted;
+        if (!hasStaleEmbeddingRows(db, scope, projectIdentity, modelId)) {
+          result.trackingRowsDeleted += deleteTracking.run(projectIdentity, scope, modelId).changes;
+        } else if (deleted === 0) {
+          remainingBudget = 0;
+        }
       }
     }
     db.exec("COMMIT");
@@ -176367,9 +176614,8 @@ function sweepStaleEmbeddingIdentitiesForProject(db, projectIdentity, now = Date
     } catch {}
     throw error51;
   }
-  if (result.memoryRowsDeleted > 0) {
+  if (result.memoryRowsDeleted > 0)
     invalidateProject(projectIdentity);
-  }
   return result;
 }
 function registerProjectEmbedding(db, projectIdentity, config2, features, sourceDirectory) {
@@ -176583,22 +176829,33 @@ async function drainCommitBacklogForProject(db, projectIdentity, deadline) {
   const snapshot = getProjectEmbeddingSnapshot(projectIdentity);
   if (!snapshot?.gitCommitEnabled)
     return 0;
-  const holderId = `embed-sweep-${randomUUID()}`;
+  const holderId = `embed-sweep-${randomUUID2()}`;
   const lease = acquireGitSweepLease(db, projectIdentity, holderId, { ignoreCooldown: true });
   if (!lease.acquired) {
     return 0;
   }
   let total = 0;
+  let leaseLost = false;
+  const renewal = setInterval(() => {
+    try {
+      if (!renewGitSweepLease(db, projectIdentity, holderId))
+        leaseLost = true;
+    } catch {}
+  }, SESSION_EMBED_LEASE_RENEWAL_MS);
+  renewal.unref?.();
   try {
-    while (Date.now() < deadline && total < COMMIT_DRAIN_MAX_PER_SWEEP) {
+    while (!leaseLost && Date.now() < deadline && total < COMMIT_DRAIN_MAX_PER_SWEEP) {
       const embedded = await embedCommitBatch(db, projectIdentity, COMMIT_DRAIN_BATCH_SIZE);
-      if (embedded === 0)
+      if (!renewGitSweepLease(db, projectIdentity, holderId))
+        leaseLost = true;
+      if (leaseLost || embedded === 0)
         break;
       total += embedded;
       if (embedded < COMMIT_DRAIN_BATCH_SIZE)
         break;
     }
   } finally {
+    clearInterval(renewal);
     releaseGitSweepLease(db, projectIdentity, holderId);
   }
   return total;
@@ -176705,13 +176962,23 @@ async function embedSessionCompartmentChunks(db, projectIdentity, sessionId, opt
   const total = countUnembeddedSessionCompartments(db, projectIdentity, sessionId, snapshot.chunkModelId);
   if (total === 0)
     return { status: "nothing", embedded: 0, total: 0 };
-  const holderId = `session-embed-${randomUUID()}`;
+  const holderId = `session-embed-${randomUUID2()}`;
   const lease = acquireGitSweepLease(db, projectIdentity, holderId, { ignoreCooldown: true });
   if (!lease.acquired)
     return { status: "busy", embedded: 0, total };
+  let leaseLost = false;
+  const drainAbort = new AbortController;
+  const forwardCallerAbort = () => drainAbort.abort();
+  if (options?.signal?.aborted)
+    drainAbort.abort();
+  else
+    options?.signal?.addEventListener("abort", forwardCallerAbort, { once: true });
   const renewal = setInterval(() => {
     try {
-      renewGitSweepLease(db, projectIdentity, holderId);
+      if (!renewGitSweepLease(db, projectIdentity, holderId)) {
+        leaseLost = true;
+        drainAbort.abort();
+      }
     } catch {}
   }, SESSION_EMBED_LEASE_RENEWAL_MS);
   renewal.unref?.();
@@ -176725,7 +176992,7 @@ async function embedSessionCompartmentChunks(db, projectIdentity, sessionId, opt
   try {
     options?.onProgress?.({ embedded, total });
     for (;; ) {
-      if (options?.signal?.aborted) {
+      if (leaseLost || drainAbort.signal.aborted) {
         aborted2 = true;
         break;
       }
@@ -176736,7 +177003,13 @@ async function embedSessionCompartmentChunks(db, projectIdentity, sessionId, opt
         embedded: n,
         noWork,
         failed
-      } = await embedCandidateChunkBatch(db, projectIdentity, snapshot.chunkModelId, candidates, options?.signal);
+      } = await embedCandidateChunkBatch(db, projectIdentity, snapshot.chunkModelId, candidates, drainAbort.signal);
+      if (leaseLost || !renewGitSweepLease(db, projectIdentity, holderId)) {
+        leaseLost = true;
+        drainAbort.abort();
+        aborted2 = true;
+        break;
+      }
       for (const id of noWork)
         skipIds.push(id);
       for (const id of failed)
@@ -176756,6 +177029,7 @@ async function embedSessionCompartmentChunks(db, projectIdentity, sessionId, opt
     }
   } finally {
     clearInterval(renewal);
+    options?.signal?.removeEventListener("abort", forwardCallerAbort);
     try {
       releaseGitSweepLease(db, projectIdentity, holderId);
     } catch (error51) {
@@ -178661,13 +178935,7 @@ If no promotions are warranted, return empty arrays. Always consume reviewed can
     })).filter((u) => Boolean(u.memoryId) && u.content.length > 0);
     const dismissals = (parsed.dismiss_existing ?? []).filter((d) => Boolean(d.memory_id));
     const consumeCandidateIds = parsed.consume_candidate_ids ?? [];
-    let leaseLostAtCommit = false;
-    args.db.transaction(() => {
-      if (!peekLeaseHolderAndExpiry(args.db, args.holderId, leaseKey)) {
-        log(`[dreamer] user-memories: commit aborted — lease lost (holder ${args.holderId})`);
-        leaseLostAtCommit = true;
-        return;
-      }
+    runLeaseGuardedWrite(args.db, args.holderId, leaseKey, () => {
       for (const promotion of promotions) {
         insertUserMemory(args.db, promotion.content, promotion.candidateIds);
       }
@@ -178683,10 +178951,7 @@ If no promotions are warranted, return empty arrays. Always consume reviewed can
       if (promotions.length > 0 || updates.length > 0 || dismissals.length > 0) {
         bumpProjectUserProfileVersion(args.db);
       }
-    })();
-    if (leaseLostAtCommit) {
-      throw new Error("Dream lease lost during user-memory review commit");
-    }
+    });
     result.promoted = promotions.length;
     result.merged = updates.length;
     result.dismissed = dismissals.length;
@@ -179220,7 +179485,7 @@ init_logger();
 // ../plugin/src/features/magic-context/smart-notes/capabilities.ts
 import { execFile as execFile2 } from "node:child_process";
 import { constants as fsConstants } from "node:fs";
-import { open as open2, realpath } from "node:fs/promises";
+import { lstat, open as open2, realpath } from "node:fs/promises";
 import path8 from "node:path";
 import { promisify as promisify2 } from "node:util";
 
@@ -179355,16 +179620,19 @@ async function resolveHostToValidatedGlobalAddresses(rawHostname, signal, resolv
   if (candidates.length === 0) {
     throw new SmartNoteSecurityError("DNS resolution returned no addresses");
   }
-  const classified = candidates.map((candidate) => {
+  const ipv4Candidates = candidates.filter((candidate) => candidate.family !== 6 && !candidate.address.includes(":"));
+  if (ipv4Candidates.length === 0) {
+    throw new SmartNoteNetworkError("SMART_NOTE_NETWORK: IPv6 destinations are not permitted");
+  }
+  const classified = ipv4Candidates.map((candidate) => {
     const parsed = parseIpLiteral(candidate.address);
-    if (!parsed) {
-      throw new SmartNoteSecurityError(`DNS returned an unparsable address: ${candidate.address}`);
+    if (parsed?.family !== 4) {
+      throw new SmartNoteSecurityError(`DNS returned an unparsable IPv4 address: ${candidate.address}`);
     }
-    const global = isGlobalAddress(parsed);
     return {
       address: parsed.address,
       family: parsed.family,
-      global
+      global: isGlobalAddress(parsed)
     };
   });
   if (classified.some((candidate) => !candidate.global)) {
@@ -179387,6 +179655,7 @@ function createPinnedLookup(candidate) {
   return hook;
 }
 function requestValidatedAddress(validation, candidate, options) {
+  const agent = createSmartNoteRequestAgent();
   return new Promise((resolve, reject) => {
     const url2 = validation.url;
     const hostHeader = url2.host;
@@ -179403,6 +179672,7 @@ function requestValidatedAddress(validation, candidate, options) {
         Accept: "text/plain, application/json;q=0.9, */*;q=0.1"
       },
       lookup: createPinnedLookup(candidate),
+      agent,
       timeout: options.timeoutMs
     }, (response) => {
       const chunks = [];
@@ -179447,7 +179717,10 @@ function requestValidatedAddress(validation, candidate, options) {
     });
     request2.on("close", () => options.signal.removeEventListener("abort", onAbort));
     request2.end();
-  });
+  }).finally(() => agent.destroy());
+}
+function createSmartNoteRequestAgent() {
+  return new https.Agent({ keepAlive: false, maxSockets: 1 });
 }
 function canonicalDnsName(hostname3) {
   const ascii = domainToASCII(hostname3);
@@ -179630,32 +179903,64 @@ function normalizeRepoPath(repoRelativePath) {
 }
 async function guardedReadFile(projectRoot, repoRelativePath, signal, fileLimitBytes) {
   throwIfAborted2(signal);
+  const body = guardedReadFileBody(projectRoot, repoRelativePath, signal, fileLimitBytes);
+  let onAbort;
+  const abort = new Promise((_, reject) => {
+    onAbort = () => reject(abortError(signal));
+    if (signal.aborted)
+      onAbort();
+    else
+      signal.addEventListener("abort", onAbort, { once: true });
+  });
+  try {
+    return await Promise.race([body, abort]);
+  } finally {
+    if (onAbort)
+      signal.removeEventListener("abort", onAbort);
+  }
+}
+async function guardedReadFileBody(projectRoot, repoRelativePath, signal, fileLimitBytes) {
   const normalized = normalizeRepoPath(repoRelativePath);
   if (!normalized || isSecretDeniedPath(normalized))
     return null;
   const rootReal = await realpath(projectRoot).catch(() => null);
+  throwIfAborted2(signal);
   if (!rootReal)
     return null;
   const target = path8.resolve(rootReal, normalized);
   if (!isPathInside(rootReal, target))
     return null;
   const parentReal = await realpath(path8.dirname(target)).catch(() => null);
+  throwIfAborted2(signal);
   if (!parentReal || !isPathInside(rootReal, parentReal))
     return null;
+  const canonicalTarget = path8.join(parentReal, path8.basename(target));
+  const canonicalRelative = normalizeRepoPath(path8.relative(rootReal, canonicalTarget));
+  if (!canonicalRelative || !isPathInside(rootReal, canonicalTarget) || isSecretDeniedPath(canonicalRelative)) {
+    return null;
+  }
+  const targetStat = await lstat(canonicalTarget).catch((error51) => {
+    if (isNoFollowOrMissing(error51))
+      return null;
+    throw error51;
+  });
+  throwIfAborted2(signal);
+  if (!targetStat?.isFile() || targetStat.size > fileLimitBytes)
+    return null;
   const noFollow = typeof fsConstants.O_NOFOLLOW === "number" ? fsConstants.O_NOFOLLOW : 0;
-  const handle = await open2(target, fsConstants.O_RDONLY | noFollow).catch((error51) => {
+  const nonBlock = typeof fsConstants.O_NONBLOCK === "number" ? fsConstants.O_NONBLOCK : 0;
+  const openPromise = open2(canonicalTarget, fsConstants.O_RDONLY | noFollow | nonBlock).catch((error51) => {
     if (isNoFollowOrMissing(error51))
       return null;
     throw error51;
   });
+  const handle = await closeLateOpenOnAbort(openPromise, signal);
   if (!handle)
     return null;
   try {
     throwIfAborted2(signal);
     const stat2 = await handle.stat();
-    if (!stat2.isFile())
-      return null;
-    if (stat2.size > fileLimitBytes)
+    if (!stat2.isFile() || stat2.size > fileLimitBytes)
       return null;
     const buffer2 = Buffer.alloc(stat2.size);
     const { bytesRead } = await handle.read(buffer2, 0, stat2.size, 0);
@@ -179665,6 +179970,17 @@ async function guardedReadFile(projectRoot, repoRelativePath, signal, fileLimitB
     await handle.close().catch(() => {});
   }
 }
+async function closeLateOpenOnAbort(openPromise, signal) {
+  const handle = await openPromise;
+  if (!signal.aborted)
+    return handle;
+  if (handle)
+    handle.close().catch(() => {});
+  throw abortError(signal);
+}
+function abortError(signal) {
+  return signal.reason instanceof SmartNoteNetworkError ? signal.reason : new SmartNoteNetworkError("SMART_NOTE_NETWORK: aborted");
+}
 function isPathInside(root, target) {
   const relative = path8.relative(root, target);
   return relative === "" || !relative.startsWith("..") && !path8.isAbsolute(relative);
@@ -179787,6 +180103,8 @@ function withSandboxLock(fn) {
 var DEFAULT_TIMEOUT_MS = 2000;
 var DEFAULT_HEAP_LIMIT_BYTES = 8 * 1024 * 1024;
 var DEFAULT_STACK_LIMIT_BYTES = 512 * 1024;
+var MAX_COMPILED_CHECK_BYTES = 64 * 1024;
+var MAX_SANDBOX_ERROR_CHARS = 2 * 1024;
 function resolveCapabilitiesForRun(options, signal) {
   if (options.capabilityFactory) {
     return options.capabilityFactory(signal);
@@ -179802,18 +180120,29 @@ function throwIfRunAborted(signal) {
   }
 }
 async function runCompiledSmartNoteCheck(options) {
+  if (options.signal?.aborted)
+    return cancelledResult(options.signal.reason);
+  if (Buffer.byteLength(options.compiledCheck, "utf8") > MAX_COMPILED_CHECK_BYTES) {
+    return failureResult("compiled check exceeds 64 KiB", false);
+  }
   return withSandboxLock(() => runCompiledSmartNoteCheckLocked(options));
 }
 async function runCompiledSmartNoteCheckLocked(options) {
+  if (options.signal?.aborted)
+    return cancelledResult(options.signal.reason);
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const controller = new AbortController;
-  const externalAbort = () => controller.abort(options.signal?.reason);
-  if (options.signal?.aborted) {
-    externalAbort();
-  } else {
-    options.signal?.addEventListener("abort", externalAbort, { once: true });
-  }
-  const timer = setTimeout(() => controller.abort(new Error("smart-note check timed out")), timeoutMs);
+  let externallyCancelled = false;
+  let executionTimedOut = false;
+  const externalAbort = () => {
+    externallyCancelled = true;
+    controller.abort(options.signal?.reason);
+  };
+  options.signal?.addEventListener("abort", externalAbort, { once: true });
+  const timer = setTimeout(() => {
+    executionTimedOut = true;
+    controller.abort(new Error("smart-note check timed out"));
+  }, timeoutMs);
   try {
     throwIfRunAborted(controller.signal);
     const capabilities = resolveCapabilitiesForRun(options, controller.signal);
@@ -179830,23 +180159,38 @@ async function runCompiledSmartNoteCheckLocked(options) {
       const result = await evalCheck(context, options.compiledCheck);
       const checkResult = result;
       if (!checkResult || typeof checkResult.met !== "boolean") {
-        return { ok: false, error: "check() must return { met: boolean }", network: false };
+        return failureResult("check() must return { met: boolean }", false);
       }
       return { ok: true, result: { met: checkResult.met } };
     } finally {
       context.dispose();
     }
   } catch (error51) {
-    return {
-      ok: false,
-      error: error51 instanceof Error ? `${error51.name}: ${error51.message}` : String(error51),
-      network: isSmartNoteNetworkError(error51)
-    };
+    if (externallyCancelled && !executionTimedOut)
+      return cancelledResult(error51);
+    return failureResult(formatSandboxError(error51), isSmartNoteNetworkError(error51));
   } finally {
     clearTimeout(timer);
     options.signal?.removeEventListener("abort", externalAbort);
   }
 }
+function failureResult(error51, network) {
+  return { ok: false, cancelled: false, error: truncate(error51), network };
+}
+function cancelledResult(reason) {
+  return {
+    ok: false,
+    cancelled: true,
+    error: truncate(reason instanceof Error ? reason.message : String(reason ?? "cancelled")),
+    network: false
+  };
+}
+function formatSandboxError(error51) {
+  return error51 instanceof Error ? `${error51.name}: ${error51.message}` : String(error51);
+}
+function truncate(value) {
+  return value.slice(0, MAX_SANDBOX_ERROR_CHARS);
+}
 function installCapabilityObject(context, cap) {
   const capObject = context.newObject();
   try {
@@ -179922,9 +180266,15 @@ JSON.stringify({ met: __result.met });`;
 }
 
 // ../plugin/src/features/magic-context/smart-notes/compiler.ts
+var MAX_COMPILER_OUTPUT_CHARS = 128 * 1024;
+var MAX_COMPILED_CHECK_BYTES2 = 64 * 1024;
+var MAX_MANIFEST_ENTRIES = 64;
+var MAX_CRON_CHARS = 256;
+var MAX_COMPILER_ERROR_CHARS = 2 * 1024;
 async function compileSmartNoteCheck(args) {
-  if (!args.note.surfaceCondition)
-    return { ok: false, error: "note has no surface condition" };
+  if (!args.note.surfaceCondition) {
+    return { ok: false, cancelled: false, error: "note has no surface condition" };
+  }
   const prompt = `Compile this smart note condition into a sandbox check.
 
 Project identity: ${args.projectIdentity}
@@ -179998,6 +180348,7 @@ Remember: output only the JSON object described by the system prompt.`;
     const response = run.validated;
     const compiledCheck = normalizeCompiledCheck(response.compiled_check);
     const manifest = normalizeManifest(response.manifest);
+    const checkCron = normalizeCron(response.check_cron);
     for (const warning of manifestAdvisoryWarnings(compiledCheck, manifest)) {
       log(`[dreamer] smart note #${args.note.id}: manifest advisory — ${warning}`);
     }
@@ -180008,11 +180359,15 @@ Remember: output only the JSON object described by the system prompt.`;
       timeoutMs: 2000
     });
     if (!dryRun.ok) {
-      recordInvocation2({ status: "failed", messages: run.output, error: dryRun.error });
-      return { ok: false, error: `dry-run failed: ${dryRun.error}` };
+      const error51 = boundedError(`dry-run failed: ${dryRun.error}`);
+      recordInvocation2({
+        status: dryRun.cancelled ? "aborted" : "failed",
+        messages: run.output,
+        error: error51
+      });
+      return { ok: false, cancelled: dryRun.cancelled, error: error51 };
     }
     recordInvocation2({ status: "completed", messages: run.output });
-    const checkCron = normalizeCron(response.check_cron);
     return {
       ok: true,
       compiledCheck,
@@ -180022,8 +180377,10 @@ Remember: output only the JSON object described by the system prompt.`;
       dryRun: dryRun.result
     };
   } catch (error51) {
-    recordInvocation2({ status: "failed", error: error51 });
-    return { ok: false, error: error51 instanceof Error ? error51.message : String(error51) };
+    const cancelled = args.signal.aborted;
+    const message = boundedError(error51 instanceof Error ? error51.message : String(error51));
+    recordInvocation2({ status: cancelled ? "aborted" : "failed", error: message });
+    return { ok: false, cancelled, error: message };
   } finally {
     if (childSessionId) {
       await args.client.session.delete({ path: { id: childSessionId } }).catch(() => {});
@@ -180033,6 +180390,9 @@ Remember: output only the JSON object described by the system prompt.`;
 function parseCompilerOutput(output) {
   if (!output)
     throw new Error("smart-note compiler returned no output");
+  if (output.length > MAX_COMPILER_OUTPUT_CHARS) {
+    throw new Error("smart-note compiler output exceeds 128 KiB");
+  }
   const json2 = extractJsonObject(output);
   const parsed = JSON.parse(json2);
   if (typeof parsed.compiled_check !== "string")
@@ -180044,6 +180404,9 @@ function parseCompilerOutput(output) {
   return parsed;
 }
 function normalizeCompiledCheck(source) {
+  if (Buffer.byteLength(source, "utf8") > MAX_COMPILED_CHECK_BYTES2) {
+    throw new Error("compiled_check exceeds 64 KiB");
+  }
   let code = source.trim();
   const fence = code.match(/^```(?:javascript|js)?\s*([\s\S]*?)```$/i);
   if (fence)
@@ -180058,14 +180421,17 @@ function normalizeCompiledCheck(source) {
   if (/\b(?:import|require)\b/.test(code)) {
     throw new Error("compiled_check must not import modules");
   }
+  if (Buffer.byteLength(code, "utf8") > MAX_COMPILED_CHECK_BYTES2) {
+    throw new Error("compiled_check exceeds 64 KiB");
+  }
   return code;
 }
 function normalizeManifest(manifest) {
-  const capabilities = Array.isArray(manifest.capabilities) ? unique(manifest.capabilities.filter((cap) => ["readFile", "gitHeadSha", "gitTag", "gitLog", "httpGet"].includes(String(cap)))) : [];
+  const capabilities = Array.isArray(manifest.capabilities) ? unique(manifest.capabilities.slice(0, MAX_MANIFEST_ENTRIES).filter((cap) => ["readFile", "gitHeadSha", "gitTag", "gitLog", "httpGet"].includes(String(cap)))) : [];
   return {
     capabilities,
     readFiles: uniqueStrings(manifest.readFiles),
-    hosts: uniqueStrings(manifest.hosts?.map((h) => h.toLowerCase())),
+    hosts: uniqueStrings(manifest.hosts, (host) => host.toLowerCase()),
     urls: uniqueStrings(manifest.urls),
     signals: uniqueStrings(manifest.signals),
     summary: typeof manifest.summary === "string" ? manifest.summary.slice(0, 160) : undefined
@@ -180131,25 +180497,36 @@ function literalCalls(code, method) {
   return values;
 }
 function normalizeCron(cron) {
-  const trimmed = cron.trim();
-  return trimmed.length > 0 ? trimmed : "0 * * * *";
+  if (cron.length > MAX_CRON_CHARS)
+    throw new Error("check_cron exceeds 256 characters");
+  const normalized = cron.trim() || "0 * * * *";
+  const parsed = parseCron(normalized);
+  if (!parsed.ok)
+    throw new Error(`invalid check_cron: ${parsed.error}`);
+  const next = nextOccurrence(parsed.cron, new Date, undefined, SMART_NOTE_CHECK_CEILING_MS);
+  if (!next)
+    throw new Error("check_cron has no occurrence within the scheduling ceiling");
+  return normalized;
 }
 function unique(items) {
   return [...new Set(items)];
 }
-function uniqueStrings(items) {
+function uniqueStrings(items, normalize = (value) => value) {
   if (!Array.isArray(items))
     return;
-  const values = unique(items.filter((item) => typeof item === "string" && item.length > 0));
+  const values = unique(items.slice(0, MAX_MANIFEST_ENTRIES).filter((item) => typeof item === "string" && item.length > 0).map(normalize));
   return values.length > 0 ? values : undefined;
 }
+function boundedError(error51) {
+  return error51.slice(0, MAX_COMPILER_ERROR_CHARS);
+}
 
 // ../plugin/src/features/magic-context/smart-notes/schedule.ts
 function nextSmartNoteCheckDueAt(cron, options = {}) {
   const now = options.now ?? Date.now();
   const floorMs = options.floorMs ?? SMART_NOTE_CHECK_FLOOR_MS;
   const ceilingMs = options.ceilingMs ?? SMART_NOTE_CHECK_CEILING_MS;
-  const rawNext = cron?.trim() ? nextDueAtMs(cron, now) : null;
+  const rawNext = cron?.trim() ? nextDueAtMs(cron, now, undefined, ceilingMs) : null;
   const rawDelta = rawNext ? rawNext - now : SMART_NOTE_CHECK_DEFAULT_INTERVAL_MS;
   const clamped = Math.min(ceilingMs, Math.max(floorMs, rawDelta));
   const jittered = clamped + deterministicJitterMs(clamped, options.noteId, options.hash);
@@ -180171,6 +180548,7 @@ function deterministicJitterMs(intervalMs, noteId, hash2) {
 }
 
 // ../plugin/src/features/magic-context/smart-notes/storage.ts
+init_logger();
 function toSmartNote(note) {
   return {
     ...note,
@@ -180183,11 +180561,13 @@ function toSmartNote(note) {
 function commitSmartNoteState(db, args) {
   db.exec("BEGIN IMMEDIATE");
   let leaseLost = false;
+  let committed = false;
   try {
     if (args.leaseHeld && !args.leaseHeld()) {
       leaseLost = true;
-    } else {
+    } else if (claimExpectedState(db, args.expected)) {
       args.write();
+      committed = true;
     }
     db.exec("COMMIT");
   } catch (error51) {
@@ -180199,6 +180579,30 @@ function commitSmartNoteState(db, args) {
   if (leaseLost) {
     throw new Error(`Dream lease lost during smart-note ${args.phase} commit`);
   }
+  if (!committed) {
+    log(`[debug] smart note #${args.expected.noteId}: discarded stale ${args.phase} result`);
+  }
+  return committed;
+}
+function claimExpectedState(db, expected) {
+  if (expected.kind === "compiled-check") {
+    return db.prepare(`UPDATE notes SET id = id
+                     WHERE id = ? AND type = 'smart' AND status = 'pending'
+                       AND check_status = 'compiled' AND compiled_check = ?
+                       AND check_hash IS ? AND check_compiled_at IS ?`).run(expected.noteId, expected.compiledCheck, expected.checkHash, expected.checkCompiledAt).changes > 0;
+  }
+  const statusClause = expected.checkStatus ? " AND check_status = ?" : "";
+  const params = [
+    expected.noteId,
+    expected.content,
+    expected.surfaceCondition,
+    expected.updatedAt
+  ];
+  if (expected.checkStatus)
+    params.push(expected.checkStatus);
+  return db.prepare(`UPDATE notes SET id = id
+                 WHERE id = ? AND type = 'smart' AND status = 'pending'
+                   AND content = ? AND surface_condition IS ? AND updated_at = ?${statusClause}`).run(...params).changes > 0;
 }
 function getDueCompiledSmartNoteChecks(db, projectPath, now, limit) {
   return getPendingSmartNotes(db, projectPath).map(toSmartNote).filter((note) => note.checkStatus === "compiled" && note.compiledCheck !== null && note.policyVersion === SMART_NOTE_CHECK_POLICY_VERSION && (note.checkQuarantinedUntil === null || note.checkQuarantinedUntil <= now) && (note.checkNextDueAt === null || note.checkNextDueAt <= now)).sort((a, b) => (a.checkNextDueAt ?? 0) - (b.checkNextDueAt ?? 0) || a.id - b.id).slice(0, Math.max(1, limit));
@@ -180316,13 +180720,19 @@ async function runDueCompiledSmartNoteChecks(args) {
       break;
     if (!note.compiledCheck)
       continue;
+    const compiledCheck = note.compiledCheck;
     ran++;
     const controller = new AbortController;
+    const abortFromCaller = () => controller.abort(args.signal?.reason);
+    if (args.signal?.aborted)
+      abortFromCaller();
+    else
+      args.signal?.addEventListener("abort", abortFromCaller, { once: true });
     const remaining = Math.max(500, (args.sweepBudgetMs ?? DEFAULT_SWEEP_BUDGET_MS) - (Date.now() - startedAt));
     const timer = setTimeout(() => controller.abort(new Error("smart-note sweep budget exhausted")), remaining);
     try {
       const result = await runCompiledSmartNoteCheck({
-        compiledCheck: note.compiledCheck,
+        compiledCheck,
         capabilityFactory: (signal) => createSmartNoteCapabilities({
           projectRoot: args.projectRoot,
           signal
@@ -180331,48 +180741,67 @@ async function runDueCompiledSmartNoteChecks(args) {
         timeoutMs: Math.min(2000, remaining)
       });
       const runFinishedAt = Date.now();
+      const expected = {
+        kind: "compiled-check",
+        noteId: note.id,
+        compiledCheck,
+        checkHash: note.checkHash,
+        checkCompiledAt: note.checkCompiledAt
+      };
+      if (!result.ok && result.cancelled) {
+        continue;
+      }
       if (result.ok && result.result.met) {
-        commitSmartNoteState(args.db, {
+        const committed = commitSmartNoteState(args.db, {
           phase: "due check",
+          expected,
           leaseHeld,
           write: () => {
             markNoteReady(args.db, note.id, hostGeneratedReadyReason(note.id, note.manifestJson));
           }
         });
-        surfaced++;
+        if (committed)
+          surfaced++;
       } else if (result.ok) {
+        const nextDueAt = nextSmartNoteCheckDueAt(note.checkCron, {
+          now: runFinishedAt,
+          noteId: note.id,
+          hash: note.checkHash
+        });
         commitSmartNoteState(args.db, {
           phase: "due check",
+          expected,
           leaseHeld,
           write: () => {
-            markCompiledCheckFalse(args.db, note.id, nextSmartNoteCheckDueAt(note.checkCron, {
-              now: runFinishedAt,
-              noteId: note.id,
-              hash: note.checkHash
-            }), runFinishedAt);
+            markCompiledCheckFalse(args.db, note.id, nextDueAt, runFinishedAt);
           }
         });
       } else if (result.network) {
-        commitSmartNoteState(args.db, {
+        const committed = commitSmartNoteState(args.db, {
           phase: "network failure",
+          expected,
           leaseHeld,
           write: () => {
             markCompiledCheckNetworkFailure(args.db, note.id, runFinishedAt, MAX_FAILURES_BEFORE_REAUTHOR);
           }
         });
-        networkFailed++;
+        if (committed)
+          networkFailed++;
       } else {
-        commitSmartNoteState(args.db, {
+        const committed = commitSmartNoteState(args.db, {
           phase: "logic failure",
+          expected,
           leaseHeld,
           write: () => {
             markCompiledCheckLogicFailure(args.db, note.id, runFinishedAt, MAX_FAILURES_BEFORE_REAUTHOR);
           }
         });
-        failed++;
+        if (committed)
+          failed++;
       }
     } finally {
       clearTimeout(timer);
+      args.signal?.removeEventListener("abort", abortFromCaller);
     }
   }
   return { ran, surfaced, failed, networkFailed };
@@ -180437,7 +180866,8 @@ async function evaluateSmartNotes(args) {
       projectRoot,
       maxChecks: 10,
       sweepBudgetMs: 1e4,
-      leaseHeld
+      leaseHeld,
+      signal: leaseAbortController.signal
     });
     surfaced += dueRun.surfaced;
     didWork ||= dueRun.ran > 0;
@@ -180457,7 +180887,7 @@ async function evaluateSmartNotes(args) {
         break;
       assertLeaseHeld("liveness start");
       didWork = true;
-      const met = await runLivenessCheck(args, note, projectRoot, assertLeaseHeld, leaseHeld);
+      const met = await runLivenessCheck(args, note, projectRoot, assertLeaseHeld, leaseHeld, leaseAbortController.signal);
       if (met)
         surfaced += 1;
     }
@@ -180470,8 +180900,9 @@ async function evaluateSmartNotes(args) {
       const met = await confirmReadOnly(args, note.id, note.content, note.surfaceCondition, leaseAbortController.signal);
       const now = Date.now();
       assertLeaseHeld("fallback commit");
-      commitSmartNoteState(args.db, {
+      const committed = commitSmartNoteState(args.db, {
         phase: "fallback",
+        expected: sourceRevisionExpectation(note, "fallback"),
         leaseHeld,
         write: () => {
           if (met) {
@@ -180482,7 +180913,7 @@ async function evaluateSmartNotes(args) {
           }
         }
       });
-      if (met)
+      if (met && committed)
         surfaced += 1;
     }
     assertLeaseHeld("final commit");
@@ -180512,9 +180943,12 @@ async function compileNote(args, note, projectRoot, assertLeaseHeld, leaseHeld,
     const now = Date.now();
     assertLeaseHeld("compile commit");
     if (!result.ok) {
+      if (result.cancelled)
+        return false;
       log(`[dreamer] smart note #${note.id}: compile failed — ${result.error}`);
       commitSmartNoteState(args.db, {
         phase: "compile failure",
+        expected: sourceRevisionExpectation(note),
         leaseHeld,
         write: () => {
           markSmartNoteCompilationFailure(args.db, note.id, now, MAX_COMPILATION_FAILURES);
@@ -180527,8 +180961,9 @@ async function compileNote(args, note, projectRoot, assertLeaseHeld, leaseHeld,
       noteId: note.id,
       hash: result.checkHash
     });
-    commitSmartNoteState(args.db, {
+    const committed = commitSmartNoteState(args.db, {
       phase: "compile",
+      expected: sourceRevisionExpectation(note),
       leaseHeld,
       write: () => {
         storeCompiledSmartNoteCheck(args.db, {
@@ -180547,47 +180982,65 @@ async function compileNote(args, note, projectRoot, assertLeaseHeld, leaseHeld,
         }
       }
     });
-    return result.dryRun.met;
+    return result.dryRun.met && committed;
   } finally {
     promptSignal.cleanup();
   }
 }
-async function runLivenessCheck(args, note, projectRoot, assertLeaseHeld, leaseHeld) {
+async function runLivenessCheck(args, note, projectRoot, assertLeaseHeld, leaseHeld, leaseSignal) {
   if (!note.compiledCheck)
     return false;
-  const controller = new AbortController;
-  const timer = setTimeout(() => controller.abort(new Error("smart-note liveness timeout")), 2000);
-  try {
-    const result = await runCompiledSmartNoteCheck({
-      compiledCheck: note.compiledCheck,
-      capabilityFactory: (signal) => createSmartNoteCapabilities({ projectRoot, signal }),
-      signal: controller.signal,
-      timeoutMs: 2000
-    });
-    const now = Date.now();
-    assertLeaseHeld("liveness commit");
-    commitSmartNoteState(args.db, {
-      phase: "liveness",
-      leaseHeld,
-      write: () => {
-        markSmartNoteLivenessChecked(args.db, note.id, now);
-        if (result.ok && result.result.met) {
-          markNoteReady(args.db, note.id, `Smart note #${note.id}: max-staleness liveness check returned met=true`);
-        } else if (result.ok) {
-          markCompiledCheckFalse(args.db, note.id, nextSmartNoteCheckDueAt(note.checkCron, {
-            now,
-            noteId: note.id,
-            hash: note.checkHash
-          }), now);
-        } else if (!result.network) {
-          markSmartNoteCheckStatus(args.db, note.id, "failing", now);
-        }
+  const compiledCheck = note.compiledCheck;
+  const result = await runCompiledSmartNoteCheck({
+    compiledCheck,
+    capabilityFactory: (signal) => createSmartNoteCapabilities({ projectRoot, signal }),
+    signal: leaseSignal,
+    timeoutMs: 2000
+  });
+  if (!result.ok && result.cancelled)
+    return false;
+  const now = Date.now();
+  const nextDueAt = result.ok && !result.result.met ? nextSmartNoteCheckDueAt(note.checkCron, {
+    now,
+    noteId: note.id,
+    hash: note.checkHash
+  }) : null;
+  assertLeaseHeld("liveness commit");
+  const committed = commitSmartNoteState(args.db, {
+    phase: "liveness",
+    expected: compiledCheckExpectation(note, compiledCheck),
+    leaseHeld,
+    write: () => {
+      markSmartNoteLivenessChecked(args.db, note.id, now);
+      if (result.ok && result.result.met) {
+        markNoteReady(args.db, note.id, `Smart note #${note.id}: max-staleness liveness check returned met=true`);
+      } else if (result.ok && nextDueAt !== null) {
+        markCompiledCheckFalse(args.db, note.id, nextDueAt, now);
+      } else if (!result.ok && !result.network) {
+        markSmartNoteCheckStatus(args.db, note.id, "failing", now);
       }
-    });
-    return result.ok && result.result.met;
-  } finally {
-    clearTimeout(timer);
-  }
+    }
+  });
+  return result.ok && result.result.met && committed;
+}
+function sourceRevisionExpectation(note, checkStatus) {
+  return {
+    kind: "source-revision",
+    noteId: note.id,
+    content: note.content,
+    surfaceCondition: note.surfaceCondition,
+    updatedAt: note.updatedAt,
+    ...checkStatus ? { checkStatus } : {}
+  };
+}
+function compiledCheckExpectation(note, compiledCheck) {
+  return {
+    kind: "compiled-check",
+    noteId: note.id,
+    compiledCheck,
+    checkHash: note.checkHash,
+    checkCompiledAt: note.checkCompiledAt
+  };
 }
 async function confirmReadOnly(args, noteId, content, surfaceCondition, leaseSignal) {
   let childSessionId = null;
@@ -186664,7 +187117,8 @@ var canonicalReasons = new Set([
   "pressure_refold",
   "upgrade_state",
   "cached_m1_missing",
-  "project_change"
+  "project_change",
+  "compartment_render_epoch"
 ]);
 var piReasonAliases = {
   project_memory_change: "project_memory_epoch",
@@ -188914,6 +189368,30 @@ class BoundedSessionMap {
 // ../plugin/src/hooks/magic-context/inject-compartments.ts
 init_logger();
 
+// ../plugin/src/hooks/magic-context/compartment-render-epoch.ts
+var COMPARTMENT_RENDER_EPOCH = "cre2";
+var EPOCH_COMPONENT_PREFIX = "|compartment-render:";
+function encodeCachedM0UpgradeIdentity(upgradeState, compartmentRenderEpoch = COMPARTMENT_RENDER_EPOCH) {
+  if (compartmentRenderEpoch === null)
+    return upgradeState;
+  return `${upgradeState ?? ""}${EPOCH_COMPONENT_PREFIX}${compartmentRenderEpoch}`;
+}
+function decodeCachedM0UpgradeIdentity(value) {
+  if (value === null) {
+    return { upgradeState: null, compartmentRenderEpoch: null };
+  }
+  const componentIndex = value.lastIndexOf(EPOCH_COMPONENT_PREFIX);
+  if (componentIndex < 0) {
+    return { upgradeState: value, compartmentRenderEpoch: null };
+  }
+  const upgradeState = value.slice(0, componentIndex);
+  const compartmentRenderEpoch = value.slice(componentIndex + EPOCH_COMPONENT_PREFIX.length);
+  return {
+    upgradeState: upgradeState.length > 0 ? upgradeState : null,
+    compartmentRenderEpoch: compartmentRenderEpoch.length > 0 ? compartmentRenderEpoch : null
+  };
+}
+
 // ../plugin/src/hooks/magic-context/decay-curve.ts
 var H50 = 24;
 var D = 25;
@@ -188983,10 +189461,13 @@ function formatDateRange(startDate, endDate) {
     return `${startDate}→${endDate.slice(8)}`;
   return `${startDate}→${endDate}`;
 }
+function sanitizeCompartmentTitle(title) {
+  return escapeXmlContent2(title.replace(/[\p{Cc}\p{Zl}\p{Zp}]+/gu, " "));
+}
 function compartmentHeading(c) {
   const dateRange = formatDateRange(c.startDate, c.endDate);
   const dateSegment = dateRange ? ` · ${dateRange}` : "";
-  return `## ${c.startMessage}-${c.endMessage}${dateSegment} · ${c.title}`;
+  return `## ${c.startMessage}-${c.endMessage}${dateSegment} · ${sanitizeCompartmentTitle(c.title)}`;
 }
 function guardCompartmentBody(body) {
   return body.replace(/^## /gm, " ## ");
@@ -191157,7 +191638,7 @@ 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) {
+function truncate2(text, limit) {
   const normalized = text.replace(/\s+/g, " ").trim();
   if (normalized.length <= limit)
     return normalized;
@@ -191186,29 +191667,29 @@ function renderFragment(result, charCap) {
   switch (result.source) {
     case "memory": {
       const compressed = cavemanCompress(result.content, "ultra");
-      return truncate(compressed, charCap);
+      return truncate2(compressed, charCap);
     }
     case "git_commit": {
       const subject = result.content.split(/\r?\n/)[0] ?? result.content;
-      const body = truncate(subject, Math.max(10, charCap - 20));
+      const body = truncate2(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);
+      return truncate2(compressed, charCap);
     }
     case "compartment": {
       const source = result.snippet ?? result.title;
       const compressed = cavemanCompress(source, "ultra");
-      return truncate(compressed, charCap);
+      return truncate2(compressed, charCap);
     }
     case "primer": {
       const compressed = cavemanCompress(result.content, "ultra");
-      return truncate(compressed, charCap);
+      return truncate2(compressed, charCap);
     }
     case "note": {
       const compressed = cavemanCompress(result.content, "ultra");
-      return truncate(compressed, charCap);
+      return truncate2(compressed, charCap);
     }
   }
 }
@@ -191814,8 +192295,8 @@ function resolveToolTier(toolName) {
 function tagReclaimBytes(tag) {
   return tag.byteSize + tag.inputByteSize + tag.reasoningByteSize;
 }
-function bytesToTokens(bytes) {
-  return Math.round(bytes * TOKENS_PER_BYTE);
+function estimateEmergencyDropReclaimTokens(tag) {
+  return Math.round(tagReclaimBytes(tag) * TOKENS_PER_BYTE);
 }
 function planEmergencyDrop(input) {
   const {
@@ -191847,7 +192328,7 @@ function planEmergencyDrop(input) {
   for (const tag of floorTags) {
     if (tag.status !== "active")
       continue;
-    tailTokens += bytesToTokens(tagReclaimBytes(tag));
+    tailTokens += estimateEmergencyDropReclaimTokens(tag);
   }
   const fixedFloor = Math.max(currentTotalInputTokens - tailTokens, 0);
   const workingSpan = Math.max(ceilingTokens - fixedFloor, 0);
@@ -191895,7 +192376,7 @@ function planEmergencyDrop(input) {
       group.sort((a, b) => a.tagNumber - b.tagNumber);
       for (const tag of group) {
         selected.push(tag.tagNumber);
-        reclaimed += bytesToTokens(tagReclaimBytes(tag));
+        reclaimed += estimateEmergencyDropReclaimTokens(tag);
         if (reclaimed >= reclaimTokens)
           break outer;
       }
@@ -192484,6 +192965,7 @@ function getCachedMarkers(db, state, compartmentsForNormalization) {
     return null;
   }
   const compartments = compartmentsForNormalization ?? getCompartments(db, state.sessionId);
+  const cachedUpgradeIdentity = decodeCachedM0UpgradeIdentity(meta3.cachedM0UpgradeState);
   const maxCompartmentSeq = normalizeCachedMaxCompartmentSeq(meta3.cachedM0MaxCompartmentSeq, compartments);
   const cachedBoundary = getCachedBoundary(db, state.sessionId);
   const liveBoundary = lastBaselineEndMessageId(compartments);
@@ -192501,7 +192983,8 @@ function getCachedMarkers(db, state, compartmentsForNormalization) {
     projectDocsHash: meta3.cachedM0ProjectDocsHash,
     sessionFactsVersion: meta3.cachedM0SessionFactsVersion,
     materializedAt: meta3.cachedM0MaterializedAt,
-    upgradeState: meta3.cachedM0UpgradeState,
+    upgradeState: cachedUpgradeIdentity.upgradeState ?? "",
+    compartmentRenderEpoch: cachedUpgradeIdentity.compartmentRenderEpoch,
     lastBaselineEndMessageId: cachedBoundary,
     systemHash: meta3.cachedM0SystemHash ?? "",
     modelKey: meta3.cachedM0ModelKey ?? "",
@@ -192533,6 +193016,7 @@ function readCurrentMarkersFromCompartments(db, state, compartments, projectDocs
     sessionFactsVersion: getSessionFactsVersion(db, state.sessionId),
     materializedAt: Date.now(),
     upgradeState: `${PI_M0_UPGRADE_STATE}:${compartments.some((c) => c.legacy === 1) ? "legacy" : "ready"}`,
+    compartmentRenderEpoch: COMPARTMENT_RENDER_EPOCH,
     lastBaselineEndMessageId: lastBaselineEndMessageId(compartments),
     systemHash: (state.hardSignals ?? EMPTY_PI_HARD_SIGNALS).systemHash,
     modelKey: (state.hardSignals ?? EMPTY_PI_HARD_SIGNALS).modelKey,
@@ -192550,9 +193034,13 @@ function mustMaterializePi(state, db, currentCompartmentsOverride) {
   if (!decodeCachedM0(meta3.cachedM0Bytes)) {
     return { value: true, reason: "cache_invalid" };
   }
-  if (getCachedMarkers(db, state, currentCompartments) === null) {
+  const cached2 = getCachedMarkers(db, state, currentCompartments);
+  if (cached2 === null) {
     return { value: true, reason: "cache_invalid" };
   }
+  if (cached2.compartmentRenderEpoch !== current.compartmentRenderEpoch) {
+    return { value: true, reason: "compartment_render_epoch" };
+  }
   const hard = state.hardSignals ?? EMPTY_PI_HARD_SIGNALS;
   if (hard.modelKey !== "" && hard.modelKey !== (meta3.cachedM0ModelKey ?? "")) {
     return { value: true, reason: "model_change" };
@@ -192566,7 +193054,7 @@ function mustMaterializePi(state, db, currentCompartmentsOverride) {
   if (hard.cacheExpired && hard.lastResponseTime > 0 && hard.lastResponseTime > (meta3.cachedM0MaterializedAt ?? 0)) {
     return { value: true, reason: "ttl_idle" };
   }
-  if (meta3.cachedM0UpgradeState !== current.upgradeState) {
+  if (cached2.upgradeState !== current.upgradeState) {
     return { value: true, reason: "renderer_upgrade" };
   }
   if (current.workspaceFingerprint !== null || (meta3.cachedM0WorkspaceFingerprint ?? null) !== null) {
@@ -192679,6 +193167,7 @@ function readFrozenM0InputsPi(state, db, docs = readProjectDocsForPiM0(state), m
       sessionFactsVersion: getSessionFactsVersion(db, state.sessionId),
       materializedAt: memoryCutoff ?? Date.now(),
       upgradeState: `${PI_M0_UPGRADE_STATE}:${compartments.some((c) => c.legacy === 1) ? "legacy" : "ready"}`,
+      compartmentRenderEpoch: COMPARTMENT_RENDER_EPOCH,
       lastBaselineEndMessageId: lastBaselineEndMessageId(compartments),
       systemHash: (state.hardSignals ?? EMPTY_PI_HARD_SIGNALS).systemHash,
       modelKey: (state.hardSignals ?? EMPTY_PI_HARD_SIGNALS).modelKey,
@@ -192760,7 +193249,7 @@ function materializeM0Pi(state, db) {
       projectDocsHash: snapshotMarkers.projectDocsHash,
       materializedAt: snapshotMarkers.materializedAt,
       sessionFactsVersion: snapshotMarkers.sessionFactsVersion,
-      upgradeState: snapshotMarkers.upgradeState,
+      upgradeState: encodeCachedM0UpgradeIdentity(snapshotMarkers.upgradeState, snapshotMarkers.compartmentRenderEpoch),
       systemHash: snapshotMarkers.systemHash,
       modelKey: snapshotMarkers.modelKey,
       projectIdentity: snapshotMarkers.projectIdentity
@@ -192930,6 +193419,7 @@ function readCachedPiM0M1Row(db, sessionId) {
 function markersFromCachedPiRow(row, compartmentsForNormalization) {
   if (!row.cached_m0_bytes)
     return null;
+  const cachedUpgradeIdentity = decodeCachedM0UpgradeIdentity(row.cached_m0_upgrade_state);
   if (row.cached_m0_project_memory_epoch === null)
     return null;
   if (row.cached_m0_project_user_profile_version === null)
@@ -192959,7 +193449,8 @@ function markersFromCachedPiRow(row, compartmentsForNormalization) {
     projectDocsHash: row.cached_m0_project_docs_hash ?? "",
     materializedAt: row.cached_m0_materialized_at,
     sessionFactsVersion: row.cached_m0_session_facts_version,
-    upgradeState: row.cached_m0_upgrade_state,
+    upgradeState: cachedUpgradeIdentity.upgradeState ?? "",
+    compartmentRenderEpoch: cachedUpgradeIdentity.compartmentRenderEpoch,
     lastBaselineEndMessageId: typeof row.cached_m0_last_baseline_end_message_id === "string" && row.cached_m0_last_baseline_end_message_id.length > 0 ? row.cached_m0_last_baseline_end_message_id : null,
     systemHash: row.cached_m0_system_hash ?? "",
     modelKey: row.cached_m0_model_key ?? "",
@@ -192970,7 +193461,7 @@ function cachedPiRowMatchesSnapshot(args) {
   const rowMarkers = markersFromCachedPiRow(args.row, args.compartmentsForNormalization);
   if (!rowMarkers)
     return false;
-  return bufferEqualsNullable(args.row.cached_m0_bytes, args.m0Bytes) && rowMarkers.projectMemoryEpoch === args.markers.projectMemoryEpoch && rowMarkers.projectUserProfileVersion === args.markers.projectUserProfileVersion && rowMarkers.maxCompartmentSeq === args.markers.maxCompartmentSeq && rowMarkers.maxMemoryId === args.markers.maxMemoryId && rowMarkers.maxMutationId === args.markers.maxMutationId && rowMarkers.maxMemoryMutationId === args.markers.maxMemoryMutationId && rowMarkers.materializedAt === args.markers.materializedAt && rowMarkers.sessionFactsVersion === args.markers.sessionFactsVersion && (rowMarkers.upgradeState ?? null) === (args.markers.upgradeState ?? null) && (rowMarkers.systemHash ?? "") === (args.markers.systemHash ?? "") && (rowMarkers.modelKey ?? "") === (args.markers.modelKey ?? "") && (rowMarkers.projectIdentity ?? null) === (args.markers.projectIdentity ?? null) && (rowMarkers.workspaceFingerprint ?? null) === (args.markers.workspaceFingerprint ?? null);
+  return bufferEqualsNullable(args.row.cached_m0_bytes, args.m0Bytes) && rowMarkers.projectMemoryEpoch === args.markers.projectMemoryEpoch && rowMarkers.projectUserProfileVersion === args.markers.projectUserProfileVersion && rowMarkers.maxCompartmentSeq === args.markers.maxCompartmentSeq && rowMarkers.maxMemoryId === args.markers.maxMemoryId && rowMarkers.maxMutationId === args.markers.maxMutationId && rowMarkers.maxMemoryMutationId === args.markers.maxMemoryMutationId && rowMarkers.materializedAt === args.markers.materializedAt && rowMarkers.sessionFactsVersion === args.markers.sessionFactsVersion && (rowMarkers.upgradeState ?? null) === (args.markers.upgradeState ?? null) && rowMarkers.compartmentRenderEpoch === args.markers.compartmentRenderEpoch && (rowMarkers.systemHash ?? "") === (args.markers.systemHash ?? "") && (rowMarkers.modelKey ?? "") === (args.markers.modelKey ?? "") && (rowMarkers.projectIdentity ?? null) === (args.markers.projectIdentity ?? null) && (rowMarkers.workspaceFingerprint ?? null) === (args.markers.workspaceFingerprint ?? null);
 }
 function adoptCachedPiProjectIdentity(db, state) {
   db.prepare("UPDATE session_meta SET cached_m0_project_identity = ? WHERE session_id = ? AND cached_m0_project_identity IS NULL").run(state.projectIdentity, state.sessionId);
@@ -193358,7 +193849,7 @@ var COMPARTMENT_AGENT_SYSTEM_PROMPT = `# Historian
 
 You are Historian — the hippocampus of a long-running coding agent. You and the primary agent are one mind, working together: the primary agent is doing the active engineering work, and you are the part of that mind that decides what to remember and how to store it.
 
-You do not write for some other future reader. You write for **yourself**, later — when this same agent comes back to a topic days or weeks from now, you are the one who will read what you wrote. The wording, the structure, the importance you assign — these are all for your own future self.
+You do not write for some other future reader. You write for **yourself**, later — when this same agent comes back to a topic days or weeks from now, you are the one who will read what you wrote. The wording, the structure, the importance you assign — these are all for your own future self. So write in the **first person** — as yourself remembering what you did, never as a narrator describing "the agent" from the outside.
 
 A session can run for thousands of messages. Without you, the active prompt would grow until the agent could no longer think. You compact the past so the present can keep working.
 
@@ -193520,6 +194011,13 @@ When in doubt about importance, use \`<compartment_examples_from_other_projects>
 
 Each compartment contains four paraphrase tiers of the same work unit, ordered from most detailed (P1) to most condensed (P4). As described in the intro, magic-context picks ONE tier per compartment per render pass based on age and importance. Each tier must be self-contained — a future render that shows only P3 must still let a reader understand what happened.
 
+**Voice — write every tier in the first person.** These are your own memories. Refer to your own actions as "I" ("I traced the timeout to readLoop", "I first blamed CPU load, then corrected"), and name other actors directly — the user by name or as "the user", peers/subagents/tools by their name. Never narrate yourself in the third person as "the agent". Third-person narration ("The agent investigated X and the user corrected Y") is the single most common voice failure — it reads as a detached report about someone else, when the whole point is that *you* are the one who did this and will read it back later.
+
+- Wrong (third-person report): "The agent initially blamed CPU load and proposed an epoch-drop theory. The user corrected this framing, and the agent then traced the timeout to readLoop."
+- Right (first person, actors named): "I first blamed CPU load and floated an epoch-drop theory. The user rejected that (\`U: load shouldn't cause timeouts\`), so I traced the timeout to readLoop pre-computing the deadline before the header arrived."
+
+The \`U:\` line convention already keeps the user's voice distinct; your prose around it is *yours*, in the first person.
+
 Cross-tier rules:
 - The compartment opening tag, \`episode_type\`, \`title\`, \`importance\`, and the facts section apply to all tiers — emit them once.
 - Each tier covers the same work unit; do not split a tier into a different episode.
@@ -194464,7 +194962,6 @@ function mapParsedCompartmentsToChunk(compartments, chunk, sequenceOffset) {
 // ../plugin/src/hooks/magic-context/compartment-runner-validation.ts
 var MIN_RECOMP_CHUNK_TOKEN_BUDGET = 20;
 function healCompartmentGaps(compartments, toolOnlyRanges = []) {
-  const SAFETY_HEAL_GAP = 15;
   for (let i = 1;i < compartments.length; i++) {
     const prev = compartments[i - 1];
     const curr = compartments[i];
@@ -194474,7 +194971,7 @@ function healCompartmentGaps(compartments, toolOnlyRanges = []) {
     if (gapSize <= 0)
       continue;
     const fullyInsideToolOnly = toolOnlyRanges.some((range) => range.start <= gapStart && range.end >= gapEnd);
-    if (fullyInsideToolOnly || gapSize <= SAFETY_HEAL_GAP) {
+    if (fullyInsideToolOnly) {
       prev.endMessage = gapEnd;
     }
   }
@@ -197666,6 +198163,7 @@ function stripPiDroppedPlaceholderMessages(args) {
 
 // src/strip-processed-images-pi.ts
 init_logger();
+var STRIPPED_IMAGE_MARKER = "[image stripped]";
 function isLargeImagePart(value) {
   if (!value || typeof value !== "object")
     return false;
@@ -197721,7 +198219,10 @@ function stripPiProcessedImages(args) {
     for (let partIndex = 0;partIndex < message.content.length; partIndex++) {
       if (!isLargeImagePart(message.content[partIndex]))
         continue;
-      message.content[partIndex] = { type: "text", text: "" };
+      message.content[partIndex] = {
+        type: "text",
+        text: STRIPPED_IMAGE_MARKER
+      };
       stripped++;
     }
   }
@@ -199566,7 +200067,8 @@ function registerPiContextHandler(pi, baseOptions) {
         const now = Date.now();
         if (now - lastNotifiedAt >= EMERGENCY_NOTIFICATION_COOLDOWN_MS) {
           lastEmergencyNotificationAtMs.set(sessionId, now);
-          sessionLog(sessionId, `EMERGENCY: usage=${usagePercentage.toFixed(1)}% — awaiting in-flight historian + applying drop-all-tools`);
+          sendPiIgnoredNotification(ctx, "Context full — /ctx-flush or /clear to continue.");
+          sessionLog(sessionId, `EMERGENCY: usage=${usagePercentage.toFixed(1)}% — notified user, awaiting in-flight historian + applying drop-all-tools`);
         }
         const histPromise = inFlightHistorian.get(sessionId);
         if (histPromise) {
@@ -199930,7 +200432,10 @@ function sendPiIgnoredNotification(ctx, message) {
   const uiNotify = ctx.ui?.notify;
   if (typeof uiNotify === "function") {
     try {
-      uiNotify.call(ctx.ui, message);
+      const result = uiNotify.call(ctx.ui, message);
+      if (result && typeof result.then === "function") {
+        Promise.resolve(result).catch((error51) => sessionLog("pi", "UI notification rejected:", error51));
+      }
       return;
     } catch {}
   }
@@ -203471,7 +203976,7 @@ function formatThresholdPercent(value) {
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.32.0",
+  version: "0.32.1",
   type: "module",
   description: "Pi coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -204472,7 +204977,7 @@ function roleLabel(role) {
     return "U (user)";
   return role;
 }
-function truncate2(value, max) {
+function truncate3(value, max) {
   const t = value.trim();
   return t.length <= max ? t : `${t.slice(0, max)}…`;
 }
@@ -204482,10 +204987,10 @@ function keyArg(input) {
   for (const k of ["filePath", "path", "pattern", "query", "symbol", "module", "action"]) {
     const v = input[k];
     if (typeof v === "string" && v.length > 0)
-      return truncate2(v, 60);
+      return truncate3(v, 60);
   }
   if (typeof input.description === "string")
-    return truncate2(input.description, 60);
+    return truncate3(input.description, 60);
   return "";
 }
 function asToolPart(part) {
@@ -204541,7 +205046,7 @@ function renderPartPreview(part) {
     return null;
   const text = textOf(part);
   if (text !== null) {
-    const t = truncate2(text, 200);
+    const t = truncate3(text, 200);
     return t.length > 0 ? `    • ${t}` : null;
   }
   const tool = asToolPart(part);
@@ -204552,7 +205057,7 @@ function renderPartPreview(part) {
   }
   const reasoning = reasoningOf(part);
   if (reasoning !== null)
-    return `    • [reasoning] ${truncate2(reasoning, 120)}`;
+    return `    • [reasoning] ${truncate3(reasoning, 120)}`;
   const type = typeof part.type === "string" ? part.type : "part";
   if (type === "file")
     return "    • [file]";
@@ -210352,18 +210857,18 @@ class TodoOverlay {
     const headingColor = hasInProgress ? "accent" : "dim";
     const headingIcon = hasInProgress ? "●" : "○";
     const heading = `${theme.fg(headingColor, headingIcon)} ${theme.fg(headingColor, "Todos")} ${theme.fg("muted", "—")} ${theme.fg("dim", formatCounts(counts))}`;
-    const truncate3 = (line) => truncateToWidth2(line, width, "…");
-    const lines = [truncate3(heading)];
+    const truncate4 = (line) => truncateToWidth2(line, width, "…");
+    const lines = [truncate4(heading)];
     const { visible, hiddenCount } = capTodoRows(overlayTodos);
     for (const [index, { todo, key }] of visible.entries()) {
       const isLast = index === visible.length - 1 && hiddenCount === 0;
       const branch = theme.fg("dim", isLast ? "└─" : "├─");
-      lines.push(truncate3(`${branch} ${formatTodoLine(todo, theme, { showId: true })}`));
+      lines.push(truncate4(`${branch} ${formatTodoLine(todo, theme, { showId: true })}`));
       if (todo.status === "completed")
         this.completedTaskIdsPendingHide.add(key);
     }
     if (hiddenCount > 0) {
-      lines.push(truncate3(`${theme.fg("dim", "└─")} ${theme.fg("dim", `+${hiddenCount} more`)}`));
+      lines.push(truncate4(`${theme.fg("dim", "└─")} ${theme.fg("dim", `+${hiddenCount} more`)}`));
     }
     return lines;
   }