@retaw106/mmc-pi 2.5.0 → 2.7.1

package/dist/index.js

@@ -139,13 +139,13 @@ import {
   getToolTagNumberByOwner,
   getNullOwnerToolTag,
   adoptNullOwnerToolTag,
+  BoundedSessionMap,
   resolveOpenCodeDbPath,
   hasV1MessageTables,
   assertOpenCodeStoreGeneration,
   withReadOnlySessionDb,
   expandToolPart,
   retreatPastHostUnservedRows,
-  isCoveredInstructionRow,
   completedToolArcCrossesBoundary,
   estimateTrueRawMessageTokens,
   buildToolArcs,
@@ -182,12 +182,13 @@ import {
   getCachedAbsoluteMessageCount2,
   primeInMemoryTailRawMessageCache2,
   readRawSessionMessageIdOrdinalsForRange2,
+  compareRawSessionMessageOrder2,
   readRawSessionMessageById2,
   getRawSessionMessageCount2,
   getRawSessionTagKeysThrough2,
   getLegacyProtectedTailStartOrdinal2,
   readSessionChunk2
-} from "./index-t2aaz8cn.js";
+} from "./index-07rh0nr2.js";
 import {
   inRootAsyncContext,
   registerSlowWriteReporter,
@@ -8911,7 +8912,7 @@ function parseFrozenCalibration(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
     return null;
   const candidate = value;
-  if (typeof candidate.revision !== "string" || candidate.revision.length === 0 || typeof candidate.providerId !== "string" || typeof candidate.modelId !== "string" || !finitePositive(candidate.systemRatio) || !finitePositive(candidate.toolsRatio) || !finitePositive(candidate.proseRatio) || candidate.source !== "seed" && candidate.source !== "family-fallback") {
+  if (typeof candidate.revision !== "string" || candidate.revision.length === 0 || typeof candidate.providerId !== "string" || typeof candidate.modelId !== "string" || !finitePositive(candidate.systemRatio) || !finitePositive(candidate.toolsRatio) || !finitePositive(candidate.proseRatio) || candidate.source !== "seed" && candidate.source !== "family-fallback" && candidate.source !== "model-id") {
     return null;
   }
   return {
@@ -10709,7 +10710,11 @@ function parsePersistedCompactionMarkerState(raw, storedTargetEndMessageId) {
     if (parsed && typeof parsed === "object" && typeof parsed.boundaryMessageId === "string" && typeof parsed.summaryMessageId === "string" && typeof parsed.compactionPartId === "string" && typeof parsed.summaryPartId === "string" && typeof parsed.boundaryOrdinal === "number") {
       const targetEndMessageId = typeof storedTargetEndMessageId === "string" && storedTargetEndMessageId.length > 0 ? storedTargetEndMessageId : typeof parsed.targetEndMessageId === "string" && parsed.targetEndMessageId.length > 0 ? parsed.targetEndMessageId : null;
       return {
-        ...parsed,
+        boundaryMessageId: parsed.boundaryMessageId,
+        summaryMessageId: parsed.summaryMessageId,
+        compactionPartId: parsed.compactionPartId,
+        summaryPartId: parsed.summaryPartId,
+        boundaryOrdinal: parsed.boundaryOrdinal,
         targetEndMessageId
       };
     }
@@ -10720,12 +10725,32 @@ function getPersistedCompactionMarkerState(db, sessionId) {
   const row = db.prepare("SELECT compaction_marker_state, compaction_marker_target_end_message_id FROM session_meta WHERE session_id = ?").get(sessionId);
   return parsePersistedCompactionMarkerState(row?.compaction_marker_state, row?.compaction_marker_target_end_message_id);
 }
-function setPersistedCompactionMarkerState(db, sessionId, state) {
-  db.transaction(() => {
+function getCompactionMarkerPublicationState(db, sessionId) {
+  const row = db.prepare("SELECT compaction_marker_state FROM session_meta WHERE session_id = ?").get(sessionId);
+  const raw = row?.compaction_marker_state ?? "";
+  let pending = null;
+  try {
+    pending = parsePersistedCompactionMarkerState(JSON.stringify(JSON.parse(raw).pending));
+  } catch {}
+  return { raw, pending };
+}
+function compareAndSetCompactionMarkerPublicationState(db, sessionId, expectedRaw, state, pending) {
+  return db.transaction(() => {
     ensureSessionMetaRow(db, sessionId);
-    const previous = state === null ? getPersistedCompactionMarkerState(db, sessionId) ?? getDeferredClearedCompactionMarkerState(db, sessionId) : null;
-    const json = state ? JSON.stringify(state) : previous ? JSON.stringify({ deferredClear: previous }) : "";
-    db.prepare("UPDATE session_meta SET compaction_marker_state = ?, compaction_marker_target_end_message_id = ? WHERE session_id = ?").run(json, state?.targetEndMessageId ?? null, sessionId);
+    let envelope = {};
+    if (pending) {
+      try {
+        const parsed = JSON.parse(expectedRaw);
+        if (parsed && typeof parsed === "object")
+          envelope = parsed;
+      } catch {}
+    }
+    const raw = JSON.stringify(pending ? { ...envelope, pending } : state);
+    const result = db.prepare(`UPDATE session_meta SET compaction_marker_state = ?, compaction_marker_target_end_message_id = ?
+             WHERE session_id = ? AND COALESCE(compaction_marker_state, '') = ?`).run(raw, state?.targetEndMessageId ?? null, sessionId, expectedRaw);
+    if (result.changes !== 1)
+      throw new Error("marker publication state changed concurrently");
+    return raw;
   }).immediate();
 }
 function getDeferredClearedCompactionMarkerState(db, sessionId) {
@@ -11144,51 +11169,6 @@ import { createHash as createHash5, randomUUID as randomUUID2 } from "node:crypt
 import { lstatSync as lstatSync2, readdirSync as readdirSync3, readFileSync as readFileSync9, rmdirSync, rmSync as rmSync3 } from "node:fs";
 import { basename, dirname as dirname3, join as join6 } from "node:path";
 
-// ../plugin/src/shared/bounded-session-map.ts
-class BoundedSessionMap {
-  maxEntries;
-  store = new Map;
-  constructor(maxEntries) {
-    if (!Number.isFinite(maxEntries) || maxEntries < 1) {
-      throw new Error(`BoundedSessionMap: maxEntries must be >= 1, got ${maxEntries}`);
-    }
-    this.maxEntries = maxEntries;
-  }
-  get(sessionId) {
-    const value = this.store.get(sessionId);
-    if (value === undefined)
-      return;
-    this.store.delete(sessionId);
-    this.store.set(sessionId, value);
-    return value;
-  }
-  peek(sessionId) {
-    return this.store.get(sessionId);
-  }
-  has(sessionId) {
-    return this.store.has(sessionId);
-  }
-  set(sessionId, value) {
-    if (this.store.has(sessionId)) {
-      this.store.delete(sessionId);
-    } else if (this.store.size >= this.maxEntries) {
-      const oldest = this.store.keys().next().value;
-      if (oldest !== undefined)
-        this.store.delete(oldest);
-    }
-    this.store.set(sessionId, value);
-  }
-  delete(sessionId) {
-    return this.store.delete(sessionId);
-  }
-  clear() {
-    this.store.clear();
-  }
-  get size() {
-    return this.store.size;
-  }
-}
-
 // ../plugin/src/shared/storage-file-mutex.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
 import { createHash as createHash4, randomUUID } from "node:crypto";
@@ -12448,9 +12428,10 @@ function closeConnection(connection) {
     counters.readersClosed += 1;
   }
 }
-function messageTimesQuery(count) {
+function messageTimesQuery(count, withVersions = false) {
   return `SELECT id, COALESCE(time_created, json_extract(data, '$.time.created')) AS created,
                    json_extract(data, '$.time.completed') AS completed
+                   ${withVersions ? ", type, seq, time_created AS version_created, time_updated AS version_updated" : ""}
             FROM session_message WHERE +session_id = ? AND id IN (${Array.from({ length: count }, () => "?").join(",")})`;
 }
 
@@ -12570,9 +12551,6 @@ class V2StoreReader {
       return null;
     return typeof row.parent_id === "string" && row.parent_id.length > 0;
   }
-  sessionIds() {
-    return this.prepare("SELECT id FROM session_v2").all().map((row) => row.id);
-  }
   storedRowsAfter(sessionID, after) {
     const row = this.prepare("SELECT COUNT(*) AS count FROM session_message WHERE session_id = ? AND seq > ?").get(sessionID, after);
     return row.count;
@@ -12591,16 +12569,46 @@ class V2StoreReader {
       return row ? decode2(row) : null;
     });
   }
-  messageTimes(sessionID, ids) {
-    const times = new Map;
+  messageTimeVersions(sessionID, ids, span) {
+    const versions = new Map;
+    if (ids.length > 0 && span && span.last - span.first < ids.length * 2) {
+      const wanted = new Set(ids);
+      const rows = this.prepare(`SELECT id, type, seq, time_created AS created, time_updated AS updated
+                FROM session_message WHERE session_id = ? AND seq >= ? AND seq <= ?`).all(sessionID, span.first, span.last);
+      for (const row of rows)
+        if (wanted.has(row.id))
+          versions.set(row.id, row);
+      for (const [id, version] of this.messageTimeVersions(sessionID, ids.filter((id) => !versions.has(id))))
+        versions.set(id, version);
+      return versions;
+    }
     for (let offset = 0;offset < ids.length; offset += 500) {
       const batch = ids.slice(offset, offset + 500);
-      const rows = this.prepare(messageTimesQuery(batch.length)).all(sessionID, ...batch);
+      const rows = this.prepare(`SELECT id, type, seq, time_created AS created, time_updated AS updated
+                FROM session_message WHERE +session_id = ? AND id IN (${batch.map(() => "?").join(",")})`).all(sessionID, ...batch);
       for (const row of rows)
+        versions.set(row.id, row);
+    }
+    return versions;
+  }
+  messageTimes(sessionID, ids, versions) {
+    const times = new Map;
+    for (let offset = 0;offset < ids.length; offset += 500) {
+      const batch = ids.slice(offset, offset + 500);
+      const rows = this.prepare(messageTimesQuery(batch.length, versions !== undefined)).all(sessionID, ...batch);
+      for (const row of rows) {
         times.set(row.id, {
           created: typeof row.created === "number" ? row.created : undefined,
           completed: typeof row.completed === "number" ? row.completed : undefined
         });
+        versions?.set(row.id, {
+          id: row.id,
+          type: row.type,
+          seq: row.seq,
+          created: row.version_created,
+          updated: row.version_updated
+        });
+      }
     }
     return times;
   }
@@ -13002,9 +13010,6 @@ function deleteUnmappedMessageFtsRows(db, sessionIds) {
          WHERE rowid > ? AND session_id IN (${placeholders})`).run(state.watermarkRowid, ...sessionIds);
 }
 
-// ../plugin/src/features/magic-context/storage-session-tables.ts
-var cleanupStatements = new WeakMap;
-
 // ../plugin/src/features/magic-context/storage-meta-session.ts
 var SESSION_META_FALLBACK_SELECTS = {
   cache_ttl: "'5m' AS cache_ttl",
@@ -13910,6 +13915,39 @@ function keywordRelevance(query, content) {
   const words = new Set(terms(cleanSearchText(content)));
   return 0.8 * needles.filter((term) => words.has(term)).length / needles.length;
 }
+var CJK_RUN = /^[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]+$/u;
+var CJK_RUN_SPLIT = /([\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]+)/u;
+function hintTerms(text) {
+  return [
+    ...new Set(terms(text).flatMap((term) => term.split(CJK_RUN_SPLIT)).filter((term) => term.length > 0 && !QUERY_STOP_WORDS.has(term)))
+  ];
+}
+function characterBigrams(run) {
+  const characters = [...run];
+  return characters.length === 1 ? characters : characters.slice(1).map((character, index) => characters[index] + character);
+}
+function hintKeywordRelevance(query, content) {
+  const needles = hintTerms(query);
+  if (needles.length === 0)
+    return 0;
+  const words = new Set(hintTerms(cleanSearchText(content)));
+  const runs = [...words].filter((word) => CJK_RUN.test(word));
+  const bigrams = new Set(runs.flatMap(characterBigrams));
+  let matched = 0;
+  for (const needle of needles) {
+    if (!CJK_RUN.test(needle)) {
+      matched += Number(words.has(needle));
+      continue;
+    }
+    const grams = characterBigrams(needle);
+    if ([...needle].length === 1) {
+      matched += Number(runs.some((run) => run.includes(needle)));
+      continue;
+    }
+    matched += Math.min(1, grams.filter((gram) => bigrams.has(gram)).length / Math.ceil(grams.length / 2));
+  }
+  return 0.8 * matched / needles.length;
+}
 function matchedSearchSnippet(content, query, cap = 220) {
   const text = cleanSearchText(content);
   const needles = new Set(terms(query));
@@ -13936,9 +13974,6 @@ function matchedSearchSnippet(content, query, cap = 220) {
 }
 
 // ../plugin/src/features/magic-context/message-index.ts
-var MESSAGE_HISTORY_ORPHAN_SAFETY_AGE_MS = 24 * 60 * 60 * 1000;
-var MESSAGE_HISTORY_ORPHAN_SWEEP_COOLDOWN_MS = 10 * 60 * 1000;
-var MESSAGE_HISTORY_ORPHAN_UNAVAILABLE_REPROBE_MS = 24 * 60 * 60 * 1000;
 var lastIndexedStatements = new WeakMap;
 var insertMessageStatements = new WeakMap;
 var upsertProgressStatements = new WeakMap;
@@ -15747,6 +15782,12 @@ function noteLkgCapturedPrefix(sessionId) {
 }
 
 // ../plugin/src/hooks/magic-context/lkg-slot.ts
+var POSITIONAL_SYSTEM_KEY = "\x00mc-system:";
+function lkgInputIdentity(id, role, index) {
+  if (typeof id === "string" && id.length > 0)
+    return id.startsWith(POSITIONAL_SYSTEM_KEY) ? null : id;
+  return role === "system" ? `${POSITIONAL_SYSTEM_KEY}${index}` : null;
+}
 var LKG_SINGLE_SLOT_BYTES = 72 * 1024 * 1024;
 var LKG_TOTAL_BYTES = 160 * 1024 * 1024;
 var LKG_METADATA_BYTES = 256;
@@ -16175,11 +16216,8 @@ function noteEntry(sessionId, input) {
   const slot = getSlot(sessionId);
   if (!slot)
     return null;
-  const messages = input.some((message) => isCoveredInstructionRow(message.info)) ? input.filter((message) => !isCoveredInstructionRow(message.info)) : input;
-  const entryInputIds = messages.map((message) => {
-    const id = message.info?.id;
-    return typeof id === "string" ? id : "";
-  });
+  const messages = input;
+  const entryInputIds = messages.map((message, index) => lkgInputIdentity(message.info?.id, message.info?.role, index) ?? "");
   const anchorIndex = entryInputIds.indexOf(slot.lastInputMessageId);
   if (anchorIndex < 0)
     return null;
@@ -16488,6 +16526,24 @@ function freezePiContentDecision(db, sessionId, kind, messageId) {
 // ../plugin/src/features/magic-context/storage-native-replay.ts
 var NATIVE_TOOL_INPUTS = "native tool inputs";
 var NATIVE_REASONING_IDS = "native reasoning ids";
+var nativeWriteBarriers = new WeakMap;
+function withNativeReplayWriteBarrier(db, sessionId, beforeWrite, edit) {
+  let sessions = nativeWriteBarriers.get(db);
+  if (!sessions) {
+    sessions = new Map;
+    nativeWriteBarriers.set(db, sessions);
+  }
+  const prior = sessions.get(sessionId);
+  sessions.set(sessionId, beforeWrite);
+  try {
+    return edit();
+  } finally {
+    if (prior)
+      sessions.set(sessionId, prior);
+    else
+      sessions.delete(sessionId);
+  }
+}
 function invalidPersistedReplayState(lane, sessionId) {
   return new Error(`invalid persisted ${lane} state for session ${sessionId}`);
 }
@@ -16572,6 +16628,7 @@ function saveNativeToolInputs(db, sessionId, inputs) {
   }
   if (requested.size === 0)
     return;
+  nativeWriteBarriers.get(db)?.get(sessionId)?.();
   const persisted = updateReplayDocument(db, sessionId, (doc) => {
     const current = parseNativeReplayState(doc, sessionId);
     let changed = false;
@@ -16598,6 +16655,7 @@ function addNativeReasoningIds(db, sessionId, ids) {
   }
   if (requested.size === 0)
     return;
+  nativeWriteBarriers.get(db)?.get(sessionId)?.();
   const persisted = updateReplayDocument(db, sessionId, (doc) => {
     const current = parseNativeReplayState(doc, sessionId);
     let changed = false;
@@ -17799,7 +17857,7 @@ function finishDatabaseOpen(db, dbPath, explicitDbPath, latestSupportedVersion)
       startMessageFtsRowidMapBackfill(db).then(async () => {
         if (!readsOpenCodeStore)
           return;
-        const { readRawSessionMessagePage, readRawSessionMessages } = await import("./read-session-chunk-hcecqvhm.js");
+        const { readRawSessionMessagePage, readRawSessionMessages } = await import("./read-session-chunk-qg5jfqjg.js");
         const { startMessageTimeBackfill } = await import("./message-time-backfill-y26yy5pp.js");
         await startMessageTimeBackfill(db, Object.assign(readRawSessionMessages, {
           readPage: readRawSessionMessagePage
@@ -21055,7 +21113,7 @@ function registerStandalonePluginMarker(version) {
 // package.json
 var package_default = {
   name: "@retaw106/mmc-pi",
-  version: "2.5.0",
+  version: "2.7.1",
   type: "module",
   description: "Pi and OMP coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -23532,6 +23590,14 @@ var RECENT_TOOL_SKELETON_WINDOW = 20;
 function buildReplacementContent(tagId) {
   return `[dropped §${tagId}§]`;
 }
+var FROZEN_TEXT_ANNOTATION_SUFFIX = /(?:\n\n(?:<instruction name="deferred_notes">(?:(?!<\/instruction>)[\s\S])*<\/instruction>|<ctx-search-hint>(?:(?!<\/ctx-search-hint>)[\s\S])*<\/ctx-search-hint>))+$/;
+function renderDroppedText(tagId, renderedText) {
+  const placeholder = buildReplacementContent(tagId);
+  if (renderedText?.startsWith(placeholder))
+    return renderedText;
+  const annotations = renderedText?.match(FROZEN_TEXT_ANNOTATION_SUFFIX)?.[0] ?? "";
+  return placeholder + annotations;
+}
 function applyNewToolDrop(target, options) {
   const plan = planNewToolDrop(target, options, !!options.persist);
   if (!plan)
@@ -23618,6 +23684,7 @@ function prepareLegacyToolSkeletonConversions(db, sessionId, targets, options =
                 AND drop_mode IN ('truncated', 'full')
               ORDER BY tag_number`).all(sessionId);
   const rows = readRows(db);
+  options.prepareRemovals?.(rows);
   const identity = JSON.stringify(rows);
   const converted = new Map;
   for (const row of rows) {
@@ -23647,13 +23714,21 @@ function prepareLegacyToolSkeletonConversions(db, sessionId, targets, options =
   };
 }
 var PENDING_OPERATION_CHUNK_SIZE = 64;
+var PENDING_OPERATION_REJECTED_LOG_CHUNK = 20;
 function applyPendingOperations(sessionId, db, targets, protectedTagIds, preloadedTags, preloadedPendingOps, syntheticPendingOps = [], editMarkerTagIds = new Set, onTagReduced, onBatchComplete, onEligibilitySnapshot) {
   let didMutateMessage = false;
   let diagnostics;
-  const reject = (reason) => {
+  const reject = (tagNumber, reason, state = {}) => {
     if (!diagnostics)
       return;
     diagnostics.reasons[reason] = (diagnostics.reasons[reason] ?? 0) + 1;
+    const persisted = state.persisted === true;
+    (diagnostics.rejected ??= []).push({
+      tagNumber,
+      reason,
+      persisted,
+      queueState: state.queueState ?? (persisted ? "removed" : "retained")
+    });
   };
   let admitted = false;
   let startedAt = 0;
@@ -23713,29 +23788,39 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
           for (const { op: pendingOp, synthetic } of chunk) {
             const tagStatus = tagStatusById.get(pendingOp.tagId);
             if (tagStatus === "compacted" || tagStatus === "dropped") {
-              reject("already_reduced");
+              reject(pendingOp.tagId, "already_reduced", {
+                queueState: synthetic ? "none" : "removed"
+              });
               if (!synthetic)
                 removePendingOp(db, sessionId, pendingOp.tagId);
               continue;
             }
             if (removedTagIds.has(pendingOp.tagId)) {
-              reject("drop_incomplete");
+              reject(pendingOp.tagId, "drop_incomplete", {
+                queueState: synthetic ? "none" : "retained"
+              });
               continue;
             }
             const target = targets.get(pendingOp.tagId);
             const veto = pendingDropVeto(pendingOp.tagId, target, protectedTagIds);
             if (veto) {
-              reject(veto);
+              reject(pendingOp.tagId, veto, {
+                queueState: synthetic ? "none" : "retained"
+              });
               continue;
             }
             const isToolTag = tagTypeById.get(pendingOp.tagId) === "tool";
             if (synthetic) {
               if (!isToolTag) {
-                reject("synthetic_non_tool");
+                reject(pendingOp.tagId, "synthetic_non_tool", {
+                  queueState: "none"
+                });
                 continue;
               }
               if (target?.canDrop?.() !== true) {
-                reject("synthetic_target_not_droppable");
+                reject(pendingOp.tagId, "synthetic_target_not_droppable", {
+                  queueState: "none"
+                });
                 continue;
               }
             }
@@ -23748,14 +23833,19 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
               if (editMarkerTagIds.has(pendingOp.tagId)) {
                 const strip = target?.hasAttachments?.() === true;
                 if (target?.canDrop?.() === false || target?.prepareDrop?.() === false || !target) {
-                  reject("edit_marker_incomplete");
+                  reject(pendingOp.tagId, "edit_marker_incomplete", {
+                    queueState: synthetic ? "none" : "retained"
+                  });
                   continue;
                 }
                 persistDrop(strip ? "edit_marker_stripped" : "edit_marker");
                 mutations.push(() => {
                   const markResult = (strip ? target?.editMarkerStripped?.() : target?.editMarker?.()) ?? "absent";
                   if (markResult === "incomplete" || markResult === "absent") {
-                    reject(`edit_marker_${markResult}`);
+                    reject(pendingOp.tagId, `edit_marker_${markResult}`, {
+                      persisted: true,
+                      queueState: synthetic ? "none" : "removed"
+                    });
                     return;
                   }
                   record(true);
@@ -23767,7 +23857,9 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
               } else {
                 const plan = planNewToolDrop(target, { inWindow: skeletonWindow.has(pendingOp.tagId) }, true, plannedRemovals);
                 if (!plan) {
-                  reject("drop_incomplete");
+                  reject(pendingOp.tagId, "drop_incomplete", {
+                    queueState: synthetic ? "none" : "retained"
+                  });
                   continue;
                 }
                 persistDrop(plan.mode);
@@ -23778,7 +23870,10 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
                 mutations.push(() => {
                   const { result: dropResult, mode: appliedMode } = plan.apply();
                   if (dropResult === "incomplete" || synthetic && dropResult !== "removed" && dropResult !== "truncated") {
-                    reject(`drop_${dropResult}`);
+                    reject(pendingOp.tagId, `drop_${dropResult}`, {
+                      persisted: true,
+                      queueState: synthetic ? "none" : "removed"
+                    });
                     return;
                   }
                   if (dropResult === "removed" || dropResult === "truncated") {
@@ -23788,15 +23883,18 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
                       mode: appliedMode === "full" ? "full" : "truncated"
                     });
                   } else {
-                    reject(`drop_${dropResult}`);
+                    reject(pendingOp.tagId, `drop_${dropResult}`, {
+                      persisted: true,
+                      queueState: synthetic ? "none" : "removed"
+                    });
                     record(false);
                   }
                 });
               }
             } else if (target) {
-              const replacement = buildReplacementContent(pendingOp.tagId);
+              const replacement = renderDroppedText(pendingOp.tagId, target.getContent?.());
               if (target.canSetContent?.(replacement) === false) {
-                reject("content_unchanged");
+                reject(pendingOp.tagId, "content_unchanged");
                 continue;
               }
               persistDrop();
@@ -23812,12 +23910,18 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
                     removedCharacters: Math.max(0, originalCharacters - replacement.length)
                   });
                 } else {
-                  reject("content_unchanged");
+                  reject(pendingOp.tagId, "content_unchanged", {
+                    persisted: true,
+                    queueState: "removed"
+                  });
                 }
               });
             } else if (!synthetic) {
-              reject("target_absent");
               persistDrop();
+              reject(pendingOp.tagId, "target_absent", {
+                persisted: true,
+                queueState: "removed"
+              });
               mutations.push(() => record(false));
             }
           }
@@ -23844,6 +23948,15 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
       const reasons = Object.entries(diagnostics.reasons).sort(([left], [right]) => left.localeCompare(right)).map(([reason, count]) => `${reason}:${count}`).join(",");
       sessionLog(sessionId, `pending operations no-op: source=${diagnostics.source} total=${diagnostics.total} persisted=${diagnostics.persistedWithoutMutation} reasons=${reasons || "none"}`);
     }
+    const rejected = diagnostics.rejected;
+    if (rejected && rejected.length > 0) {
+      const lineCount = Math.ceil(rejected.length / PENDING_OPERATION_REJECTED_LOG_CHUNK);
+      for (let offset = 0;offset < rejected.length; offset += PENDING_OPERATION_REJECTED_LOG_CHUNK) {
+        const entries = rejected.slice(offset, offset + PENDING_OPERATION_REJECTED_LOG_CHUNK).map((entry) => `${entry.tagNumber}:${entry.reason}:${entry.queueState}${entry.persisted ? ":persisted" : ""}`).join(",");
+        const chunkLabel = lineCount > 1 ? ` chunk=${Math.floor(offset / PENDING_OPERATION_REJECTED_LOG_CHUNK) + 1}/${lineCount}` : "";
+        sessionLog(sessionId, `pending operations rejected: source=${diagnostics.source} total=${diagnostics.total} mutated=${diagnostics.mutated} persisted=${diagnostics.persistedWithoutMutation}${chunkLabel} rejected=${entries}`);
+      }
+    }
   }
   return didMutateMessage;
 }
@@ -23884,7 +23997,7 @@ function applyFlushedStatuses(sessionId, db, targets, preloadedTags) {
           }
         }
       } else if (target) {
-        const changed = target.setContent(buildReplacementContent(tag.tagNumber));
+        const changed = target.setContent(renderDroppedText(tag.tagNumber, target.getContent?.()));
         if (changed)
           didMutateMessage = true;
       }
