@cortexkit/pi-magic-context 0.31.4 → 0.32.0

package/dist/index.js

@@ -15166,7 +15166,7 @@ async function resolvePromptContext(client, sessionId) {
 var PROMPT_CONTEXT_MESSAGE_LIMIT = 50;
 
 // src/index.ts
-import { createRequire as createRequire3 } from "node:module";
+import { createRequire as createRequire4 } from "node:module";
 import { join as join13, resolve as resolve3 } from "node:path";
 
 // ../plugin/src/config/agent-disable.ts
@@ -148774,6 +148774,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);
@@ -148796,7 +148802,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) {
@@ -148804,10 +148810,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)
@@ -148818,6 +148821,7 @@ function readRawSessionMessagesFromDb(db, sessionId) {
       id: row.id,
       role,
       parts: partsByMessageId.get(row.id) ?? [],
+      createdAt: row.time_created ?? null,
       version: row.time_updated ?? null
     };
   });
@@ -148832,7 +148836,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);
@@ -148868,6 +148872,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;
@@ -149630,6 +149635,7 @@ var reconciliationScheduledSessions = new Set;
 var sessionLocks = new Map;
 var incrementalTimers = new Map;
 var pendingIncrementalKeys = new Set;
+var completedIncrementalKeys = new Set;
 function defer(fn) {
   const immediate = globalThis.setImmediate;
   if (typeof immediate === "function") {
@@ -149697,9 +149703,9 @@ function scheduleReconciliation(db, sessionId, readMessages) {
     });
   });
 }
