@cortexkit/pi-magic-context 0.31.5 → 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;
 }
 
@@ -159849,8 +159914,11 @@ var MagicContextConfigSchema = exports_external.object({
     provider: "local",
     model: DEFAULT_LOCAL_EMBEDDING_MODEL
   }).describe("Embedding provider configuration"),
-  temporal_awareness: exports_external.boolean().default(true).describe('Inject wall-clock gap markers (<!-- +Xm -->) between user messages where > 5 min elapsed since the previous message, and add start/end date attributes on compartments. Gives the agent a sense of session pacing and "how long ago" across multi-day sessions. Graduated from experimental.temporal_awareness; default: true (set false to opt out).'),
+  temporal_awareness: exports_external.boolean().default(true).describe('Inject wall-clock gap markers (<!-- +Xm -->) between user messages where > 5 min elapsed since the previous message, and add compact date ranges to compartment headings. Gives the agent a sense of session pacing and "how long ago" across multi-day sessions. Graduated from experimental.temporal_awareness; default: true (set false to opt out).'),
   keep_subagents: exports_external.boolean().default(false).describe("Debug: keep the child sessions Magic Context spawns for its own subagents (historian, dreamer, sidekick, memory-migration) instead of deleting them on success. Useful for short-term inspection/data collection — their full transcript (prompt, tool calls, token usage, output) stays in the host session store. Kept sessions accumulate until manually cleared; leave false for normal use. Requires a restart to take effect."),
