@cortexkit/pi-magic-context 0.32.0 → 0.32.1

package/dist/subagent-entry.js

@@ -8128,11 +8128,11 @@ function buildNodeSqliteDatabaseClass(DatabaseSync) {
     }
     transaction(fn) {
       const self = this;
-      const wrapped = function(...args) {
+      const execute = (mode, receiver, args) => {
         const nested = self.isTransaction === true;
-        self.exec(nested ? `SAVEPOINT ${SAVEPOINT}` : "BEGIN");
+        self.exec(nested ? `SAVEPOINT ${SAVEPOINT}` : `BEGIN${mode ? ` ${mode}` : ""}`);
         try {
-          const result = fn.apply(this, args);
+          const result = fn.apply(receiver, args);
           self.exec(nested ? `RELEASE ${SAVEPOINT}` : "COMMIT");
           return result;
         } catch (error) {
@@ -8145,6 +8145,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;
     }
   }
@@ -8188,10 +8203,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 = [
@@ -8220,10 +8241,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) {
@@ -8254,10 +8276,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);
   }
 }
 
@@ -10209,6 +10232,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);
@@ -10238,40 +10289,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/shared/commit-detection.ts
@@ -143025,7 +143081,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,
@@ -143033,7 +143090,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) {
@@ -143053,13 +143110,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);
@@ -143143,7 +143196,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;
@@ -143193,7 +143246,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) {
   mkdirSync3(dir, { recursive: true, mode: 448 });
@@ -143886,6 +143939,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,
@@ -144119,6 +144183,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");
@@ -159576,10 +159641,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)) {
@@ -159591,14 +159656,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;
 }
 
@@ -160842,22 +160907,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);
@@ -161161,12 +161210,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");
@@ -162091,22 +162134,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);
@@ -162126,12 +162153,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,
@@ -162204,24 +162225,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());
@@ -162242,12 +162245,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();
@@ -162549,6 +162546,7 @@ function invalidateMemory(projectPath, memoryId) {
 }
 
 // ../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;
@@ -162570,9 +162568,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;
@@ -162610,7 +162613,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) {
@@ -162626,6 +162629,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;
@@ -162854,6 +162858,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 = {
@@ -162868,24 +162921,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");
@@ -162895,9 +162969,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) {
@@ -163117,16 +163190,27 @@ async function drainCommitBacklogForProject(db, projectIdentity, deadline) {
     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;
@@ -163237,9 +163321,19 @@ async function embedSessionCompartmentChunks(db, projectIdentity, sessionId, opt
   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?.();
@@ -163253,7 +163347,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;
       }
@@ -163264,7 +163358,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)
@@ -163284,6 +163384,7 @@ async function embedSessionCompartmentChunks(db, projectIdentity, sessionId, opt
     }
   } finally {
     clearInterval(renewal);
+    options?.signal?.removeEventListener("abort", forwardCallerAbort);
     try {
       releaseGitSweepLease(db, projectIdentity, holderId);
     } catch (error51) {
@@ -164199,6 +164300,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 placeholders2 = messageRows.map(() => "?").join(", ");
+  const partRows = db.prepare(`SELECT message_id, data, time_updated
+             FROM part
+             WHERE session_id = ? AND message_id IN (${placeholders2})
+             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";
 }
@@ -164506,6 +164667,31 @@ function readRawSessionMessages(sessionId) {
   }
   return readRawSessionMessagesFromSource(sessionId);
 }
+function readRawSessionMessagePage(sessionId, afterOrdinal, limit, finalWatermark) {
+  const provider2 = sessionProviders.get(sessionId);
+  if (provider2?.readMessagePage) {
+    return provider2.readMessagePage(afterOrdinal, limit, finalWatermark);
+  }
+  if (provider2) {
+    return provider2.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 provider2 = sessionProviders.get(sessionId);
+  if (provider2) {
+    if (provider2.getMessageCount)
+      return provider2.getMessageCount();
+    return provider2.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)
@@ -170663,11 +170849,10 @@ async function normalizeVerificationFiles(args) {
 // ../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) {
@@ -170689,19 +170874,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;
 }
@@ -170713,27 +170890,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);
+function getDeleteFtsRangeStatement(db) {
+  let stmt = deleteFtsRangeStatements.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);
-  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;
 }
@@ -170761,16 +170922,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") {
@@ -170785,22 +170947,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");
@@ -170818,38 +170979,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 {
@@ -171990,13 +172157,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);
@@ -172004,19 +172175,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);
     }
   })();
 }
@@ -172024,9 +172198,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);
     }
   })();
 }
@@ -175768,6 +175942,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;
@@ -175837,10 +176035,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, " ## ");