@cortexkit/opencode-magic-context 0.45.0 → 0.46.1

package/dist/{index-2aq21j41.js → index-pkbcrdqs.js}

@@ -5,9 +5,12 @@ import {
   log,
   sessionLog
 } from "./index-hybnrwq0.js";
+import {
+  isKnownAutocommit
+} from "./index-b35pxds2.js";
 import {
   isTransientSqliteError
-} from "./index-a4m2b1yv.js";
+} from "./index-fg34g6a5.js";
 import {
   BoundedSessionMap,
   renderUserFacingFailure,
@@ -63,9 +66,6 @@ import {
   updateSessionMeta,
   advanceToolReclaimWatermark,
   getNotes,
-  getPendingOps,
-  getPendingOpsCount,
-  removePendingOp,
   getActivePrimers,
   saveSourceContent,
   replaceSourceContent,
@@ -101,36 +101,23 @@ import {
   compareOpenCodeMessagesByCanonicalOrder,
   MARKER_SUMMARY_TEXT,
   applyDeferredCompactionMarker,
+  injectTemporalMarkers,
   clearInjectionCache,
   getVisibleMemoryIds,
   renderCompartmentInjection,
+  MaterializeContentionError,
   mustMaterialize,
   hydrateCachedM0Mural,
   prepareCachedM0M1Replay,
   hasCompleteCachedM0M1,
   injectM0M1,
+  observeNoteNudgeServe,
   peekNoteNudgeText,
   markNoteNudgeDelivered,
   getActiveCompartmentRun
-} from "./index-16ny736w.js";
+} from "./index-sjthx78w.js";
 import {
-  textMentionsRecentCommit,
-  hasMeaningfulUserText2,
-  estimateTokens
-} from "./index-gd5qx1j9.js";
-import {
-  isValidLanguageCode
-} from "./index-q7yesyk9.js";
-import {
-  resolveWorkspaceShareCategories,
-  resolveWorkspaceIdentitySet,
-  expandWorkspaceIdentitySetWithAliases,
-  resolveStoredPathWorkspaceIdentity,
-  sourceNameForMemory
-} from "./index-fr2z4qy8.js";
-import {
-  CTX_REDUCE_KEEP,
-  newestCtxReduceTagNumbers,
+  protectedToolTagNumbers,
   stripWellFormedLeadingTagPrefix,
   byteSize,
   stripTagPrefix,
@@ -147,11 +134,14 @@ import {
   formatTailHygienePrefixMismatch,
   refreshTailHygieneBaseline,
   effectiveTailHygiene,
-  assertTailHygieneContentUnchanged,
+  assertTailHygieneContentUnchangedIfEnabled,
   CHANNEL1_FLOOR_TOKENS,
   estimateEmergencyDropReclaimTokens,
   planEmergencyDrop,
   measureEmergencyTag,
+  getPendingOps,
+  getPendingOpsCount,
+  removePendingOp,
   getRecentTagOwnerMessageIds,
   AGE_RECLAIM_MIN_TOKENS,
   getOldestActiveUnprotectedToolTags,
@@ -169,9 +159,10 @@ import {
   getMaxTagNumberBySession,
   getTagNumberByMessageId,
   getAssignableTagNumberByMessageId,
-  getTagsBySession,
   getActiveTagsBySession,
   getTailHygieneTags,
+  getTagsByNumbers,
+  getNewestToolTagNumbers,
   getDroppedTagsByNumbers,
   getTagById,
   getToolTagNumberByOwner,
@@ -199,21 +190,42 @@ import {
   extractToolCallObservation,
   ToolMutationBatch,
   createToolDropTarget
-} from "./index-4krbw8z9.js";
+} from "./index-3h0ybwah.js";
+import {
+  textMentionsRecentCommit,
+  hasMeaningfulUserText2,
+  estimateTokens
+} from "./index-5eqk6z3s.js";
+import {
+  isValidLanguageCode
+} from "./index-8x2v7gg9.js";
+import {
+  resolveWorkspaceShareCategories,
+  resolveWorkspaceIdentitySet,
+  expandWorkspaceIdentitySetWithAliases,
+  resolveStoredPathWorkspaceIdentity,
+  sourceNameForMemory
+} from "./index-r5hmbx3t.js";
+import {
+  getTemporalDecisions,
+  freezeTemporalDecisions,
+  stableStringify
+} from "./index-5gq3b2ya.js";
+import {
+  normalizeProtectedToolName,
+  mergeProtectedTools
+} from "./index-q4yp4b52.js";
 import {
   openCodeDbExists,
   withReadOnlySessionDb,
   getMessageTimesFromOpenCodeDb
-} from "./index-bmzf7zxv.js";
-import {
-  stableStringify
-} from "./index-anq4nn6f.js";
+} from "./index-majxda46.js";
 import {
   getErrorMessage
 } from "./index-y8v6yerm.js";
 import {
   logSlowWriteTransaction
-} from "./index-x23gah8c.js";
+} from "./index-sj29b3z2.js";
 
 // src/features/magic-context/storage-reasoning-removal.ts
 var NAMESPACE = "reasoningRemoval";
@@ -333,12 +345,14 @@ function foldChangesServedPrefix(before, after) {
 function foldBustsServedPrefix(reason, before, after) {
   return CACHE_LOSING_FOLD_REASONS.has(reason ?? "") || foldChangesServedPrefix(before, after);
 }
-function convertLegacyToolSkeletons(db, sessionId, targets, options = {}) {
-  const rows = db.prepare(`SELECT tag_number AS tagNumber, drop_mode AS dropMode, message_id AS callId
+function prepareLegacyToolSkeletonConversions(db, sessionId, targets, options = {}) {
+  const readRows = (connection) => connection.prepare(`SELECT tag_number AS tagNumber, drop_mode AS dropMode, message_id AS callId
                FROM tags
               WHERE session_id = ? AND type = 'tool' AND status = 'dropped'
                 AND drop_mode IN ('truncated', 'full')
               ORDER BY tag_number`).all(sessionId);
+  const rows = readRows(db);
+  const identity = JSON.stringify(rows);
   const converted = new Map;
   for (const row of rows) {
     const target = targets.get(row.tagNumber);
@@ -355,10 +369,16 @@ function convertLegacyToolSkeletons(db, sessionId, targets, options = {}) {
     } else {
       mode = hasSmallToolInput(target) || cannotRemove ? "skeleton_real" : "full";
     }
-    updateTagDropMode(db, sessionId, row.tagNumber, mode);
     converted.set(row.tagNumber, mode);
   }
-  return converted;
+  return {
+    converted,
+    isCurrent: (connection) => JSON.stringify(readRows(connection)) === identity,
+    persist: (connection) => {
+      for (const [tagNumber, mode] of converted)
+        updateTagDropMode(connection, sessionId, tagNumber, mode);
+    }
+  };
 }
 function renderConvertedToolSkeletons(targets, converted) {
   let didMutate = false;
@@ -384,11 +404,16 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
     db.transaction(() => {
       admitted = true;
       startedAt = performance.now();
-      const tags = preloadedTags ?? getTagsBySession(db, sessionId);
+      const pendingOps = preloadedPendingOps ?? getPendingOps(db, sessionId);
+      const tags = preloadedTags ?? getTagsByNumbers(db, sessionId, [
+        ...new Set([
+          ...pendingOps.map((op) => op.tagId),
+          ...syntheticPendingOps.map((op) => op.tagId)
+        ])
+      ]);
       const tagById = new Map(tags.map((tag) => [tag.tagNumber, tag]));
       const tagStatusById = new Map(tags.map((tag) => [tag.tagNumber, tag.status]));
       const tagTypeById = new Map(tags.map((tag) => [tag.tagNumber, tag.type]));
-      const pendingOps = preloadedPendingOps ?? getPendingOps(db, sessionId);
       const opsToApply = [
         ...pendingOps.map((op) => ({ op, synthetic: false })),
         ...syntheticPendingOps.map((op) => ({ op, synthetic: true }))
@@ -400,7 +425,7 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
         persistedWithoutMutation: 0,
         reasons: {}
       };
-      const skeletonWindow = new Set(tags.filter((tag) => tag.type === "tool").map((tag) => tag.tagNumber).sort((left, right) => right - left).slice(0, RECENT_TOOL_SKELETON_WINDOW));
+      const skeletonWindow = new Set(preloadedTags ? tags.filter((tag) => tag.type === "tool").map((tag) => tag.tagNumber).sort((left, right) => right - left).slice(0, RECENT_TOOL_SKELETON_WINDOW) : getNewestToolTagNumbers(db, sessionId, RECENT_TOOL_SKELETON_WINDOW));
       for (const { op: pendingOp, synthetic } of opsToApply) {
         let operationMutated = false;
         const tagStatus = tagStatusById.get(pendingOp.tagId);
@@ -786,6 +811,47 @@ var ftsPlainStatements = new WeakMap;
 var datedFtsPlainStatements = new WeakMap;
 var getBySHAsStatements = new WeakMap;
 var datedGetBySHAsStatements = new WeakMap;
+var embeddingCache = new WeakMap;
+function getSearchEmbeddings(db, projectPath, modelId) {
+  if (!isKnownAutocommit(db)) {
+    embeddingCache.delete(db);
+    return loadProjectCommitEmbeddings(db, projectPath, modelId);
+  }
+  let cache = embeddingCache.get(db);
+  if (!cache) {
+    cache = {
+      revisionStatement: db.prepare(`SELECT total_changes() AS writes,
+                (SELECT data_version FROM pragma_data_version) AS dataVersion,
+                (SELECT schema_version FROM pragma_schema_version) AS schemaVersion`),
+      revision: "",
+      entries: new Map
+    };
+    embeddingCache.set(db, cache);
+  }
+  const revision = JSON.stringify(cache.revisionStatement.get());
+  if (revision !== cache.revision) {
+    cache.entries.clear();
+    cache.revision = revision;
+  }
+  const key = JSON.stringify([projectPath, modelId]);
+  const cached = cache.entries.get(key);
+  if (cached) {
+    cache.entries.delete(key);
+    cache.entries.set(key, cached);
+    return cached;
+  }
+  const vectors = loadProjectCommitEmbeddings(db, projectPath, modelId);
+  const size = (entries) => [...entries.values()].reduce((sum, vector) => sum + vector.byteLength, 0);
+  if (size(vectors) <= 32 * 1024 * 1024)
+    cache.entries.set(key, vectors);
+  while (cache.entries.size > 16 || [...cache.entries.values()].reduce((sum, entry) => sum + size(entry), 0) > 32 * 1024 * 1024) {
+    const oldest = cache.entries.keys().next().value;
+    if (oldest === undefined)
+      break;
+    cache.entries.delete(oldest);
+  }
+  return vectors;
+}
 function rowToCommit(row) {
   return {
     sha: row.sha,
@@ -882,7 +948,7 @@ function searchGitCommitsSync(db, projectPath, query, options) {
   });
   const semanticScores = new Map;
   if (options.queryEmbedding && options.queryModelId && options.queryModelId !== "off") {
-    const embeddings = loadProjectCommitEmbeddings(db, projectPath, options.queryModelId);
+    const embeddings = getSearchEmbeddings(db, projectPath, options.queryModelId);
     for (const [sha, embedding] of embeddings.entries()) {
       const similarity = clamp01(cosineSimilarity(options.queryEmbedding, embedding));
       if (similarity > 0) {
@@ -3122,9 +3188,20 @@ function findLastUserMessageId(messages) {
   }
   return null;
 }
+function findNoteNudgeUserMessageId(messages) {
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message.info.role !== "user" || typeof message.info.id !== "string")
+      continue;
+    if (message.parts.some((part) => isTextPart(part) && part.ignored !== true && part.text.trim())) {
+      return message.info.id;
+    }
+  }
+  return null;
+}
 function appendReminderToUserMessageById(messages, messageId, reminder) {
   for (const message of messages) {
-    if (message.info.id !== messageId || !isMeaningfulUserMessage(message)) {
+    if (message.info.id !== messageId || message.info.role !== "user") {
       continue;
     }
     appendReminderToUserMessage(message, reminder);
@@ -3374,9 +3451,15 @@ function canConsumeDeferredOnThisPass(args) {
   return args.schedulerDecision === "execute" || args.contextPercentage >= (args.forceMaterializationPercentage ?? escalationBands(65).forceMaterializationPercentage);
 }
 function hasReclaimRide(signals) {
-  return signals.hardFold || signals.force || signals.explicitFlush || signals.publishedHistory;
-}
-var RECLAIM_RIDE_NAMES = ["hardFold", "force", "explicitFlush", "publishedHistory"];
+  return signals.hardFold || signals.force || signals.explicitFlush || signals.publishedHistory || signals.subagentExecute === true;
+}
+var RECLAIM_RIDE_NAMES = [
+  "hardFold",
+  "force",
+  "explicitFlush",
+  "publishedHistory",
+  "subagentExecute"
+];
 function reclaimRideLabel(signals) {
   const active = RECLAIM_RIDE_NAMES.filter((name) => signals[name]);
   return `ride=${active.length > 0 ? active.join("+") : "none"}`;
@@ -3390,6 +3473,8 @@ function rearmChannel2AfterCoverageAdvancingHardFold(input) {
   return casChannel2NudgeState(input.db, input.sessionId, "delivered", "");
 }
 function rearmChannel2AfterMeasuredCollapse(input) {
+  if (!input.rebuilding && (!input.previous || effectiveTailHygiene(input.baseline).u >= effectiveTailHygiene(input.previous).u))
+    return false;
   if (!input.baseline.evaluable || input.baseline.generationInvalidated)
     return false;
   if (effectiveTailHygiene(input.baseline).u >= CHANNEL1_FLOOR_TOKENS)
@@ -3656,6 +3741,29 @@ function hasLoggedCtxReducePermissionDeny(sessionId) {
 function markCtxReducePermissionDenyLogged(sessionId) {
   ctxReducePermissionDenyLogged.set(sessionId, true);
 }
+var ctxReducePermissionObservations = new Map;
+function observeCtxReducePermissionDeny(client, sessionId, activeAgent) {
+  if (hasLoggedCtxReducePermissionDeny(sessionId))
+    return;
+  const inFlight = ctxReducePermissionObservations.get(sessionId);
+  if (inFlight)
+    return inFlight;
+  const read = (async () => {
+    try {
+      const denied = await resolveToolPermissionDenied(client, sessionId, CTX_REDUCE_TOOL, activeAgent);
+      if (denied && !hasLoggedCtxReducePermissionDeny(sessionId)) {
+        markCtxReducePermissionDenyLogged(sessionId);
+        sessionLog(sessionId, "ctx_reduce permission is denied by OpenCode; frozen guidance remains until session restart");
+      }
+    } catch (error) {
+      sessionLog(sessionId, "ctx_reduce permission read failed (ignored):", error);
+    } finally {
+      ctxReducePermissionObservations.delete(sessionId);
+    }
+  })();
+  ctxReducePermissionObservations.set(sessionId, read);
+  return read;
+}
 function resolveTodowriteAvailabilityFromMessages(sessionId, messages) {
   return resolveToolAvailabilityFromMessages(sessionId, TODOWRITE_TOOL, messages);
 }
@@ -3725,18 +3833,20 @@ function messageHasReducePart(message) {
   }
   return false;
 }
-function sentinelizeReduceParts(message) {
+function sentinelizeReduceParts(message, onFirstApplication) {
   let touched = false;
   for (let j = 0;j < message.parts.length; j++) {
     const part = message.parts[j];
     if (isSentinel(part))
       continue;
     if (isReduceToolPart(part)) {
+      onFirstApplication?.(message, j);
       message.parts[j] = makeSentinel(part);
       touched = true;
     }
   }
   if (touched && !hasAnyMeaningfulPart(message.parts)) {
+    onFirstApplication?.(message, 0);
     message.parts.length = 0;
     message.parts.push(makeSentinel(undefined));
   }
@@ -3752,10 +3862,15 @@ function dropStaleReduceCalls(messages, frozenIds, options = {}) {
     const message = messages[i];
     const id = typeof message.info.id === "string" ? message.info.id : undefined;
     const inFrozen = id !== undefined && frozenIds.has(id);
-    const isNewDetection = !inFrozen && detect && i < protectedStart && id !== undefined && messageHasReducePart(message) && !message.parts.some(toolPartHasUserAnswer);
+    const isNewDetection = !inFrozen && detect && i < protectedStart && id !== undefined && messageHasReducePart(message) && !message.parts.some((part) => {
+      if (!isRecord(part))
+        return false;
+      const callId = part.callID ?? part.toolCallId ?? part.id;
+      return typeof callId === "string" && options.protectedCallIds?.has(callId);
+    }) && !message.parts.some(toolPartHasUserAnswer);
     if (!inFrozen && !isNewDetection)
       continue;
-    const touched = sentinelizeReduceParts(message);
+    const touched = sentinelizeReduceParts(message, isNewDetection ? options.onFirstApplication : undefined);
     if (touched) {
       didDrop = true;
       if (isNewDetection && id !== undefined)
@@ -3834,11 +3949,35 @@ function estimateDroppedTokensFromTagReductions(db, sessionId, reductions) {
 
 // src/hooks/magic-context/emergency-fail-closed.ts
 var ENGINE_RECONNECTING_USER_MESSAGE = "Magic Context's engine is reconnecting. Send your message again in a few seconds.";
+var PROTECTED_TOOL_RESULTS_OVER_LIMIT = "The tool results kept by protected_tools are larger than this model's context window, so this turn was not sent. Lower the protected_tools counts.";
+var PROTECTED_TOOL_RESULTS_OVER_LIMIT_CODE = "protected_tool_results_over_limit";
+function contextRefusalError(message) {
+  return new EmergencyFailClosedError(message, {
+    code: message === PROTECTED_TOOL_RESULTS_OVER_LIMIT ? PROTECTED_TOOL_RESULTS_OVER_LIMIT_CODE : undefined
+  });
+}
+function protectedToolRefusal(error) {
+  const seen = new Set;
+  while (error && typeof error === "object" && !seen.has(error)) {
+    seen.add(error);
+    const current = error;
+    if (current.code === PROTECTED_TOOL_RESULTS_OVER_LIMIT_CODE)
+      return contextRefusalError(PROTECTED_TOOL_RESULTS_OVER_LIMIT);
+    error = current.cause;
+  }
+  return;
+}
+function outgoingContextRefusal(estimate, limit, protectedToolTokens = 0) {
+  if (estimate?.refusalGrade !== true || typeof estimate.refusalTokens !== "number" || !Number.isFinite(estimate.refusalTokens) || !limit || !Number.isFinite(limit) || limit <= 0 || estimate.refusalTokens <= limit || !Number.isFinite(protectedToolTokens) || protectedToolTokens <= limit)
+    return;
+  return PROTECTED_TOOL_RESULTS_OVER_LIMIT;
+}
 
 class EmergencyFailClosedError extends Error {
-  code = "EMERGENCY_FAIL_CLOSED";
+  code;
   constructor(message, options) {
     super(message, options);
+    this.code = options?.code ?? "EMERGENCY_FAIL_CLOSED";
     this.name = "EmergencyFailClosedError";
   }
 }
@@ -4080,6 +4219,7 @@ var DEDUP_SAFE_TOOLS = new Set([
 ]);
 function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config, preloadedTags) {
   const tags = preloadedTags ?? getActiveTagsBySession(db, sessionId);
+  const protectedTools = config.protectedToolTags ?? protectedToolTagNumbers(tags, config.protectedTools);
   const maxTag = getMaxTagNumberBySession(db, sessionId);
   let droppedTools = 0;
   let emergencyDroppedTools = 0;
@@ -4109,7 +4249,8 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
       usagePercentage: emergency.usagePercentage,
       priorInputSample,
       hasPriorDrop: priorInputSample > 0,
-      passAlreadyPriced: emergency.passAlreadyPriced === true
+      passAlreadyPriced: emergency.passAlreadyPriced === true,
+      protectedToolTags: protectedTools
     });
     if (plan.shouldDrop) {
       const toDrop = new Set(plan.tagNumbers);
@@ -4227,6 +4368,8 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
           if (config.protectedTagNumbers.has(tag.tagNumber))
             continue;
           const target = targets.get(tag.tagNumber);
+          if (protectedTools.has(tag.tagNumber))
+            continue;
           if (target?.canDrop?.() === false)
             continue;
           const { result, mode } = applyNewToolDrop(target, { inWindow: false });
@@ -4451,7 +4594,7 @@ function isSystemInjectedText(text) {
     return false;
   return SYSTEM_INJECTION_PATTERNS.some((pattern) => pattern.test(stripped));
 }
-function stripSystemInjectedMessages(messages, protectedTailStart, providerID) {
+function stripSystemInjectedMessages(messages, protectedTailStart, providerID, onFirstApplication) {
   let stripped = 0;
   const sentineledIds = [];
   for (let i = 0;i < messages.length; i++) {
@@ -4490,6 +4633,7 @@ function stripSystemInjectedMessages(messages, protectedTailStart, providerID) {
       break;
     }
     if (hasContentPart && allContentIsSystemInjection) {
+      onFirstApplication?.(msg, 0);
       msg.parts.length = 0;
       msg.parts.push(makeWholeMessageSentinel(providerID));
       stripped++;
@@ -4509,7 +4653,7 @@ var METADATA_PART_TYPES = new Set([
   "subtask",
   "compaction"
 ]);
-function stripDroppedPlaceholderMessages(messages, providerID) {
+function stripDroppedPlaceholderMessages(messages, providerID, onFirstApplication) {
   let stripped = 0;
   const sentineledIds = [];
   for (let i = 0;i < messages.length; i++) {
@@ -4548,6 +4692,7 @@ function stripDroppedPlaceholderMessages(messages, providerID) {
       break;
     }
     if (hasContentPart && !hasNonDroppedContent) {
+      onFirstApplication?.(msg, 0);
       msg.parts.length = 0;
       msg.parts.push(makeWholeMessageSentinel(providerID));
       stripped++;
@@ -5021,6 +5166,8 @@ function stripProcessedImages(messages, frozenIds, options) {
         continue;
       }
       if (typeof part.url === "string" && part.url.startsWith("data:") && part.url.length > 200) {
+        if (isNewDetection)
+          options.onFirstApplication?.(msg, j);
         msg.parts[j] = makeSentinel(part);
         stripped++;
         touchedThisMsg = true;
@@ -5163,7 +5310,6 @@ function settleDroppedReasoningParts(messages, mode) {
 }
 
 // src/hooks/magic-context/supersession-reclaim.ts
-var TODOWRITE_KEEP = 1;
 var SUPERSESSION_RECENT_MESSAGE_WINDOW = 20;
 function recentSupersessionOwnerMessageIds(db, sessionId) {
   return getRecentTagOwnerMessageIds(db, sessionId, SUPERSESSION_RECENT_MESSAGE_WINDOW);
@@ -5175,22 +5321,17 @@ function buildSupersessionReclaimOps(input) {
   const tags = getActiveTagsBySession(input.db, input.sessionId);
   const toolTags = tags.filter((tag) => tag.type === "tool" && tag.status === "active").sort((left, right) => right.tagNumber - left.tagNumber);
   const dropTagIds = [];
-  let todowriteSeen = 0;
-  let ctxReduceSeen = 0;
+  const protectedTags = input.protectedToolTags ?? protectedToolTagNumbers(toolTags, input.protectedTools);
   for (const tag of toolTags) {
     if (input.protectedTagNumbers?.has(tag.tagNumber)) {
       continue;
     }
-    const name = tag.toolName;
+    const name = normalizeProtectedToolName(tag.toolName);
     if (!name)
       continue;
     let isTarget = false;
-    if (name === "todowrite") {
-      todowriteSeen += 1;
-      isTarget = todowriteSeen > TODOWRITE_KEEP;
-    } else if (name === "ctx_reduce") {
-      ctxReduceSeen += 1;
-      isTarget = ctxReduceSeen > CTX_REDUCE_KEEP;
+    if (name === "todowrite" || name === "ctx_reduce") {
+      isTarget = true;
     } else if (ZERO_VALUE_META_TOOLS.has(name)) {
       isTarget = true;
     } else if (name === "ctx_note") {
@@ -5205,6 +5346,8 @@ function buildSupersessionReclaimOps(input) {
   for (const tagId of dropTagIds) {
     if (realPendingTagIds.has(tagId))
       continue;
+    if (protectedTags.has(tagId))
+      continue;
     if (input.targets.get(tagId)?.canDrop?.() !== true)
       continue;
     synthetic.push({
@@ -5224,6 +5367,7 @@ function buildEditSupersessionReclaim(input) {
   const seenFile = new Set;
   const ops = [];
   const editMarkerTagIds = new Set;
+  const protectedTags = input.protectedToolTags ?? protectedToolTagNumbers(tags, input.protectedTools);
   for (const tag of editTags) {
     if (input.protectedTagNumbers?.has(tag.tagNumber)) {
       continue;
@@ -5240,6 +5384,8 @@ function buildEditSupersessionReclaim(input) {
     }
     if (realPendingTagIds.has(tag.tagNumber))
       continue;
+    if (protectedTags.has(tag.tagNumber))
+      continue;
     if (input.targets.get(tag.tagNumber)?.canDrop?.() !== true)
       continue;
     editMarkerTagIds.add(tag.tagNumber);
@@ -5273,7 +5419,7 @@ function buildSyntheticToolReclaimOps(input) {
     return [];
   const realPendingTagIds = new Set((input.pendingOps ?? []).map((op) => op.tagId));
   const tags = getActiveToolTagsForAgeReclaim(input.db, input.sessionId);
-  const newestTodowriteTag = tags.reduce((newest, tag) => tag.toolName === "todowrite" && (newest === null || tag.tagNumber > newest) ? tag.tagNumber : newest, null);
+  const protectedTags = input.protectedToolTags ?? protectedToolTagNumbers(tags, input.protectedTools);
   const synthetic = [];
   for (const tag of tags) {
     if (tag.tagNumber > watermark)
@@ -5281,7 +5427,7 @@ function buildSyntheticToolReclaimOps(input) {
     if (tag.reclaimableTokens !== null && tag.reclaimableTokens < AGE_RECLAIM_MIN_TOKENS) {
       continue;
     }
-    if (tag.tagNumber === newestTodowriteTag)
+    if (protectedTags.has(tag.tagNumber))
       continue;
     if (realPendingTagIds.has(tag.tagNumber))
       continue;
@@ -6350,12 +6496,14 @@ async function applyTodoSynthesis2(args) {
   let permissionDenied = cachedToolPermissionDenied(args.sessionId, "todowrite") ?? persistedPermissionDenied ?? false;
   const toolsMapUnavailable = args.todowriteAvailability.frozen && !args.todowriteAvailability.callable;
   if (args.isCacheBustingPass && args.client && !toolsMapUnavailable) {
+    const tTodoPermission = performance.now();
     try {
       permissionDenied = await todowritePermissionDenied(args.client, args.sessionId, args.activeAgent);
       setPersistedTodoPermissionDenied(args.db, args.sessionId, permissionDenied);
     } catch (error) {
       sessionLog(args.sessionId, "todowrite permission read failed; retaining the last successful verdict:", error);
     }
+    logTransformTiming(args.sessionId, "pp.todoPermissionRead", tTodoPermission);
   }
   const todowriteUnavailable = toolsMapUnavailable || permissionDenied;
   if (args.isCacheBustingPass && todowriteUnavailable) {
@@ -6500,7 +6648,7 @@ function replayRustModeBindingMismatchStrips2(args) {
   }
   stripReasoningFromAssistantIds(args.messages, args.resolvedProviderID, recoveryMessageIds);
 }
-var RUST_MARKER_LOCK_SKIP_LOG2 = "rust compaction-marker: pending target write skipped on lock contention; next pass retries";
+var RUST_MARKER_LOCK_SKIP_LOG2 = "rust compaction-marker: pending target write skipped on lock contention; next cache-busting pass retries";
 function isSqliteLockContentionError(error) {
   if (!error || typeof error !== "object")
     return false;
@@ -6514,6 +6662,8 @@ function isSqliteLockContentionError(error) {
   return false;
 }
 function applyRustModeDeferredCompactionMarker2(args) {
+  if (!args.cacheBustingPass)
+    return;
   const { boundary } = args;
   if (boundary) {
     if (!Number.isSafeInteger(boundary.rowVersion) || boundary.rowVersion <= 0 || !Number.isSafeInteger(boundary.ordinal) || boundary.ordinal < 0 || boundary.endMessageId.length === 0) {
@@ -6551,12 +6701,21 @@ function applyRustModeDeferredCompactionMarker2(args) {
   const pending = getPendingCompactionMarkerState(args.db, args.sessionId);
   if (!pending)
     return;
+  const consumed = args.consumedBoundary ?? boundary;
+  if (!consumed || pending.ordinal > consumed.ordinal || pending.ordinal === consumed.ordinal && pending.endMessageId !== consumed.endMessageId) {
+    sessionLog(args.sessionId, "rust compaction-marker drain: pending target not covered by served response; retaining retry state");
+    return;
+  }
+  if (args.admissionProven === false)
+    return;
   const trustedBoundary = boundary && pending.ordinal === boundary.ordinal && pending.endMessageId === boundary.endMessageId ? {
     rowVersion: boundary.rowVersion,
     ordinal: boundary.ordinal,
     endMessageId: boundary.endMessageId
   } : undefined;
+  args.beforeApply?.();
   const outcome = (args.applyDeferred ?? applyDeferredCompactionMarker)(args.db, args.sessionId, pending, args.sessionDirectory, trustedBoundary);
+  args.afterApply?.(outcome);
   switch (outcome.kind) {
     case "applied":
     case "already-current":
@@ -6651,19 +6810,26 @@ function runRustModePostprocess2(args) {
     getDeferredClearedCompactionMarkerState(args.db, args.sessionId)
   ]);
   const servedMarkerBefore = servedMarkerRecord();
-  applyRustModeDeferredCompactionMarker2({
-    ...args.compactionMarkerStrategy ? { applyDeferred: args.compactionMarkerStrategy.applyDeferred } : {},
-    db: args.db,
-    sessionId: args.sessionId,
-    boundary: args.materializedBoundary,
-    sessionDirectory: args.sessionDirectory
-  });
+  if (args.cacheBustingPass) {
+    applyRustModeDeferredCompactionMarker2({
+      cacheBustingPass: true,
+      admissionProven: args.markerAdmissionProven,
+      beforeApply: args.beforeMarkerApply,
+      afterApply: args.afterMarkerApply,
+      ...args.compactionMarkerStrategy ? { applyDeferred: args.compactionMarkerStrategy.applyDeferred } : {},
+      db: args.db,
+      sessionId: args.sessionId,
+      boundary: args.materializedBoundary,
+      consumedBoundary: args.consumedBoundary,
+      sessionDirectory: args.sessionDirectory
+    });
+  }
   (args.compactionMarkerStrategy?.reconcile ?? reconcileMarkerRepresentation2)(args.messages, getPersistedCompactionMarkerState(args.db, args.sessionId), {
     db: args.db,
     sessionId: args.sessionId,
     tagger: args.tagger,
     ctxReduceAvailability: args.ctxReduceAvailability,
-    isCacheBustingPass: args.materializedBoundary != null
+    isCacheBustingPass: args.cacheBustingPass === true
   });
   for (const anchor of getNoteNudgeAnchors(args.db, args.sessionId)) {
     appendReminderToUserMessageById(args.messages, anchor.messageId, anchor.text);
@@ -6681,7 +6847,7 @@ function runRustModePostprocess2(args) {
         trailingBlankDecisions.set(id, decision);
       }
       const candidates = findTrailingBlankDecisionCandidates(args.messages, trailingBlankDecisions, { sourceDecisions: args.trailingBlankSourceDecisions }).filter(([id]) => id === args.trailingBlankNewestAssistantId);
-      if (candidates.length > 0) {
+      if ((args.prefixPermissionSupported ?? args.cacheBustingPass === true) && candidates.length > 0) {
         const persisted = addTrailingBlankDecisions(args.db, args.sessionId, candidates, {
           overwriteMessageId: args.trailingBlankNewestAssistantId
         });
@@ -6703,14 +6869,22 @@ function runRustModePostprocess2(args) {
   const absorbingStripDecisions = new Map([...trailingBlankDecisions].filter(([, decision]) => decision === "strip"));
   applyFrozenTrailingBlankDecisions(args.messages, absorbingStripDecisions);
   let noteNudgeAppended = false;
-  const currentUserMessageId = findLastUserMessageId(args.messages);
+  const currentUserMessageId = findNoteNudgeUserMessageId(args.messages);
+  const eligibility = observeNoteNudgeServe({
+    db: args.db,
+    sessionId: args.sessionId,
+    userMessageIds: args.messages.filter((m) => m.info.role === "user" && typeof m.info.id === "string").map((m) => m.info.id),
+    anchorMessageId: currentUserMessageId,
+    isLiveTail: args.messages.at(-1)?.info.id === currentUserMessageId,
+    isCacheBustingPass: args.cacheBustingPass === true
+  });
   const noteReadStillVisible = hasVisibleNoteReadCall(args.messages);
-  const deferredNoteText = peekNoteNudgeText(args.db, args.sessionId, currentUserMessageId, args.projectPath, noteReadStillVisible);
+  const deferredNoteText = peekNoteNudgeText(args.db, args.sessionId, currentUserMessageId, args.projectPath, noteReadStillVisible, eligibility);
   if (deferredNoteText) {
     const instruction = `
 
 <instruction name="deferred_notes">${deferredNoteText}</instruction>`;
-    const anchoredMessageId = findLastUserMessageId(args.messages);
+    const anchoredMessageId = currentUserMessageId;
     const outcome = markNoteNudgeDelivered(args.db, args.sessionId, instruction, anchoredMessageId);
     if (anchoredMessageId && outcome.ok) {
       appendReminderToUserMessageById(args.messages, anchoredMessageId, instruction);
@@ -6847,6 +7021,10 @@ async function abortSessionFailClosed2(client, sessionId) {
 function evaluateEmergencyFailClosed2(input) {
   const estimate = input.finalWireEstimate;
   const limit = input.providerProvenLimitTokens;
+  const refusalMessage = outgoingContextRefusal(estimate, input.contextLimitTokens ?? limit, input.protectedToolTokens);
+  if (refusalMessage) {
+    return { shouldAbort: true, reason: "refusal-grade-final-wire-over-limit", refusalMessage };
+  }
   if (input.emergencyRecoveryArmed && estimate?.trusted === true && Number.isFinite(estimate.tokens) && estimate.tokens > 0 && typeof limit === "number" && Number.isFinite(limit) && limit > 0 && estimate.tokens < limit * 0.8) {
     return {
       shouldAbort: false,
@@ -6992,13 +7170,23 @@ async function runPostTransformPhase2(args) {
         hardSignals: args.m0M1.hardSignals,
         muralEnabled: args.m0M1.muralEnabled,
         compactionOff,
-        onFoldCommit: (db, rendered) => {
-          committedFoldBustsServedPrefix = foldBustsServedPrefix(foldDueDecision.reason, servedPrefixBeforeFold, rendered);
-          if (!committedFoldBustsServedPrefix)
-            return;
-          for (const [tagNumber, mode] of convertLegacyToolSkeletons(db, args.sessionId, args.targets)) {
-            convertedToolSkeletons.set(tagNumber, mode);
-          }
+        onFoldPrepare: () => {
+          const conversions = prepareLegacyToolSkeletonConversions(args.db, args.sessionId, args.targets);
+          return (db, rendered) => {
+            const bustsPrefix = foldBustsServedPrefix(foldDueDecision.reason, servedPrefixBeforeFold, rendered);
+            if (bustsPrefix) {
+              if (!conversions.isCurrent(db)) {
+                throw new MaterializeContentionError({
+                  reason: "fold conversion snapshot changed"
+                });
+              }
+              conversions.persist(db);
+              for (const [tagNumber, mode] of conversions.converted) {
+                convertedToolSkeletons.set(tagNumber, mode);
+              }
+            }
+            committedFoldBustsServedPrefix = bustsPrefix;
+          };
         }
       });
       preparedPrefix = foldResult;
@@ -7033,8 +7221,10 @@ async function runPostTransformPhase2(args) {
       failPass("m0-m1-fold-preexecution-degradation", error);
       sessionLog(args.sessionId, "transform: m[0] HARD fold pre-execution failed:", getErrorMessage(error));
     }
-    sessionLog(args.sessionId, `m[0] HARD fold decision: reason=${foldDueDecision.reason ?? "unknown"} executed=${foldExecutedThisPass} bustsServedPrefix=${foldBustsServedPrefixThisPass}`);
+    sessionLog(args.sessionId, `m[0] HARD fold decision: reason=${m0MaterializeReason ?? foldDueDecision.reason ?? (foldExecutedThisPass ? "drift" : "soft_refresh")} executed=${foldExecutedThisPass} bustsServedPrefix=${foldBustsServedPrefixThisPass}`);
   }
+  logTransformTiming(args.sessionId, "pp.prefixPreflight", tPostprocessSetup, `foldExecuted=${foldExecutedThisPass} m1Refreshed=${publishedM1RefreshedThisPass}`);
+  const tPassDecisions = performance.now();
   const shouldReadPendingOps = !compactionOff && (materializationRequested || publishedM1RefreshedThisPass || args.schedulerDecision === "execute" || forceMaterialization || foldExecutedThisPass || firstRenderBust || compartmentRunning);
   const pendingOps = shouldReadPendingOps ? getPendingOps(args.db, args.sessionId) : [];
   const hasPendingUserOps = pendingOps.length > 0;
@@ -7044,6 +7234,7 @@ async function runPostTransformPhase2(args) {
   };
   const idleExpiryRebuild = !freezeM0M1 && args.m0M1?.hardSignals?.cacheExpired === true;
   const rideSignals = {
+    subagentExecute: !args.fullFeatureMode && args.schedulerDecision === "execute",
     hardFold: foldBustsServedPrefixThisPass || firstRenderBust || idleExpiryRebuild,
     force: emergencyDropEligible && (args.contextUsage.percentage >= 95 || getEmergencyInputSample(args.db, args.sessionId) === 0),
     explicitFlush: isExplicitFlush || deferredMaterialize && !prefixPreflightFailed,
@@ -7053,16 +7244,18 @@ async function runPostTransformPhase2(args) {
   const shouldApplyPendingOps = publishedWorkDrainAllowed;
   const shouldRunHeuristics = !compactionOff && hasReclaimRide(rideSignals) && (rideSignals.publishedHistory || materializationRequested || forceMaterialization || foldBustsServedPrefixThisPass || firstRenderBust || emergencyDropEligible || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
   const isCacheBustingPass = publishedWorkDrainAllowed;
+  const previousTemporalDecisions = args.temporalCandidates && !compactionOff ? new Map([
+    ...args.temporalObservedDecisions ?? [],
+    ...getTemporalDecisions(args.db, args.sessionId, args.temporalReplayIds ?? args.temporalCandidates.keys())
+  ]) : undefined;
+  const temporalDecisions = args.temporalCandidates && !compactionOff ? isCacheBustingPass ? new Map([
+    ...previousTemporalDecisions ?? [],
+    ...freezeTemporalDecisions(args.db, args.sessionId, args.temporalCandidates)
+  ]) : previousTemporalDecisions : undefined;
+  const temporalInjected = temporalDecisions ? injectTemporalMarkers(args.messages, temporalDecisions) : 0;
+  const temporalFirstApplication = temporalInjected > 0 && [...temporalDecisions ?? []].some(([id, marker]) => marker && !previousTemporalDecisions?.has(id));
   if (isCacheBustingPass && args.client && args.ctxReduceAvailability.callable && !hasLoggedCtxReducePermissionDeny(args.sessionId)) {
-    try {
-      const denied = await resolveToolPermissionDenied(args.client, args.sessionId, "ctx_reduce", args.activeAgent);
-      if (denied) {
-        markCtxReducePermissionDenyLogged(args.sessionId);
-        sessionLog(args.sessionId, "ctx_reduce permission is denied by OpenCode; frozen guidance remains until session restart");
-      }
-    } catch (error) {
-      sessionLog(args.sessionId, "ctx_reduce permission read failed (ignored):", error);
-    }
+    observeCtxReducePermissionDeny(args.client, args.sessionId, args.activeAgent);
   }
   const canUseEmptySentinels = modelAcceptsEmptyContent(args.resolvedProviderID);
   const prefixBoundModel = args.thinkingBindingRecoveryEnabledForModel === true;
@@ -7103,6 +7296,19 @@ async function runPostTransformPhase2(args) {
   let explicitMaterializedSuccessfully = false;
   let deferredMaterializedSuccessfully = false;
   let pendingOpsDidMutate = false;
+  const protectedToolTags = protectedToolTagNumbers(args.tags, args.protectedTools);
+  const firstApplicationEdits = { any: false, beforeNewerThinking: false };
+  const recordFirstApplicationWireEdit = (beforeNewerThinking) => {
+    firstApplicationEdits.any = true;
+    firstApplicationEdits.beforeNewerThinking ||= beforeNewerThinking;
+  };
+  if (temporalFirstApplication)
+    recordFirstApplicationWireEdit(true);
+  const firstApplicationLocations = new Map;
+  const recordFirstApplicationAt = (message, partIndex) => {
+    recordFirstApplicationWireEdit(false);
+    firstApplicationLocations.set(message, Math.min(firstApplicationLocations.get(message) ?? Infinity, partIndex));
+  };
   let heuristicOrReasoningDidMutate = false;
   let heuristicOrReasoningEditBesidesTrim = false;
   let droppedCount = 0;
@@ -7133,12 +7339,16 @@ async function runPostTransformPhase2(args) {
     }
   }
   let autoReclaimDidMutateThisPass = false;
+  logTransformTiming(args.sessionId, "pp.passDecisions", tPassDecisions, `pendingOps=${pendingOps.length}`);
   try {
     if (shouldApplyPendingOps) {
       const applyReason = isExplicitFlush ? "explicit_flush" : deferredMaterialize ? "deferred_materialization" : foldBustsServedPrefixThisPass && args.schedulerDecision !== "execute" ? `m0_hard_fold (drain folded into executed m[0] bust, scheduler=${args.schedulerDecision})` : `${reclaimRideLabel(rideSignals)} (scheduler=${args.schedulerDecision})`;
       sessionLog(args.sessionId, `pending ops WILL APPLY — reason=${applyReason}, pendingOps=${formatPendingOpsDepth()}, context=${args.contextUsage.percentage.toFixed(1)}%`);
       const tApply = performance.now();
-      pendingOpsDidMutate = applyPendingOperations(args.sessionId, args.db, args.targets, args.contextUsage.percentage >= 95 ? newestCtxReduceTagNumbers(getTagsBySession(args.db, args.sessionId)) : args.protectedTagIds, undefined, pendingOps, [], new Set, (reduction) => droppedTokenReductions.push(reduction));
+      pendingOpsDidMutate = applyPendingOperations(args.sessionId, args.db, args.targets, new Set([
+        ...args.contextUsage.percentage >= 95 ? [] : args.protectedTagIds,
+        ...protectedToolTags
+      ]), undefined, pendingOps, [], new Set, (reduction) => droppedTokenReductions.push(reduction));
       if (pendingOpsDidMutate) {
         droppedCount += pendingOps.length;
         for (const pendingOp of pendingOps) {
@@ -7167,6 +7377,7 @@ async function runPostTransformPhase2(args) {
       let cleanup = applyHeuristicCleanup(args.sessionId, args.db, args.targets, args.messageTagNumbers, {
         protectedTagNumbers: args.protectedTagNumbers,
         protectedCutoff: args.protectedCutoff,
+        protectedToolTags,
         emergency: emergencyDropEligible && args.emergencyCeilingTokens !== undefined && args.emergencyCeilingTokens > 0 ? {
           currentTotalInputTokens: args.contextUsage.inputTokens,
           ceilingTokens: args.emergencyCeilingTokens,
@@ -7180,6 +7391,7 @@ async function runPostTransformPhase2(args) {
         const ridingCleanup = applyHeuristicCleanup(args.sessionId, args.db, args.targets, args.messageTagNumbers, {
           protectedTagNumbers: args.protectedTagNumbers,
           protectedCutoff: args.protectedCutoff,
+          protectedToolTags,
           routine: true,
           caveman: cavemanConfig
         }, getActiveTagsBySession(args.db, args.sessionId));
@@ -7301,15 +7513,17 @@ async function runPostTransformPhase2(args) {
     let autoReclaimTargetCount = 0;
     let autoReclaimDidMutate = false;
     if (toolReclaimApplicationOpportunity && !emergencyDropEligible) {
+      const tReclaimSelect = performance.now();
       const syntheticPendingOps = buildSyntheticToolReclaimOps({
         db: args.db,
         sessionId: args.sessionId,
         targets: args.targets,
         watermark: args.sessionMeta.toolReclaimWatermark ?? 0,
+        protectedToolTags,
         pendingOps
       });
       const editMarkerTagIds = new Set;
-      if (args.smartDrops) {
+      {
         const recentMessageIds = recentSupersessionOwnerMessageIds(args.db, args.sessionId);
         const selectedIds = new Set(syntheticPendingOps.map((op) => op.tagId));
         const supersessionOps = buildSupersessionReclaimOps({
@@ -7318,7 +7532,8 @@ async function runPostTransformPhase2(args) {
           targets: args.targets,
           pendingOps,
           recentMessageIds,
-          protectedTagNumbers: args.protectedTagNumbers
+          protectedTagNumbers: args.protectedTagNumbers,
+          protectedToolTags
         });
         for (const op of supersessionOps) {
           if (!selectedIds.has(op.tagId)) {
@@ -7332,7 +7547,8 @@ async function runPostTransformPhase2(args) {
           targets: args.targets,
           pendingOps,
           recentMessageIds,
-          protectedTagNumbers: args.protectedTagNumbers
+          protectedTagNumbers: args.protectedTagNumbers,
+          protectedToolTags
         });
         for (const op of editReclaim.ops) {
           if (!selectedIds.has(op.tagId)) {
@@ -7343,8 +7559,11 @@ async function runPostTransformPhase2(args) {
         }
       }
       autoReclaimTargetCount = syntheticPendingOps.length;
+      logTransformTiming(args.sessionId, "toolReclaim.select", tReclaimSelect, `targets=${autoReclaimTargetCount}`);
       if (syntheticPendingOps.length > 0) {
+        const tReclaimApply = performance.now();
         autoReclaimDidMutate = applyPendingOperations(args.sessionId, args.db, args.targets, args.protectedTagIds, undefined, [], syntheticPendingOps, editMarkerTagIds, (reduction) => droppedTokenReductions.push(reduction));
+        logTransformTiming(args.sessionId, "toolReclaim.apply", tReclaimApply);
         if (autoReclaimDidMutate) {
           droppedCount += syntheticPendingOps.length;
           autoReclaimDidMutateThisPass = true;
@@ -7358,6 +7577,7 @@ async function runPostTransformPhase2(args) {
         }
       }
     }
+    const tBatchFinalize = performance.now();
     args.batch?.finalize();
     if (toolReclaimApplicationOpportunity) {
       const maxTagNumber = advanceToolReclaimWatermarkToCurrentMax(args.db, args.sessionId);
@@ -7366,7 +7586,7 @@ async function runPostTransformPhase2(args) {
     if (autoReclaimTargetCount > 0) {
       sessionLog(args.sessionId, `tool reclaim auto-drop: targets=${autoReclaimTargetCount} mutated=${autoReclaimDidMutate}`);
     }
-    logTransformTiming(args.sessionId, "batchFinalize:heuristics", performance.now());
+    logTransformTiming(args.sessionId, "batchFinalize:heuristics", tBatchFinalize);
     if (args.sessionMeta.lastTransformError !== null) {
       updateSessionMeta(args.db, args.sessionId, { lastTransformError: null });
     }
@@ -7382,7 +7602,9 @@ async function runPostTransformPhase2(args) {
     updateSessionMeta(args.db, args.sessionId, { lastTransformError: getErrorMessage(error) });
   }
   if (isCacheBustingPass) {
+    const tDroppedEstimate = performance.now();
     droppedTokens = estimateDroppedTokensFromTagReductions(args.db, args.sessionId, droppedTokenReductions);
+    logTransformTiming(args.sessionId, "pp.droppedTokenEstimate", tDroppedEstimate);
   }
   logTransformTiming(args.sessionId, "pp.setupAndOperations", tPostprocessSetup);
   const tReplaySnapshot = performance.now();
@@ -7394,7 +7616,9 @@ async function runPostTransformPhase2(args) {
       const frozenStaleReduceIds = replaySnapshot.staleReduceStrippedIds;
       const staleReduceResult = dropStaleReduceCalls(args.messages, frozenStaleReduceIds, {
         detect: isCacheBustingPass,
-        protectedCount: args.protectedCount
+        protectedCount: args.protectedCount,
+        protectedCallIds: new Set(args.tags.filter((tag) => protectedToolTags.has(tag.tagNumber)).map((tag) => tag.messageId)),
+        onFirstApplication: recordFirstApplicationAt
       });
       if (isCacheBustingPass && staleReduceResult.newlyStrippedIds.length > 0) {
         addStaleReduceStrippedIds(args.db, args.sessionId, staleReduceResult.newlyStrippedIds);
@@ -7412,7 +7636,8 @@ async function runPostTransformPhase2(args) {
       const imageResult = stripProcessedImages(args.messages, frozenImageIds, {
         detect: isCacheBustingPass && args.watermark > 0,
         watermark: args.watermark,
-        messageTagNumbers: args.messageTagNumbers
+        messageTagNumbers: args.messageTagNumbers,
+        onFirstApplication: recordFirstApplicationAt
       });
       if (isCacheBustingPass && imageResult.newlyStrippedIds.length > 0) {
         addProcessedImageStrippedIds(args.db, args.sessionId, imageResult.newlyStrippedIds);
@@ -7430,6 +7655,7 @@ async function runPostTransformPhase2(args) {
     }
     const tInjectM0M1 = performance.now();
     try {
+      const messagesBeforeInjection = args.messages.slice();
       const result = injectM0M1({
         db: args.db,
         sessionId: args.sessionId,
@@ -7452,6 +7678,14 @@ async function runPostTransformPhase2(args) {
         compactionOff
       });
       deliveredPrefix = result;
+      if (result.prefixTrimStatus === "applied") {
+        const retainedMessages = new Set(args.messages);
+        const trimmedMessageIds = messagesBeforeInjection.filter((message) => !retainedMessages.has(message)).map((message) => message.info.id).filter((id) => typeof id === "string");
+        const currentPolicy = mergeProtectedTools(args.protectedTools);
+        const previousPolicy = args.channel1StateBySession?.get(args.sessionId)?.protectedToolsPolicy;
+        const eligibleTagNumbers = new Set(args.tags.filter((tag) => tag.type === "tool" && ((currentPolicy[normalizeProtectedToolName(tag.toolName)] ?? 0) > 0 || (previousPolicy?.[normalizeProtectedToolName(tag.toolName)] ?? 0) > 0)).map((tag) => tag.tagNumber));
+        markTagsCompactedByMessageIds(args.db, args.sessionId, trimmedMessageIds, eligibleTagNumbers);
+      }
       if (result.injected) {
         m0M1InjectedThisPass = true;
         prependedMessageCount += result.prependedMessageCount;
@@ -7500,9 +7734,9 @@ async function runPostTransformPhase2(args) {
       }
     }
     if (isCacheBustingPass) {
-      const droppedResult = stripDroppedPlaceholderMessages(args.messages, args.resolvedProviderID);
+      const droppedResult = stripDroppedPlaceholderMessages(args.messages, args.resolvedProviderID, recordFirstApplicationAt);
       const protectedTailStart = Math.max(0, args.messages.length - SYSTEM_INJECTION_ACTIONABLE_TAIL_MESSAGES);
-      const systemInjectedResult = stripSystemInjectedMessages(args.messages, protectedTailStart, args.resolvedProviderID);
+      const systemInjectedResult = stripSystemInjectedMessages(args.messages, protectedTailStart, args.resolvedProviderID, recordFirstApplicationAt);
       const hiddenMessages = args.hiddenMessagesAtCompactionSeam ?? [];
       const hiddenDroppedResult = stripDroppedPlaceholderMessages(hiddenMessages, args.resolvedProviderID);
       const hiddenSystemInjectedResult = stripSystemInjectedMessages(hiddenMessages, hiddenMessages.length, args.resolvedProviderID);
@@ -7562,7 +7796,9 @@ async function runPostTransformPhase2(args) {
         suppressV12HistoryDrain = true;
         sessionLog(args.sessionId, `compaction-marker drain: refusing ordinal ${pending.ordinal} because prefix trim through ${args.pendingCompartmentInjection?.compartmentEndMessageId ?? "<none>"} was not proven; preserving deferred history refresh signal`);
       } else {
+        const tMarkerDrain = performance.now();
         const outcome = (args.compactionMarkerStrategy ?? defaultCompactionMarkerStrategy2).applyDeferred(args.db, args.sessionId, pending, args.sessionDirectory);
+        logTransformTiming(args.sessionId, "pp.markerDrain", tMarkerDrain, `outcome=${outcome.kind}`);
         switch (outcome.kind) {
           case "applied":
           case "already-current":
@@ -7588,6 +7824,7 @@ async function runPostTransformPhase2(args) {
   }
   const deferredClearedMarkerRetires = !compactionOff && isCacheBustingPass && persistedCompactionMarkerState === null && getDeferredClearedCompactionMarkerState(args.db, args.sessionId) !== null;
   if (!compactionOff) {
+    const tMarkerWire = performance.now();
     (args.compactionMarkerStrategy ?? defaultCompactionMarkerStrategy2).reconcile(args.messages, persistedCompactionMarkerState, {
       db: args.db,
       sessionId: args.sessionId,
@@ -7595,6 +7832,7 @@ async function runPostTransformPhase2(args) {
       ctxReduceAvailability: args.ctxReduceAvailability,
       isCacheBustingPass
     });
+    logTransformTiming(args.sessionId, "pp.markerWireReconcile", tMarkerWire);
   }
   const deferredHistoryDrainEligible = historyWasConsumedThisPass && args.deferredHistoryWasPendingAtPassStart && !suppressV12HistoryDrain;
   if (deferredHistoryDrainEligible) {
@@ -7607,12 +7845,21 @@ async function runPostTransformPhase2(args) {
   const tNoteAndTodo = performance.now();
   const noteReadStillVisible = args.fullFeatureMode ? hasVisibleNoteReadCall(args.messages) : false;
   let noteNudgeAppendedThisPass = false;
-  const deferredNoteText = args.fullFeatureMode ? peekNoteNudgeText(args.db, args.sessionId, args.currentTurnId, args.projectPath, noteReadStillVisible) : null;
+  const noteNudgeUserMessageId = findNoteNudgeUserMessageId(args.messages);
+  const noteNudgeEligibility = args.fullFeatureMode ? observeNoteNudgeServe({
+    db: args.db,
+    sessionId: args.sessionId,
+    userMessageIds: args.messages.filter((m) => m.info.role === "user" && typeof m.info.id === "string").map((m) => m.info.id),
+    anchorMessageId: noteNudgeUserMessageId,
+    isLiveTail: args.messages.at(-1)?.info.id === noteNudgeUserMessageId,
+    isCacheBustingPass
+  }) : undefined;
+  const deferredNoteText = args.fullFeatureMode ? peekNoteNudgeText(args.db, args.sessionId, noteNudgeUserMessageId, args.projectPath, noteReadStillVisible, noteNudgeEligibility) : null;
   if (deferredNoteText) {
     const noteInstruction = `
 
 <instruction name="deferred_notes">${deferredNoteText}</instruction>`;
-    const anchoredMessageId = findLastUserMessageId(args.messages);
+    const anchoredMessageId = noteNudgeUserMessageId;
     const outcome = markNoteNudgeDelivered(args.db, args.sessionId, noteInstruction, anchoredMessageId);
     if (anchoredMessageId && outcome.ok) {
       appendReminderToUserMessageById(args.messages, anchoredMessageId, noteInstruction);
@@ -7711,7 +7958,7 @@ async function runPostTransformPhase2(args) {
   }
   const materializeReason = m0MaterializeReason ?? (explicitMaterializedSuccessfully ? "explicit_flush" : null);
   const materialized = m0RematerializedThisPass || explicitMaterializedSuccessfully || deferredMaterializedSuccessfully;
-  let bustedThisPass = firstRenderBust || pendingOpsDidMutate || heuristicOrReasoningDidMutate || autoReclaimDidMutateThisPass || convertedToolSkeletonsDidMutate || m0RematerializedThisPass || m0M1InjectedThisPass && historyWasConsumedThisPass || historyWasConsumedThisPass;
+  let bustedThisPass = firstApplicationEdits.any || firstRenderBust || pendingOpsDidMutate || heuristicOrReasoningDidMutate || autoReclaimDidMutateThisPass || convertedToolSkeletonsDidMutate || m0RematerializedThisPass || m0M1InjectedThisPass && historyWasConsumedThisPass || historyWasConsumedThisPass;
   const proactiveThinkingStripPermitted = isCacheBustingPass;
   const tFrozenDecisions = performance.now();
   if (reasoningMutationTargetUnknown) {
@@ -7730,7 +7977,6 @@ async function runPostTransformPhase2(args) {
     }
   }
   const mergedReasoningStrippedIds = new Set(replaySnapshot?.mergedReasoningStrippedIds ?? []);
-  let lateEditBeforeNewestThinking = false;
   const thinkingBindingRecoveryMessageIds = new Set;
   let thinkingBindingRecovery = null;
   if (!compactionOff) {
@@ -7756,8 +8002,7 @@ async function runPostTransformPhase2(args) {
             mergedReasoningStrippedIds.add(thinkingBindingRecoveryFrozenId(messageId));
           }
           if (thinkingBindingRecovery.messageIds.length > 0) {
-            bustedThisPass = true;
-            lateEditBeforeNewestThinking = true;
+            recordFirstApplicationWireEdit(true);
           }
         } else {
           failPass("thinking-binding-recovery-persistence-failure");
@@ -7774,8 +8019,7 @@ async function runPostTransformPhase2(args) {
             for (const id of getMergedReasoningStrippedIds(args.db, args.sessionId)) {
               mergedReasoningStrippedIds.add(id);
             }
-            bustedThisPass = true;
-            lateEditBeforeNewestThinking = true;
+            recordFirstApplicationWireEdit(true);
           } else {
             failPass("merged-reasoning-strip-persistence-failure");
             sessionLog(args.sessionId, "merged reasoning strip: persistence failed; leaving newly detected assistants intact");
@@ -7789,6 +8033,25 @@ async function runPostTransformPhase2(args) {
   }
   const trailingBlankDecisions = new Map(replaySnapshot?.trailingBlankDecisions ?? []);
   const newestAssistantId = typeof trailingBlankNewestAssistant?.info.id === "string" ? trailingBlankNewestAssistant.info.id : undefined;
+  let trailingDecisionMessages;
+  const recordTrailingBlankWireEdit = (id, next) => {
+    trailingDecisionMessages ??= new Map(args.messages.flatMap((message) => typeof message.info.id === "string" ? [[message.info.id, message]] : []));
+    const message = trailingDecisionMessages.get(id);
+    if (!message)
+      return;
+    const before = [{ ...message, parts: [...message.parts] }];
+    const after = [{ ...message, parts: [...message.parts] }];
+    const previous = trailingBlankDecisions.get(id);
+    if (previous)
+      applyFrozenTrailingBlankDecisions(before, new Map([[id, previous]]));
+    applyFrozenTrailingBlankDecisions(after, new Map([[id, next]]));
+    if (JSON.stringify(before[0].parts) !== JSON.stringify(after[0].parts)) {
+      let partIndex = 0;
+      while (partIndex < before[0].parts.length && JSON.stringify(before[0].parts[partIndex]) === JSON.stringify(after[0].parts[partIndex]))
+        partIndex++;
+      recordFirstApplicationAt(message, partIndex);
+    }
+  };
   if (isCacheBustingPass && trailingBlankDecisions.size > 0) {
     const visibleMessageIds = new Set(args.messages.flatMap((message) => typeof message.info.id === "string" ? [message.info.id] : []));
     const poisonedKeepIds = [];
@@ -7808,9 +8071,8 @@ async function runPostTransformPhase2(args) {
           sessionLog(args.sessionId, "trailing blank heal: persistence failed; retaining frozen keep decisions");
         } else {
           for (const id of demotedIds) {
+            recordTrailingBlankWireEdit(id, "strip");
             trailingBlankDecisions.set(id, "strip");
-            bustedThisPass = true;
-            lateEditBeforeNewestThinking = true;
             sessionLog(args.sessionId, `trailing blank heal: demoted message ${id} from keep to strip because its source has no trailing blank`);
           }
         }
@@ -7835,13 +8097,11 @@ async function runPostTransformPhase2(args) {
           const committed = getTrailingBlankDecisions(args.db, args.sessionId, candidates.map(([id]) => id));
           for (const [id] of candidates) {
             const decision = committed.get(id);
-            if (decision)
+            if (decision) {
+              if (isCacheBustingPass)
+                recordTrailingBlankWireEdit(id, decision);
               trailingBlankDecisions.set(id, decision);
-          }
-          if (isCacheBustingPass)
-            bustedThisPass = true;
-          if (isCacheBustingPass && candidates.some(([id]) => id !== newestAssistantId)) {
-            lateEditBeforeNewestThinking = true;
+            }
           }
         } else {
           failPass("trailing-blank-decision-persistence-failure");
@@ -7854,6 +8114,7 @@ async function runPostTransformPhase2(args) {
     }
   }
   logTransformTiming(args.sessionId, "pp.frozenDecisions", tFrozenDecisions);
+  bustedThisPass ||= firstApplicationEdits.any;
   const finalizeOptions = {
     prependedMessageCount,
     reasoningMutatedMessages,
@@ -7865,7 +8126,33 @@ async function runPostTransformPhase2(args) {
     skipTrailingWhitespaceStrip: compactionOff
   };
   const dropModeSwitchesThisPass = !canUseEmptySentinels && !dropLeavesReasoning && typeof args.resolvedProviderID === "string" && isCacheBustingPass && reasoningRemovalReadable && args.messages.some((message) => message.info.role === "assistant" && message.parts.some((part) => isNeutralizedReasoningPart(part)));
-  const prefixEditBesidesReasoningTrim = firstRenderBust || materializationRequested || explicitMaterializedSuccessfully || deferredMaterializedSuccessfully || foldBustsServedPrefixThisPass || publishedM1RefreshedThisPass || m0RematerializedThisPass || m0M1InjectedThisPass && historyWasConsumedThisPass || historyWasConsumedThisPass || pendingOpsDidMutate || heuristicOrReasoningEditBesidesTrim || emergency || autoReclaimDidMutateThisPass || convertedToolSkeletonsDidMutate || deferredClearedMarkerRetires || noteNudgeAppendedThisPass || todoAnchorMovedThisPass || autoSearchHintAppendedThisPass || dropModeSwitchesThisPass || lateEditBeforeNewestThinking;
+  if (prefixBoundModel && firstApplicationLocations.size > 0 && !firstApplicationEdits.beforeNewerThinking) {
+    const remaining = args.messages.map((message) => ({
+      ...message,
+      parts: [...message.parts]
+    }));
+    stripClearedReasoning(remaining);
+    stripReasoningFromAssistantIds(remaining, args.resolvedProviderID, thinkingBindingRecoveryMessageIds);
+    stripReasoningFromMergedAssistants(remaining, args.resolvedProviderID, {
+      frozenMessageIds: mergedReasoningStrippedIds,
+      mutationExemptMessage: remaining[args.messages.indexOf(reasoningMutationExemptMessage)]
+    });
+    let newerThinking = false;
+    for (let index = remaining.length - 1;index >= 0; index--) {
+      const message = remaining[index];
+      const editIndex = firstApplicationLocations.get(args.messages[index]);
+      if (editIndex !== undefined && editIndex >= message.parts.length && newerThinking)
+        firstApplicationEdits.beforeNewerThinking = true;
+      for (let partIndex = message.parts.length - 1;partIndex >= 0; partIndex--) {
+        const part = message.parts[partIndex];
+        if (message.info.role === "assistant" && isRecord(part) && part.ignored !== true && (part.type === "reasoning" || part.type === "thinking" || part.type === "redacted_thinking"))
+          newerThinking = true;
+        if (editIndex !== undefined && partIndex === editIndex && newerThinking)
+          firstApplicationEdits.beforeNewerThinking = true;
+      }
+    }
+  }
+  const prefixEditBesidesReasoningTrim = firstRenderBust || materializationRequested || explicitMaterializedSuccessfully || deferredMaterializedSuccessfully || foldBustsServedPrefixThisPass || publishedM1RefreshedThisPass || m0RematerializedThisPass || m0M1InjectedThisPass && historyWasConsumedThisPass || historyWasConsumedThisPass || pendingOpsDidMutate || heuristicOrReasoningEditBesidesTrim || emergency || autoReclaimDidMutateThisPass || convertedToolSkeletonsDidMutate || deferredClearedMarkerRetires || noteNudgeAppendedThisPass || todoAnchorMovedThisPass || autoSearchHintAppendedThisPass || dropModeSwitchesThisPass || firstApplicationEdits.beforeNewerThinking;
   let proactiveThinkingStrip = null;
   if (!compactionOff && args.thinkingBindingRecoveryEnabledForModel === true && proactiveThinkingStripPermitted && prefixEditBesidesReasoningTrim) {
     const outcome = freezeReasoningOnBustingPass2({
@@ -7905,6 +8192,8 @@ async function runPostTransformPhase2(args) {
     settledDroppedReasoning = settleDroppedReasoningParts(args.messages, mode);
   }
   const tFinalRepresentation = performance.now();
+  if (temporalDecisions)
+    injectTemporalMarkers(args.messages, temporalDecisions);
   const finalRepresentation = finalizeMessageRepresentation2(args.messages, args.resolvedProviderID, finalizeOptions);
   const removedReasoningParts = reasoningRemovalEnabled ? removeReasoningParts(args.messages, removedReasoningIds, args.resolvedProviderID) : 0;
   sessionLog(args.sessionId, `final representation: clearedParts=${finalRepresentation.clearedParts} mergedReasoningParts=${finalRepresentation.mergedReasoningParts} removedReasoningParts=${removedReasoningParts} settledDroppedReasoning=${settledDroppedReasoning}`);
@@ -7926,6 +8215,8 @@ async function runPostTransformPhase2(args) {
           messages: args.messages,
           tags,
           protectedTagNumbers: args.protectedTagNumbers,
+          protectedToolTags,
+          protectedTools: args.protectedTools,
           pendingDropTagNumbers,
           cacheBusting: bustedThisPass,
           previous,
@@ -7957,7 +8248,9 @@ async function runPostTransformPhase2(args) {
           rearmChannel2AfterMeasuredCollapse({
             db: args.db,
             sessionId: args.sessionId,
-            baseline
+            baseline,
+            rebuilding: bustedThisPass,
+            previous
           });
         } catch (error) {
           sessionLog(args.sessionId, "channel2 U-collapse reset failed (ignored):", error);
@@ -7992,14 +8285,12 @@ async function runPostTransformPhase2(args) {
     } catch (error) {
       sessionLog(args.sessionId, "ERROR [tail-hygiene-last-writer-check-failed]: structural production guard failed open:", error);
     }
-    if (true) {
-      assertTailHygieneContentUnchanged({
-        messages: args.messages,
-        tags: assertedBaseline.tags,
-        protectedTagNumbers: assertedBaseline.protectedTagNumbers,
-        expectedSignature: assertedBaseline.contentSignature
-      });
-    }
+    assertTailHygieneContentUnchangedIfEnabled({
+      messages: args.messages,
+      tags: assertedBaseline.tags,
+      protectedTagNumbers: assertedBaseline.protectedTagNumbers,
+      expectedSignature: assertedBaseline.contentSignature
+    });
   }
   logTransformTiming(args.sessionId, "pp.tailGuard", tTailGuard);
   return {
@@ -8036,4 +8327,4 @@ function checkM0MutationDriftAndSignal2(args) {
   return false;
 }
 
-export { indexCommitsForProject, embedUnembeddedCommits, createTagger, createUnifiedSearchDiagnostics, parseIdShapedQuery, resolveMemoriesByIdsForSearch, unifiedSearch, formatSearchResults, cavemanWordRulesForLanguage, findSessionId, findLastUserMessageId, clearAutoSearchForSession, setCtxReduceRegisteredGlobally, resolveCtxReduceAvailabilityFromMessages, resolveCtxReduceAvailability, primeCtxReduceSpawnPermission, ctxReduceSpawnPermissionReadNeeded, spawnAgentFromMessages, spawnAgentFromOpenCodeDb, todowritePermissionDenied, cachedToolPermissionDenied, clearToolPermissionDenied, resolveTodowriteAvailabilityFromMessages, resolveTodowriteAvailability, canConsumeDeferredOnThisPass, hasReclaimRide, reclaimRideLabel, replayCavemanCompression, DegradedPassRefusalError, degradedPassError, ENGINE_RECONNECTING_USER_MESSAGE, EmergencyFailClosedError, replayClearedReasoning, replayStrippedInlineThinking, stripClearedReasoning, snapshotTrailingBlankSourceDecisions, applyFlushedStatuses, stripStructuralNoise, logTransformTiming, hasRecentAssistantCommit, tagMessages, resetDegradedCacheCount2, isSyntheticHeadMessage2, applyTodoSynthesis2, freezeReasoningOnBustingPass2, firstServedDivergenceIndex2, rustModeServedKeyAfterPersistedStrips2, replayRustModeBindingMismatchStrips2, RUST_MARKER_LOCK_SKIP_LOG2, applyRustModeDeferredCompactionMarker2, clearRustModeBoundaryRecord2, runRustModePostprocess2, reconcileMarkerRepresentation2, clearPendingCompactionMarkerAfterSuccessfulDrain2, defaultCompactionMarkerStrategy2, abortSessionFailClosed2, evaluateEmergencyFailClosed2, finalizeMessageRepresentation2, runPostTransformPhase2, checkM0MutationDriftAndSignal2 };
+export { indexCommitsForProject, embedUnembeddedCommits, createTagger, createUnifiedSearchDiagnostics, parseIdShapedQuery, resolveMemoriesByIdsForSearch, unifiedSearch, formatSearchResults, cavemanWordRulesForLanguage, findSessionId, findLastUserMessageId, clearAutoSearchForSession, setCtxReduceRegisteredGlobally, resolveCtxReduceAvailabilityFromMessages, resolveCtxReduceAvailability, primeCtxReduceSpawnPermission, ctxReduceSpawnPermissionReadNeeded, spawnAgentFromMessages, spawnAgentFromOpenCodeDb, todowritePermissionDenied, cachedToolPermissionDenied, clearToolPermissionDenied, resolveTodowriteAvailabilityFromMessages, resolveTodowriteAvailability, canConsumeDeferredOnThisPass, hasReclaimRide, reclaimRideLabel, replayCavemanCompression, DegradedPassRefusalError, degradedPassError, ENGINE_RECONNECTING_USER_MESSAGE, contextRefusalError, protectedToolRefusal, outgoingContextRefusal, EmergencyFailClosedError, replayClearedReasoning, replayStrippedInlineThinking, stripClearedReasoning, snapshotTrailingBlankSourceDecisions, applyFlushedStatuses, stripStructuralNoise, logTransformTiming, hasRecentAssistantCommit, tagMessages, resetDegradedCacheCount2, isSyntheticHeadMessage2, applyTodoSynthesis2, freezeReasoningOnBustingPass2, firstServedDivergenceIndex2, rustModeServedKeyAfterPersistedStrips2, replayRustModeBindingMismatchStrips2, RUST_MARKER_LOCK_SKIP_LOG2, applyRustModeDeferredCompactionMarker2, clearRustModeBoundaryRecord2, runRustModePostprocess2, reconcileMarkerRepresentation2, clearPendingCompactionMarkerAfterSuccessfulDrain2, defaultCompactionMarkerStrategy2, abortSessionFailClosed2, evaluateEmergencyFailClosed2, finalizeMessageRepresentation2, runPostTransformPhase2, checkM0MutationDriftAndSignal2 };