@@ -23892,6 +24005,15 @@ function applyFlushedStatuses(sessionId, db, targets, preloadedTags) {
   }
   return didMutateMessage;
 }
+function prepareFlushedToolRemovals(targets, tags) {
+  for (const tag of tags) {
+    if (tag.status !== "dropped" || tag.type !== "tool")
+      continue;
+    if (tag.dropMode != null && tag.dropMode !== "full")
+      continue;
+    targets.get(tag.tagNumber)?.prepareReplayDrop?.();
+  }
+}
 
 // ../plugin/src/hooks/magic-context/cache-busting-signals.ts
 function hasReclaimRide(signals) {
@@ -25565,6 +25687,56 @@ function isHistorianDrainBudgetSpent(args) {
   return true;
 }
 
+// ../plugin/src/hooks/magic-context/historian-history-wait.ts
+var historyWaits = new Map;
+function newestMessageId(snapshot) {
+  try {
+    const count = getRawSessionMessageOrdinalCount2(snapshot.sessionId);
+    const ids = readRawSessionMessageIdOrdinalsForRange2(snapshot.sessionId, count, count);
+    const newest = ids.keys().next().value;
+    if (newest)
+      return newest;
+  } catch {}
+  return snapshot.rawLastMessageIdAtTrigger;
+}
+function recoveryWindow(snapshot, percentage) {
+  return percentage >= escalationBands(snapshot.executeThresholdPercentage).forceMaterializationPercentage || snapshot.emergencyTailScale !== undefined;
+}
+function clearHistorianHistoryWait(sessionId) {
+  historyWaits.delete(sessionId);
+}
+function recordHistorianNoProgress(snapshot, emergency = false) {
+  const newest = newestMessageId(snapshot);
+  if (!newest)
+    return;
+  const previous = historyWaits.get(snapshot.sessionId);
+  const sameHistory = previous?.newestMessageId === newest;
+  historyWaits.set(snapshot.sessionId, {
+    newestMessageId: newest,
+    recoveryAttempted: sameHistory && previous.recoveryAttempted || emergency || recoveryWindow(snapshot, snapshot.usagePercentage)
+  });
+}
+function shouldWaitForNewHistorianHistory(snapshot, options = {}) {
+  const wait = historyWaits.get(snapshot.sessionId);
+  if (!wait)
+    return false;
+  const newest = newestMessageId(snapshot);
+  if (newest && newest !== wait.newestMessageId) {
+    try {
+      const order = compareRawSessionMessageOrder2(snapshot.sessionId, newest, wait.newestMessageId);
+      if (order === null || order > 0)
+        return false;
+    } catch {}
+  }
+  const recovery = options.emergency || recoveryWindow(snapshot, options.usagePercentage ?? snapshot.usagePercentage);
+  if (recovery && !wait.recoveryAttempted) {
+    if (options.claim)
+      wait.recoveryAttempted = true;
+    return false;
+  }
+  return true;
+}
+
 // ../plugin/src/hooks/magic-context/active-anthropic-turn.ts
 function isInActiveAnthropicTurn(messages, index, anthropic) {
   const start = activeAnthropicTurnStart(messages, anthropic);
@@ -25948,6 +26120,13 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
     }
     return { shouldFire: false };
   }