+  shadow_transform: exports_external.object({
+    enabled: exports_external.boolean().default(false).describe("Dev flag: mirror every transform pass to the Magic Context Rust module over subc and byte-compare outputs. No behavior impact; default off.")
+  }).default({ enabled: false }).describe("Developer-only shadow transform lane. When enabled, the plugin fire-and-forgets a copy of each finalized transform to the Rust module for comparison; the live output is unchanged."),
   todowrite: exports_external.object({
     enabled: exports_external.boolean().default(true).describe("Pi only: register Magic Context's todowrite task-list tool. Disable if you use your own todo extension. OpenCode ships its own built-in todowrite; this setting has no effect there."),
     overlay: exports_external.boolean().default(true).describe("Pi only: show the persistent todo overlay above the editor while tasks are active.")
@@ -160007,6 +160075,10 @@ function stripUnsafeProjectConfigFields(projectRaw) {
     delete projectRaw.sqlite;
     warnings.push("Ignoring sqlite.* from project config (security: SQLite cache/mmap PRAGMAs apply to the " + "process-global shared database handle; only user-level config may set them).");
   }
+  if ("shadow_transform" in projectRaw) {
+    delete projectRaw.shadow_transform;
+    warnings.push("Ignoring shadow_transform from project config (security: this developer-only mirror lane is user-level only).");
+  }
   const embedding = projectRaw.embedding;
   if (isPlainObject3(embedding)) {
     const removed = [];
@@ -160679,6 +160751,9 @@ function loadPiConfigDetailed(opts = {}) {
   };
 }
 
+// src/embedding-bootstrap.ts
+import { statSync as statSync3 } from "node:fs";
+
 // ../plugin/src/features/magic-context/memory/embedding.ts
 init_logger();
 
@@ -160832,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);
@@ -161151,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");
@@ -162081,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);
@@ -162116,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,
@@ -162194,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());
@@ -162232,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();
@@ -162539,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;
@@ -162560,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;
@@ -162600,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) {
@@ -162616,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;
@@ -162844,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 = {
@@ -162858,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");
@@ -162885,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) {
@@ -163107,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;
@@ -163227,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?.();
@@ -163243,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;
       }
@@ -163254,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)
@@ -163274,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) {
@@ -163471,8 +163582,38 @@ function handleUntrustedLoad(db, projectIdentity, directory, detailed) {
 }
 
 // src/embedding-bootstrap.ts
+var registrationFingerprintsByDatabase = new WeakMap;
+function configCandidatePaths(directory, loadedPaths) {
+  const projectBase = cortexKitProjectConfigBasePath(directory);
+  const userBase = cortexKitUserConfigBasePath();
+  return [
+    `${projectBase}.jsonc`,
+    `${projectBase}.json`,
+    `${userBase}.jsonc`,
+    `${userBase}.json`,
+    ...loadedPaths
+  ].filter((path4, index, paths) => paths.indexOf(path4) === index);
+}
+function configFingerprint(paths) {
+  return paths.map((path4) => {
+    try {
+      const stat2 = statSync3(path4);
+      return `${path4}:${stat2.size}:${stat2.mtimeMs}`;
+    } catch {
+      return `${path4}:missing`;
+    }
+  }).join("|");
+}
 async function ensureProjectRegisteredFromPiDirectory(directory, db) {
   const projectIdentity = resolveProjectIdentity(directory);
+  let registrationFingerprints = registrationFingerprintsByDatabase.get(db);
+  if (!registrationFingerprints) {
+    registrationFingerprints = new Map;
+    registrationFingerprintsByDatabase.set(db, registrationFingerprints);
+  }
+  const cached2 = registrationFingerprints.get(projectIdentity);
+  if (cached2 && configFingerprint(cached2.paths) === cached2.fingerprint)
+    return;
   const detailed = loadPiConfigDetailed({ cwd: directory });
   if (isConfigLoadUntrusted(detailed)) {
     handleUntrustedLoad(db, projectIdentity, directory, detailed);
@@ -163483,6 +163624,11 @@ async function ensureProjectRegisteredFromPiDirectory(directory, db) {
     gitCommitEnabled: detailed.config.memory.git_commit_indexing.enabled
   };
   registerProjectEmbedding(db, projectIdentity, detailed.config.embedding, features, directory);
+  const fingerprintPaths = configCandidatePaths(directory, detailed.loadedFromPaths);
+  registrationFingerprints.set(projectIdentity, {
+    paths: fingerprintPaths,
+    fingerprint: configFingerprint(fingerprintPaths)
+  });
 }
 // ../plugin/src/features/magic-context/compartment-lease.ts
 var COMPARTMENT_LEASE_TTL_MS = 5 * 60 * 1000;
@@ -164102,6 +164248,12 @@ function parseJsonRecord(value) {
     return null;
   }
 }
+function isRawCompactionSummaryInfo(info) {
+  if (info === null || typeof info !== "object" || Array.isArray(info))
+    return false;
+  const candidate = info;
+  return candidate.summary === true && candidate.finish === "stop";
+}
 function parseJsonUnknown(value) {
   try {
     return JSON.parse(value);
@@ -164124,7 +164276,7 @@ function attachRawPartVersion(value, timeUpdated) {
   return value;
 }
 function readRawSessionMessagesFromDb(db, sessionId) {
-  const messageRows = db.prepare("SELECT id, data, time_updated FROM message WHERE session_id = ? ORDER BY time_created ASC, id ASC").all(sessionId).filter(isRawMessageRow);
+  const messageRows = db.prepare("SELECT id, data, time_created, time_updated FROM message WHERE session_id = ? ORDER BY time_created ASC, id ASC").all(sessionId).filter(isRawMessageRow);
   const partRows = db.prepare("SELECT message_id, data, time_updated FROM part WHERE session_id = ? ORDER BY time_created ASC, id ASC").all(sessionId).filter(isRawPartRow);
   const partsByMessageId = new Map;
   for (const part of partRows) {
@@ -164132,10 +164284,7 @@ function readRawSessionMessagesFromDb(db, sessionId) {
     list.push(attachRawPartVersion(parseJsonUnknown(part.data), part.time_updated));
     partsByMessageId.set(part.message_id, list);
   }
-  const filtered = messageRows.filter((row) => {
-    const info = parseJsonRecord(row.data);
-    return !(info?.summary === true && info?.finish === "stop");
-  });
+  const filtered = messageRows.filter((row) => !isRawCompactionSummaryInfo(parseJsonRecord(row.data)));
   return filtered.flatMap((row, index) => {
     const info = parseJsonRecord(row.data);
     if (!info)
@@ -164146,10 +164295,71 @@ function readRawSessionMessagesFromDb(db, sessionId) {
       id: row.id,
       role,
       parts: partsByMessageId.get(row.id) ?? [],
+      createdAt: row.time_created ?? null,
+      version: row.time_updated ?? null
+    };
+  });
+}
+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";
 }
@@ -164160,7 +164370,7 @@ function readRawSessionTailFromDb(db, sessionId, baseOrdinal, anchorMessageId) {
   const anchorInfo = parseJsonRecord(anchorRow.data ?? "");
   if (anchorInfo?.summary === true && anchorInfo?.finish === "stop")
     return null;
-  const messageRows = db.prepare(`SELECT id, data, time_updated FROM message
+  const messageRows = db.prepare(`SELECT id, data, time_created, time_updated FROM message
              WHERE session_id = ?
                AND (time_created > ? OR (time_created = ? AND id >= ?))
              ORDER BY time_created ASC, id ASC`).all(sessionId, anchorRow.time_created, anchorRow.time_created, anchorRow.id).filter(isRawMessageRow);
@@ -164196,6 +164406,7 @@ function readRawSessionTailFromDb(db, sessionId, baseOrdinal, anchorMessageId) {
       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
     });
     ord += 1;
@@ -164456,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)
@@ -164714,9 +164950,9 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
 // ../plugin/src/tools/ctx-expand/constants.ts
 var CTX_EXPAND_DESCRIPTION = `Recover the original conversation from your compacted history.
 
-Older parts of this session are summarized into <compartment> blocks inside <session-history> — e.g. <compartment start="120" end="245" title="Fixed tagger collision">. Each one replaces the raw messages in that ordinal range with a summary. When the summary isn't enough — you need exact wording, a specific value, an error message, or the reasoning behind a decision — expand the range:
+Older parts of this session are summarized under \`## start-end · date · title\` headings inside <session-history> — e.g. \`## 120-245 · … · Fixed tagger collision\`. Each heading replaces the raw messages in that ordinal range with a summary. When the summary isn't enough — you need exact wording, a specific value, an error message, or the reasoning behind a decision — expand the range:
 
-ctx_expand(start=120, end=245)  ← the compartment's own start/end attributes
+ctx_expand(start=120, end=245)  ← the heading's start/end range
 
 Returns the raw transcript as [N] U:/A: lines, capped at ~15K tokens; an oversized range returns the head and tells you where to continue. Also works with ordinals from ctx_search message results — expand a window around a hit (e.g. start=N-10, end=N+5). Ranges after the last compartment are your live tail — already visible in context, not expandable.
 
@@ -169128,7 +169364,7 @@ function resolvePiStableId(msg, index, entryIds, entryIdByRef) {
   const role = m.role ?? "unknown";
   return typeof m.timestamp === "number" ? `pi-msg-${index}-${m.timestamp}-${role}` : `pi-msg-${index}-${role}`;
 }
-function isMidTurnPi(event, _sessionId) {
+function isMidTurnPi(event, _sessionId, branchEntries) {
   const messages = event?.messages;
   if (!Array.isArray(messages))
     return false;
@@ -169147,7 +169383,7 @@ function isMidTurnPi(event, _sessionId) {
   }
   if (latestAssistant === null)
     return false;
-  if (hasRealUserAfter(messages, latestAssistantIndex))
+  if (hasRealUserAfter(messages, latestAssistantIndex, branchEntries))
     return false;
   if (latestAssistant.stopReason === "toolUse")
     return true;
@@ -169171,12 +169407,27 @@ function isMidTurnPi(event, _sessionId) {
   }
   return false;
 }
-function hasRealUserAfter(messages, latestAssistantIndex) {
-  for (const msg of messages.slice(latestAssistantIndex + 1)) {
-    if (msg === null || typeof msg !== "object")
+function hasRealUserAfter(messages, latestAssistantIndex, branchEntries) {
+  if (!branchEntries)
+    return false;
+  const genuineUserMessages = new Set;
+  for (const entry of branchEntries) {
+    if (entry === null || typeof entry !== "object")
       continue;
-    if (msg.role === "user")
+    const record4 = entry;
+    if (record4.type !== "message")
+      continue;
+    const message = record4.message;
+    if (message === null || typeof message !== "object")
+      continue;
+    if (message.role === "user") {
+      genuineUserMessages.add(message);
+    }
+  }
+  for (const msg of messages.slice(latestAssistantIndex + 1)) {
+    if (msg !== null && typeof msg === "object" && genuineUserMessages.has(msg)) {
       return true;
+    }
   }
   return false;
 }
@@ -170406,7 +170657,7 @@ function getMemoryVerifications(db, memoryIds) {
 }
 // ../plugin/src/features/magic-context/memory/verification-paths.ts
 import { execFile } from "node:child_process";
-import { existsSync as existsSync9, realpathSync as realpathSync2, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync9, realpathSync as realpathSync2, statSync as statSync4 } from "node:fs";
 import path4 from "node:path";
 import { promisify } from "node:util";
 var execFileAsync = promisify(execFile);
@@ -170548,7 +170799,7 @@ async function normalizeVerificationFiles(args) {
     }
     if (existsSync9(candidate)) {
       try {
-        if (statSync3(candidate).isDirectory()) {
+        if (statSync4(candidate).isDirectory()) {
           warnings.push(`Skipped verification path "${value}" because it is a directory.`);
           continue;
         }
@@ -170598,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) {
@@ -170624,19 +170874,11 @@ function getInsertMessageStatement(db) {
   }
   return stmt;
 }
-function getUpsertIndexStatement(db) {
-  let stmt = upsertIndexStatements.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, 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);
-  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;
 }
@@ -170648,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;
 }
@@ -170696,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") {
@@ -170720,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");
@@ -170753,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 {
@@ -170798,7 +171030,7 @@ function indexMessagesAfterOrdinal(db, sessionId, messages, lastIndexedOrdinal,
 }
 // ../plugin/src/features/magic-context/project-docs-hash.ts
 import { createHash as createHash7 } from "node:crypto";
-import { lstatSync, readFileSync as readFileSync5, statSync as statSync4 } from "node:fs";
+import { lstatSync, readFileSync as readFileSync5, statSync as statSync5 } from "node:fs";
 import path5 from "node:path";
 var PROJECT_DOC_FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
 var PROJECT_DOCS_DELIMITER = `
@@ -170829,7 +171061,7 @@ function fingerprintFile(filePath) {
 }
 function readDirectoryMtimeMs(projectDirectory) {
   try {
-    return statSync4(projectDirectory).mtimeMs;
+    return statSync5(projectDirectory).mtimeMs;
   } catch {
     return 0;
   }
@@ -170919,6 +171151,160 @@ function readProjectDocsCanonical(projectDirectory) {
   });
   return { renderedBlock, canonicalHash };
 }
+// ../plugin/src/features/magic-context/storage-clone.ts
+function runImmediate2(db, body) {
+  db.exec("BEGIN IMMEDIATE");
+  let committed = false;
+  try {
+    const result = body();
+    db.exec("COMMIT");
+    committed = true;
+    return result;
+  } finally {
+    if (!committed) {
+      try {
+        db.exec("ROLLBACK");
+      } catch {}
+    }
+  }
+}
+function countRows(db, table, sessionId) {
+  const row = db.prepare(`SELECT COUNT(*) AS count FROM ${table} WHERE session_id = ?`).get(sessionId);
+  return typeof row?.count === "number" ? row.count : 0;
+}
+function filterIdBlob(raw, includeMessageId) {
+  if (!raw)
+    return "";
+  try {
+    const value = JSON.parse(raw);
+    if (!Array.isArray(value))
+      return "";
+    const filtered = value.filter((id) => typeof id === "string" && includeMessageId(id));
+    return filtered.length > 0 ? JSON.stringify(filtered) : "";
+  } catch {
+    return "";
+  }
+}
+function clampWatermark(value, maxCopiedTag) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+    return 0;
+  return Math.min(Math.floor(value), maxCopiedTag);
+}
+function copySessionStateForClone(db, sourceSessionId, destinationSessionId, filter) {
+  return runImmediate2(db, () => {
+    if (countRows(db, "compartments", destinationSessionId) > 0 || countRows(db, "tags", destinationSessionId) > 0) {
+      return {
+        kind: "destination-not-empty",
+        compartmentsCopied: 0,
+        tagsCopied: 0,
+        pendingOpsCopied: 0,
+        pendingMarkerMigrated: false
+      };
+    }
+    const sourceCompartments = db.prepare(`SELECT sequence, start_message, end_message, start_message_id, end_message_id,
+                        title, content, p1, p2, p3, p4, importance, episode_type, legacy,
+                        created_at, harness
+                   FROM compartments WHERE session_id = ? ORDER BY sequence ASC`).all(sourceSessionId);
+    const insertCompartment = db.prepare(`INSERT INTO compartments
+                (session_id, sequence, start_message, end_message, start_message_id,
+                 end_message_id, title, content, p1, p2, p3, p4, importance,
+                 episode_type, legacy, created_at, harness)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    const copiedCompartments = [];
+    for (const row of sourceCompartments) {
+      const startMessage = filter.resolveBoundaryOrdinal(row.start_message_id);
+      const endMessage = filter.resolveBoundaryOrdinal(row.end_message_id);
+      if (startMessage === undefined || endMessage === undefined)
+        continue;
+      insertCompartment.run(destinationSessionId, row.sequence, startMessage, endMessage, row.start_message_id, row.end_message_id, row.title, row.content, row.p1, row.p2, row.p3, row.p4, row.importance, row.episode_type, row.legacy, row.created_at, row.harness);
+      copiedCompartments.push({
+        sequence: row.sequence,
+        startMessage,
+        endMessage,
+        startMessageId: row.start_message_id,
+        endMessageId: row.end_message_id
+      });
+    }
+    const sourceTags = db.prepare(`SELECT message_id, type, status, byte_size, tag_number, harness,
+                        entry_fingerprint, token_count, input_token_count,
+                        reasoning_token_count, reasoning_byte_size, drop_mode, tool_name,
+                        input_byte_size, caveman_depth, tool_owner_message_id
+                   FROM tags WHERE session_id = ? ORDER BY tag_number ASC`).all(sourceSessionId);
+    const insertTag = db.prepare(`INSERT INTO tags
+                (session_id, message_id, type, status, byte_size, tag_number, harness,
+                 entry_fingerprint, token_count, input_token_count, reasoning_token_count,
+                 reasoning_byte_size, drop_mode, tool_name, input_byte_size,
+                 caveman_depth, tool_owner_message_id)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    const copiedTagNumbers = [];
+    for (const row of sourceTags) {
+      if (!filter.includeTag({
+        messageId: row.message_id,
+        type: row.type,
+        tagNumber: row.tag_number,
+        toolOwnerMessageId: row.tool_owner_message_id
+      })) {
+        continue;
+      }
+      insertTag.run(destinationSessionId, row.message_id, row.type, row.status, row.byte_size, row.tag_number, row.harness, row.entry_fingerprint, row.token_count, row.input_token_count, row.reasoning_token_count, row.reasoning_byte_size, row.drop_mode, row.tool_name, row.input_byte_size, row.caveman_depth, row.tool_owner_message_id);
+      copiedTagNumbers.push(row.tag_number);
+    }
+    if (copiedTagNumbers.length > 0) {
+      const placeholders3 = copiedTagNumbers.map(() => "?").join(", ");
+      db.prepare(`INSERT INTO source_contents (tag_id, session_id, content, created_at, harness)
+                 SELECT tag_id, ?, content, created_at, harness
+                   FROM source_contents
+                  WHERE session_id = ? AND tag_id IN (${placeholders3})`).run(destinationSessionId, sourceSessionId, ...copiedTagNumbers);
+      db.prepare(`INSERT INTO pending_ops (session_id, tag_id, operation, queued_at, harness)
+                 SELECT ?, tag_id, operation, queued_at, harness
+                   FROM pending_ops
+                  WHERE session_id = ? AND tag_id IN (${placeholders3})`).run(destinationSessionId, sourceSessionId, ...copiedTagNumbers);
+    }
+    const meta3 = db.prepare(`SELECT cleared_reasoning_through_tag, tool_reclaim_watermark,
+                        pi_stable_id_scheme, stripped_placeholder_ids,
+                        stale_reduce_stripped_ids, processed_image_stripped_ids,
+                        pending_pi_compaction_marker_state, last_todo_state,
+                        todo_synthetic_call_id, todo_synthetic_anchor_message_id,
+                        todo_synthetic_state_json
+                   FROM session_meta WHERE session_id = ?`).get(sourceSessionId);
+    const maxCopiedTag = copiedTagNumbers.reduce((max, value) => Math.max(max, value), 0);
+    const pendingMarker = filter.selectPendingPiMarker(meta3?.pending_pi_compaction_marker_state ?? null, copiedCompartments);
+    const todoAnchor = meta3?.todo_synthetic_anchor_message_id ?? "";
+    const migrateTodo = todoAnchor.length > 0 && filter.includeMessageId(todoAnchor);
+    db.prepare(`INSERT INTO session_meta
+                (session_id, harness, counter, cleared_reasoning_through_tag,
+                 tool_reclaim_watermark, pi_stable_id_scheme, stripped_placeholder_ids,
+                 stale_reduce_stripped_ids, processed_image_stripped_ids,
+                 pending_pi_compaction_marker_state, last_todo_state,
+                 todo_synthetic_call_id, todo_synthetic_anchor_message_id,
+                 todo_synthetic_state_json)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+             ON CONFLICT(session_id) DO UPDATE SET
+                harness = excluded.harness,
+                counter = excluded.counter,
+                cleared_reasoning_through_tag = excluded.cleared_reasoning_through_tag,
+                tool_reclaim_watermark = excluded.tool_reclaim_watermark,
+                pi_stable_id_scheme = excluded.pi_stable_id_scheme,
+                stripped_placeholder_ids = excluded.stripped_placeholder_ids,
+                stale_reduce_stripped_ids = excluded.stale_reduce_stripped_ids,
+                processed_image_stripped_ids = excluded.processed_image_stripped_ids,
+                pending_pi_compaction_marker_state = excluded.pending_pi_compaction_marker_state,
+                last_todo_state = excluded.last_todo_state,
+                todo_synthetic_call_id = excluded.todo_synthetic_call_id,
+                todo_synthetic_anchor_message_id = excluded.todo_synthetic_anchor_message_id,
+                todo_synthetic_state_json = excluded.todo_synthetic_state_json,
+                cached_m0_bytes = NULL,
+                cached_m1_bytes = NULL`).run(destinationSessionId, getHarness(), maxCopiedTag, clampWatermark(meta3?.cleared_reasoning_through_tag ?? null, maxCopiedTag), clampWatermark(meta3?.tool_reclaim_watermark ?? null, maxCopiedTag), typeof meta3?.pi_stable_id_scheme === "number" && Number.isFinite(meta3.pi_stable_id_scheme) ? meta3.pi_stable_id_scheme : null, filterIdBlob(meta3?.stripped_placeholder_ids ?? null, filter.includeMessageId), filterIdBlob(meta3?.stale_reduce_stripped_ids ?? null, filter.includeMessageId), filterIdBlob(meta3?.processed_image_stripped_ids ?? null, filter.includeMessageId), pendingMarker, migrateTodo ? meta3?.last_todo_state ?? "" : "", migrateTodo ? meta3?.todo_synthetic_call_id ?? "" : "", migrateTodo ? todoAnchor : "", migrateTodo ? meta3?.todo_synthetic_state_json ?? "" : "");
+    const pendingOpsRow = db.prepare("SELECT COUNT(*) AS count FROM pending_ops WHERE session_id = ?").get(destinationSessionId);
+    return {
+      kind: "migrated",
+      compartmentsCopied: copiedCompartments.length,
+      tagsCopied: copiedTagNumbers.length,
+      pendingOpsCopied: typeof pendingOpsRow?.count === "number" ? pendingOpsRow.count : 0,
+      pendingMarkerMigrated: pendingMarker !== null
+    };
+  });
+}
 // ../plugin/src/features/magic-context/storage-m0-mutation-log.ts
 var M0_MUTATION_TYPES = new Set([
   "compartment_delete",
@@ -171771,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);
@@ -171785,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);
     }
   })();
 }