-function scheduleIncrementalIndex(db, sessionId, messageId, readSingleMessage) {
+function scheduleIncrementalIndex(db, sessionId, messageId, messageSource) {
   const key = `${sessionId}\x00${messageId}`;
-  if (incrementalTimers.has(key) || pendingIncrementalKeys.has(key)) {
+  if (completedIncrementalKeys.has(key) || incrementalTimers.has(key) || pendingIncrementalKeys.has(key)) {
     return;
   }
   const timer = setTimeout(() => {
@@ -149707,12 +149713,12 @@ function scheduleIncrementalIndex(db, sessionId, messageId, readSingleMessage) {
     pendingIncrementalKeys.add(key);
     let attemptedOrdinal = null;
     runWithSessionLock(sessionId, () => {
-      const message = readSingleMessage(sessionId, messageId);
-      if (!message) {
+      const message = typeof messageSource === "function" ? messageSource(sessionId, messageId) : messageSource;
+      if (!message)
         return;
-      }
       attemptedOrdinal = message.ordinal;
       indexSingleMessage(db, sessionId, message);
+      completedIncrementalKeys.add(key);
     }).catch((error) => {
       markMessageIndexDirty(db, sessionId, attemptedOrdinal ?? getLastIndexedOrdinal(db, sessionId) + 1);
       reconciledSessions.delete(sessionId);
@@ -149739,6 +149745,10 @@ function clearSessionTracking(sessionId) {
       pendingIncrementalKeys.delete(key);
     }
   }
+  for (const key of completedIncrementalKeys) {
+    if (key.startsWith(prefix))
+      completedIncrementalKeys.delete(key);
+  }
 }
 
 // ../plugin/src/features/magic-context/overflow-detection.ts
@@ -152561,6 +152571,160 @@ function readProjectDocsCanonical(projectDirectory) {
   });
   return { renderedBlock, canonicalHash };
 }
+// ../plugin/src/features/magic-context/storage-clone.ts
+function runImmediate(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 runImmediate(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 placeholders2 = 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 (${placeholders2})`).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 (${placeholders2})`).run(destinationSessionId, sourceSessionId, ...copiedTagNumbers);
+    }
+    const meta = 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(meta?.pending_pi_compaction_marker_state ?? null, copiedCompartments);
+    const todoAnchor = meta?.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(meta?.cleared_reasoning_through_tag ?? null, maxCopiedTag), clampWatermark(meta?.tool_reclaim_watermark ?? null, maxCopiedTag), typeof meta?.pi_stable_id_scheme === "number" && Number.isFinite(meta.pi_stable_id_scheme) ? meta.pi_stable_id_scheme : null, filterIdBlob(meta?.stripped_placeholder_ids ?? null, filter.includeMessageId), filterIdBlob(meta?.stale_reduce_stripped_ids ?? null, filter.includeMessageId), filterIdBlob(meta?.processed_image_stripped_ids ?? null, filter.includeMessageId), pendingMarker, migrateTodo ? meta?.last_todo_state ?? "" : "", migrateTodo ? meta?.todo_synthetic_call_id ?? "" : "", migrateTodo ? todoAnchor : "", migrateTodo ? meta?.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-db.ts
 import { chmodSync, copyFileSync, cpSync, existsSync as existsSync7, mkdirSync as mkdirSync4, mkdtempSync } from "node:fs";
 init_data_path();
@@ -155070,6 +155234,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";
 }
@@ -155792,6 +155986,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) {
@@ -155935,6 +156130,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
@@ -156036,6 +156243,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
@@ -156206,27 +156426,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);
@@ -156235,26 +156452,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) {
@@ -156326,10 +156545,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 [];
@@ -156344,6 +156593,10 @@ function getTagsByNumbers(db, sessionId, tagNumbers) {
   const rows = db.prepare(`SELECT ${TAG_SELECT_COLUMNS} FROM tags WHERE session_id = ? AND tag_number IN (${placeholders3}) 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;
@@ -157256,6 +157509,461 @@ function shouldKeepSubagents() {
 // src/index.ts
 init_logger();
 
+// src/clone-inheritance.ts
+import { readFile } from "node:fs/promises";
+init_logger();
+
+// src/read-session-pi.ts
+var SYNTH_USER_ID_PREFIX = "synth-user-";
+function resolvePiStableId(msg, index, entryIds, entryIdByRef) {
+  if (!msg || typeof msg !== "object")
+    return;
+  const byRef = entryIdByRef?.get(msg);
+  if (typeof byRef === "string" && byRef.length > 0)
+    return byRef;
+  const positional = entryIds?.[index];
+  if (typeof positional === "string" && positional.length > 0)
+    return positional;
+  const m = msg;
+  const role = m.role ?? "unknown";
+  return typeof m.timestamp === "number" ? `pi-msg-${index}-${m.timestamp}-${role}` : `pi-msg-${index}-${role}`;
+}
+function isMidTurnPi(event, _sessionId, branchEntries) {
+  const messages = event?.messages;
+  if (!Array.isArray(messages))
+    return false;
+  let latestAssistantIndex = -1;
+  let latestAssistant = null;
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const msg = messages[i];
+    if (msg !== null && typeof msg === "object") {
+      const record = msg;
+      if (record.role === "assistant") {
+        latestAssistantIndex = i;
+        latestAssistant = record;
+        break;
+      }
+    }
+  }
+  if (latestAssistant === null)
+    return false;
+  if (hasRealUserAfter(messages, latestAssistantIndex, branchEntries))
+    return false;
+  if (latestAssistant.stopReason === "toolUse")
+    return true;
+  const toolCallIds = getToolCallIds(latestAssistant.content);
+  if (toolCallIds.size === 0)
+    return false;
+  const pairedToolResultIds = new Set;
+  for (const msg of messages.slice(latestAssistantIndex + 1)) {
+    if (msg === null || typeof msg !== "object")
+      continue;
+    const record = msg;
+    if (record.role !== "toolResult")
+      continue;
+    if (typeof record.toolCallId === "string") {
+      pairedToolResultIds.add(record.toolCallId);
+    }
+  }
+  for (const id of toolCallIds) {
+    if (!pairedToolResultIds.has(id))
+      return true;
+  }
+  return false;
+}
+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;
+    const record = entry;
+    if (record.type !== "message")
+      continue;
+    const message = record.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;
+}
+function getToolCallIds(content) {
+  const ids = new Set;
+  if (!Array.isArray(content))
+    return ids;
+  for (const item of content) {
+    if (item === null || typeof item !== "object")
+      continue;
+    const record = item;
+    if (record.type === "toolCall" && typeof record.id === "string") {
+      ids.add(record.id);
+    }
+  }
+  return ids;
+}
+function readPiSessionMessages(ctx) {
+  const sm = ctx.sessionManager;
+  if (sm === undefined)
+    return [];
+  const getBranch = sm.getBranch;
+  if (typeof getBranch !== "function")
+    return [];
+  let entries;
+  try {
+    entries = getBranch.call(sm);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(entries))
+    return [];
+  return convertEntriesToRawMessages(entries);
+}
+function findLastModelKeyFromBranch(entries) {
+  if (!Array.isArray(entries))
+    return;
+  for (let i = entries.length - 1;i >= 0; i--) {
+    const e = entries[i];
+    if (!e || typeof e !== "object")
+      continue;
+    const v = e;
+    if (v.type !== "model_change")
+      continue;
+    if (typeof v.provider === "string" && v.provider.length > 0 && typeof v.modelId === "string" && v.modelId.length > 0) {
+      return `${v.provider}/${v.modelId}`;
+    }
+  }
+  return;
+}
+function rawEntryVersion(entry) {
+  const record = entry;
+  const updated = record.updatedAt ?? record.updated_at ?? record.timestamp;
+  return typeof updated === "string" || typeof updated === "number" ? updated : entry.id;
+}
+function attachPiPartVersion(parts, version) {
+  return parts.map((part) => {
+    if (part === null || typeof part !== "object" || Array.isArray(part))
+      return part;
+    try {
+      Object.defineProperty(part, "__magicContextPartUpdatedAt", {
+        value: version,
+        enumerable: false,
+        configurable: true
+      });
+    } catch {}
+    return part;
+  });
+}
+function convertEntriesToRawMessages(entries) {
+  const result = [];
+  let nextOrdinal = 1;
+  let pendingToolParts = [];
+  let pendingFirstRealId = "";
+  let pendingFirstRealVersion = "";
+  for (const entry of entries) {
+    if (!isMessageEntry(entry)) {
+      continue;
+    }
+    const msg = entry.message;
+    const role = msg.role;
+    if (role === "toolResult") {
+      const version = rawEntryVersion(entry);
+      pendingToolParts.push(...attachPiPartVersion(synthesizeToolResultParts(msg), version));
+      if (pendingFirstRealId === "") {
+        pendingFirstRealId = entry.id;
+        pendingFirstRealVersion = version;
+      }
+      continue;
+    }
+    if (role === "user") {
+      const version = rawEntryVersion(entry);
+      const parts = [
+        ...pendingToolParts,
+        ...attachPiPartVersion(synthesizeUserParts(msg), version)
+      ];
+      pendingToolParts = [];
+      pendingFirstRealId = "";
+      pendingFirstRealVersion = "";
+      result.push({
+        ordinal: nextOrdinal++,
+        id: entry.id,
+        role: "user",
+        parts,
+        version
+      });
+      continue;
+    }
+    if (role === "assistant") {
+      if (pendingToolParts.length > 0) {
+        result.push({
+          ordinal: nextOrdinal++,
+          id: `${SYNTH_USER_ID_PREFIX}${pendingFirstRealId}`,
+          role: "user",
+          parts: pendingToolParts,
+          version: pendingFirstRealVersion
+        });
+        pendingToolParts = [];
+        pendingFirstRealId = "";
+        pendingFirstRealVersion = "";
+      }
+      const version = rawEntryVersion(entry);
+      result.push({
+        ordinal: nextOrdinal++,
+        id: entry.id,
+        role: "assistant",
+        parts: attachPiPartVersion(synthesizeAssistantParts(msg), version),
+        version
+      });
+      continue;
+    }
+    result.push({
+      ordinal: nextOrdinal++,
+      id: entry.id,
+      role: typeof role === "string" ? role : "unknown",
+      parts: [],
+      version: rawEntryVersion(entry)
+    });
+  }
+  if (pendingToolParts.length > 0) {
+    result.push({
+      ordinal: nextOrdinal,
+      id: `${SYNTH_USER_ID_PREFIX}${pendingFirstRealId}`,
+      role: "user",
+      parts: pendingToolParts,
+      version: pendingFirstRealVersion
+    });
+  }
+  return result;
+}
+function isMessageEntry(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  const v = value;
+  if (v.type !== "message")
+    return false;
+  if (typeof v.id !== "string")
+    return false;
+  if (v.message === null || typeof v.message !== "object")
+    return false;
+  return true;
+}
+function synthesizeUserParts(msg) {
+  const m = msg;
+  if (typeof m.content === "string") {
+    if (m.content.trim().length === 0)
+      return [];
+    return [{ type: "text", text: m.content }];
+  }
+  if (!Array.isArray(m.content))
+    return [];
+  const parts = [];
+  for (const c of m.content) {
+    if (c === null || typeof c !== "object")
+      continue;
+    const cc = c;
+    if (cc.type === "text" && typeof cc.text === "string") {
+      parts.push({ type: "text", text: cc.text });
+    }
+  }
+  return parts;
+}
+function synthesizeAssistantParts(msg) {
+  const m = msg;
+  if (!Array.isArray(m.content))
+    return [];
+  const parts = [];
+  for (const c of m.content) {
+    if (c === null || typeof c !== "object")
+      continue;
+    const cc = c;
+    if (cc.type === "text" && typeof cc.text === "string") {
+      parts.push({ type: "text", text: cc.text });
+    } else if (cc.type === "toolCall" && typeof cc.id === "string") {
+      parts.push({
+        type: "tool",
+        tool: typeof cc.name === "string" ? cc.name : "unknown",
+        callID: cc.id,
+        state: {
+          input: cc.arguments ?? {}
+        }
+      });
+    }
+  }
+  return parts;
+}
+function synthesizeToolResultParts(msg) {
+  const m = msg;
+  const callID = typeof m.toolCallId === "string" ? m.toolCallId : "";
+  const tool = typeof m.toolName === "string" ? m.toolName : "unknown";
+  if (!callID)
+    return [];
+  let output = "";
+  if (Array.isArray(m.content)) {
+    const fragments = [];
+    for (const c of m.content) {
+      if (c === null || typeof c !== "object")
+        continue;
+      const cc = c;
+      if (cc.type === "text" && typeof cc.text === "string") {
+        fragments.push(cc.text);
+      }
+    }
+    output = fragments.join(`
+`);
+  }
+  return [
+    {
+      type: "tool",
+      tool,
+      callID,
+      state: {
+        output
+      }
+    }
+  ];
+}
+
+// src/clone-inheritance.ts
+var CONTENT_ID_SUFFIX2 = /:(?:p|file)\d+$/;
+function entryId(entry) {
+  if (entry === null || typeof entry !== "object")
+    return null;
+  const id = entry.id;
+  return typeof id === "string" && id.length > 0 ? id : null;
+}
+function branchPosition(entries, id) {
+  return entries.findIndex((entry) => entryId(entry) === id);
+}
+function latestCompactionFirstKept(entries) {
+  for (let index = entries.length - 1;index >= 0; index--) {
+    const entry = entries[index];
+    if (entry === null || typeof entry !== "object")
+      continue;
+    const value = entry;
+    if (value.type === "compaction" && typeof value.firstKeptEntryId === "string" && value.firstKeptEntryId.length > 0) {
+      return value.firstKeptEntryId;
+    }
+  }
+  return null;
+}
+function parsePendingMarker(raw) {
+  if (!raw)
+    return null;
+  try {
+    const value = JSON.parse(raw);
+    if (typeof value.firstKeptEntryId === "string" && typeof value.endMessageId === "string" && typeof value.ordinal === "number" && Number.isFinite(value.ordinal) && typeof value.tokensBefore === "number" && Number.isFinite(value.tokensBefore) && typeof value.summary === "string" && typeof value.publishedAt === "number" && Number.isFinite(value.publishedAt)) {
+      return value;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function createCloneFilter(entries) {
+  const rawMessages = convertEntriesToRawMessages([...entries]);
+  const rawOrdinalById = new Map(rawMessages.map((message) => [message.id, message.ordinal]));
+  const validStateIds = new Set(rawOrdinalById.keys());
+  for (const entry of entries) {
+    const id = entryId(entry);
+    if (id)
+      validStateIds.add(id);
+  }
+  const includeMessageId = (id) => validStateIds.has(id);
+  return {
+    resolveBoundaryOrdinal: (id) => rawOrdinalById.get(id),
+    includeMessageId,
+    includeTag: (tag) => {
+      if (tag.type === "tool") {
+        return typeof tag.toolOwnerMessageId === "string" && includeMessageId(tag.toolOwnerMessageId);
+      }
+      return rawOrdinalById.has(tag.messageId.replace(CONTENT_ID_SUFFIX2, ""));
+    },
+    selectPendingPiMarker: (rawState, copiedCompartments) => {
+      const pending = parsePendingMarker(rawState);
+      if (!pending)
+        return null;
+      const pendingFirstKeptPosition = branchPosition(entries, pending.firstKeptEntryId);
+      if (pendingFirstKeptPosition < 0)
+        return null;
+      const mappedOrdinal = rawOrdinalById.get(pending.endMessageId);
+      if (mappedOrdinal === undefined)
+        return null;
+      const matchingCompartment = copiedCompartments.find((compartment) => compartment.endMessageId === pending.endMessageId && compartment.endMessage === mappedOrdinal);
+      if (!matchingCompartment)
+        return null;
+      const currentFirstKept = latestCompactionFirstKept(entries);
+      if (currentFirstKept !== null) {
+        const currentPosition = branchPosition(entries, currentFirstKept);
+        if (currentPosition >= pendingFirstKeptPosition)
+          return null;
+      }
+      return JSON.stringify({ ...pending, ordinal: mappedOrdinal });
+    }
+  };
+}
+async function readPiSessionIdFromFile(filePath) {
+  const contents = await readFile(filePath, "utf8");
+  const newline = contents.indexOf(`
+`);
+  const headerText = newline >= 0 ? contents.slice(0, newline) : contents;
+  const header = JSON.parse(headerText);
+  if (header.type !== "session" || typeof header.id !== "string" || header.id.length === 0) {
+    throw new Error("previous session file has no valid session header");
+  }
+  return header.id;
+}
+async function handlePiCloneSessionStart(event, ctx, deps) {
+  if (event.reason !== "fork" || typeof event.previousSessionFile !== "string") {
+    return null;
+  }
+  let stage = "resolve-destination";
+  let sourceSessionId = "unknown";
+  let destinationSessionId = "unknown";
+  const writeLog = deps.writeLog ?? log;
+  try {
+    const manager = ctx.sessionManager;
+    if (typeof manager?.getSessionId !== "function") {
+      throw new Error("Pi session manager does not expose getSessionId");
+    }
+    destinationSessionId = manager.getSessionId() ?? "";
+    if (destinationSessionId.length === 0) {
+      throw new Error("Pi clone session id is empty");
+    }
+    stage = "read-source-header";
+    sourceSessionId = await readPiSessionIdFromFile(event.previousSessionFile);
+    stage = "read-clone-branch";
+    if (typeof manager.getBranch !== "function") {
+      throw new Error("Pi session manager does not expose getBranch");
+    }
+    const branchEntries = manager.getBranch();
+    if (!Array.isArray(branchEntries)) {
+      throw new Error("Pi clone branch is unavailable");
+    }
+    stage = "copy-state";
+    const result = copySessionStateForClone(deps.db, sourceSessionId, destinationSessionId, createCloneFilter(branchEntries));
+    if (result.kind === "destination-not-empty") {
+      writeLog(`[magic-context][pi] clone-inheritance: skipped source=${sourceSessionId} dest=${destinationSessionId} stage=destination-guard reason=destination-not-empty`);
+      return result;
+    }
+    stage = "signal-marker";
+    if (result.pendingMarkerMigrated) {
+      deps.signalPendingMarker(destinationSessionId);
+    }
+    writeLog(`[magic-context][pi] clone-inheritance: migrated compartments=${result.compartmentsCopied} tags=${result.tagsCopied} source=${sourceSessionId} dest=${destinationSessionId} reason=fork`);
+    return result;
+  } catch (error) {
+    writeLog(`[magic-context][pi] clone-inheritance: failed source=${sourceSessionId} dest=${destinationSessionId} stage=${stage} error=${error instanceof Error ? error.message : String(error)}; run /ctx-wrapup to rebuild, or re-clone`);
+    return null;
+  }
+}
+
 // ../plugin/src/agents/language-directive.ts
 var ENGLISH_LANGUAGE_NAMES = new Intl.DisplayNames(["en"], {
   type: "language",
@@ -157588,18 +158296,48 @@ function inferAccountingSubagent(agent) {
     return "recomp";
   return "historian";
 }
+var ALREADY_PROCESSING_PREFIX = "Agent is already processing";
+var ISOLATED_RETRY_MODEL_UNAVAILABLE_MESSAGE = "model unavailable in isolated retry: it is provided by a disabled extension; configure it through models.json or add a built-in/provider-configured fallback";
+var MODEL_RESOLUTION_ERROR_PATTERNS = [
+  /unknown model/i,
+  /unknown provider/i,
+  /model.+not found/i,
+  /provider.+not found/i,
+  /could not resolve model/i,
+  /no models? (matched|available|configured)/i,
+  /model.+not configured/i
+];
 
 class PiSubagentRunner {
   harness = "pi";
   invocation;
   spawnImpl;
   platform;
+  extraArgs;
   constructor(options = {}) {
     this.invocation = options.piBinary ? { command: options.piBinary, prefixArgs: [] } : resolvePiInvocation();
     this.spawnImpl = options.spawnImpl ?? childProcess.spawn;
     this.platform = options.platform ?? process.platform;
+    this.extraArgs = options.extraArgs ?? [];
   }
   async run(options) {
+    const primaryRunMode = { disableDiscoveredExtensions: false };
+    const primaryResult = await this.runModelChain(options, primaryRunMode);
+    if (this.spawnUsesNoExtensions(primaryRunMode) || !isPiExtensionCollisionFailure(primaryResult)) {
+      return primaryResult;
+    }
+    const sessionId = options.accountingSessionId ?? "pi-subagent";
+    sessionLog(sessionId, "pi subagent: a loaded Pi extension started an agent turn before the child's prompt could run; retrying with an isolated extension set (user extensions disabled for this run)");
+    const isolatedResult = await this.runModelChain(options, {
+      disableDiscoveredExtensions: true
+    });
+    if (!isolatedResult.ok && isIsolatedRetryModelUnavailable(isolatedResult)) {
+      sessionLog(sessionId, ISOLATED_RETRY_MODEL_UNAVAILABLE_MESSAGE);
+      return annotateIsolatedRetryModelUnavailable(isolatedResult);
+    }
+    return isolatedResult;
+  }
+  async runModelChain(options, runMode) {
     const models = [options.model, ...options.fallbackModels ?? []].filter((model) => typeof model === "string" && model.length > 0);
     const attempts = models.length > 0 ? models : [undefined];
     let lastResult = null;
@@ -157610,17 +158348,23 @@ class PiSubagentRunner {
         model,
         fallbackModels: undefined
       };
-      const result = await this.runOnce(attemptOptions);
+      const result = await this.runOnce(attemptOptions, runMode);
       if (result.ok)
         return result;
       lastResult = result;
+      if (!this.spawnUsesNoExtensions(runMode) && isPiExtensionCollisionFailure(result)) {
+        return result;
+      }
       if (index >= attempts.length - 1 || !isFallbackEligible(result.reason)) {
         return result;
       }
     }
-    return lastResult ?? this.runOnce({ ...options, fallbackModels: undefined });
+    return lastResult ?? this.runOnce({ ...options, fallbackModels: undefined }, runMode);
   }
-  async runOnce(options) {
+  spawnUsesNoExtensions(runMode) {
+    return runMode.disableDiscoveredExtensions || hasNoExtensionsArg([...this.invocation.prefixArgs, ...this.extraArgs]);
+  }
+  async runOnce(options, runMode) {
     const startTime = Date.now();
     let recordedAccounting = false;
     const recordAccounting = (result, messages = []) => {
@@ -157695,6 +158439,7 @@ class PiSubagentRunner {
       }
     }
     const args = buildArgs(options, {
+      disableDiscoveredExtensions: runMode.disableDiscoveredExtensions,
       omitPositionalMessage: deliverViaStdin,
       systemPromptPath
     });
@@ -157722,7 +158467,7 @@ class PiSubagentRunner {
       };
       let child;
       try {
-        child = this.spawnImpl(this.invocation.command, [...this.invocation.prefixArgs, ...args], {
+        child = this.spawnImpl(this.invocation.command, [...this.invocation.prefixArgs, ...this.extraArgs, ...args], {
           cwd: options.cwd,
           env: {
             ...process.env,
@@ -158016,6 +158761,32 @@ class PiSubagentRunner {
     });
   }
 }
+function getResultStderr(result) {
+  const stderr = result.meta?.stderr;
+  return typeof stderr === "string" ? stderr : "";
+}
+function hasNoExtensionsArg(args) {
+  return args.includes("--no-extensions");
+}
+function isPiExtensionCollisionFailure(result) {
+  return !result.ok && result.reason === "non_zero_exit" && getResultStderr(result).includes(ALREADY_PROCESSING_PREFIX);
+}
+function isIsolatedRetryModelUnavailable(result) {
+  if (result.ok)
+    return false;
+  const diagnosticText = `${result.error}
+${getResultStderr(result)}`;
+  return MODEL_RESOLUTION_ERROR_PATTERNS.some((pattern) => pattern.test(diagnosticText));
+}
+function annotateIsolatedRetryModelUnavailable(result) {
+  if (result.error.startsWith(ISOLATED_RETRY_MODEL_UNAVAILABLE_MESSAGE)) {
+    return result;
+  }
+  return {
+    ...result,
+    error: `${ISOLATED_RETRY_MODEL_UNAVAILABLE_MESSAGE}. Original failure: ${result.error}`
+  };
+}
 function isFallbackEligible(reason) {
   return reason === "model_failed" || reason === "truncated" || reason === "non_zero_exit" || reason === "no_assistant";
 }
@@ -158030,9 +158801,13 @@ function buildArgs(options, opts) {
     "--no-prompt-templates",
     "--no-context-files"
   ];
-  const shouldLoadSubagentExtension = SUBAGENT_ENTRY_PATH && (SEARCH_ONLY_SUBAGENT_TOOL_AGENTS.has(options.agent) || DREAMER_ACTION_AGENTS.has(options.agent));
+  if (opts?.disableDiscoveredExtensions) {
+    args.push("--no-extensions");
+  }
+  const subagentEntryPath = opts?.subagentEntryPath ?? SUBAGENT_ENTRY_PATH;
+  const shouldLoadSubagentExtension = subagentEntryPath && (SEARCH_ONLY_SUBAGENT_TOOL_AGENTS.has(options.agent) || DREAMER_ACTION_AGENTS.has(options.agent));
   if (shouldLoadSubagentExtension) {
-    args.push("--extension", SUBAGENT_ENTRY_PATH);
+    args.push("--extension", subagentEntryPath);
     if (DREAMER_ACTION_AGENTS.has(options.agent)) {
       args.push("--magic-context-dreamer-actions");
     }
@@ -173412,8 +174187,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.")
@@ -175131,7 +175909,7 @@ var GIT_SWEEP_COOLDOWN_MS = 10 * 60 * 1000;
 var GIT_SWEEP_LEASE_TTL_MS = 5 * 60 * 1000;
 var GIT_SWEEP_NON_INDEXABLE_REPROBE_MS = 24 * 60 * 60 * 1000;
 var GIT_SWEEP_LEASE_RENEWAL_MS = 60 * 1000;
-function runImmediate(db, body) {
+function runImmediate2(db, body) {
   db.exec("BEGIN IMMEDIATE");
   let committed = false;
   try {
@@ -175164,7 +175942,7 @@ function getGitSweepCoordinatorState(db, projectPath) {
 function acquireGitSweepLease(db, projectPath, holderId, options = {}) {
   const cooldownMs = options.cooldownMs ?? GIT_SWEEP_COOLDOWN_MS;
   const leaseTtlMs = options.leaseTtlMs ?? GIT_SWEEP_LEASE_TTL_MS;
-  return runImmediate(db, () => {
+  return runImmediate2(db, () => {
     const now = Date.now();
     const row = getGitSweepCoordinatorState(db, projectPath);
     if (row?.leaseHolder && row.leaseExpiresAt !== null && row.leaseExpiresAt > now) {
@@ -175212,7 +175990,7 @@ function acquireGitSweepLease(db, projectPath, holderId, options = {}) {
   });
 }
 function renewGitSweepLease(db, projectPath, holderId, leaseTtlMs = GIT_SWEEP_LEASE_TTL_MS) {
-  return runImmediate(db, () => {
+  return runImmediate2(db, () => {
     const now = Date.now();
     const leaseExpiresAt = now + leaseTtlMs;
     const result = db.prepare(`UPDATE git_sweep_coordinator
@@ -175224,7 +176002,7 @@ function renewGitSweepLease(db, projectPath, holderId, leaseTtlMs = GIT_SWEEP_LE
   });
 }
 function markGitSweepSuccessAndRelease(db, projectPath, holderId) {
-  return runImmediate(db, () => {
+  return runImmediate2(db, () => {
     const now = Date.now();
     const result = db.prepare(`UPDATE git_sweep_coordinator
                  SET lease_holder = NULL,
@@ -175237,7 +176015,7 @@ function markGitSweepSuccessAndRelease(db, projectPath, holderId) {
   });
 }
 function parkGitSweepNonIndexable(db, projectPath, holderId, reprobeMs = GIT_SWEEP_NON_INDEXABLE_REPROBE_MS) {
-  return runImmediate(db, () => {
+  return runImmediate2(db, () => {
     const now = Date.now();
     const sweptAt = now + reprobeMs - GIT_SWEEP_COOLDOWN_MS;
     const result = db.prepare(`UPDATE git_sweep_coordinator
@@ -175251,7 +176029,7 @@ function parkGitSweepNonIndexable(db, projectPath, holderId, reprobeMs = GIT_SWE
   });
 }
 function releaseGitSweepLease(db, projectPath, holderId) {
-  runImmediate(db, () => {
+  runImmediate2(db, () => {
     db.prepare(`UPDATE git_sweep_coordinator
              SET lease_holder = NULL,
                  lease_expires_at = NULL
@@ -177248,7 +178026,7 @@ function peekLeaseHolderAndExpiry(db, expectedHolder, leaseKey = DREAMING_LEASE_
   const expiry = Number(expiryStr);
   return Number.isFinite(expiry) && expiry >= Date.now();
 }
-function runImmediate2(db, body) {
+function runImmediate3(db, body) {
   db.exec("BEGIN IMMEDIATE");
   let committed = false;
   try {
@@ -177266,7 +178044,7 @@ function runImmediate2(db, body) {
 }
 function acquireLease(db, holderId, leaseKey = DREAMING_LEASE_KEY) {
   const keys = rowKeys(leaseKey);
-  return runImmediate2(db, () => {
+  return runImmediate3(db, () => {
     if (isLeaseActive(db, leaseKey)) {
       const existingHolder = getLeaseHolder(db, leaseKey);
       if (existingHolder && existingHolder !== holderId) {
@@ -177282,7 +178060,7 @@ function acquireLease(db, holderId, leaseKey = DREAMING_LEASE_KEY) {
 }
 function renewLease(db, holderId, leaseKey = DREAMING_LEASE_KEY) {
   const keys = rowKeys(leaseKey);
-  return runImmediate2(db, () => {
+  return runImmediate3(db, () => {
     if (getLeaseHolder(db, leaseKey) !== holderId || !isLeaseActive(db, leaseKey)) {
       return false;
     }
@@ -177293,7 +178071,7 @@ function renewLease(db, holderId, leaseKey = DREAMING_LEASE_KEY) {
   });
 }
 function runLeaseGuardedWrite(db, holderId, leaseKey, fn) {
-  return runImmediate2(db, () => {
+  return runImmediate3(db, () => {
     if (!peekLeaseHolderAndExpiry(db, holderId, leaseKey)) {
       throw new Error("Dream lease lost before guarded write");
     }
@@ -177347,7 +178125,7 @@ function startLeaseHeartbeat(db, holderId, leaseKey, onLost, intervalMs = LEASE_
 }
 function releaseLease(db, holderId, leaseKey = DREAMING_LEASE_KEY) {
   const keys = rowKeys(leaseKey);
-  runImmediate2(db, () => {
+  runImmediate3(db, () => {
     if (getLeaseHolder(db, leaseKey) !== holderId) {
       return;
     }
@@ -183320,6 +184098,9 @@ async function sweepGitCommits(args) {
   }
 }
 
+// src/embedding-bootstrap.ts
+import { statSync as statSync7 } from "node:fs";
+
 // ../plugin/src/plugin/embedding-bootstrap-helpers.ts
 import { createHash as createHash11 } from "node:crypto";
 init_logger();
@@ -183867,6 +184648,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 embedding2 = projectRaw.embedding;
   if (isPlainObject3(embedding2)) {
     const removed = [];
@@ -184540,8 +185325,38 @@ function loadPiConfigDetailed(opts = {}) {
 }
 
 // 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((path11, index, paths) => paths.indexOf(path11) === index);
+}
+function configFingerprint(paths) {
+  return paths.map((path11) => {
+    try {
+      const stat2 = statSync7(path11);
+      return `${path11}:${stat2.size}:${stat2.mtimeMs}`;
+    } catch {
+      return `${path11}: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);
@@ -184552,315 +185367,65 @@ async function ensureProjectRegisteredFromPiDirectory(directory, db) {
     gitCommitEnabled: detailed.config.memory.git_commit_indexing.enabled
   };
   registerProjectEmbedding(db, projectIdentity, detailed.config.embedding, features, directory);
-}
-
-// src/read-session-pi.ts
-var SYNTH_USER_ID_PREFIX = "synth-user-";
-function resolvePiStableId(msg, index, entryIds, entryIdByRef) {
-  if (!msg || typeof msg !== "object")
-    return;
-  const byRef = entryIdByRef?.get(msg);
-  if (typeof byRef === "string" && byRef.length > 0)
-    return byRef;
-  const positional = entryIds?.[index];
-  if (typeof positional === "string" && positional.length > 0)
-    return positional;
-  const m = msg;
-  const role = m.role ?? "unknown";
-  return typeof m.timestamp === "number" ? `pi-msg-${index}-${m.timestamp}-${role}` : `pi-msg-${index}-${role}`;
-}
-function isMidTurnPi(event, _sessionId) {
-  const messages = event?.messages;
-  if (!Array.isArray(messages))
-    return false;
-  let latestAssistantIndex = -1;
-  let latestAssistant = null;
-  for (let i = messages.length - 1;i >= 0; i--) {
-    const msg = messages[i];
-    if (msg !== null && typeof msg === "object") {
-      const record2 = msg;
-      if (record2.role === "assistant") {
-        latestAssistantIndex = i;
-        latestAssistant = record2;
-        break;
-      }
-    }
-  }
-  if (latestAssistant === null)
-    return false;
-  if (hasRealUserAfter(messages, latestAssistantIndex))
-    return false;
-  if (latestAssistant.stopReason === "toolUse")
-    return true;
-  const toolCallIds = getToolCallIds(latestAssistant.content);
-  if (toolCallIds.size === 0)
-    return false;
-  const pairedToolResultIds = new Set;
-  for (const msg of messages.slice(latestAssistantIndex + 1)) {
-    if (msg === null || typeof msg !== "object")
-      continue;
-    const record2 = msg;
-    if (record2.role !== "toolResult")
-      continue;
-    if (typeof record2.toolCallId === "string") {
-      pairedToolResultIds.add(record2.toolCallId);
-    }
-  }
-  for (const id of toolCallIds) {
-    if (!pairedToolResultIds.has(id))
-      return true;
-  }
-  return false;
-}
-function hasRealUserAfter(messages, latestAssistantIndex) {
-  for (const msg of messages.slice(latestAssistantIndex + 1)) {
-    if (msg === null || typeof msg !== "object")
-      continue;
-    if (msg.role === "user")
-      return true;
-  }
-  return false;
-}
-function getToolCallIds(content) {
-  const ids = new Set;
-  if (!Array.isArray(content))
-    return ids;
-  for (const item of content) {
-    if (item === null || typeof item !== "object")
-      continue;
-    const record2 = item;
-    if (record2.type === "toolCall" && typeof record2.id === "string") {
-      ids.add(record2.id);
-    }
-  }
-  return ids;
-}
-function readPiSessionMessages(ctx) {
-  const sm = ctx.sessionManager;
-  if (sm === undefined)
-    return [];
-  const getBranch = sm.getBranch;
-  if (typeof getBranch !== "function")
-    return [];
-  let entries;
-  try {
-    entries = getBranch.call(sm);
-  } catch {
-    return [];
-  }
-  if (!Array.isArray(entries))
-    return [];
-  return convertEntriesToRawMessages(entries);
-}
-function findLastModelKeyFromBranch(entries) {
-  if (!Array.isArray(entries))
-    return;
-  for (let i = entries.length - 1;i >= 0; i--) {
-    const e = entries[i];
-    if (!e || typeof e !== "object")
-      continue;
-    const v = e;
-    if (v.type !== "model_change")
-      continue;
-    if (typeof v.provider === "string" && v.provider.length > 0 && typeof v.modelId === "string" && v.modelId.length > 0) {
-      return `${v.provider}/${v.modelId}`;
-    }
-  }
-  return;
-}
-function rawEntryVersion(entry) {
-  const record2 = entry;
-  const updated = record2.updatedAt ?? record2.updated_at ?? record2.timestamp;
-  return typeof updated === "string" || typeof updated === "number" ? updated : entry.id;
-}
-function attachPiPartVersion(parts, version2) {
-  return parts.map((part) => {
-    if (part === null || typeof part !== "object" || Array.isArray(part))
-      return part;
-    try {
-      Object.defineProperty(part, "__magicContextPartUpdatedAt", {
-        value: version2,
-        enumerable: false,
-        configurable: true
-      });
-    } catch {}
-    return part;
+  const fingerprintPaths = configCandidatePaths(directory, detailed.loadedFromPaths);
+  registrationFingerprints.set(projectIdentity, {
+    paths: fingerprintPaths,
+    fingerprint: configFingerprint(fingerprintPaths)
   });
 }
-function convertEntriesToRawMessages(entries) {
-  const result = [];
-  let nextOrdinal = 1;
-  let pendingToolParts = [];
-  let pendingFirstRealId = "";
-  let pendingFirstRealVersion = "";
-  for (const entry of entries) {
-    if (!isMessageEntry(entry)) {
-      continue;
-    }
-    const msg = entry.message;
-    const role = msg.role;
-    if (role === "toolResult") {
-      const version2 = rawEntryVersion(entry);
-      pendingToolParts.push(...attachPiPartVersion(synthesizeToolResultParts(msg), version2));
-      if (pendingFirstRealId === "") {
-        pendingFirstRealId = entry.id;
-        pendingFirstRealVersion = version2;
-      }
-      continue;
-    }
-    if (role === "user") {
-      const version2 = rawEntryVersion(entry);
-      const parts = [
-        ...pendingToolParts,
-        ...attachPiPartVersion(synthesizeUserParts(msg), version2)
-      ];
-      pendingToolParts = [];
-      pendingFirstRealId = "";
-      pendingFirstRealVersion = "";
-      result.push({
-        ordinal: nextOrdinal++,
-        id: entry.id,
-        role: "user",
-        parts,
-        version: version2
-      });
-      continue;
-    }
-    if (role === "assistant") {
-      if (pendingToolParts.length > 0) {
-        result.push({
-          ordinal: nextOrdinal++,
-          id: `${SYNTH_USER_ID_PREFIX}${pendingFirstRealId}`,
-          role: "user",
-          parts: pendingToolParts,
-          version: pendingFirstRealVersion
-        });
-        pendingToolParts = [];
-        pendingFirstRealId = "";
-        pendingFirstRealVersion = "";
+
+// src/dreamer/pi-session-api.ts
+import { readFileSync as readFileSync9 } from "node:fs";
+import { createRequire as createRequire3 } from "node:module";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+var PI_CODING_AGENT_MODULE = "@earendil-works/pi-coding-agent";
+var defaultLoaders = [
+  {
+    name: "Bare import",
+    load: async () => await import(PI_CODING_AGENT_MODULE)
+  },
+  {
+    name: "Resolve from running Pi binary entry",
+    load: async () => {
+      if (!process.argv[1]) {
+        throw new Error("process.argv[1] is undefined");
       }
-      const version2 = rawEntryVersion(entry);
-      result.push({
-        ordinal: nextOrdinal++,
-        id: entry.id,
-        role: "assistant",
-        parts: attachPiPartVersion(synthesizeAssistantParts(msg), version2),
-        version: version2
-      });
-      continue;
+      const require2 = createRequire3(process.argv[1]);
+      const resolved = require2.resolve(PI_CODING_AGENT_MODULE);
+      return await import(pathToFileURL2(resolved).href);
     }
-    result.push({
-      ordinal: nextOrdinal++,
-      id: entry.id,
-      role: typeof role === "string" ? role : "unknown",
-      parts: [],
-      version: rawEntryVersion(entry)
-    });
-  }
-  if (pendingToolParts.length > 0) {
-    result.push({
-      ordinal: nextOrdinal,
-      id: `${SYNTH_USER_ID_PREFIX}${pendingFirstRealId}`,
-      role: "user",
-      parts: pendingToolParts,
-      version: pendingFirstRealVersion
-    });
   }
-  return result;
-}
-function isMessageEntry(value) {
-  if (value === null || typeof value !== "object")
-    return false;
-  const v = value;
-  if (v.type !== "message")
-    return false;
-  if (typeof v.id !== "string")
-    return false;
-  if (v.message === null || typeof v.message !== "object")
-    return false;
-  return true;
-}
-function synthesizeUserParts(msg) {
-  const m = msg;
-  if (typeof m.content === "string") {
-    if (m.content.trim().length === 0)
-      return [];
-    return [{ type: "text", text: m.content }];
-  }
-  if (!Array.isArray(m.content))
-    return [];
-  const parts = [];
-  for (const c of m.content) {
-    if (c === null || typeof c !== "object")
-      continue;
-    const cc = c;
-    if (cc.type === "text" && typeof cc.text === "string") {
-      parts.push({ type: "text", text: cc.text });
-    }
-  }
-  return parts;
-}
-function synthesizeAssistantParts(msg) {
-  const m = msg;
-  if (!Array.isArray(m.content))
-    return [];
-  const parts = [];
-  for (const c of m.content) {
-    if (c === null || typeof c !== "object")
-      continue;
-    const cc = c;
-    if (cc.type === "text" && typeof cc.text === "string") {
-      parts.push({ type: "text", text: cc.text });
-    } else if (cc.type === "toolCall" && typeof cc.id === "string") {
-      parts.push({
-        type: "tool",
-        tool: typeof cc.name === "string" ? cc.name : "unknown",
-        callID: cc.id,
-        state: {
-          input: cc.arguments ?? {}
-        }
-      });
-    }
-  }
-  return parts;
-}
-function synthesizeToolResultParts(msg) {
-  const m = msg;
-  const callID = typeof m.toolCallId === "string" ? m.toolCallId : "";
-  const tool = typeof m.toolName === "string" ? m.toolName : "unknown";
-  if (!callID)
-    return [];
-  let output = "";
-  if (Array.isArray(m.content)) {
-    const fragments = [];
-    for (const c of m.content) {
-      if (c === null || typeof c !== "object")
-        continue;
-      const cc = c;
-      if (cc.type === "text" && typeof cc.text === "string") {
-        fragments.push(cc.text);
+];
+var cachedModulePromise = null;
+async function resolvePiCodingAgentModule(loaders) {
+  if (cachedModulePromise) {
+    return cachedModulePromise;
+  }
+  const activeLoaders = loaders ?? defaultLoaders;
+  const promise2 = (async () => {
+    const errors3 = [];
+    for (const loader of activeLoaders) {
+      try {
+        return await loader.load();
+      } catch (err) {
+        errors3.push(err);
       }
     }
-    output = fragments.join(`
-`);
-  }
-  return [
-    {
-      type: "tool",
-      tool,
-      callID,
-      state: {
-        output
-      }
+    throw new Error(`Failed to resolve ${PI_CODING_AGENT_MODULE} via all strategies:
+` + errors3.map((e, i) => `  - ${activeLoaders[i].name}: ${e.message || e}`).join(`
+`) + `
+Likely cause: symlinked or nonstandard install layout.`);
+  })();
+  cachedModulePromise = promise2;
+  promise2.catch(() => {
+    if (cachedModulePromise === promise2) {
+      cachedModulePromise = null;
     }
-  ];
+  });
+  return promise2;
 }
-
-// src/dreamer/pi-session-api.ts
-import { readFileSync as readFileSync9 } from "node:fs";
-var PI_CODING_AGENT_MODULE = "@earendil-works/pi-coding-agent";
-async function loadDefaultPiSessionApi() {
-  const mod = await import(PI_CODING_AGENT_MODULE);
+async function loadDefaultPiSessionApi(loaders) {
+  const mod = await resolvePiCodingAgentModule(loaders);
   const listSessions = mod.SessionManager?.listAll;
   if (typeof listSessions !== "function") {
     throw new Error("Pi session APIs unavailable: expected SessionManager.listAll on pi-coding-agent");
@@ -185261,6 +185826,8 @@ function makeMessage(role, parts) {
 }
 
 // src/commands/pi-command-utils.ts
+init_logger();
+import { Box, Text } from "@earendil-works/pi-tui";
 var CTX_STATUS_CUSTOM_TYPE = "ctx-status";
 function resolveSessionId(ctx) {
   const sm = ctx.sessionManager;
@@ -185274,13 +185841,49 @@ function resolveSessionId(ctx) {
     return;
   }
 }
+function statusTitleColor(level) {
+  switch (level) {
+    case "success":
+      return "success";
+    case "warning":
+      return "warning";
+    case "error":
+      return "error";
+    default:
+      return "accent";
+  }
+}
+var renderCtxStatusEntry = (entry, _options, theme) => {
+  const data = entry?.data;
+  if (!data || typeof data !== "object" || typeof data.title !== "string" || typeof data.text !== "string") {
+    return;
+  }
+  const title = theme.bold(theme.fg(statusTitleColor(data.level), `[${data.title}]`));
+  const body = theme.fg("customMessageText", data.text);
+  const box = new Box(1, 0, (text) => theme.bg("customMessageBg", text));
+  box.addChild(new Text(`${title}
+${body}`));
+  return box;
+};
+function registerCtxStatusEntryRenderer(pi) {
+  if (typeof pi.registerEntryRenderer !== "function")
+    return false;
+  try {
+    pi.registerEntryRenderer(CTX_STATUS_CUSTOM_TYPE, renderCtxStatusEntry);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function sendCtxStatusMessage(pi, content, details) {
-  pi.sendMessage({
-    customType: CTX_STATUS_CUSTOM_TYPE,
-    content: content.text,
-    display: true,
-    details: { ...content, details }
-  }, { triggerTurn: false });
+  const data = {
+    ...content,
+    details: details ?? content.details
+  };
+  if (typeof pi.appendEntry === "function") {
+    pi.appendEntry(CTX_STATUS_CUSTOM_TYPE, data);
+  }
+  sessionLog("pi-status", `${content.title}: ${content.text}`);
 }
 
 // src/commands/ctx-dream.ts
@@ -185740,8 +186343,8 @@ function makeToolCompositeKey(ownerMsgId, callId) {
   return `${ownerMsgId}${TOOL_COMPOSITE_KEY_SEP}${callId}`;
 }
 var GET_COUNTER_SQL = `SELECT counter FROM session_meta WHERE session_id = ?`;
-var GET_ASSIGNMENTS_SQL = "SELECT message_id, tag_number, type, tool_owner_message_id FROM tags WHERE session_id = ? ORDER BY tag_number ASC";
-var GET_ASSIGNMENTS_SCOPED_SQL = "SELECT message_id, tag_number, type, tool_owner_message_id FROM tags WHERE session_id = ? AND tag_number >= ? ORDER BY tag_number ASC";
+var GET_ASSIGNMENTS_SQL = "SELECT message_id, tag_number, type, tool_owner_message_id, byte_size, token_count, input_byte_size, input_token_count FROM tags WHERE session_id = ? ORDER BY tag_number ASC";
+var GET_ASSIGNMENTS_SCOPED_SQL = "SELECT message_id, tag_number, type, tool_owner_message_id, byte_size, token_count, input_byte_size, input_token_count FROM tags WHERE session_id = ? AND tag_number >= ? ORDER BY tag_number ASC";
 var PROBE_DATA_VERSION_SQL = "PRAGMA main.data_version";
 var probeDataVersionStatements = new WeakMap;
 function getProbeDataVersionStatement(db) {
@@ -185765,6 +186368,14 @@ function isAssignmentRow(row) {
     return false;
   if (candidate.tool_owner_message_id !== null && typeof candidate.tool_owner_message_id !== "string")
     return false;
+  if (typeof candidate.byte_size !== "number")
+    return false;
+  if (candidate.token_count !== null && typeof candidate.token_count !== "number")
+    return false;
+  if (typeof candidate.input_byte_size !== "number")
+    return false;
+  if (candidate.input_token_count !== null && typeof candidate.input_token_count !== "number")
+    return false;
   return true;
 }
 var UPSERT_COUNTER_SQL = `
@@ -185799,6 +186410,7 @@ var MAX_TAG_ALLOC_RETRIES = 5;
 function createTagger() {
   const counters = new Map;
   const assignments = new Map;
+  const toolAccountingBySession = new Map;
   const loadSignatures = new Map;
   function getSessionAssignments(sessionId) {
     let map2 = assignments.get(sessionId);
@@ -185808,6 +186420,14 @@ function createTagger() {
     }
     return map2;
   }
+  function getSessionToolAccounting(sessionId) {
+    let map2 = toolAccountingBySession.get(sessionId);
+    if (!map2) {
+      map2 = new Map;
+      toolAccountingBySession.set(sessionId, map2);
+    }
+    return map2;
+  }
   function isUniqueConstraintError(error51) {
     return error51 instanceof Error && "code" in error51 && error51.code === "SQLITE_CONSTRAINT_UNIQUE";
   }
@@ -185861,6 +186481,14 @@ function createTagger() {
       }
       counters.set(sessionId, next);
       sessionAssignments.set(mapKey, next);
+      if (type === "tool") {
+        getSessionToolAccounting(sessionId).set(next, {
+          byteSize: byteSize2,
+          tokenCount: tokenCounts?.tokenCount ?? null,
+          inputByteSize,
+          inputTokenCount: tokenCounts?.inputTokenCount ?? null
+        });
+      }
       return next;
     }
     throw new Error(`tagger.allocateTag: failed to allocate tag for session=${sessionId} key=${mapKey} after ${MAX_TAG_ALLOC_RETRIES} retries`);
@@ -185921,6 +186549,13 @@ function createTagger() {
   function getToolTag(sessionId, callId, ownerMsgId) {
     return assignments.get(sessionId)?.get(makeToolCompositeKey(ownerMsgId, callId));
   }
+  function getToolTagAccounting(sessionId, callId, ownerMsgId) {
+    const tagNumber = getToolTag(sessionId, callId, ownerMsgId);
+    return tagNumber === undefined ? undefined : toolAccountingBySession.get(sessionId)?.get(tagNumber);
+  }
+  function setToolTagAccounting(sessionId, tagNumber, accounting) {
+    getSessionToolAccounting(sessionId).set(tagNumber, accounting);
+  }
   function bindTag(sessionId, messageId, tagNumber) {
     getSessionAssignments(sessionId).set(messageId, tagNumber);
   }
@@ -185939,6 +186574,7 @@ function createTagger() {
   function resetCounter(sessionId, db) {
     counters.set(sessionId, 0);
     assignments.delete(sessionId);
+    toolAccountingBySession.delete(sessionId);
     loadSignatures.delete(sessionId);
     getResetCounterStatement(db).run(sessionId, getHarness());
   }
@@ -185961,11 +186597,19 @@ function createTagger() {
     const assignmentRows = (floor > 0 ? db.prepare(GET_ASSIGNMENTS_SCOPED_SQL).all(sessionId, floor) : db.prepare(GET_ASSIGNMENTS_SQL).all(sessionId)).filter(isAssignmentRow);
     const sessionAssignments = getSessionAssignments(sessionId);
     sessionAssignments.clear();
+    const sessionToolAccounting = getSessionToolAccounting(sessionId);
+    sessionToolAccounting.clear();
     let maxTagNumber = 0;
     for (const assignment of assignmentRows) {
       if (assignment.type === "tool") {
         if (assignment.tool_owner_message_id !== null) {
           sessionAssignments.set(makeToolCompositeKey(assignment.tool_owner_message_id, assignment.message_id), assignment.tag_number);
+          sessionToolAccounting.set(assignment.tag_number, {
+            byteSize: assignment.byte_size,
+            tokenCount: assignment.token_count,
+            inputByteSize: assignment.input_byte_size,
+            inputTokenCount: assignment.input_token_count
+          });
         }
       } else {
         sessionAssignments.set(assignment.message_id, assignment.tag_number);
@@ -185985,6 +186629,7 @@ function createTagger() {
   function cleanup(sessionId) {
     counters.delete(sessionId);
     assignments.delete(sessionId);
+    toolAccountingBySession.delete(sessionId);
     loadSignatures.delete(sessionId);
   }
   return {
@@ -185992,6 +186637,8 @@ function createTagger() {
     assignToolTag,
     getTag,
     getToolTag,
+    getToolTagAccounting,
+    setToolTagAccounting,
     bindTag,
     unbindTag,
     bindToolTag,
@@ -187967,26 +188614,28 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
     sessionLog(sessionId, `compartment trigger: skipped — historian already in progress (usage=${usage.percentage.toFixed(1)}%)`);
     return { shouldFire: false };
   }
-  if (inMemoryTail) {
+  const lazyInMemoryTail = typeof inMemoryTail === "function" ? inMemoryTail : undefined;
+  let resolvedInMemoryTail = typeof inMemoryTail === "function" ? undefined : inMemoryTail;
+  if (resolvedInMemoryTail) {
     try {
       const policyVersion = loadProtectedTailMeta(db, sessionId).protectedTailPolicyVersion;
       if (policyVersion < 3)
-        inMemoryTail = undefined;
+        resolvedInMemoryTail = undefined;
     } catch {
-      inMemoryTail = undefined;
+      resolvedInMemoryTail = undefined;
     }
   }
-  const taggerFloor = taggerFloorOverride !== undefined && taggerFloorOverride > 0 ? taggerFloorOverride : inMemoryTail ? deriveTagLoadFloor(db, sessionId, inMemoryTail.messages.map((m) => m.id)) : 0;
+  const taggerFloor = taggerFloorOverride !== undefined && taggerFloorOverride > 0 ? taggerFloorOverride : resolvedInMemoryTail ? deriveTagLoadFloor(db, sessionId, resolvedInMemoryTail.messages.map((m) => m.id)) : 0;
   const proactiveFloorForGate = getProactiveCompartmentTriggerPercentage(executeThresholdPercentage);
   if (usage.percentage < proactiveFloorForGate) {
     try {
-      const boundFloor = inMemoryTail ? taggerFloor : 0;
+      const boundFloor = resolvedInMemoryTail || lazyInMemoryTail ? taggerFloor : 0;
       const { bound: persistedBound, nullCount } = getTriggerTagTokenUpperBound(db, sessionId, boundFloor);
       if (nullCount === 0) {
-        const untaggedUpperBound = inMemoryTail ? estimateUntaggedInMemoryTailUpperBound(db, sessionId, inMemoryTail, taggerFloor) : 0;
+        const untaggedUpperBound = resolvedInMemoryTail ? estimateUntaggedInMemoryTailUpperBound(db, sessionId, resolvedInMemoryTail, taggerFloor) : 0;
         const eligibleUpperBound = persistedBound + untaggedUpperBound;
         if (eligibleUpperBound < triggerBudget) {
-          const memorySuffix = inMemoryTail ? ` (persisted=${persistedBound}, untagged-memory≤${untaggedUpperBound})` : "";
+          const memorySuffix = resolvedInMemoryTail ? ` (persisted=${persistedBound}, untagged-memory≤${untaggedUpperBound})` : "";
           sessionLog(sessionId, `compartment trigger: cheap-skip at ${usage.percentage.toFixed(1)}% (below proactive floor ${proactiveFloorForGate}%) — live-tail upper bound ${eligibleUpperBound}${memorySuffix} < triggerBudget ${triggerBudget}; no size trigger possible, skipped full raw read`);
           return { shouldFire: false };
         }
@@ -187995,7 +188644,16 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
       sessionLog(sessionId, `compartment trigger: cheap-gate skipped (falling through to full read): ${error51 instanceof Error ? error51.message : String(error51)}`);
     }
   }
-  const tailInfo = getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, inMemoryTail, taggerFloor);
+  if (lazyInMemoryTail) {
+    try {
+      const policyVersion = loadProtectedTailMeta(db, sessionId).protectedTailPolicyVersion;
+      if (policyVersion >= 3)
+        resolvedInMemoryTail = lazyInMemoryTail();
+    } catch {
+      resolvedInMemoryTail = undefined;
+    }
+  }
+  const tailInfo = getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, resolvedInMemoryTail, taggerFloor);
   if (!tailInfo.hasNewRawHistory) {
     try {
       const lastCompartmentEnd = getLastCompartmentEndMessage(db, sessionId);
@@ -188022,11 +188680,11 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
     }
     const scale = usage.percentage >= BLOCK_UNTIL_DONE_PERCENTAGE ? 0.25 : 0.5;
     const scaledBoundary = withRawSessionMessageCache(() => {
-      if (inMemoryTail) {
+      if (resolvedInMemoryTail) {
         primeInMemoryTailRawMessageCache({
           sessionId,
-          messages: inMemoryTail.messages,
-          absoluteMessageCount: inMemoryTail.absoluteMessageCount
+          messages: resolvedInMemoryTail.messages,
+          absoluteMessageCount: resolvedInMemoryTail.absoluteMessageCount
         });
       }
       return resolveOpenCodeProtectedTailBoundary({
@@ -188313,12 +188971,26 @@ 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 compartmentHeading(c) {
+  const dateRange = formatDateRange(c.startDate, c.endDate);
+  const dateSegment = dateRange ? ` · ${dateRange}` : "";
+  return `## ${c.startMessage}-${c.endMessage}${dateSegment} · ${c.title}`;
+}
+function guardCompartmentBody(body) {
+  return body.replace(/^## /gm, " ## ");
+}
 function isTieredRow(c) {
   return typeof c.p1 === "string" && c.p1.length > 0;
 }
@@ -188348,25 +189020,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);
@@ -188489,33 +189158,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(memory, workspace) {
   return resolveStoredPathWorkspaceIdentity(memory.projectPath, workspace.identities, workspace.canonicalIdentityByStoredPath);
@@ -188533,11 +189178,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;
@@ -188548,13 +189200,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 memory of selectionOrder) {
-    const memoryTokens = estimateTokens(renderMemoryLineV2(memory, renderOptions.sourceNameByMemoryId?.get(memory.id)));
-    if (usedTokens + memoryTokens > budgetTokens)
+    const cost = accounting.candidateCost(memory);
+    if (accounting.usedTokens + cost > budgetTokens)
       continue;
+    accounting.admit(memory, cost);
     selected.push(memory);
-    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`);
@@ -188568,23 +189220,22 @@ function trimWorkspaceMemoriesToBudgetV2(sessionId, memories, budgetTokens, work
   }
   const selected = [];
   const selectedIds = new Set;
-  let usedTokens = MEMORY_BLOCK_WRAPPER_TOKENS;
-  const tokenCost = (memory) => estimateTokens(renderMemoryLineV2(memory, renderOptions.sourceNameByMemoryId?.get(memory.id)));
+  const accounting = createMemoryBlockAccounting(renderOptions);
   const trySelect = (memory) => {
     if (selectedIds.has(memory.id))
       return false;
-    const tokens = tokenCost(memory);
-    if (usedTokens + tokens > budgetTokens)
+    const cost = accounting.candidateCost(memory);
+    if (accounting.usedTokens + cost > budgetTokens)
       return false;
     selected.push(memory);
     selectedIds.add(memory.id);
-    usedTokens += tokens;
+    accounting.admit(memory, cost);
     return true;
   };
   for (const memory of memories.filter((candidate) => candidate.status === "permanent").sort(memorySelectionOrder)) {
     trySelect(memory);
   }
-  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 memory of memories) {
@@ -188603,15 +189254,15 @@ function trimWorkspaceMemoriesToBudgetV2(sessionId, memories, budgetTokens, work
     for (const memory of candidates) {
       if (selectedIds.has(memory.id))
         continue;
-      const tokens = tokenCost(memory);
-      if (memberTokens + tokens > floorTokens)
+      const cost = accounting.candidateCost(memory);
+      if (memberTokens + cost > floorTokens)
         continue;
-      if (usedTokens + tokens > budgetTokens)
+      if (accounting.usedTokens + cost > budgetTokens)
         continue;
       selected.push(memory);
       selectedIds.add(memory.id);
-      usedTokens += tokens;
-      memberTokens += tokens;
+      accounting.admit(memory, cost);
+      memberTokens += cost;
     }
   }
   const remaining = memories.filter((memory) => !selectedIds.has(memory.id)).sort(memorySelectionOrder);
@@ -188635,17 +189286,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(memory) {
+      const line = renderMemoryLineV2(memory, renderOptions.sourceNameByMemoryId?.get(memory.id));
+      let cost = estimateTokens(`${line}
+`);
+      if (!seenCategories.has(memory.category)) {
+        let tags = categoryCost.get(memory.category);
+        if (tags === undefined) {
+          tags = estimateTokens(`<${escapeXmlAttr(memory.category)}>
+</${escapeXmlAttr(memory.category)}>
+`);
+          categoryCost.set(memory.category, tags);
+        }
+        cost += tags;
+      }
+      return cost;
+    },
+    admit(memory, cost) {
+      this.usedTokens += cost;
+      seenCategories.add(memory.category);
+    }
+  };
+}
 function renderMemoryLineV2(memory, sourceName) {
-  const sourceAttr = sourceName ? ` source="${escapeXmlAttr(sourceName)}"` : "";
-  return `  <memory id="${memory.id}" category="${escapeXmlAttr(memory.category)}"${sourceAttr} importance="${memory.importance ?? 50}">${escapeXmlContent(memory.content)}</memory>`;
+  const source = sourceName ? ` [${escapeXmlContent(sourceName)}]` : "";
+  return `#${memory.id}${source}: ${escapeXmlContent(memory.content)}`;
 }
 function renderMemoryBlockV2(memories, wrapper = "project-memory", renderOptions = {}) {
   if (memories.length === 0)
     return "";
+  const ordered = [...memories].sort(memoryRenderOrder);
   const lines = [`<${wrapper}>`];
-  for (const memory of memories) {
+  let openCategory;
+  for (const memory of ordered) {
+    if (memory.category !== openCategory) {
+      if (openCategory !== undefined)
+        lines.push(`</${escapeXmlAttr(openCategory)}>`);
+      openCategory = memory.category;
+      lines.push(`<${escapeXmlAttr(openCategory)}>`);
+    }
     lines.push(renderMemoryLineV2(memory, renderOptions.sourceNameByMemoryId?.get(memory.id)));
   }
+  if (openCategory !== undefined)
+    lines.push(`</${escapeXmlAttr(openCategory)}>`);
   lines.push(`</${wrapper}>`);
   return lines.join(`
 `);
@@ -188939,6 +189628,7 @@ function readUint32BE(b, offset) {
 function tagTranscript(sessionId, transcript, tagger, db, options = {}) {
   const skipPrefixInjection = options.skipPrefixInjection === true;
   const targets = new Map;
+  const timing = options.onTiming ? { identity: 0, prefix: 0, targets: 0, tokenCounting: 0 } : undefined;
   const toolAggregates = new Map;
   const openToolAggregateKeysByCallId = new Map;
   let activeToolResultRun;
@@ -188948,6 +189638,7 @@ function tagTranscript(sessionId, transcript, tagger, db, options = {}) {
       continue;
     activeToolResultRun = undefined;
     const messageId = message.info.id;
+    const reuseIdentity = messageId !== undefined && options.reuseMessageIds?.has(messageId) === true;
     let textOrdinal = 0;
     const parts = message.parts;
     for (let partIndex = 0;partIndex < parts.length; partIndex += 1) {
@@ -188973,7 +189664,10 @@ function tagTranscript(sessionId, transcript, tagger, db, options = {}) {
           db,
           targets,
           skipPrefixInjection,
-          entryFingerprint: options.entryFingerprintByMessageId?.get(messageId) ?? null
+          entryFingerprint: options.entryFingerprintByMessageId?.get(messageId) ?? null,
+          reuseIdentity,
+          timing,
+          textTokenCache: options.textTokenCache
         });
         textOrdinal += 1;
         continue;
@@ -188983,12 +189677,8 @@ function tagTranscript(sessionId, transcript, tagger, db, options = {}) {
           activeToolResultRun = undefined;
           continue;
         }
+        const identityStart = timing ? performance.now() : 0;
         const callId = part.id;
-        const text = part.getText() ?? "";
-        const toolByteSize = getToolPartByteSize(part, text);
-        const toolTokenCount = getToolPartTokenCount(part, text);
-        const meta3 = part.getToolMetadata();
-        const inputTokenCount = meta3.inputTokenCount;
         if (typeof callId !== "string" || callId.length === 0) {
           activeToolResultRun = undefined;
           tagToolPart({
@@ -189001,7 +189691,9 @@ function tagTranscript(sessionId, transcript, tagger, db, options = {}) {
             tagger,
             db,
             targets,
-            skipPrefixInjection
+            skipPrefixInjection,
+            reuseIdentity,
+            timing
           });
           continue;
         }
@@ -189017,79 +189709,234 @@ function tagTranscript(sessionId, transcript, tagger, db, options = {}) {
         const aggregateKey = existingKey ?? makeToolCompositeKey(messageId, callId);
         const existing = toolAggregates.get(aggregateKey);
         if (existing) {
-          existing.occurrences.push({
-            message,
+          existing.occurrences.push({ message, part, kind: part.kind });
+          const canReuseIdentity = reuseIdentity && existing.identityReusable;
+          let text2 = "";
+          if (canReuseIdentity) {
+            if (part.kind === "tool_result") {
+              text2 = part.getText() ?? "";
+              applyGrownToolResultAccounting({
+                db,
+                sessionId,
+                tagger,
+                aggregate: existing,
+                byteSize: getToolPartByteSize(part, text2),
+                part,
+                text: text2,
+                timing,
+                tokenCache: options.toolTokenCache,
+                tokenCacheKey: aggregateKey
+              });
+            }
+            if (timing)
+              timing.identity += performance.now() - identityStart;
+          } else {
+            const accounting = readAggregateToolAccounting(part, timing, options.toolTokenCache, aggregateKey);
+            text2 = accounting.text;
+            if (part.kind === "tool_result") {
+              applyGrownToolResultAccounting({
+                db,
+                sessionId,
+                tagger,
+                aggregate: existing,
+                byteSize: accounting.byteSize,
+                part,
+                text: text2,
+                timing,
+                knownTokenCount: accounting.tokenCount
+              });
+            }
+            if (existing.toolName === null && accounting.toolName) {
+              existing.toolName = accounting.toolName;
+            }
+            if (existing.inputByteSize === 0 && part.kind === "tool_use" && accounting.inputByteSize > 0) {
+              existing.inputByteSize = accounting.inputByteSize;
+              updateTagInputByteSize(db, sessionId, existing.tagId, accounting.inputByteSize);
+            }
+            if (existing.inputTokenCount === null && part.kind === "tool_use" && accounting.inputTokenCount > 0) {
+              existing.inputTokenCount = accounting.inputTokenCount;
+              updateTagInputTokenCount(db, sessionId, existing.tagId, accounting.inputTokenCount);
+            }
+            syncToolAggregateAccounting(tagger, sessionId, existing);
+            if (timing)
+              timing.identity += performance.now() - identityStart;
+          }
+          existing.identityReusable &&= reuseIdentity;
+          applyToolPrefixAndTarget({
+            skipPrefixInjection,
             part,
-            kind: part.kind
+            text: text2,
+            tagId: existing.tagId,
+            aggregate: existing,
+            targets,
+            timing
           });
-          if (part.kind === "tool_result" && toolByteSize > existing.maxByteSize) {
-            existing.maxByteSize = toolByteSize;
-            existing.maxTokenCount = toolTokenCount;
-            updateTagByteSize(db, sessionId, existing.tagId, toolByteSize);
-            updateTagTokenCount(db, sessionId, existing.tagId, toolTokenCount);
-          }
-          if (existing.toolName === null && meta3.toolName) {
-            existing.toolName = meta3.toolName;
-          }
-          if (existing.inputByteSize === 0 && part.kind === "tool_use" && meta3.inputByteSize > 0) {
-            existing.inputByteSize = meta3.inputByteSize;
-            updateTagInputByteSize(db, sessionId, existing.tagId, meta3.inputByteSize);
-          }
-          if (!existing.inputTokenStored && part.kind === "tool_use" && inputTokenCount > 0) {
-            existing.inputTokenStored = true;
-            updateTagInputTokenCount(db, sessionId, existing.tagId, inputTokenCount);
-          }
-          if (!skipPrefixInjection && part.kind === "tool_result") {
-            part.setText(prependTag(existing.tagId, text));
-          }
-          targets.set(existing.tagId, buildAggregateTarget(existing.tagId, existing.occurrences));
           if (part.kind === "tool_result") {
             markToolAggregateResolved(callId, aggregateKey, openToolAggregateKeysByCallId);
             activeToolResultRun = { callId, aggregateKey };
           }
+          continue;
+        }
+        const reusableTagId = reuseIdentity ? tagger.getToolTag(sessionId, callId, messageId) : undefined;
+        const reusableAccounting = reuseIdentity ? tagger.getToolTagAccounting(sessionId, callId, messageId) : undefined;
+        let aggregate;
+        let text = "";
+        if (reusableTagId !== undefined && reusableAccounting !== undefined) {
+          aggregate = {
+            callId,
+            tagId: reusableTagId,
+            identityReusable: true,
+            occurrences: [{ message, part, kind: part.kind }],
+            maxByteSize: reusableAccounting.byteSize,
+            maxTokenCount: reusableAccounting.tokenCount ?? 0,
+            toolName: null,
+            inputByteSize: reusableAccounting.inputByteSize,
+            inputTokenCount: reusableAccounting.inputTokenCount
+          };
+          if (part.kind === "tool_result") {
+            text = part.getText() ?? "";
+            applyGrownToolResultAccounting({
+              db,
+              sessionId,
+              tagger,
+              aggregate,
+              byteSize: getToolPartByteSize(part, text),
+              part,
+              text,
+              timing,
+              tokenCache: options.toolTokenCache,
+              tokenCacheKey: aggregateKey
+            });
+          }
+          if (timing)
+            timing.identity += performance.now() - identityStart;
         } else {
-          const outputByteSize = part.kind === "tool_result" ? toolByteSize : 0;
-          const outputTokenCount = part.kind === "tool_result" ? toolTokenCount : 0;
-          const firstInputTokenCount = part.kind === "tool_use" ? inputTokenCount : 0;
-          const tagId = tagger.assignToolTag(sessionId, callId, messageId, outputByteSize, db, 0, meta3.toolName ?? null, meta3.inputByteSize, () => ({
+          const accounting = readAggregateToolAccounting(part, timing, options.toolTokenCache, aggregateKey);
+          text = accounting.text;
+          const outputByteSize = part.kind === "tool_result" ? accounting.byteSize : 0;
+          const outputTokenCount = part.kind === "tool_result" ? accounting.tokenCount : 0;
+          const firstInputTokenCount = part.kind === "tool_use" ? accounting.inputTokenCount : 0;
+          const tagId = tagger.assignToolTag(sessionId, callId, messageId, outputByteSize, db, 0, accounting.toolName, accounting.inputByteSize, () => ({
             tokenCount: outputTokenCount,
             inputTokenCount: firstInputTokenCount,
             reasoningTokenCount: null
           }));
-          const aggregate = {
+          const persistedAccounting = tagger.getToolTagAccounting(sessionId, callId, messageId);
+          aggregate = {
             callId,
             tagId,
-            occurrences: [
-              {
-                message,
-                part,
-                kind: part.kind
-              }
-            ],
-            maxByteSize: outputByteSize,
-            maxTokenCount: outputTokenCount,
-            toolName: meta3.toolName ?? null,
-            inputByteSize: part.kind === "tool_use" ? meta3.inputByteSize : 0,
-            inputTokenStored: part.kind === "tool_use" && firstInputTokenCount > 0
+            identityReusable: false,
+            occurrences: [{ message, part, kind: part.kind }],
+            maxByteSize: persistedAccounting?.byteSize ?? outputByteSize,
+            maxTokenCount: persistedAccounting?.tokenCount ?? outputTokenCount,
+            toolName: accounting.toolName,
+            inputByteSize: persistedAccounting?.inputByteSize ?? (part.kind === "tool_use" ? accounting.inputByteSize : 0),
+            inputTokenCount: persistedAccounting?.inputTokenCount ?? (part.kind === "tool_use" ? firstInputTokenCount : null)
           };
-          toolAggregates.set(aggregateKey, aggregate);
-          if (part.kind === "tool_use") {
-            openToolAggregateKeysByCallId.set(callId, [...pendingKeys, aggregateKey]);
-          }
-          if (!skipPrefixInjection && part.kind === "tool_result") {
-            part.setText(prependTag(tagId, text));
-          }
-          targets.set(tagId, buildAggregateTarget(tagId, aggregate.occurrences));
           if (part.kind === "tool_result") {
-            markToolAggregateResolved(callId, aggregateKey, openToolAggregateKeysByCallId);
-            activeToolResultRun = { callId, aggregateKey };
+            applyGrownToolResultAccounting({
+              db,
+              sessionId,
+              tagger,
+              aggregate,
+              byteSize: accounting.byteSize,
+              part,
+              text,
+              timing,
+              knownTokenCount: accounting.tokenCount
+            });
           }
+          syncToolAggregateAccounting(tagger, sessionId, aggregate);
+          if (timing)
+            timing.identity += performance.now() - identityStart;
+        }
+        toolAggregates.set(aggregateKey, aggregate);
+        if (part.kind === "tool_use") {
+          openToolAggregateKeysByCallId.set(callId, [...pendingKeys, aggregateKey]);
+        }
+        applyToolPrefixAndTarget({
+          skipPrefixInjection,
+          part,
+          text,
+          tagId: aggregate.tagId,
+          aggregate,
+          targets,
+          timing
+        });
+        if (part.kind === "tool_result") {
+          markToolAggregateResolved(callId, aggregateKey, openToolAggregateKeysByCallId);
+          activeToolResultRun = { callId, aggregateKey };
         }
       }
     }
   }
+  if (timing && options.onTiming) {
+    options.onTiming("identity", timing.identity);
+    options.onTiming("prefix", timing.prefix);
+    options.onTiming("targets", timing.targets);
+    options.onTiming("tokenCounting", timing.tokenCounting);
+  }
   return { targets };
 }
+function syncToolAggregateAccounting(tagger, sessionId, aggregate) {
+  tagger.setToolTagAccounting(sessionId, aggregate.tagId, {
+    byteSize: aggregate.maxByteSize,
+    tokenCount: aggregate.maxTokenCount,
+    inputByteSize: aggregate.inputByteSize,
+    inputTokenCount: aggregate.inputTokenCount
+  });
+}
+function applyGrownToolResultAccounting(args) {
+  if (args.byteSize <= args.aggregate.maxByteSize)
+    return;
+  let tokenCount = args.knownTokenCount;
+  if (tokenCount !== undefined && args.tokenCacheKey) {
+    args.tokenCache?.set(args.tokenCacheKey, { text: args.text, tokenCount });
+  }
+  if (tokenCount === undefined) {
+    const tokenStart = args.timing ? performance.now() : 0;
+    tokenCount = getCachedToolPartTokenCount(args.part, args.text, args.tokenCache, args.tokenCacheKey);
+    if (args.timing)
+      args.timing.tokenCounting += performance.now() - tokenStart;
+  }
+  args.aggregate.maxByteSize = args.byteSize;
+  args.aggregate.maxTokenCount = tokenCount;
+  updateTagByteSize(args.db, args.sessionId, args.aggregate.tagId, args.byteSize);
+  updateTagTokenCount(args.db, args.sessionId, args.aggregate.tagId, tokenCount);
+  syncToolAggregateAccounting(args.tagger, args.sessionId, args.aggregate);
+}
+function readAggregateToolAccounting(part, timing, tokenCache, tokenCacheKey) {
+  const text = part.getText() ?? "";
+  const byteSize2 = getToolPartByteSize(part, text);
+  const metadata = part.getToolMetadata();
+  let tokenCount = 0;
+  if (part.kind === "tool_result") {
+    const tokenStart = timing ? performance.now() : 0;
+    tokenCount = getCachedToolPartTokenCount(part, text, tokenCache, tokenCacheKey);
+    if (timing)
+      timing.tokenCounting += performance.now() - tokenStart;
+  }
+  return {
+    text,
+    byteSize: byteSize2,
+    tokenCount,
+    toolName: metadata.toolName ?? null,
+    inputByteSize: metadata.inputByteSize,
+    inputTokenCount: metadata.inputTokenCount
+  };
+}
+function applyToolPrefixAndTarget(args) {
+  if (!args.skipPrefixInjection && args.part.kind === "tool_result") {
+    const prefixStart = args.timing ? performance.now() : 0;
+    args.part.setText(prependTag(args.tagId, args.text));
+    if (args.timing)
+      args.timing.prefix += performance.now() - prefixStart;
+  }
+  const targetStart = args.timing ? performance.now() : 0;
+  args.targets.set(args.tagId, buildAggregateTarget(args.tagId, args.aggregate.occurrences));
+  if (args.timing)
+    args.timing.targets += performance.now() - targetStart;
+}
 function findLastUnresolvedToolAggregateKey(pendingKeys, toolAggregates) {
   for (let i = pendingKeys.length - 1;i >= 0; i -= 1) {
     const key = pendingKeys[i];
@@ -189140,6 +189987,15 @@ function getToolPartTokenCount(part, text) {
   }
   return 0;
 }
+function getCachedToolPartTokenCount(part, text, cache, cacheKey2) {
+  const cached2 = cacheKey2 ? cache?.get(cacheKey2) : undefined;
+  if (cached2?.text === text)
+    return cached2.tokenCount;
+  const tokenCount = getToolPartTokenCount(part, text);
+  if (cacheKey2)
+    cache?.set(cacheKey2, { text, tokenCount });
+  return tokenCount;
+}
 function getNonTextToolResultByteSize(part) {
   const raw = part.rawByteSize?.();
   if (typeof raw === "number" && raw > 0)
@@ -189160,39 +190016,97 @@ function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
 function tagTextPart(args) {
+  const identityStart = args.timing ? performance.now() : 0;
   const text = args.part.getText() ?? "";
   const contentId = `${args.messageId}:p${args.textOrdinal}`;
-  const tagId = args.tagger.assignTag(args.sessionId, contentId, "message", byteSize(text), args.db, 0, null, 0, args.entryFingerprint, () => ({
-    tokenCount: estimateTagTextTokens(stripTagPrefix(text)),
-    inputTokenCount: null,
-    reasoningTokenCount: null
-  }));
+  const reusableTagId = args.reuseIdentity ? args.tagger.getTag(args.sessionId, contentId, "message") : undefined;
+  if (reusableTagId !== undefined) {
+    if (args.timing)
+      args.timing.identity += performance.now() - identityStart;
+    applyTextPrefixAndTarget(args, reusableTagId, text);
+    return;
+  }
+  const tagId = args.tagger.assignTag(args.sessionId, contentId, "message", byteSize(text), args.db, 0, null, 0, args.entryFingerprint, () => {
+    const tokenStart = args.timing ? performance.now() : 0;
+    const cached2 = args.textTokenCache?.get(contentId);
+    const tokenCount = cached2?.text === text ? cached2.tokenCount : estimateTagTextTokens(stripTagPrefix(text));
+    if (cached2?.text !== text) {
+      args.textTokenCache?.set(contentId, { text, tokenCount });
+    }
+    const counts = {
+      tokenCount,
+      inputTokenCount: null,
+      reasoningTokenCount: null
+    };
+    if (args.timing)
+      args.timing.tokenCounting += performance.now() - tokenStart;
+    return counts;
+  });
   const sourceContent = stripTagPrefix(text);
   if (sourceContent.trim().length > 0) {
     saveSourceContent(args.db, args.sessionId, tagId, sourceContent);
   }
+  if (args.timing)
+    args.timing.identity += performance.now() - identityStart;
+  applyTextPrefixAndTarget(args, tagId, text);
+}
+function applyTextPrefixAndTarget(args, tagId, text) {
   if (!args.skipPrefixInjection) {
+    const prefixStart = args.timing ? performance.now() : 0;
     args.part.setText(prependTag(tagId, text));
+    if (args.timing)
+      args.timing.prefix += performance.now() - prefixStart;
   }
+  const targetStart = args.timing ? performance.now() : 0;
   args.targets.set(tagId, buildTextTarget(args.part, args.message));
+  if (args.timing)
+    args.timing.targets += performance.now() - targetStart;
 }
 function tagToolPart(args) {
+  const identityStart = args.timing ? performance.now() : 0;
   const stableId = args.part.id;
   const contentId = stableId ?? `${args.messageId}:t${args.partIndex}`;
+  const reusableTagId = args.reuseIdentity ? args.tagger.getToolTag(args.sessionId, contentId, contentId) : undefined;
+  if (reusableTagId !== undefined) {
+    const text2 = args.part.kind === "tool_result" ? args.part.getText() ?? "" : "";
+    if (args.timing)
+      args.timing.identity += performance.now() - identityStart;
+    applySingleToolPrefixAndTarget(args, reusableTagId, text2);
+    return;
+  }
   const text = args.part.getText() ?? "";
   const toolByteSize = getToolPartByteSize(args.part, text);
-  const toolTokenCount = getToolPartTokenCount(args.part, text);
   const meta3 = args.part.getToolMetadata();
-  const tagId = args.tagger.assignToolTag(args.sessionId, contentId, contentId, toolByteSize, args.db, 0, meta3.toolName ?? null, meta3.inputByteSize, () => ({
-    tokenCount: toolTokenCount,
-    inputTokenCount: meta3.inputTokenCount,
-    reasoningTokenCount: null
-  }));
+  const tokenStart = args.timing ? performance.now() : 0;
+  const toolTokenCount = getToolPartTokenCount(args.part, text);
+  if (args.timing)
+    args.timing.tokenCounting += performance.now() - tokenStart;
+  const tagId = args.tagger.assignToolTag(args.sessionId, contentId, contentId, toolByteSize, args.db, 0, meta3.toolName ?? null, meta3.inputByteSize, () => {
+    const tokenStart2 = args.timing ? performance.now() : 0;
+    const counts = {
+      tokenCount: toolTokenCount,
+      inputTokenCount: meta3.inputTokenCount,
+      reasoningTokenCount: null
+    };
+    if (args.timing)
+      args.timing.tokenCounting += performance.now() - tokenStart2;
+    return counts;
+  });
+  if (args.timing)
+    args.timing.identity += performance.now() - identityStart;
+  applySingleToolPrefixAndTarget(args, tagId, text);
+}
+function applySingleToolPrefixAndTarget(args, tagId, text) {
   if (!args.skipPrefixInjection && args.part.kind === "tool_result") {
-    const tagged = prependTag(tagId, text);
-    args.part.setText(tagged);
+    const prefixStart = args.timing ? performance.now() : 0;
+    args.part.setText(prependTag(tagId, text));
+    if (args.timing)
+      args.timing.prefix += performance.now() - prefixStart;
   }
+  const targetStart = args.timing ? performance.now() : 0;
   args.targets.set(tagId, buildToolTarget(args.part, args.message, tagId));
+  if (args.timing)
+    args.timing.targets += performance.now() - targetStart;
 }
 function setToolContentOrText(part, content) {
   try {
@@ -190472,6 +191386,7 @@ async function runAutoSearchHintForPi(args) {
     sessionLog(sessionId, "Pi auto-search: strict entry-id resolution failed; replayed persisted decisions only");
     return messages;
   }
+  await args.ensureProjectRegistered?.();
   const writeNoHintAndReconcile = (reason) => {
     const outcome2 = appendAutoSearchHintDecision(db, sessionId, {
       messageId: userMsgId,
@@ -190619,8 +191534,17 @@ function getEntryId(entry) {
   const id = entry.id;
   return typeof id === "string" ? id : null;
 }
-function findEntryIndex(branchEntries, entryId) {
-  return branchEntries.findIndex((entry) => getEntryId(entry) === entryId);
+function findEntryIndex(branchEntries, entryId2) {
+  return branchEntries.findIndex((entry) => getEntryId(entry) === entryId2);
+}
+
+// src/context-perf-hooks.ts
+var timingObserver;
+function hasPiTransformTimingObserver() {
+  return timingObserver !== undefined;
+}
+function recordPiTransformTiming(sample) {
+  timingObserver?.(sample);
 }
 
 // src/ctx-reduce-nudge-pi.ts
@@ -191319,7 +192243,7 @@ init_logger();
 function resolveStableId(msg, index, entryIds) {
   return resolvePiStableId(msg, index, entryIds) ?? "";
 }
-function trimPiMessagesToBoundary(piMessages, entryIds, cutoffMessageId) {
+function trimPiMessagesToBoundary(piMessages, entryIds, cutoffMessageId, trimMutableEntryIds = false) {
   if (cutoffMessageId.length === 0)
     return 0;
   const effectiveCutoffId = cutoffMessageId.startsWith(SYNTH_USER_ID_PREFIX) ? cutoffMessageId.slice(SYNTH_USER_ID_PREFIX.length) : cutoffMessageId;
@@ -191386,6 +192310,10 @@ function trimPiMessagesToBoundary(piMessages, entryIds, cutoffMessageId) {
   const kept = piMessages.filter((_, index) => !remove.has(index));
   const removed = piMessages.length - kept.length;
   piMessages.splice(0, piMessages.length, ...kept);
+  if (trimMutableEntryIds && Array.isArray(entryIds)) {
+    const keptIds = entryIds.filter((_, index) => !remove.has(index));
+    entryIds.splice(0, entryIds.length, ...keptIds);
+  }
   return removed;
 }
 function toolPairKey(callId, assistantIndex) {
@@ -191496,6 +192424,23 @@ var EMPTY_PI_HARD_SIGNALS = {
   cacheExpired: false,
   lastResponseTime: 0
 };
+var injectionTokenCountsBySession = new Map;
+function cachedInjectionTokenCounts(sessionId, m0, m1) {
+  const cached2 = injectionTokenCountsBySession.get(sessionId);
+  if (cached2?.m0 === m0 && cached2.m1 === m1)
+    return cached2;
+  const counts = {
+    m0,
+    m0Tokens: estimateTokens(m0),
+    m1,
+    m1Tokens: m1 === PI_M1_PLACEHOLDER ? 0 : estimateTokens(m1)
+  };
+  injectionTokenCountsBySession.set(sessionId, counts);
+  return counts;
+}
+function clearPiInjectionTokenCountCache(sessionId) {
+  injectionTokenCountsBySession.delete(sessionId);
+}
 function decodeCachedM0(value) {
   if (!value)
     return null;
@@ -191514,6 +192459,20 @@ function getCachedBoundary(db, sessionId) {
   const row = db.prepare("SELECT cached_m0_last_baseline_end_message_id AS boundary FROM session_meta WHERE session_id = ?").get(sessionId);
   return typeof row?.boundary === "string" && row.boundary.length > 0 ? row.boundary : null;
 }
+function trimPiMessagesToCachedBoundary(db, sessionId, piMessages, entryIds) {
+  const row = db.prepare(`SELECT cached_m0_bytes AS m0, cached_m1_bytes AS m1,
+			        cached_m0_last_baseline_end_message_id AS boundary
+			 FROM session_meta WHERE session_id = ?`).get(sessionId);
+  if (!row?.m0 || !row.m1 || typeof row.boundary !== "string")
+    return 0;
+  const boundary = row.boundary;
+  if (boundary.length === 0)
+    return 0;
+  const boundaryIsLive = getCompartments(db, sessionId).some((compartment) => compartment.endMessageId === boundary);
+  if (!boundaryIsLive)
+    return 0;
+  return trimPiMessagesToBoundary(piMessages, entryIds, boundary, true);
+}
 function setCachedBoundary(db, sessionId, boundary) {
   db.prepare("UPDATE session_meta SET cached_m0_last_baseline_end_message_id = ? WHERE session_id = ?").run(boundary, sessionId);
 }
@@ -191583,7 +192542,7 @@ function readCurrentMarkersFromCompartments(db, state, compartments, projectDocs
 function mustMaterializePi(state, db, currentCompartmentsOverride) {
   const meta3 = getOrCreateSessionMeta(db, state.sessionId);
   const currentCompartments = currentCompartmentsOverride ?? getCompartments(db, state.sessionId);
-  const current = readCurrentMarkersFromCompartments(db, state, currentCompartments);
+  const current = readCurrentMarkersFromCompartments(db, state, currentCompartments, meta3.cachedM0ProjectDocsHash ?? undefined);
   if (!meta3.cachedM0Bytes)
     return { value: true, reason: "first_render" };
   if (!meta3.cachedM1Bytes)
@@ -192217,8 +193176,7 @@ function injectM0M1Pi(state, db, piMessages, entryIds, recomputeM1ThisPass = fal
   const M1_ABSOLUTE_CAP_RATIO = 0.2;
   const m1AbsoluteBudget = (state.historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS) * M1_ABSOLUTE_CAP_RATIO;
   const m1HasContent = m1 !== PI_M1_PLACEHOLDER;
-  const m1Tokens = m1HasContent ? estimateTokens(m1) : 0;
-  const m0Tokens = estimateTokens(m0);
+  const { m0Tokens, m1Tokens } = cachedInjectionTokenCounts(state.sessionId, m0, m1);
   const m1OverAbsoluteCap = m1HasContent && m1Tokens > m1AbsoluteBudget;
   if (!materialized && !contentionExhausted && m1Recomputed && recomputeM1ThisPass && (memoryUpdateCount > 40 || m1OverAbsoluteCap || m1HasContent && m0Tokens >= M0_DRIFT_RATIO_FLOOR_TOKENS && m1Tokens > m0Tokens * M1_DRIFT_RATIO)) {
     decision = { value: true, reason: "drift" };
@@ -196644,7 +197602,6 @@ function stripPiDroppedPlaceholderMessages(args) {
   const { db, sessionId, messages, isCacheBusting, stableIdByRef } = args;
   const persistedIds = getStrippedPlaceholderIds(db, sessionId);
   const idsToStrip = new Set(persistedIds);
-  let discovered = 0;
   const idOf = (msg, index) => {
     const m = msg && typeof msg === "object" ? msg : undefined;
     const carried = m ? stableIdByRef?.get(m) : undefined;
@@ -196663,15 +197620,36 @@ function stripPiDroppedPlaceholderMessages(args) {
       if (!id)
         continue;
       presentIds?.add(id);
-      if (!messageIsPlaceholderOnly(messages[i]))
-        continue;
-      if (!idsToStrip.has(id)) {
-        idsToStrip.add(id);
+      if (messageIsPlaceholderOnly(messages[i]) && !persistedIds.has(id)) {
         discoveredIds.push(id);
-        discovered++;
       }
     }
   }
+  const removedIds = [];
+  if (presentIds) {
+    for (const id of persistedIds) {
+      if (!presentIds.has(id))
+        removedIds.push(id);
+    }
+  }
+  let discovered = 0;
+  let pruned = 0;
+  if (discoveredIds.length > 0 || removedIds.length > 0) {
+    const persisted = (args.applyDelta ?? applyStrippedPlaceholderDelta)(db, sessionId, {
+      add: discoveredIds,
+      remove: removedIds
+    });
+    if (persisted) {
+      for (const id of discoveredIds)
+        idsToStrip.add(id);
+      for (const id of removedIds)
+        idsToStrip.delete(id);
+      discovered = discoveredIds.length;
+      pruned = removedIds.length;
+    } else {
+      sessionLog(sessionId, "placeholder strip: persistence failed; leaving newly discovered messages intact");
+    }
+  }
   let removed = 0;
   for (let i = messages.length - 1;i >= 0; i--) {
     const id = idOf(messages[i], i);
@@ -196680,29 +197658,76 @@ function stripPiDroppedPlaceholderMessages(args) {
     messages.splice(i, 1);
     removed++;
   }
-  let pruned = 0;
-  if (presentIds) {
-    const removedIds = [];
-    for (const id of persistedIds) {
-      if (!presentIds.has(id))
-        removedIds.push(id);
-    }
-    pruned = removedIds.length;
-    if (discoveredIds.length > 0 || removedIds.length > 0) {
-      applyStrippedPlaceholderDelta(db, sessionId, {
-        add: discoveredIds,
-        remove: removedIds
-      });
-    }
-  } else if (discoveredIds.length > 0) {
-    applyStrippedPlaceholderDelta(db, sessionId, { add: discoveredIds });
-  }
   if (removed > 0 || discovered > 0 || pruned > 0) {
     sessionLog(sessionId, `placeholder strip: removed=${removed} discovered=${discovered} pruned=${pruned}`);
   }
   return { removed, discovered };
 }
 
+// src/strip-processed-images-pi.ts
+init_logger();
+function isLargeImagePart(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const part = value;
+  return part.type === "image" && typeof part.mimeType === "string" && part.mimeType.startsWith("image/") && typeof part.data === "string" && part.data.length > 200;
+}
+function stripPiProcessedImages(args) {
+  const frozenIds = getProcessedImageStrippedIds(args.db, args.sessionId);
+  const newlyStrippedIds = [];
+  let hasAssistantResponse = false;
+  if (args.detect && args.watermark > 0) {
+    for (let i = args.messages.length - 1;i >= 0; i--) {
+      const raw = args.messages[i];
+      if (!raw || typeof raw !== "object")
+        continue;
+      const message = raw;
+      if (message.role === "assistant") {
+        hasAssistantResponse = true;
+        continue;
+      }
+      if (message.role !== "user" && message.role !== "toolResult" || !hasAssistantResponse || !Array.isArray(message.content) || !message.content.some(isLargeImagePart)) {
+        continue;
+      }
+      const id = args.stableId(raw, i);
+      if (!id || frozenIds.has(id))
+        continue;
+      const maxTag = args.messageIdToMaxTag.get(id) ?? 0;
+      if (maxTag <= args.watermark)
+        newlyStrippedIds.push(id);
+    }
+  }
+  if (newlyStrippedIds.length > 0) {
+    const persisted = (args.addIds ?? addProcessedImageStrippedIds)(args.db, args.sessionId, newlyStrippedIds);
+    if (persisted) {
+      for (const id of newlyStrippedIds)
+        frozenIds.add(id);
+    } else {
+      newlyStrippedIds.length = 0;
+      sessionLog(args.sessionId, "processed-image strip: persistence failed; leaving newly detected images intact");
+    }
+  }
+  let stripped = 0;
+  for (let i = 0;i < args.messages.length; i++) {
+    const raw = args.messages[i];
+    if (!raw || typeof raw !== "object")
+      continue;
+    const id = args.stableId(raw, i);
+    if (!id || !frozenIds.has(id))
+      continue;
+    const message = raw;
+    if (!Array.isArray(message.content))
+      continue;
+    for (let partIndex = 0;partIndex < message.content.length; partIndex++) {
+      if (!isLargeImagePart(message.content[partIndex]))
+        continue;
+      message.content[partIndex] = { type: "text", text: "" };
+      stripped++;
+    }
+  }
+  return { stripped, newlyStrippedIds };
+}
+
 // src/system-prompt.ts
 import { createHash as createHash12 } from "node:crypto";
 
@@ -196723,6 +197748,7 @@ Context is managed for you entirely automatically — there's nothing to prune a
 var CTX_NOTE_GUIDANCE = `Use \`ctx_note\` ONLY for genuinely future concerns — something to revisit much later, not work coming up in the next few turns (that's already in your active context) and not active multi-step work (use todos for that). Magic Context preserves your full context across both compaction and restarts, so an upcoming restart or "let's come back to this later" is never a reason to take a note — nothing is lost either way. Notes you do take survive compression and resurface at natural work boundaries (after commits, historian runs, todo completion).`;
 var TOOL_HISTORY_GUIDANCE = `Compressed history intentionally omits tool calls and their outputs — summaries like "I edited file X" are historian records, not patterns to replicate. In the live conversation, older tool calls and their results are cleaned up to save context — you may see your own past messages referencing actions without the corresponding tool call or result visible. This is normal context management. ALWAYS use real tool calls; never simulate, fabricate, or inline tool outputs in your text. If there is no tool result message, the action did not happen. NEVER simulate, hallucinate or claim tool calls, command output, search results, file edits, or diffs in plain text as if they actually occurred.`;
 var MEMORY_GUIDANCE = `Use \`ctx_memory\` for durable project knowledge: write what future sessions must know, update/archive/merge the memories you see in \`<project-memory>\` when they drift. Memories persist across sessions and every new session starts with them.
+Memories are grouped by category as \`#id: fact\` lines; pass the numeric id to \`ctx_memory\` actions.
 **Save to memory proactively**: If you spent multiple turns finding something (a file path, a DB location, a config pattern, a workaround), save it with \`ctx_memory\` so future sessions don't repeat the search. Examples:
 - Found a project's source code path after searching → \`ctx_memory(action="write", category="CONFIG_VALUES", content="OpenCode source is at ~/Work/OSS/opencode")\`
 - Discovered a non-obvious build/test command → \`ctx_memory(action="write", category="PROJECT_RULES", content="Always use scripts/release.sh for releases")\`
@@ -196736,7 +197762,7 @@ Use \`ctx_reduce\` to mark spent tagged content as discardable and reclaim space
 Do not announce or narrate \`ctx_reduce\` drops — just call the tool silently. Saying "I'll drop these outputs" wastes tokens the user does not care about.
 ${CTX_NOTE_GUIDANCE}
 ${memoryGuidanceBlock(memoryEnabled)}Use \`ctx_search\` to search across project memories, indexed git commits, and this session's full conversation history (including compacted parts) from one query.
-Use \`ctx_expand\` to recover the raw conversation behind a \`<compartment>\` summary in \`<session-history>\` — pass its \`start\`/\`end\` attributes when the summary is not enough (exact wording, values, error text).
+Use \`ctx_expand\` to recover the raw conversation behind a summary under a \`## start-end · date · title\` heading inside \`<session-history>\` — pass the heading's start/end range when the summary is not enough (exact wording, values, error text).
 **Search before asking the user**: If you can't remember or don't know something that might have been discussed before or stored in project memory, use \`ctx_search\` before asking the user. Examples:
 - Can't remember where a related codebase or dependency lives → \`ctx_search(query="opencode source code path")\`
 - Forgot a prior architectural decision or constraint → \`ctx_search(query="why did we choose SQLite over postgres")\`
@@ -196751,7 +197777,7 @@ NEVER drop assistant text messages unless they are exceptionally large. Your con
 Before your turn finishes, consider using \`ctx_reduce\` to drop large tool outputs you no longer need.`;
 var BASE_INTRO_NO_REDUCE = (memoryEnabled) => `${CTX_NOTE_GUIDANCE}
 ${memoryGuidanceBlock(memoryEnabled)}Use \`ctx_search\` to search across project memories, indexed git commits, and this session's full conversation history (including compacted parts) from one query.
-Use \`ctx_expand\` to recover the raw conversation behind a \`<compartment>\` summary in \`<session-history>\` — pass its \`start\`/\`end\` attributes when the summary is not enough (exact wording, values, error text).
+Use \`ctx_expand\` to recover the raw conversation behind a summary under a \`## start-end · date · title\` heading inside \`<session-history>\` — pass the heading's start/end range when the summary is not enough (exact wording, values, error text).
 **Search before asking the user**: If you can't remember or don't know something that might have been discussed before or stored in project memory, use \`ctx_search\` before asking the user. Examples:
 - Can't remember where a related codebase or dependency lives → \`ctx_search(query="opencode source code path")\`
 - Forgot a prior architectural decision or constraint → \`ctx_search(query="why did we choose SQLite over postgres")\`
@@ -196951,74 +197977,222 @@ function withTimeout(p, ms) {
 }
 
 // src/tokenize-pi-messages.ts
-function tokenizePiMessages(messages) {
+function tokenizePiMessages(messages, options) {
   let conversation = 0;
   let toolCall = 0;
+  let cacheValidationMs = 0;
+  let bpeMs = 0;
+  const liveIds = options ? new Set : undefined;
   for (const raw of messages) {
     if (!raw || typeof raw !== "object")
       continue;
-    const msg = raw;
-    const content = msg.content;
-    if (msg.role === "user" || msg.role === "assistant") {
-      if (typeof content === "string") {
-        conversation += estimateTokens(content);
+    const cacheValidationStart = options?.onTiming ? performance.now() : 0;
+    const resolvedStableId = options?.stableId(raw);
+    const stableId = resolvedStableId !== undefined && isTokenCacheSafeMessage(raw) ? resolvedStableId : undefined;
+    const fingerprint = stableId === undefined ? null : buildTokenCacheFingerprint(raw);
+    if (stableId !== undefined && fingerprint !== null) {
+      liveIds?.add(stableId);
+      const cached2 = options?.cache.get(stableId);
+      if (cached2 && tokenCacheFingerprintsEqual(cached2.fingerprint, fingerprint)) {
+        conversation += cached2.counts.conversation;
+        toolCall += cached2.counts.toolCall;
+        cacheValidationMs += performance.now() - cacheValidationStart;
         continue;
       }
-      if (!Array.isArray(content))
+    }
+    cacheValidationMs += performance.now() - cacheValidationStart;
+    const bpeStart = options?.onTiming ? performance.now() : 0;
+    const beforeConversation = conversation;
+    const beforeToolCall = toolCall;
+    try {
+      const msg = raw;
+      const content = msg.content;
+      if (msg.role === "user" || msg.role === "assistant") {
+        if (typeof content === "string") {
+          conversation += estimateTokens(content);
+          continue;
+        }
+        if (!Array.isArray(content))
+          continue;
+        for (const part of content) {
+          if (!part || typeof part !== "object")
+            continue;
+          const p = part;
+          switch (p.type) {
+            case "text":
+              if (typeof p.text === "string")
+                conversation += estimateTokens(p.text);
+              if (typeof p.textSignature === "string")
+                conversation += estimateTokens(p.textSignature);
+              break;
+            case "thinking":
+              if (typeof p.thinking === "string")
+                conversation += estimateTokens(p.thinking);
+              if (typeof p.thinkingSignature === "string")
+                conversation += estimateTokens(p.thinkingSignature);
+              break;
+            case "image":
+              conversation += 1200;
+              break;
+            case "toolCall":
+              if (typeof p.name === "string")
+                toolCall += estimateTokens(p.name);
+              if (p.arguments !== undefined) {
+                const s = typeof p.arguments === "string" ? p.arguments : safeJsonStringify2(p.arguments);
+                if (s)
+                  toolCall += estimateTokens(s);
+              }
+              break;
+          }
+        }
         continue;
-      for (const part of content) {
-        if (!part || typeof part !== "object")
+      }
+      if (msg.role === "toolResult") {
+        if (typeof content === "string") {
+          toolCall += estimateTokens(content);
           continue;
-        const p = part;
-        switch (p.type) {
-          case "text":
-            if (typeof p.text === "string")
-              conversation += estimateTokens(p.text);
-            if (typeof p.textSignature === "string")
-              conversation += estimateTokens(p.textSignature);
-            break;
-          case "thinking":
-            if (typeof p.thinking === "string")
-              conversation += estimateTokens(p.thinking);
-            if (typeof p.thinkingSignature === "string")
-              conversation += estimateTokens(p.thinkingSignature);
-            break;
-          case "image":
-            conversation += 1200;
-            break;
-          case "toolCall":
-            if (typeof p.name === "string")
-              toolCall += estimateTokens(p.name);
-            if (p.arguments !== undefined) {
-              const s = typeof p.arguments === "string" ? p.arguments : safeJsonStringify2(p.arguments);
-              if (s)
-                toolCall += estimateTokens(s);
-            }
-            break;
         }
+        if (!Array.isArray(content))
+          continue;
+        for (const part of content) {
+          if (!part || typeof part !== "object")
+            continue;
+          const p = part;
+          if (p.type === "text" && typeof p.text === "string") {
+            toolCall += estimateTokens(p.text);
+          } else if (p.type === "image") {
+            toolCall += 1200;
+          }
+        }
+      }
+    } finally {
+      bpeMs += performance.now() - bpeStart;
+      if (stableId !== undefined && fingerprint !== null) {
+        options?.cache.set(stableId, {
+          fingerprint,
+          counts: {
+            conversation: conversation - beforeConversation,
+            toolCall: toolCall - beforeToolCall
+          }
+        });
+      }
+    }
+  }
+  if (options && liveIds) {
+    const cachePruneStart = options.onTiming ? performance.now() : 0;
+    for (const id of options.cache.keys()) {
+      if (!liveIds.has(id))
+        options.cache.delete(id);
+    }
+    options.onTiming?.("cachePrune", performance.now() - cachePruneStart);
+  }
+  options?.onTiming?.("cacheValidation", cacheValidationMs);
+  options?.onTiming?.("bpe", bpeMs);
+  return { conversation, toolCall };
+}
+function buildTokenCacheFingerprint(value) {
+  const message = value;
+  const role = typeof message.role === "string" ? message.role : null;
+  const fingerprint = [role];
+  if (role !== "user" && role !== "assistant" && role !== "toolResult") {
+    return fingerprint;
+  }
+  if (typeof message.content === "string") {
+    fingerprint.push("string", message.content);
+    return fingerprint;
+  }
+  if (!Array.isArray(message.content)) {
+    fingerprint.push("non-array");
+    return fingerprint;
+  }
+  fingerprint.push("parts");
+  for (const rawPart of message.content) {
+    if (!rawPart || typeof rawPart !== "object")
+      continue;
+    const part = rawPart;
+    if (role === "toolResult") {
+      if (part.type === "text" && typeof part.text === "string") {
+        fingerprint.push("text", part.text);
+      } else if (part.type === "image") {
+        fingerprint.push("image");
       }
       continue;
     }
-    if (msg.role === "toolResult") {
-      if (typeof content === "string") {
-        toolCall += estimateTokens(content);
-        continue;
+    switch (part.type) {
+      case "text":
+        fingerprint.push("text", typeof part.text === "string" ? part.text : null, typeof part.textSignature === "string" ? part.textSignature : null);
+        break;
+      case "thinking":
+        fingerprint.push("thinking", typeof part.thinking === "string" ? part.thinking : null, typeof part.thinkingSignature === "string" ? part.thinkingSignature : null);
+        break;
+      case "image":
+        fingerprint.push("image");
+        break;
+      case "toolCall": {
+        const argumentsJson = part.arguments === undefined ? null : typeof part.arguments === "string" ? part.arguments : safeJsonStringify2(part.arguments);
+        fingerprint.push("toolCall", typeof part.name === "string" ? part.name : null, argumentsJson);
+        break;
       }
-      if (!Array.isArray(content))
+    }
+  }
+  return fingerprint;
+}
+function tokenCacheFingerprintsEqual(left, right) {
+  if (left.length !== right.length)
+    return false;
+  for (let index = 0;index < left.length; index += 1) {
+    if (left[index] !== right[index])
+      return false;
+  }
+  return true;
+}
+function isTokenCacheSafeMessage(value) {
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null)
+    return false;
+  if ("toJSON" in value)
+    return false;
+  if (!isJsonVisibleDataProperty(value, "role") || !isJsonVisibleDataProperty(value, "content")) {
+    return false;
+  }
+  return isPlainJsonData(value.content, new Set);
+}
+function isJsonVisibleDataProperty(value, key) {
+  if (!(key in value))
+    return true;
+  const descriptor = Object.getOwnPropertyDescriptor(value, key);
+  return descriptor !== undefined && descriptor.enumerable === true && "value" in descriptor;
+}
+function isPlainJsonData(value, seen) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "undefined") {
+    return true;
+  }
+  if (typeof value !== "object" || seen.has(value))
+    return false;
+  const prototype = Object.getPrototypeOf(value);
+  if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) {
+    return false;
+  }
+  if ("toJSON" in value)
+    return false;
+  seen.add(value);
+  try {
+    for (const key of Reflect.ownKeys(value)) {
+      if (Array.isArray(value) && key === "length")
         continue;
-      for (const part of content) {
-        if (!part || typeof part !== "object")
-          continue;
-        const p = part;
-        if (p.type === "text" && typeof p.text === "string") {
-          toolCall += estimateTokens(p.text);
-        } else if (p.type === "image") {
-          toolCall += 1200;
-        }
+      if (typeof key !== "string")
+        return false;
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor?.enumerable || !("value" in descriptor)) {
+        return false;
       }
+      if (!isPlainJsonData(descriptor.value, seen))
+        return false;
     }
+    return true;
+  } finally {
+    seen.delete(value);
   }
-  return { conversation, toolCall };
 }
 function safeJsonStringify2(value) {
   try {
@@ -197522,6 +198696,9 @@ function applyForwardPressureFloor(trailingPercentage, trailingInputTokens, piUs
   } : { percentage: trailingPercentage, inputTokens: trailingInputTokens };
 }
 var injectM0M1PiForRun = injectM0M1Pi;
+var persistReasoningWatermarkForRun = updateSessionMeta;
+var persistStableIdSchemeForRun = updateSessionMeta;
+var afterFallbackAdoptionForTests;
 var DEFAULT_CLEAR_REASONING_AGE = 50;
 var PI_STABLE_ID_SCHEME = 1;
 var lastEmergencyNotificationAtMs = new Map;
@@ -197539,9 +198716,26 @@ var activeContextHandlerSessions = new Set;
 var lastHeuristicsTurnIdBySession = new Map;
 var firstContextPassSeenBySession = new Set;
 var liveModelBySession = new Map;
+var taggedStableMessageIdsBySession = new Map;
+var taggersBySession = new Map;
+function recordSuccessfulTaggedMessageIds(sessionId, entryIds) {
+  const liveRealIds = new Set;
+  for (const entryId2 of entryIds) {
+    if (entryId2 && !entryId2.startsWith("pi-msg-"))
+      liveRealIds.add(entryId2);
+  }
+  taggedStableMessageIdsBySession.set(sessionId, liveRealIds);
+}
+var piMessageTokenCacheBySession = new Map;
+var piTagTextTokenCacheBySession = new Map;
+var piTagToolTokenCacheBySession = new Map;
+var piBranchProjectionBySession = new Map;
+var piBranchLookupByProjection = new WeakMap;
 function logTransformTiming(sessionId, stage, start, extra) {
-  const elapsed = (performance.now() - start).toFixed(1);
+  const elapsedMs = performance.now() - start;
+  const elapsed = elapsedMs.toFixed(1);
   const suffix = extra ? ` ${extra}` : "";
+  recordPiTransformTiming({ sessionId, stage, elapsedMs, extra });
   sessionLog(sessionId, `transform stage: stage=${stage} elapsed=${elapsed}ms${suffix}`);
 }
 function resolvePiContextModelKey(ctx) {
@@ -197558,6 +198752,35 @@ function resolvePiContextModelKey(ctx) {
 function readPiSessionMessageById(ctx, messageId) {
   return readPiSessionMessages(ctx).find((message) => message.id === messageId) ?? null;
 }
+function convertLocatedPiUserEntry(branchEntries, messageId) {
+  let rawOrdinal = 0;
+  let pendingToolStart = -1;
+  for (let index = 0;index < branchEntries.length; index += 1) {
+    const entry = branchEntries[index];
+    if (!entry || typeof entry !== "object")
+      continue;
+    const record2 = entry;
+    if (record2.type !== "message" || !record2.message || typeof record2.message !== "object") {
+      continue;
+    }
+    const role = record2.message.role;
+    if (role === "toolResult") {
+      if (pendingToolStart < 0)
+        pendingToolStart = index;
+      continue;
+    }
+    if (role === "assistant" && pendingToolStart >= 0)
+      rawOrdinal += 1;
+    rawOrdinal += 1;
+    if (record2.id === messageId && role === "user") {
+      const start = pendingToolStart >= 0 ? pendingToolStart : index;
+      const converted = convertEntriesToRawMessages(branchEntries.slice(start, index + 1)).find((message) => message.id === messageId);
+      return converted ? { ...converted, ordinal: rawOrdinal } : null;
+    }
+    pendingToolStart = -1;
+  }
+  return null;
+}
 function signalPiHistoryRefresh(sessionId) {
   historyRefreshSessions.add(sessionId);
 }
@@ -197709,29 +198932,7 @@ function collectMessageEntryIdsByRef(ctx, messages, sessionId, preloadedBranchEn
       return null;
     }
   }
-  const entryIdByMsgRef = new Map;
-  const entryIdsByFingerprint = new Map;
-  for (const entry of entries) {
-    if (!entry || typeof entry !== "object")
-      continue;
-    const e = entry;
-    if (e.type !== "message")
-      continue;
-    if (typeof e.id !== "string")
-      continue;
-    if (!e.message || typeof e.message !== "object")
-      continue;
-    const message = e.message;
-    entryIdByMsgRef.set(message, e.id);
-    const fingerprint = piMessageEntryFingerprint(e.message);
-    if (fingerprint) {
-      const bucket = entryIdsByFingerprint.get(fingerprint);
-      if (bucket)
-        bucket.push(e.id);
-      else
-        entryIdsByFingerprint.set(fingerprint, [e.id]);
-    }
-  }
+  const { entryIdByMessageRef, entryIdsByFingerprint } = getPiBranchEntryLookup(entries);
   const result = new Array(messages.length);
   let resolved = 0;
   let fingerprintResolved = 0;
@@ -197742,7 +198943,7 @@ function collectMessageEntryIdsByRef(ctx, messages, sessionId, preloadedBranchEn
       result[i] = undefined;
       continue;
     }
-    const id = entryIdByMsgRef.get(msg);
+    const id = entryIdByMessageRef.get(msg);
     if (typeof id === "string") {
       result[i] = id;
       resolved += 1;
@@ -197761,38 +198962,183 @@ function collectMessageEntryIdsByRef(ctx, messages, sessionId, preloadedBranchEn
     }
   }
   if (resolved < messages.length) {
-    log(`[magic-context][pi]${sessionId ? `[${sessionId}]` : ""} ` + `collectMessageEntryIdsByRef: resolved=${resolved}/${messages.length} ` + `(fingerprint=${fingerprintResolved}, branchEntries=${entries.length}, messageEntries=${entryIdByMsgRef.size}) — ` + `unmapped slots fall through to synthesized ids; boundary lookup still works ` + `for any compartment whose start/end message is among the resolved set`);
+    log(`[magic-context][pi]${sessionId ? `[${sessionId}]` : ""} ` + `collectMessageEntryIdsByRef: resolved=${resolved}/${messages.length} ` + `(fingerprint=${fingerprintResolved}, branchEntries=${entries.length}, messageEntries=${entryIdByMessageRef.size}) — ` + `unmapped slots fall through to synthesized ids; boundary lookup still works ` + `for any compartment whose start/end message is among the resolved set`);
   }
   return result;
 }
-function buildEntryIdByRefMap(branchEntries) {
-  const map2 = new Map;
-  if (!branchEntries)
-    return map2;
-  for (const entry of branchEntries) {
-    if (!entry || typeof entry !== "object")
-      continue;
-    const e = entry;
-    if (e.type !== "message")
-      continue;
-    if (typeof e.id !== "string")
-      continue;
-    if (!e.message || typeof e.message !== "object")
+function addPiBranchEntryToLookup(lookup, entry) {
+  if (!entry || typeof entry !== "object")
+    return;
+  const row = entry;
+  if (row.type !== "message" || typeof row.id !== "string" || !row.message || typeof row.message !== "object") {
+    return;
+  }
+  lookup.entryIdByMessageRef.set(row.message, row.id);
+  const fingerprint = piMessageEntryFingerprint(row.message);
+  if (!fingerprint)
+    return;
+  const bucket = lookup.entryIdsByFingerprint.get(fingerprint);
+  if (bucket)
+    bucket.push(row.id);
+  else
+    lookup.entryIdsByFingerprint.set(fingerprint, [row.id]);
+}
+function isPiContextEmitEligible(entry) {
+  if (!entry || typeof entry !== "object")
+    return false;
+  const row = entry;
+  if (typeof row.id !== "string")
+    return false;
+  return row.type === "message" || row.type === "custom_message" || row.type === "branch_summary" && typeof row.summary === "string" && row.summary.length > 0;
+}
+function buildPiAlignedEntryIds(entries) {
+  let compactionIndex = -1;
+  let firstKeptEntryId;
+  for (let index = entries.length - 1;index >= 0; index -= 1) {
+    const row = entries[index];
+    if (row?.type !== "compaction")
       continue;
-    map2.set(e.message, e.id);
+    compactionIndex = index;
+    firstKeptEntryId = typeof row.firstKeptEntryId === "string" ? row.firstKeptEntryId : undefined;
+    break;
   }
-  return map2;
+  if (compactionIndex < 0) {
+    return entries.filter(isPiContextEmitEligible).map((entry) => entry.id);
+  }
+  const ids = [undefined];
+  if (firstKeptEntryId !== undefined) {
+    let foundFirstKept = false;
+    for (let index = 0;index < compactionIndex; index += 1) {
+      const entry = entries[index];
+      if (entry?.id === firstKeptEntryId) {
+        foundFirstKept = true;
+      }
+      if (foundFirstKept && isPiContextEmitEligible(entry))
+        ids.push(entry.id);
+    }
+  }
+  for (let index = compactionIndex + 1;index < entries.length; index += 1) {
+    const entry = entries[index];
+    if (isPiContextEmitEligible(entry))
+      ids.push(entry.id);
+  }
+  return ids;
+}
+function getPiBranchEntryLookup(entries) {
+  const cached2 = piBranchLookupByProjection.get(entries);
+  if (cached2)
+    return cached2;
+  const lookup = {
+    entryIdByMessageRef: new Map,
+    entryIdsByFingerprint: new Map,
+    alignedEntryIds: buildPiAlignedEntryIds(entries)
+  };
+  for (const entry of entries)
+    addPiBranchEntryToLookup(lookup, entry);
+  piBranchLookupByProjection.set(entries, lookup);
+  return lookup;
+}
+function buildEntryIdByRefMap(branchEntries) {
+  return branchEntries ? getPiBranchEntryLookup(branchEntries).entryIdByMessageRef : new Map;
 }
 function readPiBranchEntriesForContext(ctx, sessionId) {
   const sm = ctx.sessionManager;
-  if (typeof sm?.getBranch !== "function")
-    return null;
-  try {
+  const installProjection = (leafId, entries) => {
+    const indexById = new Map;
+    const lookup = getPiBranchEntryLookup(entries);
+    for (let index = 0;index < entries.length; index += 1) {
+      const entry = entries[index];
+      if (entry && typeof entry === "object") {
+        const id = entry.id;
+        if (typeof id === "string")
+          indexById.set(id, index);
+      }
+    }
+    const projection = { leafId, entries, indexById, lookup };
+    piBranchProjectionBySession.set(sessionId, projection);
+    piBranchLookupByProjection.set(entries, lookup);
+    return entries;
+  };
+  const fallbackToBranch = () => {
+    if (typeof sm?.getBranch !== "function")
+      return null;
     const entries = sm.getBranch.call(sm);
-    return Array.isArray(entries) ? entries : null;
+    if (!Array.isArray(entries))
+      return null;
+    const leafId = typeof entries.at(-1)?.id === "string" ? entries.at(-1).id ?? "" : "";
+    return leafId ? installProjection(leafId, entries) : entries;
+  };
+  try {
+    if (typeof sm?.getLeafId !== "function" || typeof sm.getEntry !== "function") {
+      return fallbackToBranch();
+    }
+    const leafId = sm.getLeafId.call(sm);
+    if (leafId === null)
+      return [];
+    if (typeof leafId !== "string" || leafId.length === 0) {
+      return fallbackToBranch();
+    }
+    const cached2 = piBranchProjectionBySession.get(sessionId);
+    if (cached2?.leafId === leafId)
+      return cached2.entries;
+    const suffix = [];
+    const seen = new Set;
+    let cursor = leafId;
+    let cachedAncestorIndex;
+    while (cursor !== null) {
+      const priorIndex = cached2?.indexById.get(cursor);
+      if (priorIndex !== undefined) {
+        cachedAncestorIndex = priorIndex;
+        break;
+      }
+      if (seen.has(cursor))
+        return fallbackToBranch();
+      seen.add(cursor);
+      const entry = sm.getEntry.call(sm, cursor);
+      if (!entry || typeof entry !== "object")
+        return fallbackToBranch();
+      const row = entry;
+      if (row.id !== cursor || row.parentId !== null && typeof row.parentId !== "string") {
+        return fallbackToBranch();
+      }
+      suffix.push(entry);
+      cursor = row.parentId;
+    }
+    suffix.reverse();
+    if (cached2 && cachedAncestorIndex === cached2.entries.length - 1) {
+      const entries2 = [...cached2.entries, ...suffix];
+      if (suffix.some((entry) => entry?.type === "compaction")) {
+        return installProjection(leafId, entries2);
+      }
+      for (let index = 0;index < suffix.length; index += 1) {
+        const entry = suffix[index];
+        const id = entry.id;
+        cached2.indexById.set(id, cached2.entries.length + index);
+        addPiBranchEntryToLookup(cached2.lookup, entry);
+        if (isPiContextEmitEligible(entry)) {
+          cached2.lookup.alignedEntryIds.push(entry.id);
+        }
+      }
+      const projection = {
+        leafId,
+        entries: entries2,
+        indexById: cached2.indexById,
+        lookup: cached2.lookup
+      };
+      piBranchProjectionBySession.set(sessionId, projection);
+      piBranchLookupByProjection.set(entries2, cached2.lookup);
+      return entries2;
+    }
+    const entries = cached2 && cachedAncestorIndex !== undefined ? [...cached2.entries.slice(0, cachedAncestorIndex + 1), ...suffix] : suffix;
+    return installProjection(leafId, entries);
   } catch (error51) {
-    sessionLog(sessionId, `Pi branch pre-read failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
-    return null;
+    sessionLog(sessionId, `Pi branch projection failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
+    try {
+      return fallbackToBranch();
+    } catch (fallbackError) {
+      sessionLog(sessionId, `Pi branch pre-read failed: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`);
+      return null;
+    }
   }
 }
 function piMessageEntryFingerprint(message) {
@@ -197826,13 +199172,15 @@ function firstPiTextContent(content) {
   }
   return null;
 }
-function buildEntryFingerprintMap(messages, resolveStableId2) {
+function buildEntryFingerprintMap(messages, resolveStableId2, reusableMessageIds, includeReusable = true) {
   const map2 = new Map;
   for (let i = 0;i < messages.length; i++) {
     const msg = messages[i];
     const id = resolveStableId2(msg, i);
     if (!id)
       continue;
+    if (!includeReusable && reusableMessageIds?.has(id))
+      continue;
     const fp = piMessageEntryFingerprint(msg);
     if (fp)
       map2.set(id, fp);
@@ -197916,8 +199264,10 @@ function hasAdoptablePiFallbackMessageTags(db, sessionId, fingerprintById) {
   return false;
 }
 function adoptPiFallbackTags(db, sessionId, tagger, fingerprintById, options = {}) {
-  const shouldRunMessageMigration = options.stampStableIdScheme !== undefined || hasAdoptablePiFallbackMessageTags(db, sessionId, fingerprintById);
-  const shouldRunToolOwnerMigration = Boolean(options.messages && options.resolveStableId && hasPiFallbackToolOwnerTags(db, sessionId));
+  const hasFallbackMessageTags = options.hasFallbackMessageTags === true || hasPiFallbackMessageTags(db, sessionId);
+  const hasFallbackToolOwnerTags = options.hasFallbackToolOwnerTags === true || hasPiFallbackToolOwnerTags(db, sessionId);
+  const shouldRunMessageMigration = hasFallbackMessageTags && hasAdoptablePiFallbackMessageTags(db, sessionId, fingerprintById);
+  const shouldRunToolOwnerMigration = Boolean(options.messages && options.resolveStableId && hasFallbackToolOwnerTags);
   if (!shouldRunMessageMigration && !shouldRunToolOwnerMigration)
     return;
   runImmediateTransaction(db, () => {
@@ -197970,14 +199320,13 @@ function adoptPiFallbackTags(db, sessionId, tagger, fingerprintById, options = {
             tagger.unbindToolTag(sessionId, realOwnerId, row.callId);
           }
           tagger.bindToolTag(sessionId, row.callId, realOwnerId, adoption.tagNumber);
+          const accounting = getPersistedToolTagAccounting(db, sessionId, adoption.tagNumber);
+          if (accounting) {
+            tagger.setToolTagAccounting(sessionId, adoption.tagNumber, accounting);
+          }
         }
       }
     }
-    if (options.stampStableIdScheme !== undefined) {
-      updateSessionMeta(db, sessionId, {
-        piStableIdScheme: options.stampStableIdScheme
-      });
-    }
   });
 }
 function registerPiContextHandler(pi, baseOptions) {
@@ -198010,12 +199359,14 @@ function registerPiContextHandler(pi, baseOptions) {
       }
       sessionIdForError = sessionId;
       const projectDirectory = ctx.cwd;
+      const fullWireMessageCount = event.messages.length;
       const options = baseOptions.resolveForProject?.(projectDirectory) ?? baseOptions;
       const schedulerConfig = options.scheduler ?? DEFAULT_SCHEDULER_CONFIG;
       const scheduler = schedulerFor(options);
       const projectIdentity = resolveProjectIdentity(projectDirectory);
       updateSessionProjectTracking(sessionId, projectIdentity, options.db);
       logTransformTiming(sessionId, "findSessionId", tFindSession, `messages=${event.messages.length}`);
+      const tEntryBranch = performance.now();
       const branchEntries = readPiBranchEntriesForContext(ctx, sessionId);
       schedulePiTransformDecisionResolve({
         db: options.db,
@@ -198030,15 +199381,39 @@ function registerPiContextHandler(pi, baseOptions) {
       const unregisterRaw = setRawMessageProvider(sessionId, rawMessageProvider);
       rawMessageProviderUnregistersBySession.set(sessionId, unregisterRaw);
       scheduleReconciliation(options.db, sessionId, readRawSessionMessages);
-      const strictEntryIds = branchEntries === null ? null : collectMessageEntryIdsByRef(ctx, event.messages, sessionId, branchEntries);
+      const branchLookup = branchEntries === null ? null : getPiBranchEntryLookup(branchEntries);
+      const alignedEntryIds = branchLookup?.alignedEntryIds ?? null;
+      const resolvedEntryIds = alignedEntryIds?.length === event.messages.length ? alignedEntryIds : branchEntries === null ? null : collectMessageEntryIdsByRef(ctx, event.messages, sessionId, branchEntries);
+      const strictEntryIds = resolvedEntryIds ? [...resolvedEntryIds] : null;
+      if (strictEntryIds && options.injection) {
+        const removed = trimPiMessagesToCachedBoundary(options.db, sessionId, event.messages, strictEntryIds);
+        if (removed > 0) {
+          logTransformTiming(sessionId, "cachedBoundaryEarlyTrim", tEntryBranch, `removed=${removed}`);
+        }
+      }
       const entryIdByRef = buildEntryIdByRefMap(branchEntries);
+      const previouslyTaggedIds = taggedStableMessageIdsBySession.get(sessionId);
+      const reusableMessageIds = new Set;
+      if (strictEntryIds && previouslyTaggedIds) {
+        for (const entryId2 of strictEntryIds) {
+          if (entryId2 && previouslyTaggedIds.has(entryId2)) {
+            reusableMessageIds.add(entryId2);
+          }
+        }
+      }
+      logTransformTiming(sessionId, "entryParseAndBranchResolution", tEntryBranch, `branchEntries=${branchEntries?.length ?? 0}`);
       const tLastUser = performance.now();
       const latestUser = findLatestUserMessageIdPi(event.messages, buildPiMessageIdByIndex(event.messages, strictEntryIds));
       logTransformTiming(sessionId, "findLastUserMessageId", tLastUser);
+      const tMessageIndexScheduling = performance.now();
       if (latestUser) {
-        scheduleIncrementalIndex(options.db, sessionId, latestUser.messageId, (_sessionId, messageId) => readPiSessionMessageById(ctx, messageId));
+        const located = branchEntries ? convertLocatedPiUserEntry(branchEntries, latestUser.messageId) : null;
+        scheduleIncrementalIndex(options.db, sessionId, latestUser.messageId, located ?? ((_sessionId, messageId) => readPiSessionMessageById(ctx, messageId)));
       }
-      tagger.initFromDb(sessionId, options.db);
+      logTransformTiming(sessionId, "messageIndexScheduling", tMessageIndexScheduling);
+      const taggerFloor = strictEntryIds ? deriveTagLoadFloor(options.db, sessionId, strictEntryIds) : 0;
+      tagger.initFromDb(sessionId, options.db, taggerFloor);
+      taggersBySession.set(sessionId, tagger);
       const isFirstContextPassForSession = !firstContextPassSeenBySession.has(sessionId);
       firstContextPassSeenBySession.add(sessionId);
       const piUsage = ctx.getContextUsage?.();
@@ -198142,7 +199517,7 @@ function registerPiContextHandler(pi, baseOptions) {
         schedulerDecision = "defer";
       }
       logTransformTiming(sessionId, "schedulerAndUsage", tScheduler);
-      const piMessageCount = Array.isArray(event.messages) ? event.messages.length : 0;
+      const piMessageCount = fullWireMessageCount;
       const looksLikeImportedSession = schedulerDecision === "defer" && usagePercentage === 0 && sessionMeta.lastResponseTime === 0 && piMessageCount >= 50;
       if (looksLikeImportedSession) {
         schedulerDecision = "execute";
@@ -198160,8 +199535,9 @@ function registerPiContextHandler(pi, baseOptions) {
         signalPiPendingMaterialization(sessionId);
         sessionLog(sessionId, `stable-id scheme cutover: stored=${storedStableIdScheme} < current=${PI_STABLE_ID_SCHEME} — forcing execute+materialize this pass`);
       }
+      const tBoundaryChecks = performance.now();
       const schedulerDecisionEarly = schedulerDecision;
-      const midTurn = isMidTurnPi(event, sessionId);
+      const midTurn = isMidTurnPi(event, sessionId, branchEntries);
       const bypassReason = detectMidTurnBypassReason({
         contextUsage: { percentage: usagePercentage },
         sessionMeta,
@@ -198209,6 +199585,7 @@ function registerPiContextHandler(pi, baseOptions) {
         }
       }
       const isCacheBusting = historyRefreshSessions.has(sessionId);
+      logTransformTiming(sessionId, "boundaryTriggerChecks", tBoundaryChecks);
       sessionLog(sessionId, `transform: usage=${usagePercentage.toFixed(1)}% (${usageInputTokens} tokens, limit=${usageContextLimit ?? "?"}) decision=${schedulerDecision}${forceMaterialization ? " force=true" : ""}${isEmergency ? " EMERGENCY=true" : ""}${isCacheBusting ? " busting=true" : ""}`);
       logTransformTiming(sessionId, "emergencyRecoveryBlock", tEmergencyRecovery);
       const entryIds = strictEntryIds ?? undefined;
@@ -198217,12 +199594,15 @@ function registerPiContextHandler(pi, baseOptions) {
         contextLimit: usageContextLimit,
         sessionId
       }) / 100)) : undefined;
+      logTransformTiming(sessionId, "prePipelineTotal", transformStartTime);
+      const tRunPipeline = performance.now();
       const result = await runPipeline({
         db: options.db,
         tagger,
         sessionId,
         projectIdentity,
         projectDirectory,
+        sessionMeta,
         messages: event.messages,
         smartDrops: options.smartDrops === true,
         protectedTags: options.protectedTags ?? 20,
@@ -198243,6 +199623,7 @@ function registerPiContextHandler(pi, baseOptions) {
         } : undefined,
         entryIds,
         entryIdByRef,
+        reusableMessageIds,
         stableIdSchemeCutover,
         schedulerDecision,
         forceMaterialization: forceMaterialization || isEmergency,
@@ -198260,8 +199641,14 @@ function registerPiContextHandler(pi, baseOptions) {
         readBranchEntries: resolvePiReadBranchEntries(ctx),
         isSubagent: sessionMeta.isSubagent
       });
-      const piDecisionSnapshotNewestAssistant = branchEntries === null ? undefined : findNewestPiAssistantEntryId(branchEntries);
-      if (result.bustedThisPass && piDecisionSnapshotNewestAssistant !== undefined) {
+      logTransformTiming(sessionId, "runPipeline", tRunPipeline);
+      const postPipelineStart = performance.now();
+      const tTransformDecision = performance.now();
+      if (strictEntryIds) {
+        recordSuccessfulTaggedMessageIds(sessionId, strictEntryIds);
+      }
+      const piDecisionSnapshotNewestAssistant = result.bustedThisPass ? findNewestPiAssistantEntryId(branchEntries) : undefined;
+      if (piDecisionSnapshotNewestAssistant !== undefined) {
         recordPendingPiTransformDecision(sessionId, {
           tsMs: Date.now(),
           decision: schedulerDecision,
@@ -198274,6 +199661,8 @@ function registerPiContextHandler(pi, baseOptions) {
           bustedThisPass: true
         }, piDecisionSnapshotNewestAssistant);
       }
+      logTransformTiming(sessionId, "transformDecisionAndReuseState", tTransformDecision);
+      const tHistorianScheduling = performance.now();
       if (options.historian) {
         maybeFireHistorian({
           pi,
@@ -198283,11 +199672,14 @@ function registerPiContextHandler(pi, baseOptions) {
           historian: options.historian,
           isFirstContextPassForSession,
           activeTags: result.activeTags,
-          rawMessageProvider
+          rawMessageProvider,
+          taggerFloor
         });
       }
+      logTransformTiming(sessionId, "historianScheduling", tHistorianScheduling);
       const tPostTransform = performance.now();
       let outputMessages = result.messages;
+      const tNoteNudges = performance.now();
       try {
         outputMessages = applyNoteNudges({
           sessionId,
@@ -198302,15 +199694,17 @@ function registerPiContextHandler(pi, baseOptions) {
       } catch (err) {
         sessionLog(sessionId, `note nudges failed: ${err instanceof Error ? err.message : String(err)}`);
       }
+      logTransformTiming(sessionId, "noteNudges", tNoteNudges);
+      const tAutoSearch = performance.now();
       if (options.autoSearch?.enabled) {
         try {
-          await ensureProjectRegisteredFromPiDirectory(projectDirectory, options.db);
           outputMessages = await runAutoSearchHintForPi({
             sessionId,
             db: options.db,
             messages: outputMessages,
             entryIds: strictEntryIds,
             entryIdByRef: result.postCommitEntryIdByRef,
+            ensureProjectRegistered: () => ensureProjectRegisteredFromPiDirectory(projectDirectory, options.db),
             options: {
               enabled: true,
               scoreThreshold: options.autoSearch.scoreThreshold,
@@ -198323,6 +199717,8 @@ function registerPiContextHandler(pi, baseOptions) {
           sessionLog(sessionId, `auto-search failed: ${err instanceof Error ? err.message : String(err)}`);
         }
       }
+      logTransformTiming(sessionId, "autoSearch", tAutoSearch);
+      const tTodoCapture = performance.now();
       try {
         const sessionMetaForTodo = getOrCreateSessionMeta(options.db, sessionId);
         if (!sessionMetaForTodo.isSubagent && sessionMetaForTodo.lastTodoState !== "") {
@@ -198339,6 +199735,8 @@ function registerPiContextHandler(pi, baseOptions) {
       } catch (err) {
         sessionLog(sessionId, `synthetic todowrite injection failed: ${err instanceof Error ? err.message : String(err)}`);
       }
+      logTransformTiming(sessionId, "todoCapture", tTodoCapture);
+      const tChannelAccounting = performance.now();
       try {
         const sessionMetaForCh1 = getOrCreateSessionMeta(options.db, sessionId);
         if (!sessionMetaForCh1.isSubagent) {
@@ -198398,16 +199796,39 @@ function registerPiContextHandler(pi, baseOptions) {
       } catch (err) {
         sessionLog(sessionId, `channel1 baseline / channel2 trigger failed: ${err instanceof Error ? err.message : String(err)}`);
       }
+      logTransformTiming(sessionId, "channelNudgeAccounting", tChannelAccounting);
+      const tWorkMetrics = performance.now();
       try {
         const metrics = computePiWorkMetrics(outputMessages);
         setSessionWorkMetrics(options.db, sessionId, metrics.newWorkTokens, metrics.totalInputTokens);
       } catch (err) {
         sessionLog(sessionId, `work-metrics update failed: ${err instanceof Error ? err.message : String(err)}`);
       }
+      logTransformTiming(sessionId, "workMetrics", tWorkMetrics);
+      const tStableIdSchemePersist = performance.now();
+      if (stableIdSchemeCutover) {
+        persistStableIdSchemeForRun(options.db, sessionId, {
+          piStableIdScheme: PI_STABLE_ID_SCHEME
+        });
+        invalidateTrueRawTokenCache({
+          sessionId,
+          reason: "pi.stable-id-scheme.changed"
+        });
+        sessionLog(sessionId, `stable-id scheme cutover complete — stamped scheme=${PI_STABLE_ID_SCHEME}`);
+      }
+      logTransformTiming(sessionId, "stableIdSchemePersist", tStableIdSchemePersist);
       logTransformTiming(sessionId, "postTransformPhase", tPostTransform);
-      sessionLog(sessionId, `transform completed in ${(performance.now() - transformStartTime).toFixed(1)}ms (${outputMessages.length} messages, ${result.targetCount} targets, watermark: ${result.reasoningWatermark})`);
       clearLastTransformErrorIfSet(options.db, sessionId);
       options.maybeAutoEmbedSession?.(sessionId, projectDirectory, projectIdentity);
+      logTransformTiming(sessionId, "postPipelineTotal", postPipelineStart);
+      const transformElapsedMs = performance.now() - transformStartTime;
+      recordPiTransformTiming({
+        sessionId,
+        stage: "total",
+        elapsedMs: transformElapsedMs,
+        extra: `messages=${outputMessages.length} targets=${result.targetCount}`
+      });
+      sessionLog(sessionId, `transform completed in ${transformElapsedMs.toFixed(1)}ms (${outputMessages.length} messages, ${result.targetCount} targets, watermark: ${result.reasoningWatermark})`);
       return { messages: outputMessages };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -198708,7 +200129,7 @@ function maybeFireHistorian(args) {
     }
     return snapshot;
   };
-  const boundarySnapshot = resolveRunnablePiBoundarySnapshot();
+  let boundarySnapshot;
   let triggered = false;
   try {
     if (isFirstContextPassForSession) {
@@ -198718,7 +200139,10 @@ function maybeFireHistorian(args) {
         sessionLog(sessionId, "historian: cleared stale compartmentInProgress flag on first context pass after restart");
       }
       const failureState = getHistorianFailureState(db, sessionId);
-      const shouldRecoverOnFirstPass = failureState.failureCount > 0 && hasEligiblePiCompartmentHistory(db, sessionId, boundarySnapshot);
+      if (failureState.failureCount > 0) {
+        boundarySnapshot = resolveRunnablePiBoundarySnapshot();
+      }
+      const shouldRecoverOnFirstPass = failureState.failureCount > 0 && boundarySnapshot !== undefined && hasEligiblePiCompartmentHistory(db, sessionId, boundarySnapshot);
       if (shouldRecoverOnFirstPass) {
         triggered = true;
         sessionLog(sessionId, `historian recovery triggered on session load after ${failureState.failureCount} failure(s)`);
@@ -198741,12 +200165,18 @@ Historian previously failed ${failureState.failureCount} time(s), so Magic Conte
         return;
       }
     }
-    const trigger = checkCompartmentTrigger(db, sessionId, sessionMeta, usage, 0, triggerInputs.executeThresholdPercentage, triggerInputs.triggerBudget, triggerInputs.clearReasoningAge, triggerInputs.commitClusterTrigger, args.activeTags, boundaryContextLimit);
+    const trigger = checkCompartmentTrigger(db, sessionId, sessionMeta, usage, 0, triggerInputs.executeThresholdPercentage, triggerInputs.triggerBudget, triggerInputs.clearReasoningAge, triggerInputs.commitClusterTrigger, args.activeTags, boundaryContextLimit, () => {
+      const messages = provider2.readMessages();
+      return { messages, absoluteMessageCount: messages.length };
+    }, args.taggerFloor);
     if (!trigger.shouldFire) {
       sessionLog(sessionId, `historian trigger eval: shouldFire=false (no trigger condition met)`);
       try {
         const overflowState = getOverflowState(db, sessionId);
-        if (overflowState.needsEmergencyRecovery && usage.percentage < FORCE_MATERIALIZATION_PERCENTAGE && !inFlightHistorian.has(sessionId) && !hasRunnableCompartmentWindow(boundarySnapshot)) {
+        if (overflowState.needsEmergencyRecovery && usage.percentage < FORCE_MATERIALIZATION_PERCENTAGE && !inFlightHistorian.has(sessionId)) {
+          boundarySnapshot ??= resolveRunnablePiBoundarySnapshot();
+        }
+        if (overflowState.needsEmergencyRecovery && usage.percentage < FORCE_MATERIALIZATION_PERCENTAGE && !inFlightHistorian.has(sessionId) && boundarySnapshot !== undefined && !hasRunnableCompartmentWindow(boundarySnapshot)) {
           clearEmergencyRecovery(db, sessionId);
           sessionLog(sessionId, `historian: disarming stale emergency recovery — real pressure ${usage.percentage.toFixed(1)}% with no runnable compartment window (would otherwise bump to 95% every pass)`);
         }
@@ -198766,7 +200196,7 @@ Historian previously failed ${failureState.failureCount} time(s), so Magic Conte
       provider: provider2,
       unregister,
       boundarySnapshot: selectPiHistorianRunBoundarySnapshot({
-        resolvedBoundarySnapshot: boundarySnapshot,
+        resolvedBoundarySnapshot: boundarySnapshot ?? trigger.boundarySnapshot ?? resolveRunnablePiBoundarySnapshot(),
         triggerBoundarySnapshot: trigger.boundarySnapshot
       }),
       refreshBoundarySnapshot: resolveRunnablePiBoundarySnapshot,
@@ -198789,6 +200219,44 @@ function pendingPiMarkerCoveredByRenderedBoundary(pending, injection) {
     return true;
   return boundary.ordinal !== null && pending.ordinal <= boundary.ordinal;
 }
+function captureReasoningMutationRollback(messages) {
+  const snapshots = [];
+  for (const raw of messages) {
+    if (!raw || typeof raw !== "object")
+      continue;
+    const message = raw;
+    if (message.role !== "assistant" || !Array.isArray(message.content))
+      continue;
+    for (const rawPart of message.content) {
+      if (!rawPart || typeof rawPart !== "object")
+        continue;
+      const part = rawPart;
+      if (part.type === "thinking") {
+        snapshots.push({
+          part,
+          field: "thinking",
+          value: part.thinking,
+          hadSignature: Object.hasOwn(part, "thinkingSignature"),
+          signature: part.thinkingSignature
+        });
+      } else if (part.type === "text") {
+        snapshots.push({ part, field: "text", value: part.text });
+      }
+    }
+  }
+  return () => {
+    for (const snapshot of snapshots) {
+      snapshot.part[snapshot.field] = snapshot.value;
+      if (snapshot.field === "thinking") {
+        if (snapshot.hadSignature) {
+          snapshot.part.thinkingSignature = snapshot.signature;
+        } else {
+          delete snapshot.part.thinkingSignature;
+        }
+      }
+    }
+  };
+}
 async function runPipeline(args) {
   let executedWorkThisPass = false;
   let historyWasConsumedThisPass = false;
@@ -198817,7 +200285,9 @@ async function runPipeline(args) {
     }
     logTransformTiming(args.sessionId, "injectTemporalMarkers", tTemporal);
   }
+  const tTranscriptBuild = performance.now();
   const transcript = createPiTranscript(args.messages, args.sessionId, args.entryIds);
+  logTransformTiming(args.sessionId, "transcriptBuild", tTranscriptBuild);
   const workingMessages = transcript.getWorkingMessages();
   const stableIdResolver = (msg, index) => resolvePiStableId(msg, index, args.entryIds, args.entryIdByRef ?? undefined);
   const currentTurnId = (() => {
@@ -198825,12 +200295,11 @@ async function runPipeline(args) {
     return findLatestUserMessageIdPi(args.messages, ids)?.messageId ?? null;
   })();
   const alreadyRanHeuristicsThisTurn = currentTurnId !== null && lastHeuristicsTurnIdBySession.get(args.sessionId) === currentTurnId;
-  const sessionMetaForAvailability = getOrCreateSessionMeta(args.db, args.sessionId);
-  const ctxReduceCallable = !sessionMetaForAvailability.isSubagent;
+  const ctxReduceCallable = !args.sessionMeta.isSubagent;
   const canConsumeDeferredLate = args.schedulerDecision === "execute" || args.forceMaterialization === true || args.contextUsage.percentage >= FORCE_MATERIALIZATION_PERCENTAGE;
   const deferredMaterializeEligible = canConsumeDeferredLate && deferredMaterializationSessions.has(args.sessionId);
   const piHardSignals = args.injection ? (() => {
-    const hardMeta = getOrCreateSessionMeta(args.db, args.sessionId);
+    const hardMeta = args.sessionMeta;
     let piTtlMs = 5 * 60 * 1000;
     try {
       piTtlMs = parseCacheTtl(hardMeta.cacheTtl);
@@ -198855,28 +200324,44 @@ async function runPipeline(args) {
   const bypassHistorianGate = args.forceMaterialization === true || m0HardFoldThisPass;
   const hasPendingMaterializeSignal = hasPendingMaterialization(args.sessionId);
   const shouldRunHeuristics = args.heuristics !== undefined && (!historianRunning || bypassHistorianGate) && (args.forceMaterialization === true || hasPendingMaterializeSignal || deferredMaterializeEligible || m0HardFoldThisPass || args.schedulerDecision === "execute" && !alreadyRanHeuristicsThisTurn);
-  const entryFingerprintByMessageId = buildEntryFingerprintMap(args.messages, stableIdResolver);
+  const tFallbackIdentity = performance.now();
+  const hasFallbackMessageTags = hasPiFallbackMessageTags(args.db, args.sessionId);
+  const entryFingerprintByMessageId = buildEntryFingerprintMap(args.messages, stableIdResolver, args.reusableMessageIds, hasFallbackMessageTags);
   adoptPiFallbackTags(args.db, args.sessionId, args.tagger, entryFingerprintByMessageId, {
     messages: args.messages,
     resolveStableId: stableIdResolver,
-    stampStableIdScheme: args.stableIdSchemeCutover ? PI_STABLE_ID_SCHEME : undefined
+    hasFallbackMessageTags
   });
-  if (args.stableIdSchemeCutover === true) {
-    invalidateTrueRawTokenCache({
-      sessionId: args.sessionId,
-      reason: "pi.stable-id-scheme.changed"
-    });
-    sessionLog(args.sessionId, `stable-id scheme cutover complete — stamped scheme=${PI_STABLE_ID_SCHEME}`);
-  }
+  logTransformTiming(args.sessionId, "fallbackIdentityAndAdoption", tFallbackIdentity);
+  afterFallbackAdoptionForTests?.(args.stableIdSchemeCutover === true);
   const tTag = performance.now();
+  let tagTextTokenCache = piTagTextTokenCacheBySession.get(args.sessionId);
+  if (!tagTextTokenCache) {
+    tagTextTokenCache = new Map;
+    piTagTextTokenCacheBySession.set(args.sessionId, tagTextTokenCache);
+  }
+  let tagToolTokenCache = piTagToolTokenCacheBySession.get(args.sessionId);
+  if (!tagToolTokenCache) {
+    tagToolTokenCache = new Map;
+    piTagToolTokenCacheBySession.set(args.sessionId, tagToolTokenCache);
+  }
   const { targets } = tagTranscript(args.sessionId, transcript, args.tagger, args.db, {
     skipPrefixInjection: !ctxReduceCallable,
-    entryFingerprintByMessageId
+    entryFingerprintByMessageId,
+    reuseMessageIds: args.reusableMessageIds,
+    textTokenCache: tagTextTokenCache,
+    toolTokenCache: tagToolTokenCache,
+    onTiming: hasPiTransformTimingObserver() ? (phase, elapsedMs) => {
+      recordPiTransformTiming({
+        sessionId: args.sessionId,
+        stage: `tag:${phase}`,
+        elapsedMs
+      });
+    } : undefined
   });
   logTransformTiming(args.sessionId, "tagMessages", tTag);
   try {
-    const sessionMeta = getOrCreateSessionMeta(args.db, args.sessionId);
-    if (!sessionMeta.isSubagent) {
+    if (!args.sessionMeta.isSubagent) {
       const hasRecentCommit = detectRecentCommit(args.messages);
       const hadPriorCommitState = commitSeenLastPass.has(args.sessionId);
       const sawCommitLastPass = commitSeenLastPass.get(args.sessionId) ?? false;
@@ -198891,6 +200376,7 @@ async function runPipeline(args) {
   const deferredMaterializationWasPending = deferredMaterializationSessions.has(args.sessionId);
   const deferredHistoryRefreshWasPending = deferredHistoryWasPendingAtPassStart;
   const pendingOps = getPendingOps(args.db, args.sessionId);
+  const pendingOperationTags = getTagsForPendingOperations(args.db, args.sessionId, pendingOps.map((operation) => operation.tagId), args.protectedTags, RECENT_TOOL_SKELETON_WINDOW);
   const baseShouldApplyPendingOps = args.schedulerDecision === "execute" || args.forceMaterialization || hasPendingMaterializeSignal || m0HardFoldThisPass;
   const deferredMaterialize = canConsumeDeferredLate && deferredMaterializationWasPending;
   const deferredHistoryRefresh = canConsumeDeferredLate && deferredHistoryRefreshWasPending;
@@ -198900,7 +200386,7 @@ async function runPipeline(args) {
     sessionLog(args.sessionId, `pending ops WILL APPLY — reason=${applyReason}, pendingOps=${pendingOps.length}, context=${args.contextUsage.percentage.toFixed(1)}%`);
     try {
       const tApplyPending = performance.now();
-      pendingOpsDidMutate = applyPendingOperations(args.sessionId, args.db, targets, args.protectedTags, undefined, pendingOps);
+      pendingOpsDidMutate = applyPendingOperations(args.sessionId, args.db, targets, args.protectedTags, pendingOperationTags, pendingOps);
       if (pendingOpsDidMutate) {
         droppedCount += pendingOps.length;
       }
@@ -198956,6 +200442,7 @@ async function runPipeline(args) {
     }
   }
   if (args.heuristics?.caveman?.enabled && !args.isSubagent) {
+    const tCavemanReplay = performance.now();
     try {
       const tags = getTagsByNumbers(args.db, args.sessionId, targetTagNumbers);
       const replayed = replayCavemanCompression(args.sessionId, args.db, targets, tags);
@@ -198965,6 +200452,7 @@ async function runPipeline(args) {
     } catch (err) {
       sessionLog(args.sessionId, `caveman replay failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
     }
+    logTransformTiming(args.sessionId, "cavemanReplay", tCavemanReplay);
   }
   let heuristicsExecuted = false;
   let heuristicsResult = null;
@@ -199015,10 +200503,10 @@ async function runPipeline(args) {
     }
   }
   if (args.reasoningClearing && shouldRunHeuristics) {
+    const rollbackReasoning = captureReasoningMutationRollback(workingMessages);
     try {
       const tClearReasoning = performance.now();
-      const meta3 = getOrCreateSessionMeta(args.db, args.sessionId);
-      const prevWatermark = meta3.clearedReasoningThroughTag ?? 0;
+      const prevWatermark = args.sessionMeta.clearedReasoningThroughTag ?? 0;
       const clearOutcome = clearOldReasoningPi({
         messages: workingMessages,
         messageIdToMaxTag,
@@ -199033,9 +200521,10 @@ async function runPipeline(args) {
       });
       const combinedWatermark = Math.max(clearOutcome.newWatermark, stripOutcome.newWatermark);
       if (combinedWatermark > prevWatermark) {
-        updateSessionMeta(args.db, args.sessionId, {
+        persistReasoningWatermarkForRun(args.db, args.sessionId, {
           clearedReasoningThroughTag: combinedWatermark
         });
+        args.sessionMeta.clearedReasoningThroughTag = combinedWatermark;
         sessionLog(args.sessionId, `reasoning cleanup: cleared=${clearOutcome.cleared} inlineStripped=${stripOutcome.stripped} watermark=${prevWatermark}→${combinedWatermark}`);
       }
       logTransformTiming(args.sessionId, "clearOldReasoning", tClearReasoning);
@@ -199048,7 +200537,8 @@ async function runPipeline(args) {
         executedWorkThisPass = true;
       }
     } catch (err) {
-      sessionLog(args.sessionId, `reasoning clearing failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
+      rollbackReasoning();
+      sessionLog(args.sessionId, `reasoning clearing failed; restored original reasoning: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
   const toolReclaimExecutePass = args.schedulerDecision === "execute";
@@ -199057,7 +200547,7 @@ async function runPipeline(args) {
   let autoReclaimTargetCount = 0;
   let autoReclaimDidMutate = false;
   if (toolReclaimExecutePass && alreadyMutatingThisPass && !emergencyDropEligible) {
-    const reclaimMeta = getOrCreateSessionMeta(args.db, args.sessionId);
+    const reclaimMeta = args.sessionMeta;
     const syntheticPendingOps = buildSyntheticToolReclaimOps({
       db: args.db,
       sessionId: args.sessionId,
@@ -199103,13 +200593,38 @@ async function runPipeline(args) {
       }
     }
   }
+  if (args.canUseEmptySentinels) {
+    const tProcessedImages = performance.now();
+    try {
+      const imageResult = stripPiProcessedImages({
+        db: args.db,
+        sessionId: args.sessionId,
+        messages: workingMessages,
+        detect: args.isCacheBusting || shouldApplyPendingOps || shouldRunHeuristics,
+        watermark: getMaxDroppedTagNumber(args.db, args.sessionId),
+        messageIdToMaxTag,
+        stableId: stableIdResolver
+      });
+      if (imageResult.newlyStrippedIds.length > 0) {
+        heuristicOrReasoningDidMutate = true;
+        executedWorkThisPass = true;
+        droppedCount += imageResult.stripped;
+      }
+    } catch (err) {
+      sessionLog(args.sessionId, `processed-image strip failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
+    }
+    logTransformTiming(args.sessionId, "stripProcessedImages", tProcessedImages);
+  }
+  const tTranscriptCommit = performance.now();
   transcript.commit();
+  logTransformTiming(args.sessionId, "transcriptCommit", tTranscriptCommit);
   if (toolReclaimExecutePass) {
     advanceToolReclaimWatermarkToCurrentMax(args.db, args.sessionId);
   }
   if (autoReclaimTargetCount > 0) {
     sessionLog(args.sessionId, `tool reclaim auto-drop: targets=${autoReclaimTargetCount} mutated=${autoReclaimDidMutate}`);
   }
+  const tPostCommitStableIdMaps = performance.now();
   const postCommitStableIdByRef = new Map;
   const postCommitEntryIdByRef = new Map;
   for (let i = 0;i < args.messages.length; i++) {
@@ -199124,6 +200639,7 @@ async function runPipeline(args) {
       postCommitEntryIdByRef.set(m, realId);
     }
   }
+  logTransformTiming(args.sessionId, "postCommitStableIdMaps", tPostCommitStableIdMaps);
   let injectionResult = null;
   if (args.injection) {
     try {
@@ -199151,6 +200667,7 @@ async function runPipeline(args) {
       sessionLog(args.sessionId, `compartment injection failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
     }
   }
+  const tDroppedPlaceholders = performance.now();
   stripPiDroppedPlaceholderMessages({
     db: args.db,
     sessionId: args.sessionId,
@@ -199159,6 +200676,7 @@ async function runPipeline(args) {
     stableIdByRef: postCommitStableIdByRef,
     forceDiscovery: args.stableIdSchemeCutover === true
   });
+  logTransformTiming(args.sessionId, "stripDroppedPlaceholders", tDroppedPlaceholders);
   const deferredHistoryDrainEligible = historyWasConsumedThisPass && materializationSatisfiedThisPass && (deferredHistoryWasPendingAtPassStart || hasPendingMaterializeSignal) && !suppressDeferredHistoryDrain && !casLost;
   let preserveDeferredMaterializationForMarkerDrain = false;
   if (deferredHistoryDrainEligible) {
@@ -199215,11 +200733,28 @@ async function runPipeline(args) {
   logTransformTiming(args.sessionId, "batchFinalize:heuristics", performance.now());
   const outputMessages = transcript.getOutputMessages();
   try {
-    const counts = tokenizePiMessages(outputMessages);
+    const tTokenAccounting = performance.now();
+    let tokenCache = piMessageTokenCacheBySession.get(args.sessionId);
+    if (!tokenCache) {
+      tokenCache = new Map;
+      piMessageTokenCacheBySession.set(args.sessionId, tokenCache);
+    }
+    const counts = tokenizePiMessages(outputMessages, {
+      cache: tokenCache,
+      stableId: (message) => postCommitEntryIdByRef.get(message),
+      onTiming: hasPiTransformTimingObserver() ? (phase, elapsedMs) => {
+        recordPiTransformTiming({
+          sessionId: args.sessionId,
+          stage: `token:${phase}`,
+          elapsedMs
+        });
+      } : undefined
+    });
     updateSessionMeta(args.db, args.sessionId, {
       conversationTokens: counts.conversation,
       toolCallTokens: counts.toolCall
     });
+    logTransformTiming(args.sessionId, "tokenAccounting", tTokenAccounting);
   } catch (err) {
     sessionLog(args.sessionId, `token accounting failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -199241,15 +200776,18 @@ async function runPipeline(args) {
     emergency,
     bustedThisPass,
     targetCount: targets.size,
-    reasoningWatermark: getOrCreateSessionMeta(args.db, args.sessionId).clearedReasoningThroughTag ?? 0,
+    reasoningWatermark: args.sessionMeta.clearedReasoningThroughTag ?? 0,
     activeTags,
     postCommitEntryIdByRef
   };
 }
 function applyNoteNudges(args) {
   const { sessionId, db, messages, projectIdentity, entryIds, entryIdByRef } = args;
+  const tNoteIndexMaps = performance.now();
   const messageIdByIndex = buildPiMessageIdByIndex(messages, entryIds, false, entryIdByRef);
   const replayMessageIdByIndex = buildPiMessageIdByIndex(messages, entryIds, true, entryIdByRef);
+  logTransformTiming(sessionId, "noteIndexMaps", tNoteIndexMaps);
+  const tStickyReplay = performance.now();
   for (const anchor of getNoteNudgeAnchors(db, sessionId)) {
     appendReminderToUserMessageByIdPi(messages, replayMessageIdByIndex, anchor.messageId, anchor.text);
   }
@@ -199258,6 +200796,7 @@ function applyNoteNudges(args) {
       appendReminderToUserMessageByIdPi(messages, replayMessageIdByIndex, decision.messageId, decision.text);
     }
   }
+  logTransformTiming(sessionId, "stickyReplayDecisions", tStickyReplay);
   const latestUser = findLatestUserMessageIdPi(messages, messageIdByIndex);
   const latestUserId = latestUser?.messageId ?? null;
   const noteReadStillVisible = hasVisibleNoteReadCallPi(messages);
@@ -199326,9 +200865,9 @@ function buildPiMessageIdByIndex(messages, entryIds, includeMessageIdFallback =
       }
       continue;
     }
-    const entryId = entryIds?.[index];
-    if (typeof entryId === "string") {
-      ids.set(index, entryId);
+    const entryId2 = entryIds?.[index];
+    if (typeof entryId2 === "string") {
+      ids.set(index, entryId2);
       continue;
     }
     if (includeMessageIdFallback) {
@@ -199402,6 +200941,17 @@ function clearContextHandlerSession(sessionId) {
   firstContextPassSeenBySession.delete(sessionId);
   commitSeenLastPass.delete(sessionId);
   liveModelBySession.delete(sessionId);
+  taggedStableMessageIdsBySession.delete(sessionId);
+  const tagger = taggersBySession.get(sessionId);
+  if (tagger) {
+    tagger.cleanup(sessionId);
+    taggersBySession.delete(sessionId);
+  }
+  piMessageTokenCacheBySession.delete(sessionId);
+  piTagTextTokenCacheBySession.delete(sessionId);
+  piTagToolTokenCacheBySession.delete(sessionId);
+  piBranchProjectionBySession.delete(sessionId);
+  clearPiInjectionTokenCountCache(sessionId);
   clearPiChannel1State(sessionId);
   lastHeuristicsTurnIdBySession.delete(sessionId);
   lastSeenProjectIdentityBySession.delete(sessionId);
@@ -201837,9 +203387,8 @@ function executeStatus(db, sessionId, protectedTags, executeThresholdPercentageC
     const compartments = getCompartments(db, sessionId);
     let historyBlockTokens = 0;
     for (const c of compartments) {
-      historyBlockTokens += estimateTokens(`<compartment start="${c.startMessage}" end="${c.endMessage}" title="${c.title}">
+      historyBlockTokens += estimateTokens(`## ${c.startMessage}-${c.endMessage} · ${c.title}
 ${c.content}
-</compartment>
 `);
     }
     const budgetTokens = historyBudgetPercentage && displayContextLimit > 0 ? Math.floor(displayContextLimit * (Math.min(executeThresholdPercentage, 80) / 100) * historyBudgetPercentage) : null;
@@ -201891,9 +203440,8 @@ function computeM0BlockTokens(db, sessionId, args) {
     try {
       const compRows = db.prepare("SELECT content, title, start_message, end_message FROM compartments WHERE session_id = ?").all(sessionId);
       for (const c of compRows) {
-        compartmentTokens += estimateTokens(`<compartment start="${c.start_message}" end="${c.end_message}" title="${c.title}">
+        compartmentTokens += estimateTokens(`## ${c.start_message}-${c.end_message} · ${c.title}
 ${c.content}
-</compartment>
 `);
       }
     } catch {}
@@ -201923,7 +203471,7 @@ function formatThresholdPercent(value) {
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.31.4",
+  version: "0.32.0",
   type: "module",
   description: "Pi coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -202902,9 +204450,9 @@ function stripTagPrefixFromAssistantMessage(message) {
 // ../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.
 
@@ -208447,6 +209995,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);
 }
@@ -208456,6 +210006,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;
@@ -208592,25 +210163,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) => [truncateToWidth2(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")];
@@ -208811,6 +210384,7 @@ function registerTodoOverlay(pi, deps) {
     overlay.hideCompletedTasksFromPreviousTurn();
   });
   pi.on("session_shutdown", async (_event, ctx) => {
+    clearTodowriteToolCallTodos();
     const sessionId = getSessionId(ctx);
     if (!sessionId)
       return;
@@ -208818,6 +210392,7 @@ function registerTodoOverlay(pi, deps) {
     overlay.disposeSession(sessionId);
   });
   pi.on("session_before_switch", async (_event, ctx) => {
+    clearTodowriteToolCallTodos();
     const sessionId = getSessionId(ctx);
     if (!sessionId)
       return;
@@ -208834,11 +210409,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);
@@ -208889,11 +210466,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);
     }
   };
 }
@@ -208971,9 +210548,13 @@ function getCompatiblePiTodoCapture(todos) {
   const normalized = normalizeTodoStateJson(todos);
   if (normalized === null)
     return null;
-  return { normalized, todos };
+  const parsed = parseTodos(todos);
+  if (parsed === null)
+    return null;
+  return { normalized, todos: parsed };
 }
 function applyCompatiblePiTodoCapture(args) {
+  rememberTodowriteToolCallTodos(args.toolCallId, args.capture.todos);
   if (args.todowriteEnabled) {
     setTodoSnapshot(args.sessionId, args.capture.todos);
     args.todoOverlay?.update(args.sessionId);
@@ -209118,7 +210699,7 @@ async function persistPiPressureFromMessageEnd(args) {
 }
 var PLUGIN_VERSION = (() => {
   try {
-    const req = createRequire3(import.meta.url);
+    const req = createRequire4(import.meta.url);
     return req("../package.json").version;
   } catch {
     return "0.0.0";
@@ -209290,11 +210871,11 @@ async function src_default2(pi) {
         projectIdentity: identity,
         memoryEnabled: cfg.memory.enabled
       }, sessionId, dir, identity, (text) => {
-        pi.sendMessage({
-          customType: "ctx-status",
-          content: text,
-          display: true
-        }, { triggerTurn: false });
+        sendCtxStatusMessage(pi, {
+          title: "/ctx-embed",
+          text,
+          level: "info"
+        });
       });
     }
   });
@@ -209362,6 +210943,12 @@ async function src_default2(pi) {
     todowriteEnabled
   });
   info(todowriteEnabled ? "registered tools: ctx_search, ctx_memory, ctx_note, ctx_expand, todowrite, ctx_reduce; registered /todos" : "registered tools: ctx_search, ctx_memory, ctx_note, ctx_expand, ctx_reduce (todowrite disabled)");
+  pi.on("session_start", async (event, ctx) => {
+    await handlePiCloneSessionStart(event, ctx, {
+      db,
+      signalPendingMarker: signalPiDeferredCompactionMarkerDrain
+    });
+  });
   const readLastTodoState = (sessionId) => getOrCreateSessionMeta(db, sessionId).lastTodoState;
   if (todowriteEnabled) {
     registerTodoStateLifecycle(pi, { readLastTodoState });
@@ -209375,6 +210962,8 @@ async function src_default2(pi) {
   info(bootProjectDeps.autoSearchConfig.enabled ? `registered auto-search hint (threshold=${bootProjectDeps.autoSearchConfig.scoreThreshold}, minChars=${bootProjectDeps.autoSearchConfig.minPromptChars})` : "registered auto-search hint: DISABLED (memory.auto_search.enabled=false)");
   registerCtxAugCommand(pi, (ctx) => resolveCurrentProjectDeps(ctx).sidekickConfig);
   info(bootProjectDeps.sidekickConfig ? `registered /ctx-aug (sidekick model=${bootProjectDeps.sidekickConfig.model})` : "registered /ctx-aug (sidekick disabled — set sidekick.disable=false and sidekick.model in config)");
+  const statusEntryRendererAvailable = registerCtxStatusEntryRenderer(pi);
+  info(statusEntryRendererAvailable ? "registered model-invisible ctx-status entry renderer" : "ctx-status entry renderer unavailable; using legacy visible-message fallback");
   const recompRunner = new PiSubagentRunner;
   const wrapupRunner = new PiSubagentRunner;
   const upgradeRunner = new PiSubagentRunner;
@@ -209702,6 +211291,7 @@ ${block}` : event.systemPrompt;
       const sessionId = ctx.sessionManager.getSessionId();
       if (event.toolName === "todowrite") {
         const todoArgs = event.args;
+        const toolCallId = typeof event.toolCallId === "string" ? event.toolCallId : undefined;
         const todos = todoArgs?.todos;
         const sessionMeta = Array.isArray(todos) ? getOrCreateSessionMeta(db, sessionId) : null;
         capturePiTodowriteArgsIfCompatible({
@@ -209710,7 +211300,8 @@ ${block}` : event.systemPrompt;
           todos,
           todowriteEnabled,
           todoOverlay,
-          persist: Boolean(sessionMeta && !sessionMeta.isSubagent)
+          persist: Boolean(sessionMeta && !sessionMeta.isSubagent),
+          toolCallId
         });
         if (Array.isArray(todos) && todos.length > 0 && todos.every((t) => t.status === "completed" || t.status === "cancelled")) {
           if (sessionMeta && !sessionMeta.isSubagent) {