+  if (tailInfo.boundarySnapshot && shouldWaitForNewHistorianHistory(tailInfo.boundarySnapshot, {
+    usagePercentage: usage.percentage,
+    emergency: getOverflowState(db, sessionId).needsEmergencyRecovery
+  })) {
+    sessionLog(sessionId, "compartment trigger: waiting for new history after no forward progress");
+    return { shouldFire: false };
+  }
   const canClearReasoning = reasoningProjection?.canClearReasoning ?? modelAcceptsEmptyContent(reasoningProjection?.providerID);
   const projectedPostDropPercentage = estimateProjectedPostDropPercentage(db, sessionId, usage, preloadedActiveTags ?? getActiveTagsBySession(db, sessionId), keepReasoningTokens, sessionMeta.clearedReasoningThroughTag, canClearReasoning, reasoningProjection?.budgetCutoff, eligiblePendingDropTagIds);
   const relativePostDropTarget = executeThresholdPercentage * POST_DROP_TARGET_RATIO;
@@ -27139,6 +27318,93 @@ function compareOpenCodeMessagesByCanonicalOrder(sessionId, leftMessageId, right
     return 1;
   return 0;
 }
+function planCompactionMarker(args, boundary) {
+  const identity = `${args.sessionId}\x00${args.endMessageId}`;
+  return {
+    boundaryMessageId: boundary.id,
+    summaryMessageId: generateMessageId(boundary.timeCreated + 1, 1n, `${identity}\x00summary-message`),
+    compactionPartId: generatePartId(boundary.timeCreated, 1n, `${identity}\x00compaction-part`),
+    summaryPartId: generatePartId(boundary.timeCreated + 1, 2n, `${identity}\x00summary-part`)
+  };
+}
+function withCompactionMarkerPublicationLock(operation) {
+  return runMarkerWriteTransaction(getWritableOpenCodeDb(), "compaction-marker-replace", operation);
+}
+var MARKER_PAIR_FROM = `FROM message m
+    JOIN part p ON +p.session_id = m.session_id
+               AND p.message_id = json_extract(m.data, '$.parentID')
+    WHERE m.session_id = ?
+      AND CASE WHEN json_valid(m.data)
+               THEN COALESCE(json_extract(m.data, '$.summary'), 0) ELSE 0 END = 1
+      AND COALESCE(json_extract(m.data, '$.finish'), '') <> ''
+      AND COALESCE(json_extract(p.data, '$.type'), '') = 'compaction'`;
+var MC_MARKER_IDENTITY = `(COALESCE(json_extract(m.data, '$.providerID'), '') = 'magic-context'
+      OR COALESCE(json_extract(m.data, '$.modelID'), '') = 'magic-context'
+      OR EXISTS (SELECT 1 FROM part t
+                 WHERE t.message_id = m.id AND +t.session_id = m.session_id
+                   AND COALESCE(json_extract(t.data, '$.type'), '') = 'text'
+                   AND COALESCE(json_extract(t.data, '$.text'), '') = ?))`;
+function inspectCompactionMarkerPublication(sessionId, recognized, summaryText) {
+  const db = getWritableOpenCodeDb();
+  const ids = [...new Set(recognized.map((marker) => marker.summaryMessageId))];
+  const placeholders = ids.map(() => "?").join(", ");
+  const rogue = db.prepare(`SELECT 1 ${MARKER_PAIR_FROM}
+      AND ${MC_MARKER_IDENTITY}
+      AND m.id NOT IN (${placeholders})
+      LIMIT 1`).get(sessionId, summaryText, ...ids);
+  if (rogue)
+    return { kind: "ambiguous" };
+  const pairs = db.prepare(`SELECT m.id AS summaryId, p.message_id AS boundaryId, p.id AS partId
+      ${MARKER_PAIR_FROM}
+      AND m.id IN (${placeholders})
+      LIMIT 2`).all(sessionId, ...ids);
+  if (pairs.length > 1)
+    return { kind: "ambiguous" };
+  const rowById = db.prepare(`SELECT 1 FROM message WHERE id = ?
+         UNION ALL SELECT 1 FROM part WHERE id IN (?, ?) LIMIT 1`);
+  if (pairs.length === 0) {
+    for (const marker of recognized) {
+      if (rowById.get(marker.summaryMessageId, marker.compactionPartId, marker.summaryPartId))
+        return { kind: "ambiguous" };
+    }
+    return { kind: "verified", marker: null };
+  }
+  const pair = pairs[0];
+  const marker = recognized.find((item) => item.summaryMessageId === pair.summaryId && item.boundaryMessageId === pair.boundaryId && item.compactionPartId === pair.partId);
+  if (!marker)
+    return { kind: "ambiguous" };
+  for (const other of recognized) {
+    if (other.summaryMessageId === marker.summaryMessageId && other.compactionPartId === marker.compactionPartId && other.summaryPartId === marker.summaryPartId)
+      continue;
+    if (rowById.get(other.summaryMessageId, other.compactionPartId, other.summaryPartId))
+      return { kind: "ambiguous" };
+  }
+  const row = db.prepare(`SELECT c.data AS compactionData FROM message m
+         JOIN message b ON b.id = ? AND b.session_id = m.session_id
+         JOIN part c ON c.id = ? AND c.message_id = b.id AND c.session_id = m.session_id
+         JOIN part t ON t.id = ? AND t.message_id = m.id AND t.session_id = m.session_id
+         WHERE m.id = ? AND m.session_id = ?
+           AND json_extract(b.data, '$.role') = 'user'
+           AND json_extract(m.data, '$.role') = 'assistant'
+           AND json_extract(m.data, '$.parentID') = b.id
+           AND json_extract(m.data, '$.summary') = 1
+           AND json_extract(m.data, '$.finish') = 'stop'
+           AND json_extract(m.data, '$.error') IS NULL
+           AND json_extract(m.data, '$.providerID') = 'magic-context'
+           AND json_extract(m.data, '$.modelID') = 'magic-context'
+           AND json_extract(t.data, '$.type') = 'text' AND json_extract(t.data, '$.text') = ?
+           AND (SELECT COUNT(*) FROM part p WHERE p.message_id = m.id AND +p.session_id = m.session_id) = 1`).get(marker.boundaryMessageId, marker.compactionPartId, marker.summaryPartId, marker.summaryMessageId, sessionId, summaryText);
+  if (!row || !isMcCanonicalCompactionPartData(JSON.parse(row.compactionData)) || findBoundaryUserMessage(sessionId, marker.boundaryMessageId)?.id !== marker.boundaryMessageId)
+    return { kind: "ambiguous" };
+  return { kind: "verified", marker };
+}
+function isCompactionMarkerIntentAbsent(marker, targetEndMessageId) {
+  if (!targetEndMessageId)
+    return false;
+  const db = getWritableOpenCodeDb();
+  return !db.prepare(`SELECT 1 FROM message WHERE id IN (?, ?)
+        UNION ALL SELECT 1 FROM part WHERE id IN (?, ?) LIMIT 1`).get(targetEndMessageId, marker.summaryMessageId, marker.compactionPartId, marker.summaryPartId);
+}
 function removeLegacyMarkerLineageRows(db, args) {
   const legacySummaries = db.prepare(`SELECT m.id
              FROM message m
@@ -27182,10 +27448,11 @@ function injectCompactionMarker(args) {
     return null;
   }
   const boundaryTime = boundary.timeCreated;
-  const markerIdentity = `${args.sessionId}\x00${args.endMessageId}`;
-  const summaryMsgId = generateMessageId(boundaryTime + 1, 1n, `${markerIdentity}\x00summary-message`);
-  const compactionPartId = generatePartId(boundaryTime, 1n, `${markerIdentity}\x00compaction-part`);
-  const summaryPartId = generatePartId(boundaryTime + 1, 2n, `${markerIdentity}\x00summary-part`);
+  const {
+    summaryMessageId: summaryMsgId,
+    compactionPartId,
+    summaryPartId
+  } = planCompactionMarker(args, boundary);
   const summaryMsgData = JSON.stringify({
     role: "assistant",
     parentID: boundary.id,
@@ -27276,25 +27543,122 @@ function replaceCompactionMarker(existing, args) {
     };
   }
 }
+function isMcCanonicalCompactionPartData(data) {
+  if (typeof data !== "object" || data === null || Array.isArray(data))
+    return false;
+  const record = data;
+  const keys = Object.keys(record).sort();
+  return keys.length === 2 && keys[0] === "auto" && keys[1] === "type" && record.type === "compaction" && record.auto === true;
+}
+
+// ../plugin/src/hooks/magic-context/compaction-marker-publication.ts
+function samePair(left, right) {
+  return left.boundaryMessageId === right.boundaryMessageId && left.summaryMessageId === right.summaryMessageId && left.compactionPartId === right.compactionPartId && left.summaryPartId === right.summaryPartId;
+}
+function publishRecoverableCompactionMarker(db, args, targetIsCurrent) {
+  const { sessionId } = args;
+  let raw = "";
+  let previous = null;
+  let oldSummary = null;
+  let intended;
+  let reason = "publication-failed";
+  let recovered;
+  let cut = "uncertain";
+  let writingState = false;
+  const persist = (state) => {
+    writingState = true;
+    db.transaction(() => {
+      raw = compareAndSetCompactionMarkerPublicationState(db, sessionId, raw, state, null);
+      if (previous && previous.summaryMessageId !== state.summaryMessageId) {
+        const tag = getTagNumberByMessageId(db, sessionId, `${previous.summaryMessageId}:p0`);
+        if (tag !== null)
+          updateTagStatus(db, sessionId, tag, "dropped");
+      }
+    }).immediate();
+    writingState = false;
+    previous = state;
+  };
+  try {
+    cut = getCompactionMarkerPublicationState(db, sessionId).pending ? "uncertain" : "definitely-no-cut";
+    const result = withCompactionMarkerPublicationLock(() => {
+      const snapshot = getCompactionMarkerPublicationState(db, sessionId);
+      if (snapshot.pending)
+        cut = "uncertain";
+      raw = snapshot.raw;
+      previous = getPersistedCompactionMarkerState(db, sessionId) ?? getDeferredClearedCompactionMarkerState(db, sessionId);
+      oldSummary = previous?.summaryMessageId ?? null;
+      if (snapshot.pending && (snapshot.pending.boundaryOrdinal > args.endOrdinal || snapshot.pending.boundaryOrdinal === args.endOrdinal && snapshot.pending.targetEndMessageId !== args.endMessageId) && !isCompactionMarkerIntentAbsent(snapshot.pending, snapshot.pending.targetEndMessageId))
+        throw new Error("a newer marker publication intent is pending");
+      const boundary = findBoundaryUserMessage(sessionId, args.endMessageId);
+      if (!targetIsCurrent() || !boundary || boundary.id !== args.resolvedBoundary?.id || boundary.timeCreated !== args.resolvedBoundary.timeCreated)
+        throw new Error("marker publication frontier changed before publication");
+      intended = {
+        ...planCompactionMarker(args, boundary),
+        boundaryOrdinal: args.endOrdinal,
+        targetEndMessageId: args.endMessageId
+      };
+      let pending = snapshot.pending;
+      if (pending) {
+        const pendingTarget = pending.targetEndMessageId;
+        const pendingBoundary = pendingTarget ? findBoundaryUserMessage(sessionId, pendingTarget) : null;
+        const compartments = pendingTarget ? getCompartmentsByEndMessageId(db, sessionId, pendingTarget) : [];
+        const validTarget = pending.targetEndMessageId === args.endMessageId && pending.boundaryOrdinal === args.endOrdinal || compartments.length === 1 && compartments[0].endMessage === pending.boundaryOrdinal;
+        if (!validTarget || !pendingBoundary || !pendingTarget || !samePair(pending, planCompactionMarker({ ...args, endMessageId: pendingTarget }, pendingBoundary)))
+          pending = null;
+      }
+      const inspection = inspectCompactionMarkerPublication(sessionId, [intended, ...previous ? [previous] : [], ...pending ? [pending] : []], args.summaryText);
+      if (inspection.kind === "ambiguous") {
+        reason = "ambiguous-left-alone";
+        return {
+          kind: cut,
+          error: new Error("unverified or ambiguous host marker pairs; left alone")
+        };
+      }
+      cut = "definitely-no-cut";
+      const host = inspection.marker;
+      if (host && (pending && samePair(host, pending) || samePair(host, intended))) {
+        const adopted = pending && samePair(host, pending) ? pending : intended;
+        recovered = adopted === pending ? "pending-intent-recovered" : "adopted-existing-pair";
+        cut = "uncertain";
+        if (samePair(host, intended))
+          return { kind: "committed", marker: host };
+        persist(adopted);
+      }
+      writingState = true;
+      raw = compareAndSetCompactionMarkerPublicationState(db, sessionId, raw, previous, intended);
+      writingState = false;
+      cut = "uncertain";
+      const replacement = replaceCompactionMarker(host, {
+        ...args,
+        resolvedBoundary: boundary
+      });
+      if (recovered && replacement.kind !== "committed")
+        return { kind: "uncertain", error: replacement.error };
+      if (replacement.kind !== "committed")
+        cut = replacement.kind === "uncertain" ? "uncertain" : "definitely-no-cut";
+      return replacement;
+    });
+    if (result.kind === "committed") {
+      if (!intended)
+        throw new Error("committed marker has no publication intent");
+      persist(intended);
+      reason = recovered ?? "published";
+    }
+    return result;
+  } catch (error) {
+    if (writingState)
+      reason = "state-write-failed";
+    return {
+      kind: cut,
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  } finally {
+    sessionLog(sessionId, `compaction-marker publication reason=${reason} oldSummary=${oldSummary ?? "none"} newSummary=${intended?.summaryMessageId ?? "none"} target=${args.endMessageId} at=${Date.now()}`);
+  }
+}
 
 // ../plugin/src/hooks/magic-context/compaction-marker-manager.ts
 var MARKER_SUMMARY_TEXT = "[Compacted by magic-context — session history is managed by the plugin]";
-function dropMarkerSummaryTag(db, sessionId, summaryMessageId) {
-  const tagNumber = getTagNumberByMessageId(db, sessionId, `${summaryMessageId}:p0`);
-  if (tagNumber !== null)
-    updateTagStatus(db, sessionId, tagNumber, "dropped");
-}
-function persistMarkerStateAndDropReplacedTag(db, sessionId, state, replacedSummaryMessageId) {
-  let transactionStartedAt = 0;
-  db.transaction(() => {
-    transactionStartedAt = performance.now();
-    setPersistedCompactionMarkerState(db, sessionId, state);
-    if (replacedSummaryMessageId !== null) {
-      dropMarkerSummaryTag(db, sessionId, replacedSummaryMessageId);
-    }
-  }).immediate();
-  logSlowWriteTransaction("marker-drain", transactionStartedAt);
-}
 function getCompartmentEndMessageIdForOrdinal(db, sessionId, endOrdinal) {
   const row = db.prepare(`SELECT end_message_id
              FROM compartments
@@ -27335,8 +27699,7 @@ function updateCompactionMarkerAfterPublication(db, sessionId, lastCompartmentEn
     return false;
   }
   const existing = getPersistedCompactionMarkerState(db, sessionId);
-  const removedSummaryMessageId = existing?.summaryMessageId ?? null;
-  if (existing) {
+  if (existing && !getCompactionMarkerPublicationState(db, sessionId).pending) {
     if (existingMarkerAlreadyCoversTarget(sessionId, existing, lastCompartmentEnd, targetEndMessageId)) {
       return true;
     }
@@ -27346,22 +27709,15 @@ function updateCompactionMarkerAfterPublication(db, sessionId, lastCompartmentEn
     sessionLog(sessionId, `compaction-marker: no user boundary found at or before endMessageId ${targetEndMessageId} (ordinal ${lastCompartmentEnd}); preserving existing marker`);
     return false;
   }
-  const replacement = replaceCompactionMarker(existing, {
+  const replacement = publishRecoverableCompactionMarker(db, {
     sessionId,
     endOrdinal: lastCompartmentEnd,
     endMessageId: targetEndMessageId,
     summaryText: MARKER_SUMMARY_TEXT,
     directory: directory ?? process.cwd(),
     resolvedBoundary: boundary
-  });
+  }, () => JSON.stringify(getPersistedCompactionMarkerState(db, sessionId)) === JSON.stringify(existing) && getCompartmentEndMessageIdForOrdinal(db, sessionId, lastCompartmentEnd) === targetEndMessageId);
   if (replacement.kind === "committed") {
-    const result = replacement.marker;
-    persistMarkerStateAndDropReplacedTag(db, sessionId, {
-      ...result,
-      boundaryOrdinal: lastCompartmentEnd,
-      targetEndMessageId
-    }, removedSummaryMessageId);
-    sessionLog(sessionId, `compaction-marker: injected at ordinal ${lastCompartmentEnd}, boundary user msg ${result.boundaryMessageId}`);
     return true;
   }
   return false;
@@ -28636,7 +28992,7 @@ function tagTranscript(sessionId, transcript, tagger, db, options = {}) {
           targets,
           skipPrefixInjection,
           entryFingerprint: options.entryFingerprintByMessageId?.get(messageId) ?? null,
-          reuseIdentity: reuseIdentity || contentDerivedTextIds !== undefined,
+          reuseIdentity: reuseIdentity || options.reuseTextMessageIds?.has(messageId) === true || contentDerivedTextIds !== undefined,
           timing,
           textIdentitySourceCache: options.textIdentitySourceCache,
           textTokenCache: options.textTokenCache
@@ -28705,7 +29061,11 @@ function tagTranscript(sessionId, transcript, tagger, db, options = {}) {
             if (timing)
               timing.identity += performance.now() - identityStart;
           } else {
-            const accounting = readAggregateToolAccounting(part, timing, options.toolTokenCache, tokenCacheKey);
+            const accounting = readAggregateToolAccounting(part, timing, options.toolTokenCache, tokenCacheKey, {
+              byteSize: existing.maxByteSize,
+              tokenCount: existing.tokenCountKnown ? existing.maxTokenCount : null,
+              inputTokenCount: existing.inputTokenCount
+            });
             text = accounting.text;
             if (part.kind === "tool_result") {
               applyGrownToolResultAccounting({
@@ -28764,6 +29124,7 @@ function tagTranscript(sessionId, transcript, tagger, db, options = {}) {
             occurrences: [{ message, part, kind: part.kind }],
             maxByteSize: reusableAccounting.byteSize,
             maxTokenCount: reusableAccounting.tokenCount ?? 0,
+            tokenCountKnown: reusableAccounting.tokenCount !== null,
             toolName: null,
             inputByteSize: reusableAccounting.inputByteSize,
             inputTokenCount: reusableAccounting.inputTokenCount,
@@ -28787,7 +29148,7 @@ function tagTranscript(sessionId, transcript, tagger, db, options = {}) {
           if (timing)
             timing.identity += performance.now() - identityStart;
         } else {
-          const accounting = readAggregateToolAccounting(part, timing, options.toolTokenCache, tokenCacheKey);
+          const accounting = readAggregateToolAccounting(part, timing, options.toolTokenCache, tokenCacheKey, tagger.getToolTagAccounting(sessionId, callId, messageId));
           text = accounting.text;
           const outputByteSize = part.kind === "tool_result" ? accounting.byteSize : 0;
           const outputTokenCount = part.kind === "tool_result" ? accounting.tokenCount : 0;
@@ -28805,6 +29166,7 @@ function tagTranscript(sessionId, transcript, tagger, db, options = {}) {
             occurrences: [{ message, part, kind: part.kind }],
             maxByteSize: persistedAccounting?.byteSize ?? outputByteSize,
             maxTokenCount: persistedAccounting?.tokenCount ?? outputTokenCount,
+            tokenCountKnown: persistedAccounting ? persistedAccounting.tokenCount !== null : true,
             toolName: accounting.toolName,
             inputByteSize: persistedAccounting?.inputByteSize ?? (part.kind === "tool_use" ? accounting.inputByteSize : 0),
             inputTokenCount: persistedAccounting?.inputTokenCount ?? (part.kind === "tool_use" ? firstInputTokenCount : null),
@@ -28859,7 +29221,7 @@ function tagTranscript(sessionId, transcript, tagger, db, options = {}) {
 function syncToolAggregateAccounting(tagger, sessionId, aggregate) {
   tagger.setToolTagAccounting(sessionId, aggregate.tagId, {
     byteSize: aggregate.maxByteSize,
-    tokenCount: aggregate.maxTokenCount,
+    tokenCount: aggregate.tokenCountKnown ? aggregate.maxTokenCount : null,
     inputByteSize: aggregate.inputByteSize,
     inputTokenCount: aggregate.inputTokenCount
   });
@@ -28879,16 +29241,19 @@ function applyGrownToolResultAccounting(args) {
   }
   args.aggregate.maxByteSize = args.byteSize;
   args.aggregate.maxTokenCount = tokenCount;
+  args.aggregate.tokenCountKnown = true;
   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) {
+function readAggregateToolAccounting(part, timing, tokenCache, tokenCacheKey, persisted) {
   const text = part.getText() ?? "";
   const byteSize = getToolPartByteSize(part, text);
-  const metadata = part.getToolMetadata();
+  const metadata = part.getToolMetadata({
+    skipInputTokenCount: persisted?.inputTokenCount != null
+  });
   let tokenCount = 0;
-  if (part.kind === "tool_result") {
+  if (part.kind === "tool_result" && (!persisted || persisted.tokenCount === null || byteSize > persisted.byteSize)) {
     const tokenStart = timing ? performance.now() : 0;
     tokenCount = getCachedToolPartTokenCount(part, text, tokenCache, tokenCacheKey);
     if (timing)
@@ -29273,6 +29638,12 @@ function buildAggregateTarget(tagId, occurrences, requiresToolArcSkeleton, conve
       return any ? "truncated" : "absent";
     },
     prepareDrop: () => !occurrences.some((occ) => occ.part.canRemove?.() === "defer"),
+    prepareReplayDrop: () => {
+      if (complete() && !requiresToolArcSkeleton) {
+        for (const occ of occurrences)
+          occ.part.canRemove?.();
+      }
+    },
     canDrop: () => complete() && !occurrences.some((occ) => occ.part.hasUserAnswer?.()),
     requiresToolArcSkeleton,
     readInput() {
@@ -29343,6 +29714,38 @@ function buildToolTarget(part, message, tagId) {
   };
 }
 
+// ../plugin/src/features/magic-context/auto-search-diagnostics.ts
+var memoryHintContent = new WeakMap;
+function withMemoryHintContent(result, fullContent) {
+  memoryHintContent.set(result, fullContent);
+  return result;
+}
+function createAutoSearchDiagnostics(threshold) {
+  return {
+    threshold,
+    lanes: {},
+    pool: "unknown",
+    poolRows: null,
+    peek: "not-run",
+    workerStarted: false
+  };
+}
+function autoSearchRelevance(query, result) {
+  const content = result.source === "memory" ? memoryHintContent.get(result) ?? result.content : result.content;
+  if (cleanSearchText(content).length === 0)
+    return 0;
+  return result.source === "message" || "matchType" in result ? hintKeywordRelevance(query, content) : result.score;
+}
+function recordAutoSearchLane(diagnostics, lane, query, results) {
+  if (!diagnostics)
+    return;
+  const scores = results.map((result) => result.relevanceScore ?? autoSearchRelevance(query, result));
+  diagnostics.lanes[lane] = {
+    top: scores.length ? Math.max(...scores) : null,
+    nearMisses: scores.filter((score) => score >= 0.5 && score < diagnostics.threshold).length
+  };
+}
+
 // ../plugin/src/features/magic-context/literal-probes.ts
 var MAX_PROBES = 5;
 var MIN_PROBE_LENGTH = 3;
@@ -29969,7 +30372,7 @@ function mergeMemoryResults(args) {
       suppressedVisibleIds.push(id);
       continue;
     }
-    results.push({
+    results.push(withMemoryHintContent({
       source: "memory",
       content: previewText(memory.content),
       score,
@@ -29977,7 +30380,7 @@ function mergeMemoryResults(args) {
       category: memory.category,
       matchType: "fts",
       sourceName: args.sourceNameByMemoryId?.get(memory.id)
-    });
+    }, memory.content));
   }
   return {
     results: results.sort((left, right) => {
@@ -30574,8 +30977,12 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
       options.diagnostics.suppressedLiveMessageMatches = outcome.suppressedLiveMessageMatches;
     }
     messageResults = outcome.results.filter((result) => result.messageId !== options.excludeMessageId);
+    recordAutoSearchLane(options.autoSearchDiagnostics, "messages", trimmedQuery, messageResults);
+    options.onAutoSearchDiagnostics?.();
   }
   const workspace = resolveSearchWorkspaceContext(db, projectPath);
+  if (options.autoSearchDiagnostics)
+    options.autoSearchDiagnostics.pool = "off";
   const [memoryOutcome, primerResults, noteResults] = await Promise.all([
     runMemory ? searchMemories({
       db,
@@ -30610,6 +31017,10 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
   if (options.diagnostics) {
     options.diagnostics.suppressedVisibleMemoryIds = memoryOutcome.suppressedVisibleIds;
   }
+  recordAutoSearchLane(options.autoSearchDiagnostics, "memory", trimmedQuery, memoryOutcome.results);
+  recordAutoSearchLane(options.autoSearchDiagnostics, "primers", trimmedQuery, primerResults);
+  recordAutoSearchLane(options.autoSearchDiagnostics, "notes", trimmedQuery, noteResults);
+  options.onAutoSearchDiagnostics?.();
   const results = [...memoryOutcome.results, ...primerResults, ...messageResults, ...noteResults].sort(compareUnifiedResults).slice(0, limit);
   const countRetrievals = options.countRetrievals ?? true;
   if (countRetrievals) {
@@ -30631,7 +31042,7 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
   if (options.autoHint) {
     return results.map((result) => ({
       ...result,
-      relevanceScore: cleanSearchText(result.content).length === 0 ? 0 : keywordRelevance(trimmedQuery, result.content)
+      relevanceScore: autoSearchRelevance(trimmedQuery, result)
     }));
   }
   return results;
@@ -30877,6 +31288,32 @@ function selectAutoSearchResults(results, threshold) {
   return results.filter((result) => relevance(result) >= threshold).sort((left, right) => relevance(right) - relevance(left));
 }
 
+// ../plugin/src/hooks/magic-context/auto-search-observation.ts
+var disabledTurns = new WeakMap;
+function logDisabledAutoSearch(db, sessionId, messageId, threshold, startedAt) {
+  const sessions = disabledTurns.get(db) ?? new Map;
+  disabledTurns.set(db, sessions);
+  if (sessions.get(sessionId) === messageId)
+    return;
+  sessions.set(sessionId, messageId);
+  observeAutoSearch(sessionId, threshold, startedAt).finish("disabled");
+}
+function observeAutoSearch(sessionId, threshold, startedAt) {
+  const diagnostics = createAutoSearchDiagnostics(threshold);
+  let logged = false;
+  return {
+    diagnostics,
+    finish(outcome, reason) {
+      if (logged)
+        return;
+      logged = true;
+      const lanes = Object.entries(diagnostics.lanes).map(([lane, value]) => `${lane}:${value.top?.toFixed(3) ?? "none"}`).join(",");
+      const nearMisses = Object.values(diagnostics.lanes).reduce((sum, lane) => sum + lane.nearMisses, 0);
+      sessionLog(sessionId, `auto-search: decision outcome=${outcome}${reason ? ` reason=${reason}` : ""} lanes=${lanes || "none"} nearMisses=${nearMisses} threshold=${threshold} pool=${diagnostics.pool} rows=${diagnostics.poolRows ?? "unknown"} workerStarted=${diagnostics.workerStarted ?? "unknown"} peek=${diagnostics.peek} elapsedMs=${Math.round(performance.now() - startedAt)}`);
+    }
+  };
+}
+
 // src/auto-search-pi.ts
 var DEFAULT_SCORE_THRESHOLD = 0.55;
 var DEFAULT_MIN_PROMPT_CHARS = 20;
@@ -31013,8 +31450,6 @@ async function runAutoSearchHintForPi(args) {
     const timestamp = message.timestamp;
     return `test-entry-${index}:${typeof timestamp === "number" ? timestamp : "no-ts"}`;
   }) : args.entryIds;
-  if (!options.enabled)
-    return messages;
   const strictResolutionFailed = entryIds === null;
   const effectiveEntryIds = strictResolutionFailed ? messages.map((message) => {
     const id = message.id;
@@ -31024,6 +31459,11 @@ async function runAutoSearchHintForPi(args) {
   if (found === null)
     return messages;
   const { message: userMsg, messageId: userMsgId } = found;
+  if (!options.enabled) {
+    if (found.index === messages.length - 1)
+      logDisabledAutoSearch(db, sessionId, userMsgId, options.scoreThreshold ?? DEFAULT_SCORE_THRESHOLD, startedAt);
+    return messages;
+  }
   const replayServedDecision = () => {
     const decision = getAutoSearchHintDecisions(db, sessionId).find((entry) => entry.messageId === userMsgId);
     if (decision?.decision === "hint") {
@@ -31052,21 +31492,24 @@ async function runAutoSearchHintForPi(args) {
       return messages;
     if (!isUsableProjectIdentity(options.projectPath))
       return messages;
+    const observation = observeAutoSearch(sessionId, options.scoreThreshold ?? DEFAULT_SCORE_THRESHOLD, startedAt);
     const writeNoHintAndReconcile = (reason) => {
       const outcome = appendAutoSearchHintDecision(db, sessionId, {
         messageId: userMsgId,
         decision: "no-hint",
         reason
       });
-      if (!outcome.ok)
+      if (!outcome.ok) {
+        observation.finish("error", "cas-exhausted");
         return;
+      }
       if (outcome.kind === "already-present" && outcome.decision.decision === "hint") {
         appendHintToUserMessage(userMsg, outcome.decision.text);
       }
+      observation.finish(outcome.decision.decision === "hint" ? "attached" : reason === "below-threshold" ? "below-threshold" : reason === "error" ? "error" : "no-candidates", reason);
     };
     const rawPartsText = collectUserPromptParts(userMsg);
     if (hasStackedAugmentation(rawPartsText)) {
-      sessionLog(sessionId, "auto-search: skipping — user message already carries augmentation/hint");
       writeNoHintAndReconcile("stacked");
       return messages;
     }
@@ -31079,6 +31522,7 @@ async function runAutoSearchHintForPi(args) {
     let results;
     try {
       const searchOptions = {
+        autoSearchDiagnostics: observation.diagnostics,
         limit: 10,
         autoHint: true,
         maxMessageOrdinal: Math.max(0, getLastCompartmentEndMessage(db, sessionId)),
@@ -31094,13 +31538,13 @@ async function runAutoSearchHintForPi(args) {
           countRetrievals: false
         });
       }, startedAt);
-    } catch (error) {
-      log(`[auto-search] unified search failed for session ${sessionId} (will retry next pass): ${error instanceof Error ? error.message : String(error)}`);
+    } catch {
+      observation.finish("error");
       return messages;
     }
     if (results === null) {
       persistAutoSearchSkip(db, sessionId, userMsgId, "timeout");
-      sessionLog(sessionId, `auto-search: timed out after ${AUTO_SEARCH_TIMEOUT_MS}ms, skipping hint for this turn (frozen)`);
+      observation.finish("timeout");
       return messages;
     }
     if (results.length === 0) {
@@ -31110,7 +31554,6 @@ async function runAutoSearchHintForPi(args) {
     const scoreThreshold = options.scoreThreshold ?? DEFAULT_SCORE_THRESHOLD;
     results = selectAutoSearchResults(results, scoreThreshold);
     if (results.length === 0) {
-      sessionLog(sessionId, `auto-search: no fragment meets relevance threshold ${scoreThreshold}`);
       writeNoHintAndReconcile("below-threshold");
       return messages;
     }
@@ -31130,12 +31573,14 @@ ${hintText}`;
       decision: "hint",
       text: payload
     });
-    if (!outcome.ok)
+    if (!outcome.ok) {
+      observation.finish("error", "cas-exhausted");
       return messages;
+    }
     if (outcome.decision.decision === "hint") {
       appendHintToUserMessage(userMsg, outcome.decision.text);
     }
-    sessionLog(sessionId, `auto-search: attached hint to ${userMsgId} (${results.length} fragments, top score ${results[0].score.toFixed(3)})`);
+    observation.finish(outcome.decision.decision === "hint" ? "attached" : "no-candidates");
     return messages;
   }, replayServedDecision));
 }
@@ -35713,6 +36158,14 @@ async function runPiHistorian(deps) {
         return;
       }
       const protectedTailStart = boundarySnapshot.protectedTailStart;
+      if (!forceDrainQuota && shouldWaitForNewHistorianHistory(boundarySnapshot, {
+        emergency: getOverflowState(db, sessionId).needsEmergencyRecovery
+      })) {
+        telemetry.status = "noop";
+        telemetry.failureReason = "waiting for new history after no forward progress";
+        sessionLog(sessionId, "historian no-op: waiting for new history after no forward progress");
+        return;
+      }
       const eligibleEndOrdinal = Math.min(boundarySnapshot.eligibleEndOrdinal, protectedTailStart);
       if (protectedTailStart <= offset || eligibleEndOrdinal <= offset) {
         telemetry.status = "noop";
@@ -35900,6 +36353,12 @@ ${chunkText}`,
       };
       retainDrainReservationForRetryThrottle = true;
       const historianEditorSystemPrompt = withContentLanguageDirective(HISTORIAN_EDITOR_SYSTEM_PROMPT, deps.language, { preserveUserQuotes: true });
+      if (!forceDrainQuota) {
+        shouldWaitForNewHistorianHistory(boundarySnapshot, {
+          emergency: getOverflowState(db, sessionId).needsEmergencyRecovery,
+          claim: true
+        });
+      }
       const firstResult = await runHistorianSubagentWithTransientRetries({
         runner,
         sessionId,
@@ -36058,6 +36517,7 @@ ${chunkText}`,
           const failCount = incrementHistorianFailure(db, sessionId, errorMsg);
           await notify(buildHistorianFailureNotice(failCount, errorMsg));
         }
+        recordHistorianNoProgress(boundarySnapshot, inEmergency);
         rollbackDrainReservation();
         return;
       }
@@ -36151,6 +36611,7 @@ ${chunkText}`,
         }
         db.exec("COMMIT");
         published = true;
+        clearHistorianHistoryWait(sessionId);
         logSlowWriteTransaction("pi_historian_publish", transactionStartedAt);
       } finally {
         if (!published) {
@@ -36873,7 +37334,8 @@ function tagAttribution(input) {
   if (!cached) {
     removed.length = 0;
     added.length = 0;
-    added.push(...input.tags);
+    for (const tag of input.tags)
+      added.push(tag);
     cached = {
       tags: input.tags,
       messageTags: new Map,
@@ -37726,7 +38188,11 @@ function mergeChangedRows(rows, dirty, replacements) {
     }
     merged.push(tag);
   }
-  merged.push(...replacements.slice(index));
+  for (;index < replacements.length; index += 1) {
+    const row = replacements[index];
+    if (row)
+      merged.push(row);
+  }
   return merged;
 }
 var entryReaders = new WeakMap;
@@ -39853,6 +40319,26 @@ async function executeContextRecompWithResult(deps, options = {}) {
 }
 
 // ../plugin/src/hooks/magic-context/history-boundary-repair.ts
+function readStoreBoundaries(db, sessionId) {
+  const columns = getTableColumnNames(db, "compartments");
+  const numbers = ["id", "sequence", "start_message", "end_message", "created_at"];
+  const strings = ["session_id", "start_message_id", "end_message_id", "title", "content"];
+  const predicates = [...numbers, ...strings].every((column) => columns.has(column)) ? [
+    ...numbers.map((column) => `typeof(${column}) IN ('integer', 'real')`),
+    ...strings.map((column) => `typeof(${column}) = 'text'`)
+  ] : ["0"];
+  for (const column of ["p1", "p2", "p3", "p4", "episode_type"]) {
+    if (columns.has(column))
+      predicates.push(`typeof(${column}) IN ('text', 'null')`);
+  }
+  for (const column of ["importance", "legacy"]) {
+    if (columns.has(column))
+      predicates.push(`typeof(${column}) IN ('integer', 'real', 'null')`);
+  }
+  return db.prepare(`SELECT sequence, ${columns.has("end_message_id") ? "end_message_id" : "NULL"} AS endMessageId
+             FROM compartments WHERE session_id = ? AND ${predicates.join(" AND ")}
+             ORDER BY sequence ASC`).all(sessionId);
+}
 function readBaseline(db, sessionId) {
   const row = db.prepare("SELECT cached_m0_bytes IS NOT NULL AS hasM0, cached_m0_last_baseline_end_message_id AS boundary FROM session_meta WHERE session_id = ?").get(sessionId);
   return {
@@ -39918,7 +40404,7 @@ function dropCompartmentsAfter(db, sessionId, anchor, holderId, activeBranch = f
 }
 function repairMissingHistoryBoundary(args) {
   const { db, sessionId, isInHostStore, scope = "store" } = args;
-  const compartments = scope === "active-branch" ? db.prepare("SELECT sequence, COALESCE(end_message_id, '') AS endMessageId FROM compartments WHERE session_id = ? ORDER BY sequence").all(sessionId) : getCompartments(db, sessionId);
+  const compartments = scope === "active-branch" ? db.prepare("SELECT sequence, COALESCE(end_message_id, '') AS endMessageId FROM compartments WHERE session_id = ? ORDER BY sequence").all(sessionId) : readStoreBoundaries(db, sessionId);
   let latestIndex = compartments.length - 1;
   while (latestIndex >= 0 && !compartments[latestIndex]?.endMessageId)
     latestIndex -= 1;
@@ -39962,7 +40448,7 @@ function repairMissingHistoryBoundary(args) {
     let dropped;
     let anchorForDrop = anchor;
     try {
-      if (scope === "active-branch" && anchor) {
+      if (anchor) {
         const row = db.prepare("SELECT end_message AS endMessage FROM compartments WHERE session_id = ? AND sequence = ?").get(sessionId, anchor.sequence);
         if (!row)
           return { kind: "unresolved", reason: "busy", missingEndMessageId: missing };
@@ -41533,6 +42019,79 @@ function canRemoveNativeToolCall(message, toolCallId) {
 var NATIVE_TOOL_REMOVAL_MARKER = '{"__magic_context_remove_tool_arc__":true}';
 
 // src/native-replay-state-pi.ts
+var removalBatches = new WeakMap;
+
+class PiToolRemovalBatchError extends Error {
+  constructor(cause) {
+    super("Native tool removal batch could not be persisted", { cause });
+  }
+}
+function isTransactionOpen(db) {
+  const connection = db;
+  return connection.inTransaction === true || connection.isTransaction === true;
+}
+function withPiToolRemovalBatch(args, edit) {
+  let sessions = removalBatches.get(args.db);
+  const enclosing = sessions?.get(args.sessionId);
+  if (enclosing)
+    return edit(enclosing.flush);
+  if (!sessions) {
+    sessions = new Map;
+    removalBatches.set(args.db, sessions);
+  }
+  let publishing = false;
+  const batch = {
+    saved: args.saved,
+    planned: new Map(args.saved),
+    requested: new Map,
+    pending: new Map,
+    flushed: false,
+    flush() {
+      if (batch.flushed)
+        return;
+      batch.persistPending();
+      batch.flushed = true;
+    },
+    persistPending() {
+      if (publishing || batch.pending.size === 0)
+        return;
+      if (!isTransactionOpen(args.db))
+        throw new Error("Native removal publication requires a caller-owned transaction");
+      try {
+        publishing = true;
+        saveNativeToolInputs(args.db, args.sessionId, batch.pending);
+        batch.pending.clear();
+      } catch (cause) {
+        throw new PiToolRemovalBatchError(cause);
+      } finally {
+        publishing = false;
+      }
+    }
+  };
+  sessions.set(args.sessionId, batch);
+  try {
+    const result = withNativeReplayWriteBarrier(args.db, args.sessionId, batch.persistPending, () => edit(batch.flush));
+    if (batch.requested.size > 0 && !batch.flushed)
+      throw new Error("Native removal markers were not flushed in the caller's transaction");
+    const saved = args.saved;
+    if (saved && batch.requested.size > 0) {
+      const prior = new Map([...batch.requested.keys()].map((id) => [id, saved.get(id)]));
+      args.rollbackObservations?.push(() => {
+        for (const [id, value] of prior) {
+          if (value === undefined)
+            saved.delete(id);
+          else
+            saved.set(id, value);
+        }
+      });
+      for (const [id, marker] of batch.requested)
+        saved.set(id, marker);
+    }
+    return result;
+  } finally {
+    sessions.delete(args.sessionId);
+  }
+}
 function applyNativeToolInputReplayPi(args, saved) {
   if (saved.size === 0 && (!args.canApply || args.changes.size === 0))
     return 0;
@@ -41644,6 +42203,12 @@ function applyNativeReasoningReplayPi(args, saved) {
 function preparePiToolRemovalMeasurements(args) {
   if (!args.saved || !args.canApply)
     return;
+  const batch = removalBatches.get(args.db)?.get(args.sessionId);
+  if (batch?.saved === args.saved) {
+    for (const callId of args.callIds)
+      authorizePiToolRemoval({ ...args, callId });
+    return;
+  }
   const requested = new Map;
   for (const callId of args.callIds) {
     if (args.saved.get(callId) !== NATIVE_TOOL_REMOVAL_MARKER)
@@ -41659,9 +42224,54 @@ function preparePiToolRemovalMeasurements(args) {
       args.saved.set(callId, marker);
   } catch {}
 }
+function preparePiToolRemovalChecks(args) {
+  if (!args.db || !isTransactionOpen(args.db) || args.rows.length === 0)
+    return;
+  const occurrences = new Map;
+  for (const raw of args.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 === "toolCall" && typeof part.id === "string")
+        occurrences.set(part.id, (occurrences.get(part.id) ?? 0) + 1);
+    }
+  }
+  const requested = [];
+  for (const row of args.rows) {
+    if (row.callId === null || occurrences.get(row.callId) !== 1)
+      continue;
+    const target = args.targets.get(row.tagNumber);
+    if (target?.requiresToolArcSkeleton || target?.canDrop?.() !== true)
+      continue;
+    if (!target.mutationParts?.some(({ part }) => part !== null && typeof part === "object" && ("kind" in part) && part.kind === "tool_use" && ("id" in part) && part.id === row.callId))
+      continue;
+    requested.push(row.callId);
+  }
+  if (requested.length)
+    args.prepare(requested);
+}
 function authorizePiToolRemoval(args) {
   if (!args.saved)
     return false;
+  const batch = removalBatches.get(args.db)?.get(args.sessionId);
+  if (batch?.saved === args.saved) {
+    if (batch.planned.get(args.callId) === NATIVE_TOOL_REMOVAL_MARKER)
+      return true;
+    if (!args.canApply)
+      return false;
+    if (batch.flushed)
+      throw new Error("Tool removal requested after lane publication");
+    batch.planned.set(args.callId, NATIVE_TOOL_REMOVAL_MARKER);
+    batch.requested.set(args.callId, NATIVE_TOOL_REMOVAL_MARKER);
+    batch.pending.set(args.callId, NATIVE_TOOL_REMOVAL_MARKER);
+    return true;
+  }
   if (args.saved.get(args.callId) === NATIVE_TOOL_REMOVAL_MARKER)
     return true;
   if (!args.canApply)
@@ -41986,16 +42596,6 @@ function registerPiGuardedContext(pi, handler, options = {}) {
     refused: false,
     ended: false
   });
-  const lifecycle = new Map;
-  receiptMaps.add(lifecycle);
-  const lifecycleCounts = (key) => {
-    let counts = lifecycle.get(key);
-    if (!counts) {
-      counts = { starts: 0, ends: 0 };
-      lifecycle.set(key, counts);
-    }
-    return counts;
-  };
   const fenceEnabled = resolvePiHarnessKind() === "omp";
   const unsendableNonces = new Map;
   receiptMaps.add(unsendableNonces);
@@ -48029,7 +48629,7 @@ function createPiAssistantPart(working, messageIndex, partIndex, markDirty) {
     setToolOutput() {
       throw new Error("setToolOutput on assistant part");
     },
-    getToolMetadata() {
+    getToolMetadata(options) {
       const current = working[messageIndex].content;
       const p = current[partIndex];
       if (p?.type !== "toolCall") {
@@ -48040,7 +48640,7 @@ function createPiAssistantPart(working, messageIndex, partIndex, markDirty) {
       try {
         const serialized = JSON.stringify(p.arguments);
         inputByteSize = serialized.length;
-        inputTokenCount = serialized ? estimateTokens(serialized) : 0;
+        inputTokenCount = serialized && !options?.skipInputTokenCount ? estimateTokens(serialized) : 0;
       } catch {
         inputByteSize = 0;
         inputTokenCount = 0;
@@ -48473,6 +49073,7 @@ function observePipelineResultForTests(sessionId, result) {
 }
 var variantChangeLogObserverForTests;
 var beforePipelineForTests;
+var thinkingFitInputObserverForTests;
 function logPiLkgRecovery(sessionId, message) {
   lkgRecoveryLogObserverForTests?.(message);
   sessionLog(sessionId, message);
@@ -48603,6 +49204,7 @@ function buildPiTextIdentityPlan(db, sessionId, tagger, transcript, reuseCandida
       sourceCache.set(tagId, source);
   }
   const driftedMessageIds = new Set;
+  const reusableTextMessageIds = new Set;
   const legacyReminderTagNumbers = new Set;
   for (const [messageId, currentSources] of currentSourcesByMessageId) {
     const legacyRows = legacyRowsByMessageId.get(messageId) ?? [];
@@ -48630,6 +49232,8 @@ function buildPiTextIdentityPlan(db, sessionId, tagger, transcript, reuseCandida
     });
     if (!vectorMatches)
       driftedMessageIds.add(messageId);
+    else if (!messageId.startsWith("pi-msg-") && legacyRows.every((row) => sourceCache.has(row.tagId) && !legacyReminderTagNumbers.has(row.tagId)))
+      reusableTextMessageIds.add(messageId);
   }
   const reusableMessageIds = new Set;
   for (const messageId of reuseCandidates) {
@@ -48640,7 +49244,8 @@ function buildPiTextIdentityPlan(db, sessionId, tagger, transcript, reuseCandida
     driftedMessageIds,
     legacyReminderTagNumbers,
     reusableMessageIds,
-    sourceCache
+    sourceCache,
+    reusableTextMessageIds
   };
 }
 var piBranchProjectionBySession = new Map;
@@ -50665,15 +51270,7 @@ function registerPiContextHandler(pi, baseOptions) {
         contextLimit: rawFallbackLimit,
         forcePercentage: forceMaterializationPercentage
       });
-      let inputForThinkingFit = (getHarness() !== "pi" || nativeFitPossible) && isPrefixBoundThinkingModel(ctx.model?.provider, ctx.model?.id) ? structuredClone(event.messages) : null;
-      let inputForFitReclaim = nativeFitPossible ? inputForThinkingFit ?? structuredClone(event.messages) : undefined;
-      if (fitInputStart !== undefined)
-        recordPiTransformTiming({
-          sessionId,
-          stage: "fitInputPreparation",
-          elapsedMs: performance.now() - fitInputStart,
-          extra: inputForFitReclaim ? "snapshot" : "no-snapshot"
-        });
+      const fitPredictionMs = fitInputStart === undefined ? undefined : performance.now() - fitInputStart;
       const pipelineArgs = {
         recoveryPrefix: recovery.prefix,
         recoveryRebuildReason: recovery.rebuildReason,
@@ -50765,7 +51362,25 @@ function registerPiContextHandler(pi, baseOptions) {
           throw new PiLkgAdmissionReplay(replay.messages, "held tag-identity rebuild: replaying the served prefix", "held_identity_repair");
         }
       };
+      const fitCopyStart = fitPredictionMs === undefined ? undefined : performance.now();
+      const thinkingFitHeld = hasActiveAnthropicThinkingTurn(pipelineArgs.messages, pipelineArgs.resolvedProviderID, pipelineArgs.resolvedModelID) && pipelineArgs.reasoningClearing?.prefixBound === true;
+      let inputForThinkingFit = !pipelineArgs.compactionOff && (getHarness() !== "pi" || nativeFitPossible) && isPrefixBoundThinkingModel(ctx.model?.provider, ctx.model?.id) && thinkingFitHeld ? structuredClone(event.messages) : null;
+      let inputForFitReclaim = nativeFitPossible ? inputForThinkingFit ?? structuredClone(event.messages) : undefined;
+      if (fitPredictionMs !== undefined && fitCopyStart !== undefined)
+        recordPiTransformTiming({
+          sessionId,
+          stage: "fitInputPreparation",
+          elapsedMs: fitPredictionMs + (performance.now() - fitCopyStart),
+          extra: inputForFitReclaim ? "snapshot" : "no-snapshot"
+        });
       let result = await budget.waitMandatory(runPipeline(pipelineArgs));
+      thinkingFitInputObserverForTests?.({
+        sessionId,
+        held: thinkingFitHeld,
+        strictThinkingKept: result.strictThinkingKept,
+        thinkingCopy: inputForThinkingFit,
+        fitReclaimCopy: inputForFitReclaim
+      });
       observePipelineResultForTests(sessionId, result);
       logTransformTiming(sessionId, "runPipeline", tRunPipeline);
       if (result.identityRebuilt || result.lkgFrozenReleaseReason)
@@ -52350,6 +52965,21 @@ async function runPipeline(args) {
   try {
     nativeRemovalInputs = getNativeReplayState(args.db, args.sessionId).toolInputs;
   } catch {}
+  const removalBatch = (edit) => withPiToolRemovalBatch({ db: args.db, sessionId: args.sessionId, saved: nativeRemovalInputs }, edit);
+  const applyToolRemovalGroup = (edit) => {
+    const savedRemovalInputs = nativeRemovalInputs;
+    nativeRemovalInputs = savedRemovalInputs && new Map(savedRemovalInputs);
+    try {
+      return args.db.transaction(() => removalBatch((flush) => {
+        const result = edit();
+        flush();
+        return result;
+      })).immediate();
+    } catch (cause) {
+      nativeRemovalInputs = savedRemovalInputs;
+      throw cause instanceof PiToolRemovalBatchError ? cause : new PiToolRemovalBatchError(cause);
+    }
+  };
   const tTranscriptBuild = performance.now();
   const transcript = createPiTranscript(args.messages, args.sessionId, args.messages.map(stableIdResolver), {
     preserveReasoningToolArcs: args.reasoningClearing?.preserveReasoningToolArcs,
@@ -52624,6 +53254,7 @@ async function runPipeline(args) {
       skipPrefixInjection: !ctxReduceCallable,
       entryFingerprintByMessageId,
       reuseMessageIds: textIdentityPlan.reusableMessageIds,
+      reuseTextMessageIds: textIdentityPlan.reusableTextMessageIds,
       textIdentityDriftMessageIds: textIdentityPlan.driftedMessageIds,
       textIdentitySourceCache: textIdentityPlan.sourceCache,
       textTokenCache: tagTextTokenCache,
@@ -52705,17 +53336,34 @@ async function runPipeline(args) {
     });
   }
   if (foldBustsServedPrefixThisPass) {
+    const savedRemovalInputs = nativeRemovalInputs;
     try {
+      nativeRemovalInputs = savedRemovalInputs && new Map(savedRemovalInputs);
       let converted = 0;
-      args.db.transaction(() => {
+      args.db.transaction(() => removalBatch((flush) => {
         converted = convertLegacyToolSkeletons(args.db, args.sessionId, targets, {
-          keepFullDrop: (callId) => nativeRemovalInputs === undefined || callId !== null && nativeRemovalInputs.get(callId) === NATIVE_TOOL_REMOVAL_MARKER
+          prepareRemovals: (rows) => preparePiToolRemovalChecks({
+            db: args.db,
+            rows,
+            targets,
+            messages: args.messages,
+            prepare: transcript.prepareToolRemovalMeasurements
+          }),
+          keepFullDrop: (callId) => nativeRemovalInputs === undefined || callId !== null && authorizePiToolRemoval({
+            db: args.db,
+            sessionId: args.sessionId,
+            callId,
+            saved: nativeRemovalInputs,
+            canApply: false
+          }) === true
         }).size;
-      }).immediate();
+        flush();
+      })).immediate();
       if (converted > 0) {
         sessionLog(args.sessionId, `pi HARD fold converted ${converted} legacy dropped-tool skeleton(s) to real-or-absent`);
       }
     } catch (error) {
+      nativeRemovalInputs = savedRemovalInputs;
       sessionLog(args.sessionId, `pi legacy dropped-tool skeleton conversion failed (kept legacy bytes): ${error instanceof Error ? error.message : String(error)}`);
     }
   }
@@ -52749,13 +53397,13 @@ async function runPipeline(args) {
     pendingDecisionLogObserverForTests?.(pendingDecisionLog);
     try {
       const tApplyPending = performance.now();
-      pendingOpsDidMutate = applyPendingOperations(args.sessionId, args.db, newTargets, new Set([
+      pendingOpsDidMutate = applyToolRemovalGroup(() => applyPendingOperations(args.sessionId, args.db, newTargets, new Set([
         ...args.contextUsage.percentage >= 95 ? [] : protectedTagNumbersForPass,
         ...protectedToolTags,
         ...identityAdoption.protectedTagNumbers
       ]), pendingOperationTags, pendingOps, [], new Set, (reduction) => droppedTokenReductions.push(reduction), undefined, (eligible) => {
         eligiblePendingDropTagIds = eligible;
-      });
+      }));
       if (pendingOpsDidMutate) {
         droppedCount += pendingOps.length;
       }
@@ -52785,7 +53433,26 @@ async function runPipeline(args) {
   const flushedDroppedTags = getDroppedTagsByNumbers(args.db, args.sessionId, targetTagNumbers);
   logTransformTiming(args.sessionId, "getDroppedTagsByNumbers", tGetTags, `targets=${targetTagNumbers.length} fetched=${flushedDroppedTags.length}`);
   const tFlushed = performance.now();
-  runPersistedReplayStage("flushed-status-failure", undefined, () => applyFlushedStatuses(args.sessionId, args.db, targets, flushedDroppedTags));
+  runPersistedReplayStage("flushed-status-failure", undefined, () => {
+    const render = () => applyFlushedStatuses(args.sessionId, args.db, targets, flushedDroppedTags);
+    const savedRemovalInputs = nativeRemovalInputs;
+    const needsRemovalPreparation = savedRemovalInputs !== undefined && flushedDroppedTags.some((tag) => tag.type === "tool" && tag.dropMode === "full" && savedRemovalInputs.get(tag.messageId) !== NATIVE_TOOL_REMOVAL_MARKER);
+    if (!isCacheBustingPass || !needsRemovalPreparation)
+      return render();
+    try {
+      nativeRemovalInputs = savedRemovalInputs && new Map(savedRemovalInputs);
+      return args.db.transaction(() => removalBatch((flush) => {
+        prepareFlushedToolRemovals(targets, flushedDroppedTags);
+        flush();
+        return render();
+      })).immediate();
+    } catch (error) {
+      nativeRemovalInputs = savedRemovalInputs;
+      if (error instanceof PiToolRemovalBatchError)
+        return render();
+      throw error;
+    }
+  });
   logTransformTiming(args.sessionId, "applyFlushedStatuses", tFlushed);
   logTransformTiming(args.sessionId, "batchFinalize:flushed", tFlushed);
   const messageIdToMaxTag = buildMessageIdToMaxTag(targets);
@@ -52847,6 +53514,7 @@ async function runPipeline(args) {
     pendingDecisionLogObserverForTests?.(heuristicsDecisionLog);
   }
   if (shouldRunHeuristics && args.heuristics) {
+    const heuristics = args.heuristics;
     try {
       const tHeuristic = performance.now();
       const independentMutationBeforeHeuristics = pendingOpsDidMutate || systemPrefixChangedThisPass || foldBustsServedPrefixThisPass || identityRebuild || firstRenderBust || heldIdleExpiryRebuild;
@@ -52854,7 +53522,7 @@ async function runPipeline(args) {
         clearEmergencyDropSample(args.db, args.sessionId);
       }
       routineCleanupApplied = (emergencyDropEligible ? args.contextUsage.percentage >= 95 || getEmergencyInputSample(args.db, args.sessionId) === 0 : args.sessionMeta.isSubagent || !routinePressureAlreadyApplied) || hasPendingMaterializeSignal || rideSignals.explicitFlush || deferredMaterialize || independentMutationBeforeHeuristics;
-      heuristicsResult = applyPiHeuristicCleanup(args.sessionId, args.db, newTargets, args.messages, {
+      heuristicsResult = applyToolRemovalGroup(() => applyPiHeuristicCleanup(args.sessionId, args.db, newTargets, args.messages, {
         protectedTools: args.protectedTools,
         prepareToolRemovalMeasurements: transcript.prepareToolRemovalMeasurements,
         protectedToolTags,
@@ -52869,10 +53537,10 @@ async function runPipeline(args) {
           usagePercentage: args.contextUsage.percentage,
           passAlreadyPriced: independentMutationBeforeHeuristics
         } : undefined,
-        caveman: args.isSubagent ? undefined : args.heuristics.caveman
-      }, activeTags, stableIdResolver);
+        caveman: args.isSubagent ? undefined : heuristics.caveman
+      }, activeTags, stableIdResolver));
       if (!routineCleanupApplied && heuristicsResult.emergencyDroppedTools > 0) {
-        const ridingCleanup = applyPiHeuristicCleanup(args.sessionId, args.db, newTargets, args.messages, {
+        const ridingCleanup = applyToolRemovalGroup(() => applyPiHeuristicCleanup(args.sessionId, args.db, newTargets, args.messages, {
           protectedTools: args.protectedTools,
           protectedToolTags,
           protectedTags: args.protectedTags,
@@ -52880,8 +53548,8 @@ async function runPipeline(args) {
           routine: true,
           staleReduceStripEnabled: true,
           onStaleReduceEdit: recordStaleReduceEdit,
-          caveman: args.isSubagent ? undefined : args.heuristics.caveman
-        }, getActiveTagsBySession(args.db, args.sessionId), stableIdResolver);
+          caveman: args.isSubagent ? undefined : heuristics.caveman
+        }, getActiveTagsBySession(args.db, args.sessionId), stableIdResolver));
         heuristicsResult = {
           droppedTools: heuristicsResult.droppedTools + ridingCleanup.droppedTools,
           deduplicatedTools: heuristicsResult.deduplicatedTools + ridingCleanup.deduplicatedTools,
@@ -52920,6 +53588,8 @@ async function runPipeline(args) {
       }
       logTransformTiming(args.sessionId, "applyHeuristicCleanup", tHeuristic, `droppedTools=${heuristicsResult.droppedTools} deduplicatedTools=${heuristicsResult.deduplicatedTools} droppedInjections=${heuristicsResult.droppedInjections} staleReduce=${heuristicsResult.droppedStaleReduceCalls} compressedTextTags=${heuristicsResult.compressedTextTags} mutatedTextTags=${heuristicsResult.mutatedTextTags}`);
     } catch (err) {
+      if (err instanceof PiToolRemovalBatchError)
+        throw err;
       sessionLog(args.sessionId, `heuristic cleanup failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
     }
   }
@@ -53056,7 +53726,7 @@ async function runPipeline(args) {
     }
     autoReclaimTargetCount = syntheticPendingOps.length;
     if (syntheticPendingOps.length > 0) {
-      autoReclaimDidMutate = applyPendingOperations(args.sessionId, args.db, newTargets, protectedTagNumbersForPass, undefined, [], syntheticPendingOps, editMarkerTagIds, (reduction) => droppedTokenReductions.push(reduction));
+      autoReclaimDidMutate = applyToolRemovalGroup(() => applyPendingOperations(args.sessionId, args.db, newTargets, protectedTagNumbersForPass, undefined, [], syntheticPendingOps, editMarkerTagIds, (reduction) => droppedTokenReductions.push(reduction)));
       if (autoReclaimDidMutate) {
         droppedCount += syntheticPendingOps.length;
         autoReclaimDidMutateThisPass = true;
@@ -58898,18 +59568,18 @@ var FULL_PARAMETER_DESCRIPTIONS = {
     message: "Message ordinal from a <session-history> heading or a mmc_search hit, not a tag number. Returns that one message in full. Use alone."
   },
   mmc_note: {
-    action: "write | read | update | dismiss. Defaults to write when content is given, else read.",
+    action: "write | read | update | dismiss.",
     content: "Note text for write/update: first line is the title (under 80 chars), then the detail.",
     filter: "Read filter: active (default), all, dismissed.",
     limit: "Rows per read (default 25).",
     offset: "Skip this many newest rows (default 0).",
-    note_ids: "Note ids: one for update, 1–50 for dismiss or read (read returns full bodies). Ignored by write."
+    note_ids: "Note ids: one for update, 1–50 for dismiss, or 1–50 to read those notes in full. Write and a plain read take an empty list."
   },
   mmc_memory: {
     action: "write | update | archive | merge | get",
-    content: "The memory text — one standalone fact (write, update, merge).",
-    category: "Kind of fact (required for write; on update/merge optional, omitted keeps the current category).",
-    ids: "Memory ids from <project-memory>: one for update, one or more for archive, two or more for merge, 1–20 for get.",
+    content: "The memory text — one standalone fact (write, update, merge). Archive and get take an empty string.",
+    category: "Kind of fact: the new fact's kind for write; on update/merge, the memory's current category to keep it. Archive and get ignore it.",
+    ids: "Memory ids from <project-memory>: one for update, one or more for archive, two or more for merge, 1–20 for get. Write takes an empty list.",
     reason: "Why it is being archived (optional)."
   },
   mmc_search: {
@@ -58932,18 +59602,18 @@ var LIGHT_PARAMETER_DESCRIPTIONS = {
     message: "Message ordinal from a <session-history> heading or a mmc_search hit, not a tag number. Returns that one message in full. Use alone."
   },
   mmc_note: {
-    action: "write | read | update | dismiss (default: write with content, else read).",
+    action: "write | read | update | dismiss.",
     content: "Note text: first line title (<80 chars), then detail.",
     filter: "Read filter: active (default), all, dismissed.",
     limit: "Rows per read (default 25).",
     offset: "Skip newest rows (default 0).",
-    note_ids: "One id for update, 1–50 for dismiss or read (full bodies). Ignored by write."
+    note_ids: "One id for update, 1–50 for dismiss, or 1–50 to read those notes in full. Write and a plain read take an empty list."
   },
   mmc_memory: {
     action: "write | update | archive | merge | get",
-    content: "One standalone fact (write, update, merge).",
-    category: "Kind of fact (required for write; optional on update/merge).",
-    ids: "Ids from <project-memory>: one for update, 1+ for archive, 2+ for merge, 1–20 for get.",
+    content: "One standalone fact (write, update, merge). Archive and get: empty string.",
+    category: "Kind of fact (write; on update/merge pass the current category to keep it). Archive and get ignore it.",
+    ids: "Ids from <project-memory>: one for update, 1+ for archive, 2+ for merge, 1–20 for get. Write: empty list.",
     reason: "Why it is archived (optional)."
   },
   mmc_search: {
@@ -59058,6 +59728,17 @@ function resolveCtxExpandMode(args, domain) {
 
 // ../plugin/src/tools/ctx-expand/render.ts
 import { createHash as createHash25 } from "node:crypto";
+function recoveryParts(sessionId, message, attachments) {
+  return attachments ? [...message.parts, ...attachments(sessionId, message.id)] : message.parts;
+}
+function attachmentNotice(part) {
+  const field = (value) => typeof value === "string" ? value.trim().replace(/[\r\n]+/g, " ") : "";
+  const source = isRecord7(part.source) ? part.source : {};
+  const location = [part.url, part.path, source.uri, source.url, source.path].map(field).find((value) => value && !/^(data|blob):/i.test(value));
+  const name = field(part.filename) || field(part.name);
+  const mime = field(part.mime) || field(part.mimeType) || field(part.mediaType);
+  return `[file]${name ? ` ${name}` : ""}${mime ? ` (${mime})` : ""}` + `${location ? ` — stored location: ${location}` : ""}` + "; content not recovered. If needed, ask the user to attach it again.";
+}
 function isRecord7(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -59164,8 +59845,8 @@ function renderPartPreview(part, expandTools) {
   if (reasoning !== null)
     return `    • [reasoning] ${truncate2(reasoning, 120)}`;
   const type = typeof part.type === "string" ? part.type : "part";
-  if (type === "file")
-    return "    • [file]";
+  if (type === "file" || type === "image")
+    return `    • ${attachmentNotice(part)}`;
   if (type === "step-start" || type === "step-finish")
     return null;
   return `    • [${type}]`;
@@ -59195,13 +59876,11 @@ ${tool.output}`);
 `);
   }
   const type = typeof part.type === "string" ? part.type : "part";
-  if (type === "file") {
-    const name = typeof part.filename === "string" && part.filename || typeof part.url === "string" && part.url || "";
-    return `  [file]${name ? ` ${name}` : ""}`;
-  }
+  if (type === "file" || type === "image")
+    return `  ${attachmentNotice(part)}`;
   return null;
 }
-function renderMessageByOrdinal(sessionId, ordinal) {
+function renderMessageByOrdinal(sessionId, ordinal, attachments) {
   const found = [];
   visitRawSessionMessages2(sessionId, ordinal, ordinal, (m) => {
     if (m.ordinal === ordinal)
@@ -59212,7 +59891,7 @@ function renderMessageByOrdinal(sessionId, ordinal) {
   if (!msg) {
     return `No message at ordinal ${ordinal} is currently in this session's stored history — ` + `it may have been removed by a session prune/revert, or the ordinal may be wrong. ` + `Re-run the tool if you still need the data.`;
   }
-  const rendered = msg.parts.map(renderPartFull).filter((l) => l !== null);
+  const rendered = recoveryParts(sessionId, msg, attachments).map(renderPartFull).filter((l) => l !== null);
   const lines = [`[${msg.ordinal}] ${roleLabel(msg.role)} — full recovery:`, ""];
   if (rendered.length === 0) {
     lines.push("  (no recoverable content — message had only structural/reasoning parts)");
@@ -59222,14 +59901,14 @@ function renderMessageByOrdinal(sessionId, ordinal) {
   return lines.join(`
 `);
 }
-function renderVerboseRange(sessionId, start, end, tokenBudget, expandTools) {
+function renderVerboseRange(sessionId, start, end, tokenBudget, expandTools, attachments) {
   const out = [];
   let usedTokens = 0;
   let lastOrdinal = start - 1;
   let truncated = false;
   visitRawSessionMessages2(sessionId, start, end, (msg) => {
     const header = `[${msg.ordinal}] ${verboseRoleLabel(msg)}`;
-    const partLines = msg.parts.map((part) => renderPartPreview(part, expandTools)).filter((l) => l !== null);
+    const partLines = recoveryParts(sessionId, msg, attachments).map((part) => renderPartPreview(part, expandTools)).filter((l) => l !== null);
     const block = partLines.length > 0 ? `${header}
 ${partLines.join(`
 `)}` : header;
@@ -59247,7 +59926,7 @@ ${partLines.join(`
 
 `), lastOrdinal, truncated };
 }
-function renderItemByTag(db, sessionId, number, textIndexDomain = "part") {
+function renderItemByTag(db, sessionId, number, textIndexDomain = "part", attachments) {
   const tag = getTagById(db, sessionId, number);
   if (!tag)
     return `no tag ${number} in this session; if ${number} came from a <session-history> heading or a ctx_search hit, it is an ordinal: use message=${number}`;
@@ -59272,17 +59951,19 @@ function renderItemByTag(db, sessionId, number, textIndexDomain = "part") {
     return rendered.length ? rendered.join(`
 `) : `Tag ${number}'s original tool call is no longer in stored history.`;
   }
-  const scoped = /^(.*):p(\d+)$/.exec(tag.messageId);
+  const scoped = /^(.*):(?:p|file)(\d+)$/.exec(tag.messageId);
   const derived = /^(.*):mc-text-v1:([a-f0-9]+):([a-f0-9]+):o(\d+)$/.exec(tag.messageId);
   const owner = scoped?.[1] ?? derived?.[1] ?? tag.messageId;
   const message = readRawSessionMessageById2(sessionId, owner);
   if (!message)
     return `Tag ${number}'s original text is no longer in stored history.`;
   const index = scoped ? Number(scoped[2]) : 0;
-  const piText = message.parts.filter((part) => isRecord7(part) && part.type === "text");
-  const part = message.parts[index];
+  const attached = attachments?.(sessionId, message.id) ?? [];
+  const parts = [...message.parts, ...attached];
+  const piText = parts.filter((part) => isRecord7(part) && part.type === "text");
+  const part = tag.type === "file" ? attached.find((part) => isRecord7(part) && part.partIndex === index) ?? message.parts[index] : parts[index];
   const matching = derived ? piText.filter((part) => isRecord7(part) && typeof part.text === "string" && createHash25("sha256").update(part.text).digest("hex") === derived[3]) : [];
-  const selected = derived ? matching[Number(derived[4])] : textIndexDomain === "text" ? piText[index] : part;
+  const selected = derived ? matching[Number(derived[4])] : textIndexDomain === "text" && tag.type !== "file" ? piText[index] : part;
   if (!selected)
     return `Tag ${number}'s original text part is no longer in stored history.`;
   const renderedPart = renderPartFull(selected);
@@ -59725,6 +60406,34 @@ var integerKeyPattern = new RegExp("^(?:0|[1-9][0-9]*)$");
 
 // ../../node_modules/.bun/typebox@1.3.27/node_modules/typebox/build/type/engine/indexed/from_object.mjs
 var NumericKeyPattern = new RegExp(IntegerKey);
+// src/tools/expand-attachments.ts
+function piRecoveryAttachments(entries) {
+  return (_sessionId, messageId) => {
+    const entry = entries.find((entry) => entry !== null && typeof entry === "object" && entry.id === messageId);
+    if (entry?.message?.role !== "user" || !Array.isArray(entry.message.content))
+      return [];
+    return entry.message.content.flatMap((part, partIndex) => {
+      if (!part || part.type !== "image" && part.type !== "file")
+        return [];
+      return [
+        {
+          type: part.type,
+          filename: part.filename ?? part.name,
+          mime: part.mimeType ?? part.mime,
+          url: [
+            part.url,
+            part.source?.uri,
+            part.source?.url,
+            part.providerFile?.uri
+          ].find((value) => typeof value === "string" && value.trim() && !/^(data|blob):/i.test(value.trim())),
+          path: part.path ?? part.source?.path,
+          partIndex
+        }
+      ];
+    });
+  };
+}
+
 // src/tools/ctx-expand.ts
 var ParamsSchema = _Object_({
   tag: Optional(Union([Number2(), String2()], {
@@ -59774,12 +60483,13 @@ function createCtxExpandTool(deps) {
         readMessages: () => readPiSessionMessages(ctx, piRawOrdinalOffsetSource(deps.db, sessionId))
       });
       try {
+        const attachments = piRecoveryAttachments(ctx.sessionManager.getBranch());
         const mode = resolveCtxExpandMode(params, "positive");
         if (mode.kind === "error") {
           return err(mode.message);
         }
         if (mode.kind === "tag") {
-          return ok(renderItemByTag(deps.db, sessionId, mode.tag, "text"));
+          return ok(renderItemByTag(deps.db, sessionId, mode.tag, "text", attachments));
         }
         const alignment = resolvePiOrdinalAlignmentForContext(deps.db, sessionId, ctx);
         if (isPiOrdinalAlignmentUnanchored(alignment)) {
@@ -59797,7 +60507,7 @@ function createCtxExpandTool(deps) {
           if (mode.message <= lostThrough) {
             return ok(`No message at ordinal ${mode.message}: it is no longer in this session's history, which now starts at message ${firstAvailable}.`);
           }
-          return ok(renderMessageByOrdinal(sessionId, mode.message));
+          return ok(renderMessageByOrdinal(sessionId, mode.message, attachments));
         }
         const { end, verbose } = mode;
         const requestedStart = mode.start;
@@ -59817,7 +60527,7 @@ function createCtxExpandTool(deps) {
 
 ` : "";
         if (verbose) {
-          const v = renderVerboseRange(sessionId, start, effectiveEnd, CTX_EXPAND_TOKEN_BUDGET, deps.expandTools);
+          const v = renderVerboseRange(sessionId, start, effectiveEnd, CTX_EXPAND_TOKEN_BUDGET, deps.expandTools, attachments);
           if (!v.text) {
             return ok(`No messages found in range ${start}-${effectiveEnd}. The range may be outside this session's history.`);
           }
@@ -59888,18 +60598,18 @@ function runImmediateTransaction2(db, fn) {
 var PRIMARY_ACTIONS = ["write", "update", "archive", "merge", "get"];
 var GET_MAX_IDS = 20;
 var ParamsShape = {
-  action: Optional(Union(PRIMARY_ACTIONS.map((a) => Literal(a)), {
+  action: Union(PRIMARY_ACTIONS.map((a) => Literal(a)), {
     description: "write | update | archive | merge | get"
-  })),
-  content: Optional(String2({
+  }),
+  content: String2({
     description: "The memory text — one standalone fact (write, update, merge)."
-  })),
-  category: Optional(Union(V2_MEMORY_CATEGORIES.map((c) => Literal(c)), {
-    description: "Kind of fact (required for write; on update/merge optional, omitted keeps the current category)."
-  })),
-  ids: Optional(_Array_(Number2(), {
+  }),
+  category: Union(V2_MEMORY_CATEGORIES.map((c) => Literal(c)), {
+    description: "Kind of fact (required for write; on update/merge, pass the memory's current category to keep it)."
+  }),
+  ids: _Array_(Number2(), {
     description: "Memory ids from <project-memory>: one for update, one or more for archive, two or more for merge, 1–20 for get."
-  })),
+  }),
   reason: Optional(String2({
     description: "Why it is being archived (optional)."
   }))
@@ -59907,6 +60617,20 @@ var ParamsShape = {
 var PrimaryParamsSchema = _Object_(ParamsShape, {
   additionalProperties: true
 });
+function rejectInvalidMemoryArguments(args) {
+  if (args === null || typeof args !== "object")
+    return;
+  const record = args;
+  if (record.content !== undefined && typeof record.content !== "string") {
+    throw new Error("Error: 'content' must be a string.");
+  }
+  if (record.reason !== undefined && typeof record.reason !== "string") {
+    throw new Error("Error: 'reason' must be a string.");
+  }
+  if (record.ids !== undefined && (!Array.isArray(record.ids) || record.ids.some((id) => typeof id !== "number" || !Number.isSafeInteger(id) || id < 1))) {
+    throw new Error("Error: 'ids' must be an array of positive memory IDs.");
+  }
+}
 function ok2(text) {
   return { content: [{ type: "text", text }], details: undefined };
 }
@@ -60005,6 +60729,10 @@ function createCtxMemoryTool(deps) {
     label: "Magic Context: Memory",
     description: CTX_MEMORY_DESCRIPTION,
     parameters: PrimaryParamsSchema,
+    prepareArguments(args) {
+      rejectInvalidMemoryArguments(args);
+      return args;
+    },
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       params = unwrapImitatedReducedArgs(params, ["action"], {
         action: { type: "enum", values: PRIMARY_ACTIONS },
@@ -60337,7 +61065,7 @@ function renderGlance(notes, options) {
   const remaining = ordered.length - options.offset - page.length;
   const footer = remaining > 0 ? `
 
-Showing ${page.length} of ${ordered.length} — ${remaining} older: mmc_note(action="read", offset=${options.offset + page.length})` : "";
+Showing ${page.length} of ${ordered.length} — ${remaining} older: mmc_note(action="read", content="", note_ids=[], offset=${options.offset + page.length})` : "";
   return `## Notes
 
 ${rows}${footer}`;
@@ -60367,22 +61095,21 @@ function formatWriteReply(noteId, tray, nowMs) {
 // src/tools/ctx-note.ts
 var FILTER_VALUES = ["active", "dismissed", "all"];
 var ParamsSchema2 = _Object_({
-  action: Optional(Union([
+  action: Union([
     Literal("write"),
     Literal("read"),
     Literal("dismiss"),
     Literal("update")
   ], {
-    description: "write | read | update | dismiss. Defaults to write when content is given, else read."
-  })),
-  content: Optional(String2({
+    description: "write | read | update | dismiss."
+  }),
+  content: String2({
     description: "Note text for write/update: first line is the title (under 80 chars), then the detail."
-  })),
-  note_ids: Optional(_Array_(Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER }), {
-    minItems: 1,
+  }),
+  note_ids: _Array_(Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER }), {
     maxItems: 50,
-    description: "Note ids: one for update, 1–50 for dismiss or read (read returns full bodies). Ignored by write."
-  })),
+    description: "Note ids: one for update, 1–50 for dismiss, or 1–50 to read those notes in full. Write and a plain read take an empty list."
+  }),
   filter: Optional(Union(FILTER_VALUES.map((value) => Literal(value)), {
     description: "Read filter: active (default), all, dismissed."
   })),
@@ -60393,6 +61120,17 @@ var ParamsSchema2 = _Object_({
     description: "Skip this many newest rows (default 0)."
   }))
 }, { additionalProperties: true });
+function rejectInvalidNoteArguments(args) {
+  if (args === null || typeof args !== "object")
+    return;
+  const record = args;
+  if (record.content !== undefined && typeof record.content !== "string") {
+    throw new Error("Error: 'content' must be a string.");
+  }
+  if (record.note_ids !== undefined && (!Array.isArray(record.note_ids) || record.note_ids.some((id) => typeof id !== "number" || !Number.isSafeInteger(id) || id < 1))) {
+    throw new Error("Error: 'note_ids' must be an array of positive note IDs.");
+  }
+}
 function ok3(text) {
   return { content: [{ type: "text", text }], details: undefined };
 }
@@ -60413,7 +61151,7 @@ function captureAnchorOrdinal(db, sessionId) {
 }
 var DISMISS_FOOTER = `
 
-To dismiss a stale note: mmc_note(action="dismiss", note_ids=[N])`;
+To dismiss a stale note: mmc_note(action="dismiss", note_ids=[N], content="")`;
 function formatDismissResults(results) {
   const dismissedCount = results.filter((result) => result.outcome === "dismissed").length;
   return `Dismissed ${dismissedCount} of ${results.length} notes.
@@ -60449,6 +61187,10 @@ function createCtxNoteTool(deps) {
     label: "Magic Context: Notes",
     description: CTX_NOTE_DESCRIPTION,
     parameters: ParamsSchema2,
+    prepareArguments(args) {
+      rejectInvalidNoteArguments(args);
+      return args;
+    },
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       params = unwrapImitatedReducedArgs(params, ["action", "content"], {
         action: {
@@ -60463,7 +61205,8 @@ function createCtxNoteTool(deps) {
       });
       const sessionId = ctx.sessionManager.getSessionId();
       const action = params.action ?? (params.content?.trim() ? "write" : "read");
-      const noteIds = action === "dismiss" || action === "update" || action === "read" && params.note_ids !== undefined ? parseNoteIds(action, params.note_ids) : undefined;
+      const targetedReadIds = action === "read" && Array.isArray(params.note_ids) && params.note_ids.length === 0 ? undefined : params.note_ids;
+      const noteIds = action === "dismiss" || action === "update" || action === "read" && targetedReadIds !== undefined ? parseNoteIds(action, targetedReadIds) : undefined;
       if (typeof noteIds === "string")
         return err3(noteIds);
       if (action === "write") {
@@ -62272,7 +63015,7 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
         harness: PI_HARNESS_KIND
       });
       const emptyHistorian = empty.find((chain) => chain.owner === "historian");
-      const historianLine = historian ? `registered historian trigger (model=${historian.model}${historian.fallbackModels?.length ? `, fallbacks=${historian.fallbackModels.join(",")}` : ""}, executeThreshold=${formatExecuteThresholdForLog(historian.executeThresholdPercentage)})` : emptyHistorian ? `registered historian trigger: DISABLED (no configured model is registered in Pi: ${formatEmptyPiModelChain(emptyHistorian)})` : undefined;
+      const historianLine = historian ? `registered historian trigger (model=${historian.model}${historian.fallbackModels?.length ? `, fallbacks=${historian.fallbackModels.map(formatPiModelForLog).join(",")}` : ""}, executeThreshold=${formatExecuteThresholdForLog(historian.executeThresholdPercentage)})` : emptyHistorian ? `registered historian trigger: DISABLED (no configured model is registered in Pi: ${formatEmptyPiModelChain(emptyHistorian)})` : undefined;
       if (historianLine && !loggedPiModelChainLines.has(historianLine)) {
         loggedPiModelChainLines.add(historianLine);
         info(historianLine);
@@ -62820,6 +63563,11 @@ function formatExecuteThresholdForLog(value) {
   const base = `${value.default}%`;
   return overrides.length > 0 ? `${base} (${overrides.join(", ")})` : base;
 }
+function formatPiModelForLog(entry) {
+  if (typeof entry === "string")
+    return entry;
+  return `${entry.model}${entry.qualifier ? ` (thinking_level=${entry.qualifier})` : ""}`;
+}
 export {
   __test,
   canonicalPiModelKey,