@@ -171805,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);
     }
   })();
 }
@@ -171885,6 +172278,36 @@ function parseStrippedBlob(raw) {
   } catch {}
   return [];
 }
+function getProcessedImageStrippedIds(db, sessionId) {
+  const row = db.prepare("SELECT processed_image_stripped_ids FROM session_meta WHERE session_id = ?").get(sessionId);
+  return new Set(parseStrippedBlob(row?.processed_image_stripped_ids));
+}
+function addProcessedImageStrippedIds(db, sessionId, ids) {
+  const add = [...ids];
+  if (add.length === 0)
+    return true;
+  ensureSessionMetaRow(db, sessionId);
+  for (let attempt = 0;attempt < CAS_RETRY_LIMIT; attempt += 1) {
+    const row = db.prepare("SELECT processed_image_stripped_ids FROM session_meta WHERE session_id = ?").get(sessionId);
+    const rawStored = row ? row.processed_image_stripped_ids ?? null : null;
+    const current = new Set(parseStrippedBlob(rawStored));
+    let changed = false;
+    for (const id of add) {
+      if (!current.has(id)) {
+        current.add(id);
+        changed = true;
+      }
+    }
+    if (!changed)
+      return true;
+    const nextBlob = JSON.stringify([...current]);
+    const result = db.prepare("UPDATE session_meta SET processed_image_stripped_ids = ? WHERE session_id = ? AND processed_image_stripped_ids IS ?").run(nextBlob, sessionId, rawStored);
+    if (result.changes > 0)
+      return true;
+  }
+  sessionLog(sessionId, `processed_image_stripped_ids CAS: ${CAS_RETRY_LIMIT} retries exhausted`);
+  return false;
+}
 function isPendingCompactionMarker(value) {
   return typeof value === "object" && value !== null && typeof value.ordinal === "number" && typeof value.endMessageId === "string" && typeof value.publishedAt === "number";
 }
@@ -172607,6 +173030,7 @@ var getTagNumbersByMessageIdStatements = new WeakMap;
 var deleteTagsByMessageIdStatements = new WeakMap;
 var getMaxTagNumberBySessionStatements = new WeakMap;
 var getTagNumberByMessageIdStatements = new WeakMap;
+var hasPiFallbackMessageTagStatements = new WeakMap;
 function getInsertTagStatement(db) {
   let stmt = insertTagStatements.get(db);
   if (!stmt) {
@@ -172750,6 +173174,18 @@ function getUpdateTagInputTokenCountStatement(db) {
 function updateTagTokenCount(db, sessionId, tagNumber, newTokenCount) {
   getUpdateTagTokenCountStatement(db).run(newTokenCount, sessionId, tagNumber);
 }
+function getPersistedToolTagAccounting(db, sessionId, tagNumber) {
+  const row = db.prepare(`SELECT byte_size AS byteSize,
+                    token_count AS tokenCount,
+                    input_byte_size AS inputByteSize,
+                    input_token_count AS inputTokenCount
+             FROM tags
+             WHERE session_id = ? AND tag_number = ? AND type = 'tool'`).get(sessionId, tagNumber);
+  if (!row || typeof row.byteSize !== "number" || row.tokenCount !== null && typeof row.tokenCount !== "number" || typeof row.inputByteSize !== "number" || row.inputTokenCount !== null && typeof row.inputTokenCount !== "number") {
+    return null;
+  }
+  return row;
+}
 function getAllStatusTagTokenTotalsFlat(db, sessionId, floor = 0) {
   const rows = floor > 0 ? db.prepare(`SELECT type, message_id, tool_owner_message_id, token_count, input_token_count, reasoning_token_count
                        FROM tags
@@ -172851,6 +173287,19 @@ function updateTagDropMode(db, sessionId, tagNumber, dropMode) {
 function updateCavemanDepth(db, sessionId, tagNumber, depth) {
   db.prepare("UPDATE tags SET caveman_depth = ? WHERE session_id = ? AND tag_number = ?").run(depth, sessionId, tagNumber);
 }
+function hasPiFallbackMessageTags(db, sessionId) {
+  let statement = hasPiFallbackMessageTagStatements.get(db);
+  if (!statement) {
+    statement = db.prepare(`SELECT 1
+             FROM tags
+             WHERE session_id = ?
+               AND type = 'message'
+               AND message_id LIKE 'pi-msg-%'
+             LIMIT 1`);
+    hasPiFallbackMessageTagStatements.set(db, statement);
+  }
+  return statement.get(sessionId) != null;
+}
 function findAdoptableFallbackTags(db, sessionId, entryFingerprint) {
   const rows = db.prepare(`SELECT tag_number AS tagNumber, message_id AS messageId
              FROM tags
@@ -173021,27 +173470,24 @@ function adoptPiFallbackToolOwnerTag(db, sessionId, tagNumber, callId, oldOwnerM
   }
   const existing = getPiFallbackToolFoldTagRowByOwner(db, sessionId, callId, newOwnerMessageId);
   if (existing === null) {
-    const result2 = db.prepare(`UPDATE tags
+    const result = db.prepare(`UPDATE tags
                  SET tool_owner_message_id = ?
                  WHERE session_id = ?
                    AND tag_number = ?
                    AND type = 'tool'
                    AND message_id = ?
                    AND tool_owner_message_id = ?`).run(newOwnerMessageId, sessionId, tagNumber, callId, oldOwnerMessageId);
-    return (result2.changes ?? 0) === 1 ? { action: "rekeyed", tagNumber } : { action: "skipped" };
+    return (result.changes ?? 0) === 1 ? { action: "rekeyed", tagNumber } : { action: "skipped" };
   }
   if (existing.tagNumber === tagNumber) {
     return { action: "skipped" };
   }
-  foldDuplicateIntoSurvivor(db, sessionId, survivor, existing);
-  const result = db.prepare(`UPDATE tags
-             SET tool_owner_message_id = ?
-             WHERE session_id = ?
-               AND tag_number = ?
-               AND type = 'tool'
-               AND message_id = ?
-               AND tool_owner_message_id = ?`).run(newOwnerMessageId, sessionId, tagNumber, callId, oldOwnerMessageId);
-  return (result.changes ?? 0) === 1 ? { action: "folded", tagNumber, deletedTagNumbers: [existing.tagNumber] } : { action: "skipped" };
+  foldDuplicateIntoSurvivor(db, sessionId, existing, survivor);
+  return {
+    action: "folded",
+    tagNumber: existing.tagNumber,
+    deletedTagNumbers: [tagNumber]
+  };
 }
 function adoptPiFallbackMessageTag(db, sessionId, tagNumber, oldFallbackMessageId, newRealMessageId) {
   const survivor = getPiFallbackFoldTagRowByNumber(db, sessionId, tagNumber);
@@ -173050,26 +173496,28 @@ function adoptPiFallbackMessageTag(db, sessionId, tagNumber, oldFallbackMessageI
   }
   const duplicates = getPiFallbackMessageFoldTagRowsByMessageId(db, sessionId, newRealMessageId).filter((row) => row.tagNumber !== tagNumber);
   if (duplicates.length === 0) {
-    const result2 = db.prepare(`UPDATE tags
+    const result = db.prepare(`UPDATE tags
                  SET message_id = ?
                  WHERE session_id = ?
                    AND tag_number = ?
                    AND type = 'message'
                    AND message_id = ?`).run(newRealMessageId, sessionId, tagNumber, oldFallbackMessageId);
-    return (result2.changes ?? 0) === 1 ? { action: "rekeyed", tagNumber } : { action: "skipped" };
+    return (result.changes ?? 0) === 1 ? { action: "rekeyed", tagNumber } : { action: "skipped" };
   }
-  const deletedTagNumbers = [];
-  for (const duplicate of duplicates) {
-    foldDuplicateIntoSurvivor(db, sessionId, survivor, duplicate);
+  const realSurvivor = duplicates[0];
+  if (!realSurvivor)
+    return { action: "skipped" };
+  const deletedTagNumbers = [tagNumber];
+  foldDuplicateIntoSurvivor(db, sessionId, realSurvivor, survivor);
+  for (const duplicate of duplicates.slice(1)) {
+    foldDuplicateIntoSurvivor(db, sessionId, realSurvivor, duplicate);
     deletedTagNumbers.push(duplicate.tagNumber);
   }
-  const result = db.prepare(`UPDATE tags
-             SET message_id = ?
-             WHERE session_id = ?
-               AND tag_number = ?
-               AND type = 'message'
-               AND message_id = ?`).run(newRealMessageId, sessionId, tagNumber, oldFallbackMessageId);
-  return (result.changes ?? 0) === 1 ? { action: "folded", tagNumber, deletedTagNumbers } : { action: "skipped" };
+  return {
+    action: "folded",
+    tagNumber: realSurvivor.tagNumber,
+    deletedTagNumbers
+  };
 }
 var getOwnerScopedToolTagNumbersStatements = new WeakMap;
 function getMaxTagNumberBySession(db, sessionId) {
@@ -173141,10 +173589,40 @@ function getActiveTagsBySessionStatement(db) {
   }
   return stmt;
 }
+function getMaxDroppedTagNumberStatement(db) {
+  let stmt = getMaxDroppedTagNumberStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT COALESCE(MAX(tag_number), 0) AS max_tag_number FROM tags WHERE session_id = ? AND status = 'dropped'");
+    getMaxDroppedTagNumberStatements.set(db, stmt);
+  }
+  return stmt;
+}
 function getActiveTagsBySession(db, sessionId) {
   const rows = getActiveTagsBySessionStatement(db).all(sessionId).filter(isTagRow);
   return rows.map(toTagEntry);
 }
+function getTagsForPendingOperations(db, sessionId, pendingTagNumbers, protectedTags, recentToolWindow) {
+  const byNumber = new Map;
+  for (const tag of getTagsByNumbers(db, sessionId, pendingTagNumbers)) {
+    byNumber.set(tag.tagNumber, tag);
+  }
+  const addRows = (sql, limit) => {
+    if (limit <= 0)
+      return;
+    const rows = db.prepare(sql).all(sessionId, limit).filter(isTagRow);
+    for (const row of rows) {
+      const tag = toTagEntry(row);
+      byNumber.set(tag.tagNumber, tag);
+    }
+  };
+  addRows(`SELECT ${TAG_SELECT_COLUMNS} FROM tags
+         WHERE session_id = ? AND status = 'active'
+         ORDER BY tag_number DESC, id DESC LIMIT ?`, protectedTags);
+  addRows(`SELECT ${TAG_SELECT_COLUMNS} FROM tags
+         WHERE session_id = ? AND type = 'tool'
+         ORDER BY tag_number DESC, id DESC LIMIT ?`, recentToolWindow);
+  return [...byNumber.values()].sort((left, right) => left.tagNumber - right.tagNumber);
+}
 function getTagsByNumbers(db, sessionId, tagNumbers) {
   if (tagNumbers.length === 0)
     return [];
@@ -173159,6 +173637,10 @@ function getTagsByNumbers(db, sessionId, tagNumbers) {
   const rows = db.prepare(`SELECT ${TAG_SELECT_COLUMNS} FROM tags WHERE session_id = ? AND tag_number IN (${placeholders4}) ORDER BY tag_number ASC, id ASC`).all(sessionId, ...tagNumbers).filter(isTagRow);
   return rows.map(toTagEntry);
 }
+function getMaxDroppedTagNumber(db, sessionId) {
+  const row = getMaxDroppedTagNumberStatement(db).get(sessionId);
+  return isMaxTagNumberRow(row) ? row.max_tag_number : 0;
+}
 var getToolTagNumberByOwnerStatements = new WeakMap;
 var getNullOwnerToolTagStatements = new WeakMap;
 var adoptNullOwnerToolTagStatements = new WeakMap;
@@ -175460,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;
@@ -175517,12 +176023,29 @@ function computeBudgetPressure(compartments, historyBudget) {
 
 // ../plugin/src/hooks/magic-context/decay-render.ts
 var DEFAULT_HISTORY_BUDGET_TOKENS = 60000;
-function escapeXmlAttr2(s) {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
 function escapeXmlContent2(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
+function formatDateRange(startDate, endDate) {
+  if (!startDate || !endDate)
+    return "";
+  if (startDate === endDate)
+    return startDate;
+  if (startDate.slice(0, 7) === endDate.slice(0, 7))
+    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} · ${sanitizeCompartmentTitle(c.title)}`;
+}
+function guardCompartmentBody(body) {
+  return body.replace(/^## /gm, " ## ");
+}
 function isTieredRow(c) {
   return typeof c.p1 === "string" && c.p1.length > 0;
 }
@@ -175552,25 +176075,22 @@ function renderCompartmentAtTier(c, tier2) {
   return renderOneCompartment(c, tier2);
 }
 function renderOneCompartment(c, tier2) {
-  const baseAttrs = `start="${c.startMessage}" end="${c.endMessage}" title="${escapeXmlAttr2(c.title)}"`;
   if (tier2 >= 5)
     return "";
+  const heading = compartmentHeading(c);
   if (c.legacy === 1 || !isTieredRow(c)) {
     const flat = (c.content ?? "").trim();
     if (tier2 >= 4 || flat.length === 0)
-      return `<compartment ${baseAttrs} />`;
-    return [
-      `<compartment ${baseAttrs}>`,
-      escapeXmlContent2(legacyBodyForTier(flat, tier2)),
-      "</compartment>"
-    ].join(`
-`);
+      return heading;
+    const body2 = guardCompartmentBody(escapeXmlContent2(legacyBodyForTier(flat, tier2)));
+    return `${heading}
+${body2}`;
   }
   const body = tierBody(c, tier2);
   if (body.length === 0)
-    return `<compartment ${baseAttrs} />`;
-  return [`<compartment ${baseAttrs}>`, escapeXmlContent2(body), "</compartment>"].join(`
-`);
+    return heading;
+  return `${heading}
+${guardCompartmentBody(escapeXmlContent2(body))}`;
 }
 function computeTiers(compartments, historyBudgetTokens) {
   const v2Compartments = compartments.map((c, originalIndex) => ({ c, originalIndex })).filter(({ c }) => c.legacy !== 1);
@@ -175693,33 +176213,9 @@ function getVisibleMemoryIds(db, sessionId) {
   }
 }
 function renderMemoryBlock(memories) {
-  const byCategory = new Map;
-  for (const m of memories) {
-    const existing = byCategory.get(m.category);
-    if (existing) {
-      existing.push(m);
-    } else {
-      byCategory.set(m.category, [m]);
-    }
-  }
-  const sections = [];
-  for (const category of CATEGORY_PRIORITY) {
-    const categoryMemories = byCategory.get(category);
-    if (!categoryMemories || categoryMemories.length === 0) {
-      continue;
-    }
-    sections.push(`<${category}>`, ...categoryMemories.map((m) => `- ${escapeXmlContent(m.content)}`), `</${category}>`);
-  }
-  if (sections.length === 0) {
-    return null;
-  }
-  return `<project-memory>
-${sections.join(`
-`)}
-</project-memory>`;
+  return renderMemoryBlockV2(memories) || null;
 }
 var DEFAULT_MEMORY_BUDGET_TOKENS = 8000;
-var MEMORY_BLOCK_WRAPPER_TOKENS = 6;
 var DEFAULT_USER_PROFILE_BUDGET_TOKENS = 4000;
 function memoryCanonicalIdentity(memory2, workspace) {
   return resolveStoredPathWorkspaceIdentity(memory2.projectPath, workspace.identities, workspace.canonicalIdentityByStoredPath);
@@ -175737,11 +176233,18 @@ function memorySelectionOrder(left, right) {
   return left.id - right.id;
 }
 function memoryRenderOrder(left, right) {
-  const aPriority = MEMORY_CATEGORY_ORDER_PRIORITY[left.category] ?? MEMORY_CATEGORY_ORDER_UNKNOWN;
-  const bPriority = MEMORY_CATEGORY_ORDER_PRIORITY[right.category] ?? MEMORY_CATEGORY_ORDER_UNKNOWN;
-  const categoryDiff = aPriority - bPriority;
-  if (categoryDiff !== 0)
-    return categoryDiff;
+  const leftPriority = V2_MEMORY_CATEGORIES.indexOf(left.category);
+  const rightPriority = V2_MEMORY_CATEGORIES.indexOf(right.category);
+  if (leftPriority >= 0 || rightPriority >= 0) {
+    if (leftPriority < 0)
+      return 1;
+    if (rightPriority < 0)
+      return -1;
+    if (leftPriority !== rightPriority)
+      return leftPriority - rightPriority;
+  } else if (left.category !== right.category) {
+    return left.category < right.category ? -1 : 1;
+  }
   return left.id - right.id;
 }
 var maxCompartmentSeqStatements = new WeakMap;
@@ -175752,13 +176255,13 @@ var newCompartmentStatements = new WeakMap;
 function trimMemoriesToBudgetV2(sessionId, memories, budgetTokens, renderOptions = {}) {
   const selectionOrder = [...memories].sort(memorySelectionOrder);
   const selected = [];
-  let usedTokens = MEMORY_BLOCK_WRAPPER_TOKENS;
+  const accounting = createMemoryBlockAccounting(renderOptions);
   for (const memory2 of selectionOrder) {
-    const memoryTokens = estimateTokens(renderMemoryLineV2(memory2, renderOptions.sourceNameByMemoryId?.get(memory2.id)));
-    if (usedTokens + memoryTokens > budgetTokens)
+    const cost = accounting.candidateCost(memory2);
+    if (accounting.usedTokens + cost > budgetTokens)
       continue;
+    accounting.admit(memory2, cost);
     selected.push(memory2);
-    usedTokens += memoryTokens;
   }
   if (selected.length < memories.length) {
     sessionLog(sessionId, `v2 trimmed memories from ${memories.length} to ${selected.length} to fit injection budget of ${budgetTokens} tokens`);
@@ -175772,23 +176275,22 @@ function trimWorkspaceMemoriesToBudgetV2(sessionId, memories, budgetTokens, work
   }
   const selected = [];
   const selectedIds = new Set;
-  let usedTokens = MEMORY_BLOCK_WRAPPER_TOKENS;
-  const tokenCost = (memory2) => estimateTokens(renderMemoryLineV2(memory2, renderOptions.sourceNameByMemoryId?.get(memory2.id)));
+  const accounting = createMemoryBlockAccounting(renderOptions);
   const trySelect = (memory2) => {
     if (selectedIds.has(memory2.id))
       return false;
-    const tokens = tokenCost(memory2);
-    if (usedTokens + tokens > budgetTokens)
+    const cost = accounting.candidateCost(memory2);
+    if (accounting.usedTokens + cost > budgetTokens)
       return false;
     selected.push(memory2);
     selectedIds.add(memory2.id);
-    usedTokens += tokens;
+    accounting.admit(memory2, cost);
     return true;
   };
   for (const memory2 of memories.filter((candidate) => candidate.status === "permanent").sort(memorySelectionOrder)) {
     trySelect(memory2);
   }
-  const remainingAfterPermanent = Math.max(0, budgetTokens - usedTokens);
+  const remainingAfterPermanent = Math.max(0, budgetTokens - accounting.usedTokens);
   const floorTokens = remainingAfterPermanent / Math.max(1, workspace.identities.length);
   const byIdentity = new Map;
   for (const memory2 of memories) {
@@ -175807,15 +176309,15 @@ function trimWorkspaceMemoriesToBudgetV2(sessionId, memories, budgetTokens, work
     for (const memory2 of candidates2) {
       if (selectedIds.has(memory2.id))
         continue;
-      const tokens = tokenCost(memory2);
-      if (memberTokens + tokens > floorTokens)
+      const cost = accounting.candidateCost(memory2);
+      if (memberTokens + cost > floorTokens)
         continue;
-      if (usedTokens + tokens > budgetTokens)
+      if (accounting.usedTokens + cost > budgetTokens)
         continue;
       selected.push(memory2);
       selectedIds.add(memory2.id);
-      usedTokens += tokens;
-      memberTokens += tokens;
+      accounting.admit(memory2, cost);
+      memberTokens += cost;
     }
   }
   const remaining = memories.filter((memory2) => !selectedIds.has(memory2.id)).sort(memorySelectionOrder);
@@ -175839,17 +176341,55 @@ function trimUserMemoriesToBudget(memories, budgetTokens) {
   }
   return selected;
 }
+function createMemoryBlockAccounting(renderOptions) {
+  const seenCategories = new Set;
+  const categoryCost = new Map;
+  return {
+    usedTokens: estimateTokens(`<project-memory>
+</project-memory>`),
+    candidateCost(memory2) {
+      const line = renderMemoryLineV2(memory2, renderOptions.sourceNameByMemoryId?.get(memory2.id));
+      let cost = estimateTokens(`${line}
+`);
+      if (!seenCategories.has(memory2.category)) {
+        let tags = categoryCost.get(memory2.category);
+        if (tags === undefined) {
+          tags = estimateTokens(`<${escapeXmlAttr(memory2.category)}>
+</${escapeXmlAttr(memory2.category)}>
+`);
+          categoryCost.set(memory2.category, tags);
+        }
+        cost += tags;
+      }
+      return cost;
+    },
+    admit(memory2, cost) {
+      this.usedTokens += cost;
+      seenCategories.add(memory2.category);
+    }
+  };
+}
 function renderMemoryLineV2(memory2, sourceName) {
-  const sourceAttr = sourceName ? ` source="${escapeXmlAttr(sourceName)}"` : "";
-  return `  <memory id="${memory2.id}" category="${escapeXmlAttr(memory2.category)}"${sourceAttr} importance="${memory2.importance ?? 50}">${escapeXmlContent(memory2.content)}</memory>`;
+  const source = sourceName ? ` [${escapeXmlContent(sourceName)}]` : "";
+  return `#${memory2.id}${source}: ${escapeXmlContent(memory2.content)}`;
 }
 function renderMemoryBlockV2(memories, wrapper = "project-memory", renderOptions = {}) {
   if (memories.length === 0)
     return "";
+  const ordered = [...memories].sort(memoryRenderOrder);
   const lines = [`<${wrapper}>`];
-  for (const memory2 of memories) {
+  let openCategory;
+  for (const memory2 of ordered) {
+    if (memory2.category !== openCategory) {
+      if (openCategory !== undefined)
+        lines.push(`</${escapeXmlAttr(openCategory)}>`);
+      openCategory = memory2.category;
+      lines.push(`<${escapeXmlAttr(openCategory)}>`);
+    }
     lines.push(renderMemoryLineV2(memory2, renderOptions.sourceNameByMemoryId?.get(memory2.id)));
   }
+  if (openCategory !== undefined)
+    lines.push(`</${escapeXmlAttr(openCategory)}>`);
   lines.push(`</${wrapper}>`);
   return lines.join(`
 `);
@@ -176163,6 +176703,8 @@ var STATUS_COLOR = {
   cancelled: "error"
 };
 var snapshotsBySession = new Map;
+var MAX_TODOWRITE_RENDER_CACHE_ENTRIES = 50;
+var cachedTodowriteTodosByToolCallId = new Map;
 function isTodoStatus2(value) {
   return TODO_STATUSES.includes(value);
 }
@@ -176172,6 +176714,27 @@ function isTodoPriority2(value) {
 function cloneTodos(todos) {
   return todos.map((todo) => ({ ...todo }));
 }
+function rememberTodowriteToolCallTodos(toolCallId, todos) {
+  if (!toolCallId)
+    return;
+  cachedTodowriteTodosByToolCallId.delete(toolCallId);
+  cachedTodowriteTodosByToolCallId.set(toolCallId, cloneTodos(todos));
+  while (cachedTodowriteTodosByToolCallId.size > MAX_TODOWRITE_RENDER_CACHE_ENTRIES) {
+    const oldestKey = cachedTodowriteTodosByToolCallId.keys().next().value;
+    if (typeof oldestKey !== "string")
+      break;
+    cachedTodowriteTodosByToolCallId.delete(oldestKey);
+  }
+}
+function getCachedTodowriteToolCallTodos(toolCallId) {
+  if (!toolCallId)
+    return null;
+  const todos = cachedTodowriteTodosByToolCallId.get(toolCallId);
+  return todos ? cloneTodos(todos) : null;
+}
+function clearTodowriteToolCallTodos() {
+  cachedTodowriteTodosByToolCallId.clear();
+}
 function parseTodos(input) {
   if (!Array.isArray(input))
     return null;
@@ -176308,25 +176871,27 @@ function capTodoRows(rows) {
     hiddenCount: rows.length - visibleCount
   };
 }
-function renderTodowriteCall(args, theme) {
-  const todos = parseTodos(args.todos) ?? [];
+function renderTodowriteCall(args, theme, context) {
+  const todos = getCachedTodowriteToolCallTodos(context?.toolCallId) ?? parseTodos(args.todos) ?? [];
   const active = activeTitleCount(todos);
   const activeColor = active > 0 ? "warning" : "success";
   const line = `${theme.fg("toolTitle", theme.bold("Todos"))} ${theme.fg("muted", "—")} ${theme.fg(activeColor, `${active} active`)}`;
   return lineComponent((width) => [truncateToWidth(line, width, "…")]);
 }
-function renderTodowriteResult(result, theme) {
+function renderTodowriteResult(result, theme, context) {
   const detailsTodos = result.details?.todos;
   let todos = parseTodos(detailsTodos);
-  if (todos === null && Array.isArray(result.content)) {
+  if ((todos === null || todos.length === 0) && Array.isArray(result.content)) {
     const text = result.content.find((part) => part !== null && typeof part === "object" && part.type === "text" && typeof part.text === "string")?.text;
     if (text) {
       try {
-        todos = parseTodos(JSON.parse(text));
+        const parsed = parseTodos(JSON.parse(text));
+        if (parsed !== null)
+          todos = parsed;
       } catch {}
     }
   }
-  const renderedTodos = todos ?? [];
+  const renderedTodos = todos !== null && todos.length > 0 ? todos : getCachedTodowriteToolCallTodos(context?.toolCallId) ?? todos ?? [];
   return lineComponent((width) => {
     if (renderedTodos.length === 0)
       return [theme.fg("dim", "No todos")];
@@ -176527,6 +177092,7 @@ function registerTodoOverlay(pi, deps) {
     overlay.hideCompletedTasksFromPreviousTurn();
   });
   pi.on("session_shutdown", async (_event, ctx) => {
+    clearTodowriteToolCallTodos();
     const sessionId = getSessionId(ctx);
     if (!sessionId)
       return;
@@ -176534,6 +177100,7 @@ function registerTodoOverlay(pi, deps) {
     overlay.disposeSession(sessionId);
   });
   pi.on("session_before_switch", async (_event, ctx) => {
+    clearTodowriteToolCallTodos();
     const sessionId = getSessionId(ctx);
     if (!sessionId)
       return;
@@ -176550,11 +177117,13 @@ function registerTodoStateLifecycle(pi, deps) {
     seedTodoSnapshotFromStateJson(sessionId, deps.readLastTodoState(sessionId));
   });
   pi.on("session_shutdown", async (_event, ctx) => {
+    clearTodowriteToolCallTodos();
     const sessionId = getSessionId(ctx);
     if (sessionId)
       clearTodoSnapshot(sessionId);
   });
   pi.on("session_before_switch", async (_event, ctx) => {
+    clearTodowriteToolCallTodos();
     const sessionId = getSessionId(ctx);
     if (sessionId)
       clearTodoSnapshot(sessionId);
@@ -176605,11 +177174,11 @@ function createTodowriteTool() {
         }
       };
     },
-    renderCall(args, theme) {
-      return renderTodowriteCall(args, theme);
+    renderCall(args, theme, context) {
+      return renderTodowriteCall(args, theme, context);
     },
-    renderResult(result, _opts, theme) {
-      return renderTodowriteResult(result, theme);
+    renderResult(result, _opts, theme, context) {
+      return renderTodowriteResult(result, theme, context);
     }
   };
 }