@cortexkit/opencode-magic-context 0.41.1 → 0.41.2

package/dist/index.js

@@ -55,6 +55,7 @@ import {
   MAX_EXECUTE_THRESHOLD,
   MagicContextConfigSchema,
   ModuleMemoryAuthorityError,
+  NEWEST_REASONING_BEARING_ASSISTANT,
   PER_HARNESS_MIGRATION_INVENTORY,
   PRIMER_CANDIDATE_MAX_AGE_MS,
   PRIMER_CANDIDATE_TTL_MS,
@@ -67,6 +68,7 @@ import {
   StaleRouteHandleError,
   SubcClient,
   SynapseEmbeddingProvider,
+  THINKING_BINDING_RECOVERY_FROZEN_PREFIX,
   ToolMutationBatch,
   USER_MEMORY_CANDIDATE_TTL_MS,
   V2_MEMORY_CATEGORIES,
@@ -85,6 +87,7 @@ import {
   applyMirroredNoteCompileFields,
   applyStrippedPlaceholderDelta,
   archiveMemory,
+  armThinkingBindingRecovery,
   assertTailHygieneContentUnchanged,
   backfillTagTokenCounts,
   beginBootQuietPeriod,
@@ -123,6 +126,7 @@ import {
   clearPersistedReasoningWatermark,
   clearPersistedTodoSyntheticAnchor,
   clearRecompStaging,
+  clearThinkingBindingRecoveryIf,
   computeCueContentHash,
   computeNormalizedHash,
   computeSyntheticCallId,
@@ -148,6 +152,7 @@ import {
   demoteTrailingBlankKeepDecisions,
   deriveTagLoadFloor,
   detectOverflow,
+  detectThinkingBindingMismatch,
   directoryHasGitMetadata,
   dismissNote,
   dismissUserMemory,
@@ -187,6 +192,7 @@ import {
   getActiveTagsBySession,
   getActiveToolTagsForAgeReclaim,
   getActiveUserMemories,
+  getAssignableTagNumberByMessageId,
   getAuthorityManagedMarker,
   getAutoSearchHintDecisions,
   getCandidateToolOwners,
@@ -206,6 +212,7 @@ import {
   getEmergencyRecoveryArmedAt,
   getHistorianFailureState,
   getIndexedMessageCorpusSize,
+  getInertWhitespaceAssistantTags,
   getLastCompartmentEndMessage,
   getLastCompartmentEndMessageId,
   getLastHookInitFailure,
@@ -269,10 +276,12 @@ import {
   getSourceContents,
   getStaleReduceStrippedIds,
   getStrippedPlaceholderIds,
+  getTagById,
   getTagNumberByMessageId,
   getTagsByNumbers,
   getTagsBySession,
   getTailHygieneTags,
+  getThinkingBindingRecoveryTarget,
   getToolTagNumberByOwner,
   getTrailingBlankDecisions,
   getTriggerTagTokenUpperBound,
@@ -305,6 +314,7 @@ import {
   isEditTool,
   isEmbeddingEnabled,
   isEmergencyRecoveryArmed,
+  isFable51ThinkingBindingModel,
   isFailClosedBlockingError,
   isFilePart,
   isLinkedGitWorktree,
@@ -331,6 +341,7 @@ import {
   markNoteNudgeDelivered,
   markNoteReady,
   markProjectLoadUntrusted,
+  markWhitespaceAssistantTagInert,
   memoryNeedsCue,
   mergeMemoryStats,
   migrateMagicContextConfigLocations,
@@ -486,6 +497,7 @@ import {
   tailHygieneStructuralSignature,
   takeDubiousOwnershipProjectIdentityWarning,
   textMentionsRecentCommit,
+  thinkingBindingRecoveryFrozenId,
   toModelEntry,
   toolOutputTokens,
   trimMemoriesToBudgetV2,
@@ -505,7 +517,7 @@ import {
   verificationFileExists,
   withContentLanguageDirective,
   withRawSessionMessageCache
-} from "./index-dh0vfghk.js";
+} from "./index-j8r0ejb3.js";
 import {
   deriveHistorianChunkTokens,
   deriveTriggerBudget,
@@ -515,12 +527,13 @@ import {
   isSaneLimit,
   refreshModelLimitsAfterAuthOnce,
   refreshModelLimitsFromApi,
+  reloadWindowOverlay,
   resolveHistorianContextLimit,
   setOutputReserveConfig,
   setStoragePrivatePermissionEnforcement,
   setWindowOverlayPath,
   shouldEnforcePrivateStoragePermissions
-} from "./index-2d4kf2ve.js";
+} from "./index-cvda5jb3.js";
 import {
   clearIgnoredMessages,
   describeError,
@@ -535,9 +548,10 @@ import {
   getOrCreateSessionMeta,
   logSlowWriteTransaction,
   markSessionCleanupPending,
+  retryPendingRustSessionCleanupsForProject,
   retryPendingSessionCleanups,
   updateSessionMeta
-} from "./index-z893kjyt.js";
+} from "./index-y1yr57fw.js";
 import {
   modelRefLookupOrder,
   piModelRefToCanonical
@@ -11863,15 +11877,15 @@ Project memory uses exactly 5 categories. Every memory belongs to one:
 - **CONFIG_VALUES** — stable configuration keys/values and conventions. Not transient measurements (test counts, sizes, versions).
 - **NAMING** — naming conventions and canonical names. Not inventories.
 
-**Legacy categories during transition:** older memories may still carry pre-v2 category names. When you touch one, map it to its 5-category home with \`action="update"\` (or \`merge\`): WORKFLOW_RULES→PROJECT_RULES, ARCHITECTURE_DECISIONS→ARCHITECTURE, CONFIG_DEFAULTS→CONFIG_VALUES, ENVIRONMENT→CONFIG_VALUES (paths) or CONSTRAINTS, KNOWN_ISSUES→CONSTRAINTS only if it's an external-system limit (otherwise archive — our own fixed bugs are not world facts). USER_DIRECTIVES / USER_PREFERENCES are NOT project categories — they live in the global user profile; archive project copies only when they add zero project-specific detail.`;
+**Legacy categories during transition:** older memories may still carry pre-v2 category names. When you touch one, map it to its 5-category home with \`action="update"\` (or \`merge\`): WORKFLOW_RULES→PROJECT_RULES, ARCHITECTURE_DECISIONS→ARCHITECTURE, CONFIG_DEFAULTS→CONFIG_VALUES, ENVIRONMENT→CONFIG_VALUES (paths) or CONSTRAINTS, KNOWN_ISSUES→CONSTRAINTS only if it's an external-system limit. USER_DIRECTIVES / USER_PREFERENCES are NOT project categories. Do not compare project memories with the global user profile or use it to justify an archive.`;
 var CURATE_SYSTEM_PROMPT = `You are a memory-pool curator for the magic-context system. You run during a scheduled dream window to keep a project's cross-session memory store lean and well-formed.
 
 ## Memory operations (ctx_memory)
 - \`action="list"\` — browse active memories, optionally filter by category
 - \`action="merge", ids=[N,M,...], content="...", category="..."\` — consolidate duplicates into one canonical memory
-- \`action="update", ids=[N], content="..."\` — rewrite a memory's content
+- \`action="update", ids=[N], content="...", superseded_by=M\` — rewrite content; name where removed detail survives when cutting more than half
 - \`action="write", category="...", content="..."\` — create a memory (SPLITS ONLY — never mint new facts)
-- \`action="archive", ids=[N], reason="..."\` — soft-archive a stale or low-value memory
+- \`action="archive", ids=[N], superseded_by=M, reason="..."\` — consolidate a redundant memory into the named active same-category survivor
 
 ## Rules
 1. **Assume the pool is accurate.** A separate verify task checks memories against code. You handle QUALITY only — duplicates, wording, low-value entries — never correctness, and you do NOT read the codebase.
@@ -11914,34 +11928,25 @@ Mapped files: ${files}${memory.hasNoFileSentinel ? " (file-independent)" : ""}`;
 
 `);
 }
-function formatUserProfileList(userMemories) {
-  if (!userMemories || userMemories.length === 0)
-    return;
-  return userMemories.map((um) => `- [U${um.id}] ${um.content}`).join(`
-`);
-}
 function buildCuratePrompt(args) {
   return `## Task: Curate Project Memory Pool (hygiene)
 
 **Project:** ${args.projectPath}
 
-The memories below are assumed ACCURATE (a separate verify task keeps them true). Your job is pool QUALITY: remove duplicates, tighten wording, and archive low-value entries that waste the ~6000-token injection budget. Explain each action in one line first. Do NOT mint new facts (that is the historian's job).
+The memories below are assumed ACCURATE (a separate verify task keeps them true). Your job is pool QUALITY: remove duplicates, tighten wording, and consolidate redundant entries that waste the ~6000-token injection budget. Explain each action in one line first. Do NOT mint new facts (that is the historian's job).
 
 Work ALL THREE phases below in order (A → B → C) over the whole pool. Do NOT stop after consolidating — a run that only merges and never improves or archives is incomplete.
 
 ### Phase A — Consolidate duplicates
-Group by category, then merge near-identical / superset-subset / same-fact-different-angle clusters into one canonical memory with \`ctx_memory(action="merge", ids=[...], content="...", category="...")\`. Preserve every unique detail; terse present tense; paths/keys verbatim. Every id in a merge MUST share the same category — the system rejects cross-category merges. If two similar memories sit in different categories they are NOT duplicates (one is miscategorized — archive the redundant one in Phase C instead). One fact per memory.
+Group by category, then merge near-identical / superset-subset / same-fact-different-angle clusters into one canonical memory with \`ctx_memory(action="merge", ids=[...], content="...", category="...")\`. Preserve every unique detail; terse present tense; paths/keys verbatim. Every id in a merge MUST share the same category — the system rejects cross-category merges. If two similar memories sit in different categories they are NOT duplicates; do not archive either as a consolidation. One fact per memory.
 
 ### Phase B — Improve wording
-Rewrite narrative/historical → operational present tense ("X uses Y because Z", not "we switched to Y"); drop session-local context and commit hashes (unless the hash is the point); add specifics where vague. \`write\` is for SPLITS ONLY (update the original down to its first fact, write the second) — a healthy run is net-neutral or net-shrinking, never net-adds facts.
+Rewrite narrative/historical → operational present tense ("X uses Y because Z", not "we switched to Y"); drop session-local context and commit hashes (unless the hash is the point); add specifics where vague. A rewrite that removes more than half the content must name the active same-category memory preserving that detail with \`superseded_by\`. \`write\` is for SPLITS ONLY (update the original down to its first fact, write the second) — a healthy run is net-neutral or net-shrinking, never net-adds facts.
 
-### Phase C — Archive stale / low-value
-Archive (with a specific reason) memories that: restate code without rationale · are redundant with a better memory · are stale implementation detail (line numbers/internals) · low signal (seen_count=1, retrieval_count=0, no constraint language) · bare config value · transient measurement · a solved bug in OUR OWN code · redundant with the global user profile (zero added project detail).
+### Phase C — Archive only into a surviving project memory
+Archive a redundant memory only when a better ACTIVE memory in the same project and category preserves its information; name that survivor with \`superseded_by\`. A bare "redundant" verdict is deletion and will be refused. Leave standalone low-value or stale entries unchanged for a human to review. The global user profile describes the operator and is never a substitute for project knowledge, so it cannot justify an archive.
 KEEP (overrides archive): constraint/rule language (must/never/always) · explains WHY (because/so that/to prevent) · EXTERNAL-system limit (CONSTRAINTS: archive only if word-for-word duplicated) · path/config WITH context · retrieval_count>0 · priority/philosophy.
-${args.userProfile ? `
-### Global user profile (for the redundancy check)
-${args.userProfile}
-` : ""}
+
 ### Memory pool
 ${renderMemoryList(args.memories)}`;
 }
@@ -12150,8 +12155,7 @@ function buildDreamTaskPrompt(task, args) {
     case "curate":
       return buildCuratePrompt({
         projectPath: args.projectPath,
-        memories: args.curate?.memories ?? [],
-        userProfile: formatUserProfileList(args.userMemories)
+        memories: args.curate?.memories ?? []
       });
     case "maintain-docs":
       return buildMaintainDocsPrompt(args.projectPath, args.lastDreamAt ?? null, args.existingDocs ?? { architecture: false, structure: false });
@@ -13403,6 +13407,7 @@ function showToast(ctx, title, message, variant = "info", duration = 3000) {
 function createLiveSessionState() {
   return {
     liveModelBySession: new Map,
+    latestAssistantMessageIdBySession: new Map,
     variantBySession: new Map,
     agentBySession: new Map,
     channel1StateBySession: new Map,
@@ -16117,6 +16122,87 @@ function recordInvocation(args, startedAt, params) {
   });
 }
 
+// src/features/magic-context/dreamer/memory-claim-safety.ts
+var POLICY_SENTENCE_START = /(?:^|[.!?]\s+|\n\s*)(?:[-*]\s+|\d+[.)]\s+)?(?:you\s+|we\s+)?(?:must(?:\s+not)?|never|always|do\s+not|don't|shall\s+not)\b/i;
+var ACTOR_POLICY = /\b(?:you|we|agents?|masons?|workers?|operators?|users?|maintainers?)\s+(?:must(?:\s+not)?|should(?:\s+not)?|need\s+to|shall(?:\s+not)?|cannot|can't|may\s+not)\b/i;
+var BEHAVIORAL_WHEN_CLAUSE = /\bwhen\s+(?:you(?:'re|\s+are)?|we(?:'re|\s+are)?|told|asked|requested|working|debugging|reviewing|checking|verifying|investigating|using|running|editing|changing)\b/i;
+var WORKFLOW_IMPERATIVE = /(?:^|[.!?]\s+|\n\s*)(?:[-*]\s+|\d+[.)]\s+)?(?:please\s+)?(?:run|use|check|ask|avoid|prefer|ensure|keep|follow|brief|report|inspect|search|open|read|review|validate|confirm|delegate|stop|start|remember)\b/i;
+var DECISION_AUTHORITY = /\b(?:the\s+)?(?:user|operator|maintainer|owner)\s+(?:decides|chooses|approves|has\s+(?:the\s+)?final\s+say)\b/i;
+function isDirectiveShapedProjectRule(category, content) {
+  if (category !== "PROJECT_RULES")
+    return false;
+  const text = content.trim();
+  if (!text)
+    return false;
+  return POLICY_SENTENCE_START.test(text) || ACTOR_POLICY.test(text) || BEHAVIORAL_WHEN_CLAUSE.test(text) || WORKFLOW_IMPERATIVE.test(text) || DECISION_AUTHORITY.test(text);
+}
+
+// src/features/magic-context/dreamer/curate-memory-safety.ts
+var PROJECT_SCOPED_CATEGORIES = new Set([
+  "PROJECT_RULES",
+  "ARCHITECTURE",
+  "CONSTRAINTS",
+  "CONFIG_VALUES",
+  "NAMING"
+]);
+var USER_PROFILE_REFERENCE = /\buser(?:[\s_-]+)(?:profile|preferences?)\b|\bU\d+\b/i;
+var refusalCountsBySession = new Map;
+function isSurvivingConsolidationTarget(memory, successor, projectIdentity) {
+  return successor !== null && successor.id !== memory.id && successor.status === "active" && successor.supersededByMemoryId === null && (successor.expiresAt === null || successor.expiresAt > Date.now()) && projectIdentity(successor) === projectIdentity(memory) && successor.category === memory.category;
+}
+function assessCurateMutationSafety(args) {
+  const { memory, successor, verdict } = args;
+  if (verdict === "archive") {
+    if (!isSurvivingConsolidationTarget(memory, successor, args.projectIdentity)) {
+      return {
+        memoryId: memory.id,
+        verdict,
+        reason: "missing-active-same-category-successor"
+      };
+    }
+    if (PROJECT_SCOPED_CATEGORIES.has(memory.category) && USER_PROFILE_REFERENCE.test(args.reason ?? "")) {
+      return {
+        memoryId: memory.id,
+        verdict,
+        reason: "user-profile-is-not-project-memory"
+      };
+    }
+  }
+  if (isDirectiveShapedProjectRule(memory.category, memory.content)) {
+    return {
+      memoryId: memory.id,
+      verdict,
+      reason: "directive-shaped-project-rule"
+    };
+  }
+  if (verdict === "update") {
+    const originalChars = memory.content.trim().length;
+    const replacementChars = args.replacementContent?.trim().length ?? 0;
+    if (replacementChars * 2 < originalChars && !isSurvivingConsolidationTarget(memory, successor, args.projectIdentity)) {
+      return {
+        memoryId: memory.id,
+        verdict,
+        reason: "content-loss",
+        originalChars,
+        replacementChars
+      };
+    }
+  }
+  return null;
+}
+function recordCurateSafetyRefusal(sessionId, refusal) {
+  const count = (refusalCountsBySession.get(sessionId) ?? 0) + 1;
+  refusalCountsBySession.set(sessionId, count);
+  const lengths = refusal.originalChars === undefined ? "" : ` original_chars=${refusal.originalChars} replacement_chars=${refusal.replacementChars ?? 0}`;
+  log(`[dreamer] curate safety refusal: session_id=${sessionId} memory_id=${refusal.memoryId} verdict=${refusal.verdict} reason=${refusal.reason}${lengths} refused=${count}`);
+  return count;
+}
+function takeCurateSafetyRefusalCount(sessionId) {
+  const count = refusalCountsBySession.get(sessionId) ?? 0;
+  refusalCountsBySession.delete(sessionId);
+  return count;
+}
+
 // src/agents/smart-note-compiler.ts
 var SMART_NOTE_COMPILER_AGENT = "smart-note-compiler";
 
@@ -18140,21 +18226,6 @@ function validateMapMemoriesManifest(text, expectedIds) {
   return parsed;
 }
 
-// src/features/magic-context/dreamer/memory-claim-safety.ts
-var POLICY_SENTENCE_START = /(?:^|[.!?]\s+|\n\s*)(?:[-*]\s+|\d+[.)]\s+)?(?:you\s+|we\s+)?(?:must(?:\s+not)?|never|always|do\s+not|don't|shall\s+not)\b/i;
-var ACTOR_POLICY = /\b(?:you|we|agents?|masons?|workers?|operators?|users?|maintainers?)\s+(?:must(?:\s+not)?|should(?:\s+not)?|need\s+to|shall(?:\s+not)?|cannot|can't|may\s+not)\b/i;
-var BEHAVIORAL_WHEN_CLAUSE = /\bwhen\s+(?:you(?:'re|\s+are)?|we(?:'re|\s+are)?|told|asked|requested|working|debugging|reviewing|checking|verifying|investigating|using|running|editing|changing)\b/i;
-var WORKFLOW_IMPERATIVE = /(?:^|[.!?]\s+|\n\s*)(?:[-*]\s+|\d+[.)]\s+)?(?:please\s+)?(?:run|use|check|ask|avoid|prefer|ensure|keep|follow|brief|report|inspect|search|open|read|review|validate|confirm|delegate|stop|start|remember)\b/i;
-var DECISION_AUTHORITY = /\b(?:the\s+)?(?:user|operator|maintainer|owner)\s+(?:decides|chooses|approves|has\s+(?:the\s+)?final\s+say)\b/i;
-function isDirectiveShapedProjectRule(category, content) {
-  if (category !== "PROJECT_RULES")
-    return false;
-  const text = content.trim();
-  if (!text)
-    return false;
-  return POLICY_SENTENCE_START.test(text) || ACTOR_POLICY.test(text) || BEHAVIORAL_WHEN_CLAUSE.test(text) || WORKFLOW_IMPERATIVE.test(text) || DECISION_AUTHORITY.test(text);
-}
-
 // src/features/magic-context/dreamer/map-memories.ts
 var MAP_BATCH_SIZE = 80;
 var MAP_BATCH_FLOOR_MS = 240000;
@@ -20425,7 +20496,8 @@ function createDreamTaskExecutor(deps) {
         deadline,
         parent,
         recordRun,
-        computeMemoryDelta
+        computeMemoryDelta,
+        reportProgress
       });
     } catch (error) {
       const { transient, brief } = classifyFailure(error);
@@ -20710,7 +20782,6 @@ async function runAgenticTask(config, ctx, helpers) {
     architecture: existsSync10(`${docsDir}/ARCHITECTURE.md`),
     structure: existsSync10(`${docsDir}/STRUCTURE.md`)
   } : undefined;
-  const userMemories = task === "curate" ? getActiveUserMemories(db).map((um) => ({ id: um.id, content: um.content })) : undefined;
   let curateMemories;
   if (task === "curate") {
     curateMemories = loadActiveMemoryPromptMemories(db, projectIdentity);
@@ -20720,7 +20791,6 @@ async function runAgenticTask(config, ctx, helpers) {
     projectPath: projectIdentity,
     lastDreamAt: lastRunAt ? String(lastRunAt) : null,
     existingDocs,
-    userMemories,
     curate: curateMemories ? { memories: curateMemories } : undefined
   });
   const abortController = new AbortController;
@@ -20778,6 +20848,11 @@ async function runAgenticTask(config, ctx, helpers) {
     });
     if (leaseLost)
       throw new Error("Dream lease lost during task");
+    const curateRefused = task === "curate" ? takeCurateSafetyRefusalCount(sessionId) : 0;
+    if (curateRefused > 0) {
+      helpers.reportProgress(curateRefused, curateRefused);
+      log(`[dreamer] curate safety summary: refused=${curateRefused}`);
+    }
     if (parent) {
       recordChildInvocation({
         db,
@@ -20798,11 +20873,14 @@ async function runAgenticTask(config, ctx, helpers) {
       }
     }
     helpers.recordRun("completed", null, {
-      memoryChanges: helpers.computeMemoryDelta(memoryBefore)
+      memoryChanges: helpers.computeMemoryDelta(memoryBefore),
+      progress: curateRefused > 0 ? `curate: refused ${curateRefused} unsafe mutation(s)` : null
     });
     return { status: "completed" };
   } finally {
     heartbeat.stop();
+    if (childSessionId)
+      takeCurateSafetyRefusalCount(childSessionId);
     if (childSessionId) {
       await deps.client.session.delete({ path: { id: childSessionId } }).catch(() => {});
     }
@@ -21522,7 +21600,7 @@ function runTick(origin) {
       const db = openTimerDatabaseOrNull("maintenance tick");
       if (!db)
         return;
-      runMessageHistoryMaintenance(db);
+      await runMessageHistoryMaintenance(db);
       for (const reg of registeredProjects.values()) {
         if (origin === "startup") {
           scheduleInitialProjectRun(reg, db);
@@ -21538,11 +21616,26 @@ function runTick(origin) {
     }
   })();
 }
-function runMessageHistoryMaintenance(db) {
+async function runMessageHistoryMaintenance(db) {
   const cleanup = retryPendingSessionCleanups(db);
   if (cleanup.cleared > 0 || cleanup.failedSessionIds.length > 0) {
     log(`[message-index] pending session cleanup: cleared=${cleanup.cleared} failed=${cleanup.failedSessionIds.length}`);
   }
+  for (const registration of registeredProjects.values()) {
+    const moduleClient = registration.sessionCleanupModuleClient;
+    if (!moduleClient)
+      continue;
+    const rustCleanup = await retryPendingRustSessionCleanupsForProject(db, registration.projectIdentity, async (sessionId) => {
+      try {
+        await moduleClient.deleteSession(sessionId, registration.directory);
+      } finally {
+        moduleClient.closeSession?.(sessionId);
+      }
+    });
+    if (rustCleanup.cleared > 0 || rustCleanup.failedSessionIds.length > 0) {
+      log(`[message-index] pending Rust session cleanup: cleared=${rustCleanup.cleared} failed=${rustCleanup.failedSessionIds.length}`);
+    }
+  }
   const sweep = sweepOrphanedOpenCodeMessageIndexes(db, openOpenCodeDb);
   if (sweep.deleted > 0) {
     log(`[message-index] orphan sweep: scanned=${sweep.scanned} deleted=${sweep.deleted} cursor=${sweep.cursor || "<complete>"}`);
@@ -22542,7 +22635,7 @@ function createTagger() {
     if (type === "tool") {
       throw new Error("tagger.assignTag: type='tool' is forbidden — use assignToolTag(sessionId, callId, ownerMsgId, ...)");
     }
-    return allocateTag(sessionId, messageId, type, byteSize2, db, reasoningByteSize, toolName, inputByteSize, null, messageId, () => getTagNumberByMessageId(db, sessionId, messageId), entryFingerprint, tokenThunk);
+    return allocateTag(sessionId, messageId, type, byteSize2, db, reasoningByteSize, toolName, inputByteSize, null, messageId, () => getAssignableTagNumberByMessageId(db, sessionId, messageId), entryFingerprint, tokenThunk);
   }
   function backfillToolTokensIfNull(db, sessionId, tagNumber, tokenThunk) {
     if (!tokenThunk)
@@ -25422,16 +25515,14 @@ var WHOLE_MESSAGE_PLACEHOLDER_TEXT = "[dropped]";
 function modelAcceptsEmptyContent(providerID) {
   return providerID === "anthropic";
 }
-function variantChangeBustsProviderCache(providerID) {
-  if (providerID === undefined)
-    return true;
-  if (providerID === "anthropic")
-    return true;
-  if (providerID === "google-vertex-anthropic")
-    return true;
-  if (providerID.includes("bedrock"))
-    return true;
-  return false;
+function variantChangeBustsProviderCache(providerID, modelID) {
+  if (!providerID || !modelID)
+    return false;
+  const normalizedProviderID = providerID.toLowerCase();
+  const isAnthropicFamily = normalizedProviderID === "anthropic" || normalizedProviderID === "google-vertex-anthropic" || normalizedProviderID.includes("bedrock");
+  if (!isAnthropicFamily)
+    return false;
+  return !isFable51ThinkingBindingModel("anthropic", modelID);
 }
 function makeSentinel(originalPart) {
   const sentinel = {
@@ -26783,20 +26874,23 @@ function createChatMessageHook(args) {
       args.agentBySession.set(sessionId, input.agent);
     }
     if (previousVariant !== undefined && input.variant !== undefined && previousVariant !== input.variant) {
-      const providerID = input.model?.providerID ?? args.liveModelBySession.get(sessionId)?.providerID;
-      if (variantChangeBustsProviderCache(providerID)) {
+      const liveModel = args.liveModelBySession.get(sessionId);
+      const providerID = input.model?.providerID ?? liveModel?.providerID;
+      const modelID = input.model?.modelID ?? liveModel?.modelID;
+      if (variantChangeBustsProviderCache(providerID, modelID)) {
         sessionLog(sessionId, `variant changed (${previousVariant} -> ${input.variant}), triggering flush`);
         args.historyRefreshSessions.add(sessionId);
         args.systemPromptRefreshSessions.add(sessionId);
         args.pendingMaterializationSessions.add(sessionId);
         args.lastHeuristicsTurnId.delete(sessionId);
       } else {
-        sessionLog(sessionId, `variant changed (${previousVariant} -> ${input.variant}) on provider ${providerID} whose cache ignores request params; deferring flush to next natural bust`);
+        sessionLog(sessionId, `variant changed (${previousVariant} -> ${input.variant}) on ${providerID ?? "unknown"}/${modelID ?? "unknown"} without a proven natural cache bust; deferring flush to next natural bust`);
       }
     }
   };
 }
 function createEventHook(args) {
+  const latestAssistantMessageIdBySession = args.latestAssistantMessageIdBySession ?? new Map;
   return async (input) => {
     await args.eventHandler(input);
     if (input.event.type === "message.updated") {
@@ -26810,24 +26904,31 @@ function createEventHook(args) {
       }
       const assistantInfo = getMessageUpdatedAssistantInfo(input.event.properties);
       if (assistantInfo?.providerID && assistantInfo?.modelID) {
-        const previous = args.liveModelBySession.get(assistantInfo.sessionID);
-        args.liveModelBySession.set(assistantInfo.sessionID, {
-          providerID: assistantInfo.providerID,
-          modelID: assistantInfo.modelID
-        });
-        if (previous && (previous.providerID !== assistantInfo.providerID || previous.modelID !== assistantInfo.modelID)) {
-          dropSlot(assistantInfo.sessionID, "model-change");
-          sessionLog(assistantInfo.sessionID, `model changed (${previous.providerID}/${previous.modelID} -> ${assistantInfo.providerID}/${assistantInfo.modelID}), clearing historian failure state and reasoning watermark`);
-          clearHistorianFailureState(args.db, assistantInfo.sessionID);
-          clearPersistedReasoningWatermark(args.db, assistantInfo.sessionID);
-          clearDetectedContextLimit(args.db, assistantInfo.sessionID);
-          clearEmergencyRecovery(args.db, assistantInfo.sessionID);
-          clearEmergencyDropSample(args.db, assistantInfo.sessionID);
-          updateSessionMeta(args.db, assistantInfo.sessionID, {
-            clearedReasoningThroughTag: 0,
-            observedSafeInputTokens: 0,
-            cacheAlertSent: false
+        const latestMessageID = latestAssistantMessageIdBySession.get(assistantInfo.sessionID);
+        const acceptsModelUpdate = latestMessageID === undefined || assistantInfo.messageID !== undefined && assistantInfo.messageID >= latestMessageID;
+        if (acceptsModelUpdate) {
+          if (assistantInfo.messageID !== undefined) {
+            latestAssistantMessageIdBySession.set(assistantInfo.sessionID, assistantInfo.messageID);
+          }
+          const previous = args.liveModelBySession.get(assistantInfo.sessionID);
+          args.liveModelBySession.set(assistantInfo.sessionID, {
+            providerID: assistantInfo.providerID,
+            modelID: assistantInfo.modelID
           });
+          if (previous && (previous.providerID !== assistantInfo.providerID || previous.modelID !== assistantInfo.modelID)) {
+            dropSlot(assistantInfo.sessionID, "model-change");
+            sessionLog(assistantInfo.sessionID, `model changed (${previous.providerID}/${previous.modelID} -> ${assistantInfo.providerID}/${assistantInfo.modelID}), clearing historian failure state and reasoning watermark`);
+            clearHistorianFailureState(args.db, assistantInfo.sessionID);
+            clearPersistedReasoningWatermark(args.db, assistantInfo.sessionID);
+            clearDetectedContextLimit(args.db, assistantInfo.sessionID);
+            clearEmergencyRecovery(args.db, assistantInfo.sessionID);
+            clearEmergencyDropSample(args.db, assistantInfo.sessionID);
+            updateSessionMeta(args.db, assistantInfo.sessionID, {
+              clearedReasoningThroughTag: 0,
+              observedSafeInputTokens: 0,
+              cacheAlertSent: false
+            });
+          }
         }
       }
     }
@@ -26840,6 +26941,7 @@ function createEventHook(args) {
     }
     if (input.event.type === "session.deleted") {
       args.liveModelBySession.delete(sessionId);
+      latestAssistantMessageIdBySession.delete(sessionId);
       args.variantBySession.delete(sessionId);
       args.agentBySession.delete(sessionId);
       args.sessionDirectoryBySession.delete(sessionId);
@@ -27807,7 +27909,7 @@ function registerRpcHandlers(rpcServer, args) {
     return { count: buildCompartmentCount(db, sessionId, moduleStatus) };
   });
   const buildManagedCtx = async (db) => {
-    const { deriveHistorianChunkTokens: deriveHistorianChunkTokens2, resolveHistorianContextLimit: resolveHistorianContextLimit2 } = await import("./derive-budgets-bb7mrpzs.js");
+    const { deriveHistorianChunkTokens: deriveHistorianChunkTokens2, resolveHistorianContextLimit: resolveHistorianContextLimit2 } = await import("./derive-budgets-9q2d3r93.js");
     const { resolveHistorianModel: resolveHistorianModel2 } = await import("./model-resolution-6w6wzw18.js");
     const { userMemoryCollectionEnabled: userMemoryCollectionEnabled2 } = await import("./task-config-gv6s04fp.js");
     const DEFAULT_HISTORIAN_TIMEOUT_MS2 = 600000;
@@ -27840,7 +27942,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = getDb();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp: runManagedRecomp2 } = await import("./recomp-orchestrator-w7xg48e3.js");
+    const { runManagedRecomp: runManagedRecomp2 } = await import("./recomp-orchestrator-m37p3fq6.js");
     const { sendIgnoredMessage: sendIgnoredMessage2 } = await import("./send-session-notification-bw7eex6w.js");
     log(`[rpc] recomp requested for session ${sessionId}`);
     const ctx = await buildManagedCtx(db);
@@ -27859,7 +27961,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = getDb();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedUpgrade: runManagedUpgrade2 } = await import("./recomp-orchestrator-w7xg48e3.js");
+    const { runManagedUpgrade: runManagedUpgrade2 } = await import("./recomp-orchestrator-m37p3fq6.js");
     const { sendIgnoredMessage: sendIgnoredMessage2 } = await import("./send-session-notification-bw7eex6w.js");
     log(`[rpc] session-upgrade requested for session ${sessionId}`);
     const ctx = await buildManagedCtx(db);
@@ -27876,7 +27978,7 @@ function registerRpcHandlers(rpcServer, args) {
     if (!db)
       return { ok: false, error: "db unavailable" };
     try {
-      const { updateSessionMeta: updateSessionMeta2 } = await import("./storage-meta-session-gr4zn7sq.js");
+      const { updateSessionMeta: updateSessionMeta2 } = await import("./storage-meta-session-dse3qv6s.js");
       updateSessionMeta2(db, sessionId, { upgradeRemindedAt: Date.now() });
       return { ok: true };
     } catch (error) {
@@ -31077,1001 +31179,1036 @@ class RawFallbackContextLimitError extends Error {
   }
 }
 
-// src/hooks/magic-context/transform-context-state.ts
-function loadPersistedUsageWatermark(db, sessionId) {
-  const result = db.prepare("SELECT last_response_time FROM session_meta WHERE session_id = ?").get(sessionId);
-  if (result === null || typeof result !== "object")
-    return null;
-  const lastResponseTime = result.last_response_time;
-  return typeof lastResponseTime === "number" ? lastResponseTime : null;
+// src/hooks/magic-context/strip-content.ts
+var DROPPED_PLACEHOLDER_PATTERN = /^\[dropped §\d+§\]$/;
+var TAG_PREFIX_PATTERN = /^§\d+§\s*/;
+var SYSTEM_INJECTION_PATTERNS = [
+  /^<!-- OMO_INTERNAL_INITIATOR -->$/,
+  /^<system-reminder>[\s\S]*<\/system-reminder>$/,
+  /^\[SYSTEM DIRECTIVE:/,
+  /^\[Category\+Skill Reminder\]/,
+  /^\[EDIT ERROR - IMMEDIATE ACTION REQUIRED\]/,
+  /^\[task CALL FAILED/,
+  /^\[EMERGENCY CONTEXT WINDOW WARNING\]/
+];
+function isSystemInjectedText(text) {
+  const stripped = text.trim().replace(TAG_PREFIX_PATTERN, "").trim();
+  if (stripped.length === 0)
+    return false;
+  return SYSTEM_INJECTION_PATTERNS.some((pattern) => pattern.test(stripped));
 }
-function loadContextUsage(contextUsageMap, db, sessionId) {
-  const contextUsageEntry = contextUsageMap.get(sessionId);
-  try {
-    const persistedLastResponseTime = loadPersistedUsageWatermark(db, sessionId);
-    const cachedLastResponseTime = contextUsageEntry?.lastResponseTime ?? contextUsageEntry?.updatedAt;
-    if (contextUsageEntry && contextUsageEntry.lastResponseTime === undefined && (persistedLastResponseTime === null || persistedLastResponseTime === 0)) {
-      return contextUsageEntry.usage;
-    }
-    if (contextUsageEntry && cachedLastResponseTime === persistedLastResponseTime) {
-      return contextUsageEntry.usage;
+function stripSystemInjectedMessages(messages, protectedTailStart, providerID) {
+  let stripped = 0;
+  const sentineledIds = [];
+  for (let i = 0;i < messages.length; i++) {
+    if (i >= protectedTailStart)
+      continue;
+    const msg = messages[i];
+    if (msg.parts.length === 0)
+      continue;
+    if (msg.info.role === "user")
+      continue;
+    if (msg.parts.length === 1 && isSentinel(msg.parts[0]))
+      continue;
+    let hasContentPart = false;
+    let allContentIsSystemInjection = true;
+    for (const part of msg.parts) {
+      if (!isRecord(part))
+        continue;
+      const partType = part.type;
+      if (METADATA_PART_TYPES.has(partType))
+        continue;
+      if (part.ignored === true)
+        continue;
+      if (partType === "tool") {
+        allContentIsSystemInjection = false;
+        break;
+      }
+      if (partType === "text" && typeof part.text === "string") {
+        hasContentPart = true;
+        if (!isSystemInjectedText(part.text)) {
+          allContentIsSystemInjection = false;
+          break;
+        }
+        continue;
+      }
+      allContentIsSystemInjection = false;
+      break;
     }
-    const persisted = loadPersistedUsage(db, sessionId);
-    if (persisted) {
-      contextUsageMap.set(sessionId, {
-        ...persisted,
-        lastResponseTime: persistedLastResponseTime ?? persisted.updatedAt,
-        hasUsageTokens: false
-      });
-      return persisted.usage;
+    if (hasContentPart && allContentIsSystemInjection) {
+      msg.parts.length = 0;
+      msg.parts.push(makeWholeMessageSentinel(providerID));
+      stripped++;
+      if (typeof msg.info.id === "string")
+        sentineledIds.push(msg.info.id);
     }
-    contextUsageMap.delete(sessionId);
-  } catch (error) {
-    sessionLog(sessionId, "transform failed loading persisted usage:", error);
-    return contextUsageEntry?.usage ?? { percentage: 0, inputTokens: 0 };
-  }
-  return { percentage: 0, inputTokens: 0 };
-}
-function resolveSchedulerDecision(scheduler, sessionMeta, contextUsage, sessionId, modelKey, contextLimit) {
-  try {
-    const schedulerDecision = scheduler.shouldExecute(sessionMeta, contextUsage, undefined, sessionId, modelKey, contextLimit);
-    sessionLog(sessionId, `transform scheduler: percentage=${contextUsage.percentage.toFixed(1)}% inputTokens=${contextUsage.inputTokens} cacheTtl=${sessionMeta.cacheTtl} lastResponseTime=${sessionMeta.lastResponseTime} decision=${schedulerDecision}`);
-    return schedulerDecision;
-  } catch (error) {
-    sessionLog(sessionId, "transform scheduler failed; defaulting to defer:", error);
-    return "defer";
-  }
-}
-
-// src/hooks/magic-context/channel2-cycle.ts
-function rearmChannel2AfterCoverageAdvancingHardFold(input) {
-  if (input.compactionOff || !input.foldExecuted || input.previousCoverage === null || input.currentCoverage === null || input.currentCoverage <= input.previousCoverage) {
-    return false;
   }
-  return casChannel2NudgeState(input.db, input.sessionId, "delivered", "");
-}
-function rearmChannel2AfterMeasuredCollapse(input) {
-  if (!input.baseline.evaluable || input.baseline.generationInvalidated)
-    return false;
-  if (effectiveTailHygiene(input.baseline).u >= CHANNEL1_FLOOR_TOKENS)
-    return false;
-  return casChannel2NudgeState(input.db, input.sessionId, "delivered", "");
-}
-
-// src/hooks/magic-context/drop-stale-reduce-calls.ts
-var STALE_TOOL_NAMES = new Set(["ctx_reduce"]);
-function isReduceToolPart(part) {
-  if (!isRecord(part))
-    return false;
-  if (part.type === "tool" && typeof part.tool === "string" && STALE_TOOL_NAMES.has(part.tool))
-    return true;
-  if (part.type === "tool-invocation" && typeof part.toolName === "string" && STALE_TOOL_NAMES.has(part.toolName))
-    return true;
-  if (part.type === "tool_use" && typeof part.name === "string" && STALE_TOOL_NAMES.has(part.name))
-    return true;
-  return false;
+  return { stripped, sentineledIds };
 }
-function hasAnyMeaningfulPart(parts) {
-  for (const part of parts) {
-    if (!isRecord(part))
+var METADATA_PART_TYPES = new Set([
+  "step-start",
+  "step-finish",
+  "snapshot",
+  "patch",
+  "agent",
+  "retry",
+  "subtask",
+  "compaction"
+]);
+function stripDroppedPlaceholderMessages(messages, providerID) {
+  let stripped = 0;
+  const sentineledIds = [];
+  for (let i = 0;i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.parts.length === 0)
       continue;
-    if (part.type === "text" && typeof part.text === "string" && part.text.trim().length > 0)
-      return true;
-    if (part.type === "thinking" || part.type === "reasoning" || part.type === "redacted_thinking")
+    if (msg.info.role === "user")
       continue;
-    if (part.type === "meta" || part.type === "step-start" || part.type === "step-finish")
+    if (msg.parts.length === 1 && isSentinel(msg.parts[0]))
       continue;
-    if (part.type !== "tool" || !isReduceToolPart(part))
-      return true;
+    let hasContentPart = false;
+    let hasNonDroppedContent = false;
+    for (const part of msg.parts) {
+      if (!isRecord(part))
+        continue;
+      const partType = part.type;
+      if (METADATA_PART_TYPES.has(partType))
+        continue;
+      if (partType === "tool") {
+        hasNonDroppedContent = true;
+        break;
+      }
+      if (partType === "text" && typeof part.text === "string") {
+        hasContentPart = true;
+        const trimmed = part.text.trim();
+        if (trimmed.length === 0)
+          continue;
+        if (!trimmed.includes("[dropped §")) {
+          hasNonDroppedContent = true;
+          break;
+        }
+        const allSegmentsDropped = trimmed.split(/(?=\[dropped §)/).filter((s) => s.trim().length > 0).every((segment) => DROPPED_PLACEHOLDER_PATTERN.test(segment.trim()));
+        if (!allSegmentsDropped) {
+          hasNonDroppedContent = true;
+          break;
+        }
+        continue;
+      }
+      if (partType === "reasoning" && typeof part.text === "string") {
+        hasContentPart = true;
+        const trimmed = part.text.trim();
+        if (trimmed.length === 0)
+          continue;
+        if (!trimmed.includes("[dropped §")) {
+          hasNonDroppedContent = true;
+          break;
+        }
+        const allSegmentsDropped = trimmed.split(/(?=\[dropped §)/).filter((s) => s.trim().length > 0).every((segment) => DROPPED_PLACEHOLDER_PATTERN.test(segment.trim()));
+        if (!allSegmentsDropped) {
+          hasNonDroppedContent = true;
+          break;
+        }
+        continue;
+      }
+      hasNonDroppedContent = true;
+      break;
+    }
+    if (hasContentPart && !hasNonDroppedContent) {
+      msg.parts.length = 0;
+      msg.parts.push(makeWholeMessageSentinel(providerID));
+      stripped++;
+      if (typeof msg.info.id === "string")
+        sentineledIds.push(msg.info.id);
+    }
   }
-  return false;
+  return { stripped, sentineledIds };
 }
-function messageHasReducePart(message) {
-  for (const part of message.parts) {
-    if (isSentinel(part))
+function replayClearedReasoning(messages, reasoningByMessage, messageTagNumbers, persistedWatermark) {
+  if (persistedWatermark <= 0)
+    return 0;
+  let cleared = 0;
+  for (const message of messages) {
+    const msgTag = messageTagNumbers.get(message) ?? 0;
+    if (msgTag === 0 || msgTag > persistedWatermark)
       continue;
-    if (isReduceToolPart(part))
-      return true;
+    const parts = reasoningByMessage.get(message);
+    if (!parts)
+      continue;
+    for (const tp of parts) {
+      if (tp.thinking !== undefined && tp.thinking !== "[cleared]") {
+        tp.thinking = "[cleared]";
+        cleared++;
+      }
+      if (tp.text !== undefined && tp.text !== "[cleared]") {
+        tp.text = "[cleared]";
+        cleared++;
+      }
+    }
   }
-  return false;
+  return cleared;
 }
-function sentinelizeReduceParts(message) {
-  let touched = false;
-  for (let j = 0;j < message.parts.length; j++) {
-    const part = message.parts[j];
-    if (isSentinel(part))
+function replayStrippedInlineThinking(messages, messageTagNumbers, persistedWatermark) {
+  if (persistedWatermark <= 0)
+    return 0;
+  let stripped = 0;
+  for (const message of messages) {
+    if (message.info.role !== "assistant")
       continue;
-    if (isReduceToolPart(part)) {
-      message.parts[j] = makeSentinel(part);
-      touched = true;
+    const msgTag = messageTagNumbers.get(message) ?? 0;
+    if (msgTag === 0 || msgTag > persistedWatermark)
+      continue;
+    for (const part of message.parts) {
+      if (!isRecord(part) || part.type !== "text" || typeof part.text !== "string")
+        continue;
+      if (!part.text.includes("<think"))
+        continue;
+      const cleaned = part.text.replace(INLINE_THINKING_PATTERN, "");
+      if (cleaned !== part.text) {
+        part.text = cleaned;
+        stripped++;
+      }
     }
   }
-  if (touched && !hasAnyMeaningfulPart(message.parts)) {
-    message.parts.length = 0;
-    message.parts.push(makeSentinel(undefined));
-  }
-  return touched;
+  return stripped;
 }
-function dropStaleReduceCalls(messages, frozenIds, options = {}) {
-  const detect = options.detect ?? false;
-  const protectedCount = options.protectedCount ?? 0;
-  const protectedStart = messages.length - protectedCount;
-  const newlyStrippedIds = [];
-  let didDrop = false;
-  for (let i = 0;i < messages.length; i++) {
-    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);
-    if (!inFrozen && !isNewDetection)
+function clearOldReasoning(messages, reasoningByMessage, messageTagNumbers, clearReasoningAge) {
+  const maxTag = findMaxTag(messageTagNumbers);
+  if (maxTag === 0)
+    return 0;
+  const ageCutoff = maxTag - clearReasoningAge;
+  let cleared = 0;
+  for (const message of messages) {
+    const msgTag = messageTagNumbers.get(message) ?? 0;
+    if (msgTag === 0 || msgTag > ageCutoff)
       continue;
-    const touched = sentinelizeReduceParts(message);
-    if (touched) {
-      didDrop = true;
-      if (isNewDetection && id !== undefined)
-        newlyStrippedIds.push(id);
+    const parts = reasoningByMessage.get(message);
+    if (!parts)
+      continue;
+    for (const tp of parts) {
+      if (tp.thinking !== undefined && tp.thinking !== "[cleared]") {
+        tp.thinking = "[cleared]";
+        cleared++;
+      }
+      if (tp.text !== undefined && tp.text !== "[cleared]") {
+        tp.text = "[cleared]";
+        cleared++;
+      }
     }
   }
-  return { didDrop, newlyStrippedIds };
+  return cleared;
 }
-
-// src/hooks/magic-context/fold-execution-gate.ts
-function foldExecutesThisPass(foldDue, materialized) {
-  return foldDue && materialized;
+function findMaxTag(messageTagNumbers) {
+  let max = 0;
+  for (const tag of messageTagNumbers.values()) {
+    if (tag > max)
+      max = tag;
+  }
+  return max;
 }
-
-// src/hooks/magic-context/system-injection-stripper.ts
-var SYSTEM_INJECTION_MARKERS = [
-  "<!-- OMO_INTERNAL_INITIATOR -->",
-  "[SYSTEM DIRECTIVE: MAGIC-CONTEXT",
-  "[SYSTEM DIRECTIVE: OH-MY-OPENCODE",
-  "[Category+Skill Reminder]",
-  "[EDIT ERROR - IMMEDIATE ACTION REQUIRED]",
-  "[task CALL FAILED - IMMEDIATE RETRY REQUIRED]",
-  "[EMERGENCY CONTEXT WINDOW WARNING]",
-  "Unstable background agent appears idle",
-  "**THE SUBAGENT JUST CLAIMED THIS TASK IS DONE."
-];
-var SYSTEM_REMINDER_REGEX = /<system-reminder>[\s\S]*?<\/system-reminder>/gi;
-var OMO_MARKER_REGEX = /<!-- OMO_INTERNAL_INITIATOR -->/g;
-function stripSystemInjection(text) {
-  let hasInjection = false;
-  for (const marker of SYSTEM_INJECTION_MARKERS) {
-    if (text.includes(marker)) {
-      hasInjection = true;
-      break;
+var CLEARED_REASONING_TYPES = new Set(["thinking", "reasoning"]);
+function stripClearedReasoning(messages) {
+  let stripped = 0;
+  for (const message of messages) {
+    if (message.info.role !== "assistant")
+      continue;
+    for (let i = 0;i < message.parts.length; i++) {
+      const part = message.parts[i];
+      if (!isRecord(part))
+        continue;
+      const partType = part.type;
+      if (!CLEARED_REASONING_TYPES.has(partType))
+        continue;
+      if (!("thinking" in part) && !("text" in part))
+        continue;
+      const thinking = "thinking" in part ? part.thinking : undefined;
+      const text = "text" in part ? part.text : undefined;
+      const isCleared = (thinking === undefined || thinking === "[cleared]") && (text === undefined || text === "[cleared]");
+      if (!isCleared)
+        continue;
+      message.parts[i] = makeSentinel(part);
+      stripped++;
     }
   }
-  if (SYSTEM_REMINDER_REGEX.test(text))
-    hasInjection = true;
-  SYSTEM_REMINDER_REGEX.lastIndex = 0;
-  if (!hasInjection)
-    return null;
-  let cleaned = text;
-  cleaned = cleaned.replace(SYSTEM_REMINDER_REGEX, "");
-  cleaned = cleaned.replace(OMO_MARKER_REGEX, "");
-  cleaned = cleaned.replace(/\[SYSTEM DIRECTIVE: OH-MY-(?:OPENCODE|CLAUDE)[^\]]*\][\s\S]*?(?=\n\n(?!\s*[-*])|$)/g, "");
-  for (const marker of SYSTEM_INJECTION_MARKERS) {
-    if (marker.startsWith("<!-- ") || marker.startsWith("[SYSTEM DIRECTIVE"))
+  return stripped;
+}
+var INLINE_THINKING_PATTERN = /<(?:thinking|think)>[\s\S]*?<\/(?:thinking|think)>\s*/g;
+function stripInlineThinking(messages, messageTagNumbers, clearReasoningAge) {
+  const maxTag = findMaxTag(messageTagNumbers);
+  if (maxTag === 0)
+    return 0;
+  const ageCutoff = maxTag - clearReasoningAge;
+  let stripped = 0;
+  for (const message of messages) {
+    if (message.info.role !== "assistant")
       continue;
-    const idx = cleaned.indexOf(marker);
-    if (idx === -1)
+    const msgTag = messageTagNumbers.get(message) ?? 0;
+    if (msgTag === 0 || msgTag > ageCutoff)
       continue;
-    const blockEnd = cleaned.indexOf(`
-
-`, idx + marker.length);
-    cleaned = blockEnd !== -1 ? cleaned.slice(0, idx) + cleaned.slice(blockEnd) : cleaned.slice(0, idx);
+    for (const part of message.parts) {
+      if (!isRecord(part) || part.type !== "text" || typeof part.text !== "string")
+        continue;
+      const cleaned = part.text.replace(INLINE_THINKING_PATTERN, "");
+      if (cleaned !== part.text) {
+        part.text = cleaned;
+        stripped++;
+      }
+    }
   }
-  return cleaned.trim();
+  return stripped;
 }
-
-// src/hooks/magic-context/heuristic-cleanup.ts
-var DEDUP_SAFE_TOOLS = new Set([
-  "mcp_grep",
-  "mcp_read",
-  "mcp_glob",
-  "mcp_ast_grep_search",
-  "mcp_lsp_diagnostics",
-  "mcp_lsp_symbols",
-  "mcp_lsp_find_references",
-  "mcp_lsp_goto_definition",
-  "mcp_lsp_prepare_rename"
-]);
-function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config, preloadedTags) {
-  const tags = preloadedTags ?? getActiveTagsBySession(db, sessionId);
-  const maxTag = getMaxTagNumberBySession(db, sessionId);
-  const protectedCutoff = maxTag - config.protectedTags;
-  let droppedTools = 0;
-  let emergencyDroppedTools = 0;
-  let emergencyReclaimedTokens = 0;
-  let deduplicatedTools = 0;
-  let droppedInjections = 0;
-  if (config.emergency) {
-    const emergency = config.emergency;
-    const priorInputSample = getEmergencyInputSample(db, sessionId);
-    const droppableTags = tags.filter((t) => t.status === "active" && t.type === "tool" && targets.get(t.tagNumber)?.canDrop?.());
-    const activeTags = tags.filter((t) => t.status === "active");
-    const plan = planEmergencyDrop({
-      tags: droppableTags,
-      floorTags: activeTags,
-      maxTag,
-      protectedTags: config.protectedTags,
-      currentTotalInputTokens: emergency.currentTotalInputTokens,
-      ceilingTokens: emergency.ceilingTokens,
-      priorInputSample,
-      hasPriorDrop: priorInputSample > 0
-    });
-    if (plan.shouldDrop) {
-      const toDrop = new Set(plan.tagNumbers);
-      const newestEmergencyTags = new Set(droppableTags.slice().sort((left, right) => right.tagNumber - left.tagNumber).slice(0, 20).map((tag) => tag.tagNumber));
-      db.transaction(() => {
-        for (const tag of tags) {
-          if (!toDrop.has(tag.tagNumber))
-            continue;
-          if (tag.status !== "active" || tag.type !== "tool")
-            continue;
-          const target = targets.get(tag.tagNumber);
-          const recent = newestEmergencyTags.has(tag.tagNumber);
-          const result = recent ? target?.truncate?.() ?? target?.drop?.() ?? "absent" : target?.drop?.() ?? "absent";
-          if (result === "removed" || result === "truncated") {
-            updateTagStatus(db, sessionId, tag.tagNumber, "dropped");
-            updateTagDropMode(db, sessionId, tag.tagNumber, recent ? "truncated" : "full");
-            droppedTools++;
-            emergencyDroppedTools++;
-            emergencyReclaimedTokens += estimateEmergencyDropReclaimTokens(tag);
-          }
-        }
-      })();
-      sessionLog(sessionId, `emergency tiered drop: ${plan.reason}`);
-    } else {
-      sessionLog(sessionId, `emergency tiered drop skipped: ${plan.reason}`);
+var REASONING_IGNORED_PART_TYPES = new Set([
+  "step-start",
+  "step-finish",
+  "snapshot",
+  "patch",
+  "agent",
+  "retry",
+  "subtask",
+  "compaction"
+]);
+var REASONING_PART_TYPES = new Set(["reasoning", "thinking", "redacted_thinking"]);
+function hasReasoningReplayContent(message) {
+  return message.parts.some((part) => {
+    if (!isRecord(part) || part.ignored === true)
+      return false;
+    const type = typeof part.type === "string" ? part.type : "";
+    if (REASONING_IGNORED_PART_TYPES.has(type))
+      return false;
+    return type !== "text" || typeof part.text !== "string" || part.text.trim().length > 0;
+  });
+}
+function findNewestReasoningBearingAssistantId(messages) {
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message.info.role !== "assistant")
+      continue;
+    if (!message.parts.some((part) => isRecord(part) && REASONING_PART_TYPES.has(String(part.type)))) {
+      continue;
     }
-    setEmergencyDropSample(db, sessionId, emergency.currentTotalInputTokens);
+    const id = message.info.id;
+    if (typeof id === "string" && id.length > 0)
+      return id;
   }
-  if (config.routine !== false) {
-    db.transaction(() => {
-      for (const tag of tags) {
-        if (tag.status !== "active")
-          continue;
-        if (tag.tagNumber > protectedCutoff)
+  return;
+}
+function assistantHasReasoningPart(messages, messageId2) {
+  return messages.some((message) => message.info.role === "assistant" && message.info.id === messageId2 && message.parts.some((part) => isRecord(part) && REASONING_PART_TYPES.has(String(part.type))));
+}
+function findLatestAssistantReasoningMutationExemptMessage(messages) {
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message.info.role === "assistant" && hasReasoningReplayContent(message))
+      return message;
+  }
+  return;
+}
+function planMergedAssistantReasoningStrip(messages, mutationExemptMessage) {
+  const plan = [];
+  let prevRole;
+  let keptReasoningInRun = false;
+  for (const message of messages) {
+    const role = message.info.role;
+    if (role !== "assistant") {
+      prevRole = role;
+      keptReasoningInRun = false;
+      continue;
+    }
+    const firstInRun = prevRole !== "assistant";
+    if (firstInRun)
+      keptReasoningInRun = false;
+    if (message === mutationExemptMessage) {
+      prevRole = role;
+      continue;
+    }
+    let keepIndex = -1;
+    if (firstInRun && !keptReasoningInRun) {
+      for (let i = 0;i < message.parts.length; i++) {
+        const part = message.parts[i];
+        if (!isRecord(part))
           continue;
-        if (tag.type !== "message")
+        const partType = part.type;
+        if (REASONING_IGNORED_PART_TYPES.has(partType))
           continue;
-        const target = targets.get(tag.tagNumber);
-        if (!target)
+        if (part.ignored === true)
           continue;
-        const content = target.getContent?.();
-        if (!content)
+        if (isSentinel(part))
           continue;
-        const stripped = stripSystemInjection(content);
-        if (stripped === null)
+        if (partType === "text" && typeof part.text === "string" && part.text.trim() === "") {
           continue;
-        const strippedSource = stripTagPrefix(stripped);
-        if (strippedSource.trim().length === 0) {
-          const dropResult = target.drop?.() ?? "absent";
-          const didReplace = dropResult === "absent" ? target.setContent(`[dropped §${tag.tagNumber}§]`) : false;
-          if (dropResult === "removed" || dropResult === "absent") {
-            replaceSourceContent(db, sessionId, tag.tagNumber, "");
-            updateTagStatus(db, sessionId, tag.tagNumber, "dropped");
-            if (dropResult === "removed" || didReplace) {
-              droppedInjections++;
-            }
-          }
-        } else {
-          const didSet = target.setContent(stripped);
-          if (didSet) {
-            replaceSourceContent(db, sessionId, tag.tagNumber, strippedSource);
-            droppedInjections++;
-          }
         }
-      }
-    })();
-  }
-  const allMessages = Array.from(messageTagNumbers.keys());
-  const toolFingerprints = buildToolFingerprints(allMessages);
-  if (config.routine !== false && toolFingerprints.size > 0) {
-    const tagsByCompositeKey = new Map;
-    for (const tag of tags) {
-      if (tag.type === "tool" && tag.status === "active" && tag.messageId) {
-        const key = tag.toolOwnerMessageId ? `${tag.toolOwnerMessageId}\x00${tag.messageId}` : tag.messageId;
-        tagsByCompositeKey.set(key, tag);
+        if (REASONING_PART_TYPES.has(partType)) {
+          keepIndex = i;
+        }
+        break;
       }
     }
-    const fingerprintGroups = new Map;
-    for (const [compositeKey, fingerprint] of toolFingerprints) {
-      const tag = tagsByCompositeKey.get(compositeKey);
-      if (!tag || tag.tagNumber > protectedCutoff)
+    const stripIndices = [];
+    for (let i = 0;i < message.parts.length; i++) {
+      const part = message.parts[i];
+      if (!isRecord(part))
+        continue;
+      if (!REASONING_PART_TYPES.has(part.type))
+        continue;
+      if (part.cache_control !== undefined)
+        continue;
+      if (i === keepIndex) {
+        keptReasoningInRun = true;
         continue;
-      const group = fingerprintGroups.get(fingerprint) ?? [];
-      group.push(tag);
-      fingerprintGroups.set(fingerprint, group);
-    }
-    db.transaction(() => {
-      for (const [, group] of fingerprintGroups) {
-        if (group.length <= 1)
-          continue;
-        group.sort((a, b) => a.tagNumber - b.tagNumber);
-        for (let i = 0;i < group.length - 1; i++) {
-          const tag = group[i];
-          const target = targets.get(tag.tagNumber);
-          const result = target?.drop?.() ?? "absent";
-          if (result === "incomplete")
-            continue;
-          updateTagDropMode(db, sessionId, tag.tagNumber, "full");
-          updateTagStatus(db, sessionId, tag.tagNumber, "dropped");
-          if (result === "removed" || result === "truncated") {
-            deduplicatedTools++;
-          }
-        }
       }
-    })();
-  }
-  if (droppedTools > 0 || deduplicatedTools > 0 || droppedInjections > 0) {
-    sessionLog(sessionId, `heuristic cleanup: dropped ${droppedTools} tool tags, deduplicated ${deduplicatedTools} tool calls, dropped ${droppedInjections} system injections`);
-  }
-  let compressedTextTags = 0;
-  let mutatedTextTags = 0;
-  if (config.routine !== false && config.caveman?.enabled) {
-    const cavemanResult = applyCavemanCleanup(sessionId, db, targets, tags, {
-      enabled: true,
-      minChars: config.caveman.minChars,
-      protectedTags: config.protectedTags
-    });
-    compressedTextTags = cavemanResult.compressedToLite + cavemanResult.compressedToFull + cavemanResult.compressedToUltra;
-    mutatedTextTags = cavemanResult.mutatedTextTags;
+      stripIndices.push(i);
+    }
+    if (stripIndices.length > 0)
+      plan.push({ message, stripIndices });
+    prevRole = role;
   }
-  return {
-    droppedTools,
-    deduplicatedTools,
-    droppedInjections,
-    emergencyDroppedTools,
-    emergencyReclaimedTokens,
-    compressedTextTags,
-    mutatedTextTags
-  };
+  return plan;
 }
-function extractToolInfo(part) {
-  if (part.type === "tool" && typeof part.tool === "string" && DEDUP_SAFE_TOOLS.has(part.tool)) {
-    const state = typeof part.state === "object" && part.state !== null ? part.state : {};
-    return { toolName: part.tool, args: state.input ?? {} };
+var MAX_FROZEN_TRAILING_BLANKS = 1e4;
+var CANONICAL_BLANK_PART = { type: "text", text: "" };
+function isSentinelInvisibleTextPart(part) {
+  return isRecord(part) && part.type === "text" && typeof part.text === "string" && part.text.trim() === "";
+}
+function isCanonicalBlankPart(part) {
+  return isRecord(part) && Object.keys(part).length === 2 && part.type === "text" && part.text === "";
+}
+function trailingBlankKeepCount(decision) {
+  if (decision === "keep")
+    return 1;
+  if (!decision.startsWith("keep:"))
+    return;
+  const countText = decision.slice("keep:".length);
+  if (!/^[1-9]\d*$/.test(countText))
+    return;
+  const count = Number(countText);
+  return Number.isSafeInteger(count) && count > 0 && count <= MAX_FROZEN_TRAILING_BLANKS ? count : undefined;
+}
+function trailingBlankDecisionForMessage(message) {
+  const id = message.info.id;
+  if (message.info.role !== "assistant" || typeof id !== "string" || id.length === 0) {
+    return;
   }
-  if (part.type === "tool-invocation" && typeof part.toolName === "string" && DEDUP_SAFE_TOOLS.has(part.toolName)) {
-    return { toolName: part.toolName, args: part.args ?? {} };
+  let trailingCount = 0;
+  while (trailingCount < message.parts.length && isSentinelInvisibleTextPart(message.parts[message.parts.length - trailingCount - 1])) {
+    trailingCount += 1;
   }
-  if (part.type === "tool_use" && typeof part.name === "string" && DEDUP_SAFE_TOOLS.has(part.name)) {
-    return { toolName: part.name, args: part.input ?? {} };
+  if (trailingCount > MAX_FROZEN_TRAILING_BLANKS && trailingCount < message.parts.length) {
+    return;
   }
-  return null;
+  const decision = message.parts.length === 0 || trailingCount === message.parts.length ? "keep" : trailingCount === 0 ? "strip" : trailingCount === 1 ? "keep" : `keep:${trailingCount}`;
+  return [id, decision];
 }
-function buildToolFingerprints(messages) {
-  const fingerprints = new Map;
+function snapshotTrailingBlankSourceDecisions(messages) {
+  const decisions = new Map;
   for (const message of messages) {
-    if (message.info.role !== "assistant")
+    const observed = trailingBlankDecisionForMessage(message);
+    if (observed)
+      decisions.set(...observed);
+  }
+  return decisions;
+}
+function findTrailingBlankDecisionCandidates(messages, frozenDecisions, options) {
+  const observedDecisions = options?.sourceDecisions ?? snapshotTrailingBlankSourceDecisions(messages);
+  const visibleIds = new Set(messages.flatMap((message) => typeof message.info.id === "string" ? [message.info.id] : []));
+  const decisions = [];
+  for (const [id, decision] of observedDecisions) {
+    if (!visibleIds.has(id))
       continue;
-    const ownerMsgId = typeof message.info.id === "string" ? message.info.id : null;
-    if (!ownerMsgId)
+    const frozen = frozenDecisions.get(id);
+    if (frozen !== undefined && (id !== options?.refreshMessageId || frozen === decision || frozen === "strip")) {
       continue;
-    for (const part of message.parts) {
-      const record = part;
-      const info = extractToolInfo(record);
-      if (!info)
-        continue;
-      const callId = extractCallId(record);
-      if (!callId)
-        continue;
-      try {
-        const fingerprint = `${ownerMsgId}:${info.toolName}:${JSON.stringify(info.args)}`;
-        const compositeKey = `${ownerMsgId}\x00${callId}`;
-        fingerprints.set(compositeKey, fingerprint);
-      } catch {}
     }
+    decisions.push([id, decision]);
   }
-  return fingerprints;
-}
-function extractCallId(part) {
-  if (part.type === "tool" && typeof part.callID === "string")
-    return part.callID;
-  if (part.type === "tool-invocation" && typeof part.callID === "string")
-    return part.callID;
-  if (part.type === "tool_use" && typeof part.id === "string")
-    return part.id;
-  return null;
+  return decisions;
 }
-
-// src/hooks/magic-context/note-visibility.ts
-var NOTE_TOOL_NAMES = new Set(["ctx_note"]);
-var READ_ACTION = "read";
-function hasVisibleNoteReadCall(messages) {
-  for (let i = messages.length - 1;i >= 0; i -= 1) {
-    const parts = messages[i]?.parts;
-    if (!Array.isArray(parts))
+function applyFrozenTrailingBlankDecisions(messages, frozenDecisions) {
+  let mutations = 0;
+  for (let messageIndex = 0;messageIndex < messages.length; messageIndex += 1) {
+    let message = messages[messageIndex];
+    const id = message.info.id;
+    if (message.info.role !== "assistant" || typeof id !== "string")
       continue;
-    for (const part of parts) {
-      if (isSentinel(part))
-        continue;
-      if (isVisibleNoteReadPart(part))
-        return true;
+    const decision = frozenDecisions.get(id);
+    if (!decision)
+      continue;
+    let lastMeaningfulIndex = message.parts.length - 1;
+    while (lastMeaningfulIndex >= 0 && isSentinelInvisibleTextPart(message.parts[lastMeaningfulIndex])) {
+      lastMeaningfulIndex -= 1;
     }
-  }
-  return false;
-}
-function isVisibleNoteReadPart(part) {
-  if (!isRecord(part))
-    return false;
-  if (part.type === "tool" && typeof part.tool === "string" && NOTE_TOOL_NAMES.has(part.tool)) {
-    const state = part.state;
-    if (isRecord(state) && isRecord(state.input)) {
-      return state.input.action === READ_ACTION;
+    const replaceParts = (start, deleteCount, insertBlankCount) => {
+      message = { ...message, parts: [...message.parts] };
+      messages[messageIndex] = message;
+      message.parts.splice(start, deleteCount, ...Array.from({ length: insertBlankCount }, () => ({ ...CANONICAL_BLANK_PART })));
+    };
+    if (lastMeaningfulIndex < 0) {
+      if (message.parts.length === 0)
+        continue;
+      if (message.parts.length !== 1 || !isCanonicalBlankPart(message.parts[0])) {
+        mutations += Math.max(1, message.parts.length);
+        replaceParts(0, message.parts.length, 1);
+      }
+      continue;
     }
-    return false;
-  }
-  if (part.type === "tool_use" && typeof part.name === "string" && NOTE_TOOL_NAMES.has(part.name)) {
-    if (isRecord(part.input)) {
-      return part.input.action === READ_ACTION;
+    const trailingCount = message.parts.length - lastMeaningfulIndex - 1;
+    const keepCount = trailingBlankKeepCount(decision);
+    if (keepCount !== undefined) {
+      if (trailingCount === 0)
+        continue;
+      const blankIndex = lastMeaningfulIndex + 1;
+      const suffixIsCanonical = trailingCount === keepCount && message.parts.slice(blankIndex).every(isCanonicalBlankPart);
+      if (!suffixIsCanonical) {
+        mutations += Math.max(1, trailingCount, keepCount);
+        replaceParts(blankIndex, trailingCount, keepCount);
+      }
+      continue;
     }
-    return false;
-  }
-  if (part.type === "tool-invocation" && typeof part.toolName === "string" && NOTE_TOOL_NAMES.has(part.toolName)) {
-    const argsCandidate = part.args ?? part.input;
-    if (isRecord(argsCandidate)) {
-      return argsCandidate.action === READ_ACTION;
+    if (trailingCount === 0)
+      continue;
+    const lastMeaningfulPart = message.parts[lastMeaningfulIndex];
+    if (isRecord(lastMeaningfulPart) && REASONING_PART_TYPES.has(lastMeaningfulPart.type)) {
+      const blankIndex = lastMeaningfulIndex + 1;
+      if (trailingCount !== 1 || !isCanonicalBlankPart(message.parts[blankIndex])) {
+        mutations += Math.max(1, trailingCount);
+        replaceParts(blankIndex, trailingCount, 1);
+      }
+      continue;
     }
-    return false;
+    mutations += trailingCount;
+    replaceParts(lastMeaningfulIndex + 1, trailingCount, 0);
   }
-  return false;
+  return mutations;
 }
-
-// src/hooks/magic-context/strip-content.ts
-var DROPPED_PLACEHOLDER_PATTERN = /^\[dropped §\d+§\]$/;
-var TAG_PREFIX_PATTERN = /^§\d+§\s*/;
-var SYSTEM_INJECTION_PATTERNS = [
-  /^<!-- OMO_INTERNAL_INITIATOR -->$/,
-  /^<system-reminder>[\s\S]*<\/system-reminder>$/,
-  /^\[SYSTEM DIRECTIVE:/,
-  /^\[Category\+Skill Reminder\]/,
-  /^\[EDIT ERROR - IMMEDIATE ACTION REQUIRED\]/,
-  /^\[task CALL FAILED/,
-  /^\[EMERGENCY CONTEXT WINDOW WARNING\]/
-];
-function isSystemInjectedText(text) {
-  const stripped = text.trim().replace(TAG_PREFIX_PATTERN, "").trim();
-  if (stripped.length === 0)
-    return false;
-  return SYSTEM_INJECTION_PATTERNS.some((pattern) => pattern.test(stripped));
+function findMergedReasoningStripCandidateIds(messages, providerID, options) {
+  if (providerID !== "anthropic")
+    return [];
+  const ids = new Set;
+  for (const entry of planMergedAssistantReasoningStrip(messages, options?.mutationExemptMessage)) {
+    const id = entry.message.info.id;
+    if (typeof id === "string" && id.length > 0)
+      ids.add(id);
+  }
+  return [...ids];
 }
-function stripSystemInjectedMessages(messages, protectedTailStart, providerID) {
+function stripReasoningFromAssistantIds(messages, providerID, messageIds) {
+  if (providerID !== "anthropic" || messageIds.size === 0)
+    return 0;
   let stripped = 0;
-  const sentineledIds = [];
-  for (let i = 0;i < messages.length; i++) {
-    if (i >= protectedTailStart)
-      continue;
-    const msg = messages[i];
-    if (msg.parts.length === 0)
-      continue;
-    if (msg.info.role === "user")
-      continue;
-    if (msg.parts.length === 1 && isSentinel(msg.parts[0]))
+  for (const message of messages) {
+    const id = message.info.id;
+    if (typeof id !== "string" || !messageIds.has(id))
       continue;
-    let hasContentPart = false;
-    let allContentIsSystemInjection = true;
-    for (const part of msg.parts) {
-      if (!isRecord(part))
-        continue;
-      const partType = part.type;
-      if (METADATA_PART_TYPES.has(partType))
-        continue;
-      if (part.ignored === true)
+    for (let index = 0;index < message.parts.length; index += 1) {
+      const part = message.parts[index];
+      if (!isRecord(part) || !REASONING_PART_TYPES.has(String(part.type)))
         continue;
-      if (partType === "tool") {
-        allContentIsSystemInjection = false;
-        break;
-      }
-      if (partType === "text" && typeof part.text === "string") {
-        hasContentPart = true;
-        if (!isSystemInjectedText(part.text)) {
-          allContentIsSystemInjection = false;
-          break;
-        }
+      message.parts[index] = makeSentinel(part);
+      stripped += 1;
+    }
+  }
+  return stripped;
+}
+function stripReasoningFromMergedAssistants(messages, providerID, options) {
+  if (providerID !== "anthropic")
+    return 0;
+  let stripped = 0;
+  for (const entry of planMergedAssistantReasoningStrip(messages, options?.mutationExemptMessage)) {
+    if (options?.frozenMessageIds) {
+      const id = entry.message.info.id;
+      if (typeof id !== "string" || !options.frozenMessageIds.has(id))
         continue;
-      }
-      allContentIsSystemInjection = false;
-      break;
     }
-    if (hasContentPart && allContentIsSystemInjection) {
-      msg.parts.length = 0;
-      msg.parts.push(makeWholeMessageSentinel(providerID));
+    for (const index of entry.stripIndices) {
+      entry.message.parts[index] = makeSentinel(entry.message.parts[index]);
       stripped++;
-      if (typeof msg.info.id === "string")
-        sentineledIds.push(msg.info.id);
     }
   }
-  return { stripped, sentineledIds };
+  return stripped;
 }
-var METADATA_PART_TYPES = new Set([
-  "step-start",
-  "step-finish",
-  "snapshot",
-  "patch",
-  "agent",
-  "retry",
-  "subtask",
-  "compaction"
-]);
-function stripDroppedPlaceholderMessages(messages, providerID) {
+function stripProcessedImages(messages, frozenIds, options) {
+  const { detect, watermark, messageTagNumbers } = options;
   let stripped = 0;
-  const sentineledIds = [];
-  for (let i = 0;i < messages.length; i++) {
+  const newlyStrippedIds = [];
+  let hasAssistantResponse = false;
+  for (let i = messages.length - 1;i >= 0; i--) {
     const msg = messages[i];
-    if (msg.parts.length === 0)
+    if (msg.info.role === "assistant") {
+      hasAssistantResponse = true;
       continue;
-    if (msg.info.role === "user")
+    }
+    if (msg.info.role !== "user") {
       continue;
-    if (msg.parts.length === 1 && isSentinel(msg.parts[0]))
+    }
+    const id = typeof msg.info.id === "string" ? msg.info.id : undefined;
+    const inFrozen = id !== undefined && frozenIds.has(id);
+    const maxTag = messageTagNumbers.get(msg) ?? 0;
+    const isNewDetection = !inFrozen && detect && hasAssistantResponse && id !== undefined && maxTag <= watermark;
+    if (!inFrozen && !isNewDetection) {
       continue;
-    let hasContentPart = false;
-    let hasNonDroppedContent = false;
-    for (const part of msg.parts) {
-      if (!isRecord(part))
-        continue;
-      const partType = part.type;
-      if (METADATA_PART_TYPES.has(partType))
+    }
+    let touchedThisMsg = false;
+    for (let j = 0;j < msg.parts.length; j++) {
+      const part = msg.parts[j];
+      if (!isRecord(part) || part.type !== "file") {
         continue;
-      if (partType === "tool") {
-        hasNonDroppedContent = true;
-        break;
       }
-      if (partType === "text" && typeof part.text === "string") {
-        hasContentPart = true;
-        const trimmed = part.text.trim();
-        if (trimmed.length === 0)
-          continue;
-        if (!trimmed.includes("[dropped §")) {
-          hasNonDroppedContent = true;
-          break;
-        }
-        const allSegmentsDropped = trimmed.split(/(?=\[dropped §)/).filter((s) => s.trim().length > 0).every((segment) => DROPPED_PLACEHOLDER_PATTERN.test(segment.trim()));
-        if (!allSegmentsDropped) {
-          hasNonDroppedContent = true;
-          break;
-        }
+      if (typeof part.mime !== "string" || !part.mime.startsWith("image/")) {
         continue;
       }
-      if (partType === "reasoning" && typeof part.text === "string") {
-        hasContentPart = true;
-        const trimmed = part.text.trim();
-        if (trimmed.length === 0)
-          continue;
-        if (!trimmed.includes("[dropped §")) {
-          hasNonDroppedContent = true;
-          break;
-        }
-        const allSegmentsDropped = trimmed.split(/(?=\[dropped §)/).filter((s) => s.trim().length > 0).every((segment) => DROPPED_PLACEHOLDER_PATTERN.test(segment.trim()));
-        if (!allSegmentsDropped) {
-          hasNonDroppedContent = true;
-          break;
-        }
-        continue;
+      if (typeof part.url === "string" && part.url.startsWith("data:") && part.url.length > 200) {
+        msg.parts[j] = makeSentinel(part);
+        stripped++;
+        touchedThisMsg = true;
       }
-      hasNonDroppedContent = true;
-      break;
     }
-    if (hasContentPart && !hasNonDroppedContent) {
-      msg.parts.length = 0;
-      msg.parts.push(makeWholeMessageSentinel(providerID));
-      stripped++;
-      if (typeof msg.info.id === "string")
-        sentineledIds.push(msg.info.id);
+    if (touchedThisMsg && isNewDetection && id !== undefined) {
+      newlyStrippedIds.push(id);
     }
   }
-  return { stripped, sentineledIds };
+  return { stripped, newlyStrippedIds };
 }
-function replayClearedReasoning(messages, reasoningByMessage, messageTagNumbers, persistedWatermark) {
-  if (persistedWatermark <= 0)
-    return 0;
-  let cleared = 0;
-  for (const message of messages) {
-    const msgTag = messageTagNumbers.get(message) ?? 0;
-    if (msgTag === 0 || msgTag > persistedWatermark)
-      continue;
-    const parts = reasoningByMessage.get(message);
-    if (!parts)
-      continue;
-    for (const tp of parts) {
-      if (tp.thinking !== undefined && tp.thinking !== "[cleared]") {
-        tp.thinking = "[cleared]";
-        cleared++;
-      }
-      if (tp.text !== undefined && tp.text !== "[cleared]") {
-        tp.text = "[cleared]";
-        cleared++;
-      }
+
+// src/hooks/magic-context/transform-context-state.ts
+function loadPersistedUsageWatermark(db, sessionId) {
+  const result = db.prepare("SELECT last_response_time FROM session_meta WHERE session_id = ?").get(sessionId);
+  if (result === null || typeof result !== "object")
+    return null;
+  const lastResponseTime = result.last_response_time;
+  return typeof lastResponseTime === "number" ? lastResponseTime : null;
+}
+function loadContextUsage(contextUsageMap, db, sessionId) {
+  const contextUsageEntry = contextUsageMap.get(sessionId);
+  try {
+    const persistedLastResponseTime = loadPersistedUsageWatermark(db, sessionId);
+    const cachedLastResponseTime = contextUsageEntry?.lastResponseTime ?? contextUsageEntry?.updatedAt;
+    if (contextUsageEntry && contextUsageEntry.lastResponseTime === undefined && (persistedLastResponseTime === null || persistedLastResponseTime === 0)) {
+      return contextUsageEntry.usage;
+    }
+    if (contextUsageEntry && cachedLastResponseTime === persistedLastResponseTime) {
+      return contextUsageEntry.usage;
     }
+    const persisted = loadPersistedUsage(db, sessionId);
+    if (persisted) {
+      contextUsageMap.set(sessionId, {
+        ...persisted,
+        lastResponseTime: persistedLastResponseTime ?? persisted.updatedAt,
+        hasUsageTokens: false
+      });
+      return persisted.usage;
+    }
+    contextUsageMap.delete(sessionId);
+  } catch (error) {
+    sessionLog(sessionId, "transform failed loading persisted usage:", error);
+    return contextUsageEntry?.usage ?? { percentage: 0, inputTokens: 0 };
   }
-  return cleared;
+  return { percentage: 0, inputTokens: 0 };
 }
-function replayStrippedInlineThinking(messages, messageTagNumbers, persistedWatermark) {
-  if (persistedWatermark <= 0)
-    return 0;
-  let stripped = 0;
-  for (const message of messages) {
-    if (message.info.role !== "assistant")
-      continue;
-    const msgTag = messageTagNumbers.get(message) ?? 0;
-    if (msgTag === 0 || msgTag > persistedWatermark)
-      continue;
-    for (const part of message.parts) {
-      if (!isRecord(part) || part.type !== "text" || typeof part.text !== "string")
-        continue;
-      if (!part.text.includes("<think"))
-        continue;
-      const cleaned = part.text.replace(INLINE_THINKING_PATTERN, "");
-      if (cleaned !== part.text) {
-        part.text = cleaned;
-        stripped++;
-      }
-    }
+function resolveSchedulerDecision(scheduler, sessionMeta, contextUsage, sessionId, modelKey, contextLimit) {
+  try {
+    const schedulerDecision = scheduler.shouldExecute(sessionMeta, contextUsage, undefined, sessionId, modelKey, contextLimit);
+    sessionLog(sessionId, `transform scheduler: percentage=${contextUsage.percentage.toFixed(1)}% inputTokens=${contextUsage.inputTokens} cacheTtl=${sessionMeta.cacheTtl} lastResponseTime=${sessionMeta.lastResponseTime} decision=${schedulerDecision}`);
+    return schedulerDecision;
+  } catch (error) {
+    sessionLog(sessionId, "transform scheduler failed; defaulting to defer:", error);
+    return "defer";
   }
-  return stripped;
 }
-function clearOldReasoning(messages, reasoningByMessage, messageTagNumbers, clearReasoningAge) {
-  const maxTag = findMaxTag(messageTagNumbers);
-  if (maxTag === 0)
-    return 0;
-  const ageCutoff = maxTag - clearReasoningAge;
-  let cleared = 0;
-  for (const message of messages) {
-    const msgTag = messageTagNumbers.get(message) ?? 0;
-    if (msgTag === 0 || msgTag > ageCutoff)
+
+// src/hooks/magic-context/channel2-cycle.ts
+function rearmChannel2AfterCoverageAdvancingHardFold(input) {
+  if (input.compactionOff || !input.foldExecuted || input.previousCoverage === null || input.currentCoverage === null || input.currentCoverage <= input.previousCoverage) {
+    return false;
+  }
+  return casChannel2NudgeState(input.db, input.sessionId, "delivered", "");
+}
+function rearmChannel2AfterMeasuredCollapse(input) {
+  if (!input.baseline.evaluable || input.baseline.generationInvalidated)
+    return false;
+  if (effectiveTailHygiene(input.baseline).u >= CHANNEL1_FLOOR_TOKENS)
+    return false;
+  return casChannel2NudgeState(input.db, input.sessionId, "delivered", "");
+}
+
+// src/hooks/magic-context/drop-stale-reduce-calls.ts
+var STALE_TOOL_NAMES = new Set(["ctx_reduce"]);
+function isReduceToolPart(part) {
+  if (!isRecord(part))
+    return false;
+  if (part.type === "tool" && typeof part.tool === "string" && STALE_TOOL_NAMES.has(part.tool))
+    return true;
+  if (part.type === "tool-invocation" && typeof part.toolName === "string" && STALE_TOOL_NAMES.has(part.toolName))
+    return true;
+  if (part.type === "tool_use" && typeof part.name === "string" && STALE_TOOL_NAMES.has(part.name))
+    return true;
+  return false;
+}
+function hasAnyMeaningfulPart(parts) {
+  for (const part of parts) {
+    if (!isRecord(part))
       continue;
-    const parts = reasoningByMessage.get(message);
-    if (!parts)
+    if (part.type === "text" && typeof part.text === "string" && part.text.trim().length > 0)
+      return true;
+    if (part.type === "thinking" || part.type === "reasoning" || part.type === "redacted_thinking")
       continue;
-    for (const tp of parts) {
-      if (tp.thinking !== undefined && tp.thinking !== "[cleared]") {
-        tp.thinking = "[cleared]";
-        cleared++;
-      }
-      if (tp.text !== undefined && tp.text !== "[cleared]") {
-        tp.text = "[cleared]";
-        cleared++;
-      }
-    }
+    if (part.type === "meta" || part.type === "step-start" || part.type === "step-finish")
+      continue;
+    if (part.type !== "tool" || !isReduceToolPart(part))
+      return true;
   }
-  return cleared;
+  return false;
 }
-function findMaxTag(messageTagNumbers) {
-  let max = 0;
-  for (const tag of messageTagNumbers.values()) {
-    if (tag > max)
-      max = tag;
+function messageHasReducePart(message) {
+  for (const part of message.parts) {
+    if (isSentinel(part))
+      continue;
+    if (isReduceToolPart(part))
+      return true;
   }
-  return max;
+  return false;
 }
-var CLEARED_REASONING_TYPES = new Set(["thinking", "reasoning"]);
-function stripClearedReasoning(messages) {
-  let stripped = 0;
-  for (const message of messages) {
-    if (message.info.role !== "assistant")
+function sentinelizeReduceParts(message) {
+  let touched = false;
+  for (let j = 0;j < message.parts.length; j++) {
+    const part = message.parts[j];
+    if (isSentinel(part))
       continue;
-    for (let i = 0;i < message.parts.length; i++) {
-      const part = message.parts[i];
-      if (!isRecord(part))
-        continue;
-      const partType = part.type;
-      if (!CLEARED_REASONING_TYPES.has(partType))
-        continue;
-      if (!("thinking" in part) && !("text" in part))
-        continue;
-      const thinking = "thinking" in part ? part.thinking : undefined;
-      const text = "text" in part ? part.text : undefined;
-      const isCleared = (thinking === undefined || thinking === "[cleared]") && (text === undefined || text === "[cleared]");
-      if (!isCleared)
-        continue;
-      message.parts[i] = makeSentinel(part);
-      stripped++;
+    if (isReduceToolPart(part)) {
+      message.parts[j] = makeSentinel(part);
+      touched = true;
     }
   }
-  return stripped;
+  if (touched && !hasAnyMeaningfulPart(message.parts)) {
+    message.parts.length = 0;
+    message.parts.push(makeSentinel(undefined));
+  }
+  return touched;
 }
-var INLINE_THINKING_PATTERN = /<(?:thinking|think)>[\s\S]*?<\/(?:thinking|think)>\s*/g;
-function stripInlineThinking(messages, messageTagNumbers, clearReasoningAge) {
-  const maxTag = findMaxTag(messageTagNumbers);
-  if (maxTag === 0)
-    return 0;
-  const ageCutoff = maxTag - clearReasoningAge;
-  let stripped = 0;
-  for (const message of messages) {
-    if (message.info.role !== "assistant")
-      continue;
-    const msgTag = messageTagNumbers.get(message) ?? 0;
-    if (msgTag === 0 || msgTag > ageCutoff)
+function dropStaleReduceCalls(messages, frozenIds, options = {}) {
+  const detect = options.detect ?? false;
+  const protectedCount = options.protectedCount ?? 0;
+  const protectedStart = messages.length - protectedCount;
+  const newlyStrippedIds = [];
+  let didDrop = false;
+  for (let i = 0;i < messages.length; i++) {
+    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);
+    if (!inFrozen && !isNewDetection)
       continue;
-    for (const part of message.parts) {
-      if (!isRecord(part) || part.type !== "text" || typeof part.text !== "string")
-        continue;
-      const cleaned = part.text.replace(INLINE_THINKING_PATTERN, "");
-      if (cleaned !== part.text) {
-        part.text = cleaned;
-        stripped++;
-      }
+    const touched = sentinelizeReduceParts(message);
+    if (touched) {
+      didDrop = true;
+      if (isNewDetection && id !== undefined)
+        newlyStrippedIds.push(id);
     }
   }
-  return stripped;
+  return { didDrop, newlyStrippedIds };
 }
-var REASONING_IGNORED_PART_TYPES = new Set([
-  "step-start",
-  "step-finish",
-  "snapshot",
-  "patch",
-  "agent",
-  "retry",
-  "subtask",
-  "compaction"
-]);
-var REASONING_PART_TYPES = new Set(["reasoning", "thinking", "redacted_thinking"]);
-function hasReasoningReplayContent(message) {
-  return message.parts.some((part) => {
-    if (!isRecord(part) || part.ignored === true)
-      return false;
-    const type = typeof part.type === "string" ? part.type : "";
-    if (REASONING_IGNORED_PART_TYPES.has(type))
-      return false;
-    return type !== "text" || typeof part.text !== "string" || part.text.trim().length > 0;
-  });
+
+// src/hooks/magic-context/fold-execution-gate.ts
+function foldExecutesThisPass(foldDue, materialized) {
+  return foldDue && materialized;
 }
-function findLatestAssistantReasoningMutationExemptMessage(messages) {
-  for (let index = messages.length - 1;index >= 0; index -= 1) {
-    const message = messages[index];
-    if (message.info.role === "assistant" && hasReasoningReplayContent(message))
-      return message;
+
+// src/hooks/magic-context/system-injection-stripper.ts
+var SYSTEM_INJECTION_MARKERS = [
+  "<!-- OMO_INTERNAL_INITIATOR -->",
+  "[SYSTEM DIRECTIVE: MAGIC-CONTEXT",
+  "[SYSTEM DIRECTIVE: OH-MY-OPENCODE",
+  "[Category+Skill Reminder]",
+  "[EDIT ERROR - IMMEDIATE ACTION REQUIRED]",
+  "[task CALL FAILED - IMMEDIATE RETRY REQUIRED]",
+  "[EMERGENCY CONTEXT WINDOW WARNING]",
+  "Unstable background agent appears idle",
+  "**THE SUBAGENT JUST CLAIMED THIS TASK IS DONE."
+];
+var SYSTEM_REMINDER_REGEX = /<system-reminder>[\s\S]*?<\/system-reminder>/gi;
+var OMO_MARKER_REGEX = /<!-- OMO_INTERNAL_INITIATOR -->/g;
+function stripSystemInjection(text) {
+  let hasInjection = false;
+  for (const marker of SYSTEM_INJECTION_MARKERS) {
+    if (text.includes(marker)) {
+      hasInjection = true;
+      break;
+    }
   }
-  return;
-}
-function planMergedAssistantReasoningStrip(messages, mutationExemptMessage) {
-  const plan = [];
-  let prevRole;
-  let keptReasoningInRun = false;
-  for (const message of messages) {
-    const role = message.info.role;
-    if (role !== "assistant") {
-      prevRole = role;
-      keptReasoningInRun = false;
+  if (SYSTEM_REMINDER_REGEX.test(text))
+    hasInjection = true;
+  SYSTEM_REMINDER_REGEX.lastIndex = 0;
+  if (!hasInjection)
+    return null;
+  let cleaned = text;
+  cleaned = cleaned.replace(SYSTEM_REMINDER_REGEX, "");
+  cleaned = cleaned.replace(OMO_MARKER_REGEX, "");
+  cleaned = cleaned.replace(/\[SYSTEM DIRECTIVE: OH-MY-(?:OPENCODE|CLAUDE)[^\]]*\][\s\S]*?(?=\n\n(?!\s*[-*])|$)/g, "");
+  for (const marker of SYSTEM_INJECTION_MARKERS) {
+    if (marker.startsWith("<!-- ") || marker.startsWith("[SYSTEM DIRECTIVE"))
       continue;
-    }
-    const firstInRun = prevRole !== "assistant";
-    if (firstInRun)
-      keptReasoningInRun = false;
-    if (message === mutationExemptMessage) {
-      prevRole = role;
+    const idx = cleaned.indexOf(marker);
+    if (idx === -1)
       continue;
+    const blockEnd = cleaned.indexOf(`
+
+`, idx + marker.length);
+    cleaned = blockEnd !== -1 ? cleaned.slice(0, idx) + cleaned.slice(blockEnd) : cleaned.slice(0, idx);
+  }
+  return cleaned.trim();
+}
+
+// src/hooks/magic-context/heuristic-cleanup.ts
+var DEDUP_SAFE_TOOLS = new Set([
+  "mcp_grep",
+  "mcp_read",
+  "mcp_glob",
+  "mcp_ast_grep_search",
+  "mcp_lsp_diagnostics",
+  "mcp_lsp_symbols",
+  "mcp_lsp_find_references",
+  "mcp_lsp_goto_definition",
+  "mcp_lsp_prepare_rename"
+]);
+function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config, preloadedTags) {
+  const tags = preloadedTags ?? getActiveTagsBySession(db, sessionId);
+  const maxTag = getMaxTagNumberBySession(db, sessionId);
+  const protectedCutoff = maxTag - config.protectedTags;
+  let droppedTools = 0;
+  let emergencyDroppedTools = 0;
+  let emergencyReclaimedTokens = 0;
+  let deduplicatedTools = 0;
+  let droppedInjections = 0;
+  if (config.emergency) {
+    const emergency = config.emergency;
+    const priorInputSample = getEmergencyInputSample(db, sessionId);
+    const droppableTags = tags.filter((t) => t.status === "active" && t.type === "tool" && targets.get(t.tagNumber)?.canDrop?.());
+    const activeTags = tags.filter((t) => t.status === "active");
+    const plan = planEmergencyDrop({
+      tags: droppableTags,
+      floorTags: activeTags,
+      maxTag,
+      protectedTags: config.protectedTags,
+      currentTotalInputTokens: emergency.currentTotalInputTokens,
+      ceilingTokens: emergency.ceilingTokens,
+      priorInputSample,
+      hasPriorDrop: priorInputSample > 0
+    });
+    if (plan.shouldDrop) {
+      const toDrop = new Set(plan.tagNumbers);
+      const newestEmergencyTags = new Set(droppableTags.slice().sort((left, right) => right.tagNumber - left.tagNumber).slice(0, 20).map((tag) => tag.tagNumber));
+      db.transaction(() => {
+        for (const tag of tags) {
+          if (!toDrop.has(tag.tagNumber))
+            continue;
+          if (tag.status !== "active" || tag.type !== "tool")
+            continue;
+          const target = targets.get(tag.tagNumber);
+          const recent = newestEmergencyTags.has(tag.tagNumber);
+          const result = recent ? target?.truncate?.() ?? target?.drop?.() ?? "absent" : target?.drop?.() ?? "absent";
+          if (result === "removed" || result === "truncated") {
+            updateTagStatus(db, sessionId, tag.tagNumber, "dropped");
+            updateTagDropMode(db, sessionId, tag.tagNumber, recent ? "truncated" : "full");
+            droppedTools++;
+            emergencyDroppedTools++;
+            emergencyReclaimedTokens += estimateEmergencyDropReclaimTokens(tag);
+          }
+        }
+      })();
+      sessionLog(sessionId, `emergency tiered drop: ${plan.reason}`);
+    } else {
+      sessionLog(sessionId, `emergency tiered drop skipped: ${plan.reason}`);
     }
-    let keepIndex = -1;
-    if (firstInRun && !keptReasoningInRun) {
-      for (let i = 0;i < message.parts.length; i++) {
-        const part = message.parts[i];
-        if (!isRecord(part))
+    setEmergencyDropSample(db, sessionId, emergency.currentTotalInputTokens);
+  }
+  if (config.routine !== false) {
+    db.transaction(() => {
+      for (const tag of tags) {
+        if (tag.status !== "active")
           continue;
-        const partType = part.type;
-        if (REASONING_IGNORED_PART_TYPES.has(partType))
+        if (tag.tagNumber > protectedCutoff)
           continue;
-        if (part.ignored === true)
+        if (tag.type !== "message")
           continue;
-        if (isSentinel(part))
+        const target = targets.get(tag.tagNumber);
+        if (!target)
           continue;
-        if (partType === "text" && typeof part.text === "string" && part.text.trim() === "") {
+        const content = target.getContent?.();
+        if (!content)
           continue;
+        const stripped = stripSystemInjection(content);
+        if (stripped === null)
+          continue;
+        const strippedSource = stripTagPrefix(stripped);
+        if (strippedSource.trim().length === 0) {
+          const dropResult = target.drop?.() ?? "absent";
+          const didReplace = dropResult === "absent" ? target.setContent(`[dropped §${tag.tagNumber}§]`) : false;
+          if (dropResult === "removed" || dropResult === "absent") {
+            replaceSourceContent(db, sessionId, tag.tagNumber, "");
+            updateTagStatus(db, sessionId, tag.tagNumber, "dropped");
+            if (dropResult === "removed" || didReplace) {
+              droppedInjections++;
+            }
+          }
+        } else {
+          const didSet = target.setContent(stripped);
+          if (didSet) {
+            replaceSourceContent(db, sessionId, tag.tagNumber, strippedSource);
+            droppedInjections++;
+          }
         }
-        if (REASONING_PART_TYPES.has(partType)) {
-          keepIndex = i;
-        }
-        break;
+      }
+    })();
+  }
+  const allMessages = Array.from(messageTagNumbers.keys());
+  const toolFingerprints = buildToolFingerprints(allMessages);
+  if (config.routine !== false && toolFingerprints.size > 0) {
+    const tagsByCompositeKey = new Map;
+    for (const tag of tags) {
+      if (tag.type === "tool" && tag.status === "active" && tag.messageId) {
+        const key = tag.toolOwnerMessageId ? `${tag.toolOwnerMessageId}\x00${tag.messageId}` : tag.messageId;
+        tagsByCompositeKey.set(key, tag);
       }
     }
-    const stripIndices = [];
-    for (let i = 0;i < message.parts.length; i++) {
-      const part = message.parts[i];
-      if (!isRecord(part))
-        continue;
-      if (!REASONING_PART_TYPES.has(part.type))
-        continue;
-      if (part.cache_control !== undefined)
-        continue;
-      if (i === keepIndex) {
-        keptReasoningInRun = true;
+    const fingerprintGroups = new Map;
+    for (const [compositeKey, fingerprint] of toolFingerprints) {
+      const tag = tagsByCompositeKey.get(compositeKey);
+      if (!tag || tag.tagNumber > protectedCutoff)
         continue;
-      }
-      stripIndices.push(i);
+      const group = fingerprintGroups.get(fingerprint) ?? [];
+      group.push(tag);
+      fingerprintGroups.set(fingerprint, group);
     }
-    if (stripIndices.length > 0)
-      plan.push({ message, stripIndices });
-    prevRole = role;
-  }
-  return plan;
-}
-var MAX_FROZEN_TRAILING_BLANKS = 1e4;
-var CANONICAL_BLANK_PART = { type: "text", text: "" };
-function isSentinelInvisibleTextPart(part) {
-  return isRecord(part) && part.type === "text" && typeof part.text === "string" && part.text.trim() === "";
-}
-function isCanonicalBlankPart(part) {
-  return isRecord(part) && Object.keys(part).length === 2 && part.type === "text" && part.text === "";
-}
-function trailingBlankKeepCount(decision) {
-  if (decision === "keep")
-    return 1;
-  if (!decision.startsWith("keep:"))
-    return;
-  const countText = decision.slice("keep:".length);
-  if (!/^[1-9]\d*$/.test(countText))
-    return;
-  const count = Number(countText);
-  return Number.isSafeInteger(count) && count > 0 && count <= MAX_FROZEN_TRAILING_BLANKS ? count : undefined;
-}
-function trailingBlankDecisionForMessage(message) {
-  const id = message.info.id;
-  if (message.info.role !== "assistant" || typeof id !== "string" || id.length === 0) {
-    return;
+    db.transaction(() => {
+      for (const [, group] of fingerprintGroups) {
+        if (group.length <= 1)
+          continue;
+        group.sort((a, b) => a.tagNumber - b.tagNumber);
+        for (let i = 0;i < group.length - 1; i++) {
+          const tag = group[i];
+          const target = targets.get(tag.tagNumber);
+          const result = target?.drop?.() ?? "absent";
+          if (result === "incomplete")
+            continue;
+          updateTagDropMode(db, sessionId, tag.tagNumber, "full");
+          updateTagStatus(db, sessionId, tag.tagNumber, "dropped");
+          if (result === "removed" || result === "truncated") {
+            deduplicatedTools++;
+          }
+        }
+      }
+    })();
   }
-  let trailingCount = 0;
-  while (trailingCount < message.parts.length && isSentinelInvisibleTextPart(message.parts[message.parts.length - trailingCount - 1])) {
-    trailingCount += 1;
+  if (droppedTools > 0 || deduplicatedTools > 0 || droppedInjections > 0) {
+    sessionLog(sessionId, `heuristic cleanup: dropped ${droppedTools} tool tags, deduplicated ${deduplicatedTools} tool calls, dropped ${droppedInjections} system injections`);
   }
-  if (trailingCount > MAX_FROZEN_TRAILING_BLANKS && trailingCount < message.parts.length) {
-    return;
+  let compressedTextTags = 0;
+  let mutatedTextTags = 0;
+  if (config.routine !== false && config.caveman?.enabled) {
+    const cavemanResult = applyCavemanCleanup(sessionId, db, targets, tags, {
+      enabled: true,
+      minChars: config.caveman.minChars,
+      protectedTags: config.protectedTags
+    });
+    compressedTextTags = cavemanResult.compressedToLite + cavemanResult.compressedToFull + cavemanResult.compressedToUltra;
+    mutatedTextTags = cavemanResult.mutatedTextTags;
   }
-  const decision = message.parts.length === 0 || trailingCount === message.parts.length ? "keep" : trailingCount === 0 ? "strip" : trailingCount === 1 ? "keep" : `keep:${trailingCount}`;
-  return [id, decision];
+  return {
+    droppedTools,
+    deduplicatedTools,
+    droppedInjections,
+    emergencyDroppedTools,
+    emergencyReclaimedTokens,
+    compressedTextTags,
+    mutatedTextTags
+  };
 }
-function snapshotTrailingBlankSourceDecisions(messages) {
-  const decisions = new Map;
-  for (const message of messages) {
-    const observed = trailingBlankDecisionForMessage(message);
-    if (observed)
-      decisions.set(...observed);
+function extractToolInfo(part) {
+  if (part.type === "tool" && typeof part.tool === "string" && DEDUP_SAFE_TOOLS.has(part.tool)) {
+    const state = typeof part.state === "object" && part.state !== null ? part.state : {};
+    return { toolName: part.tool, args: state.input ?? {} };
   }
-  return decisions;
-}
-function findTrailingBlankDecisionCandidates(messages, frozenDecisions, options) {
-  const observedDecisions = options?.sourceDecisions ?? snapshotTrailingBlankSourceDecisions(messages);
-  const visibleIds = new Set(messages.flatMap((message) => typeof message.info.id === "string" ? [message.info.id] : []));
-  const decisions = [];
-  for (const [id, decision] of observedDecisions) {
-    if (!visibleIds.has(id))
-      continue;
-    const frozen = frozenDecisions.get(id);
-    if (frozen !== undefined && (id !== options?.refreshMessageId || frozen === decision)) {
-      continue;
-    }
-    decisions.push([id, decision]);
+  if (part.type === "tool-invocation" && typeof part.toolName === "string" && DEDUP_SAFE_TOOLS.has(part.toolName)) {
+    return { toolName: part.toolName, args: part.args ?? {} };
   }
-  return decisions;
+  if (part.type === "tool_use" && typeof part.name === "string" && DEDUP_SAFE_TOOLS.has(part.name)) {
+    return { toolName: part.name, args: part.input ?? {} };
+  }
+  return null;
 }
-function applyFrozenTrailingBlankDecisions(messages, newestAssistantId, frozenDecisions) {
-  let mutations = 0;
-  for (let messageIndex = 0;messageIndex < messages.length; messageIndex += 1) {
-    let message = messages[messageIndex];
-    const id = message.info.id;
-    if (message.info.role !== "assistant" || typeof id !== "string")
+function buildToolFingerprints(messages) {
+  const fingerprints = new Map;
+  for (const message of messages) {
+    if (message.info.role !== "assistant")
       continue;
-    const decision = frozenDecisions.get(id);
-    if (!decision)
+    const ownerMsgId = typeof message.info.id === "string" ? message.info.id : null;
+    if (!ownerMsgId)
       continue;
-    let lastMeaningfulIndex = message.parts.length - 1;
-    while (lastMeaningfulIndex >= 0 && isSentinelInvisibleTextPart(message.parts[lastMeaningfulIndex])) {
-      lastMeaningfulIndex -= 1;
-    }
-    const replaceParts = (start, deleteCount, insertBlankCount) => {
-      message = { ...message, parts: [...message.parts] };
-      messages[messageIndex] = message;
-      message.parts.splice(start, deleteCount, ...Array.from({ length: insertBlankCount }, () => ({ ...CANONICAL_BLANK_PART })));
-    };
-    if (lastMeaningfulIndex < 0) {
-      if (message.parts.length === 0)
+    for (const part of message.parts) {
+      const record = part;
+      const info = extractToolInfo(record);
+      if (!info)
         continue;
-      if (message.parts.length !== 1 || !isCanonicalBlankPart(message.parts[0])) {
-        mutations += Math.max(1, message.parts.length);
-        replaceParts(0, message.parts.length, 1);
-      }
-      continue;
-    }
-    const trailingCount = message.parts.length - lastMeaningfulIndex - 1;
-    const keepCount = trailingBlankKeepCount(decision);
-    if (keepCount !== undefined) {
-      if (trailingCount === 0)
+      const callId = extractCallId(record);
+      if (!callId)
         continue;
-      const blankIndex = lastMeaningfulIndex + 1;
-      const suffixIsCanonical = trailingCount === keepCount && message.parts.slice(blankIndex).every(isCanonicalBlankPart);
-      if (!suffixIsCanonical) {
-        mutations += Math.max(1, trailingCount, keepCount);
-        replaceParts(blankIndex, trailingCount, keepCount);
-      }
-      continue;
-    }
-    if (id === newestAssistantId || trailingCount === 0)
-      continue;
-    const lastMeaningfulPart = message.parts[lastMeaningfulIndex];
-    if (isRecord(lastMeaningfulPart) && REASONING_PART_TYPES.has(lastMeaningfulPart.type)) {
-      const blankIndex = lastMeaningfulIndex + 1;
-      if (trailingCount !== 1 || !isCanonicalBlankPart(message.parts[blankIndex])) {
-        mutations += Math.max(1, trailingCount);
-        replaceParts(blankIndex, trailingCount, 1);
-      }
-      continue;
+      try {
+        const fingerprint = `${ownerMsgId}:${info.toolName}:${JSON.stringify(info.args)}`;
+        const compositeKey = `${ownerMsgId}\x00${callId}`;
+        fingerprints.set(compositeKey, fingerprint);
+      } catch {}
     }
-    mutations += trailingCount;
-    replaceParts(lastMeaningfulIndex + 1, trailingCount, 0);
   }
-  return mutations;
+  return fingerprints;
 }
-function findMergedReasoningStripCandidateIds(messages, providerID, options) {
-  if (providerID !== "anthropic")
-    return [];
-  const ids = new Set;
-  for (const entry of planMergedAssistantReasoningStrip(messages, options?.mutationExemptMessage)) {
-    const id = entry.message.info.id;
-    if (typeof id === "string" && id.length > 0)
-      ids.add(id);
-  }
-  return [...ids];
+function extractCallId(part) {
+  if (part.type === "tool" && typeof part.callID === "string")
+    return part.callID;
+  if (part.type === "tool-invocation" && typeof part.callID === "string")
+    return part.callID;
+  if (part.type === "tool_use" && typeof part.id === "string")
+    return part.id;
+  return null;
 }
-function stripReasoningFromMergedAssistants(messages, providerID, options) {
-  if (providerID !== "anthropic")
-    return 0;
-  let stripped = 0;
-  for (const entry of planMergedAssistantReasoningStrip(messages, options?.mutationExemptMessage)) {
-    if (options?.frozenMessageIds) {
-      const id = entry.message.info.id;
-      if (typeof id !== "string" || !options.frozenMessageIds.has(id))
+
+// src/hooks/magic-context/note-visibility.ts
+var NOTE_TOOL_NAMES = new Set(["ctx_note"]);
+var READ_ACTION = "read";
+function hasVisibleNoteReadCall(messages) {
+  for (let i = messages.length - 1;i >= 0; i -= 1) {
+    const parts = messages[i]?.parts;
+    if (!Array.isArray(parts))
+      continue;
+    for (const part of parts) {
+      if (isSentinel(part))
         continue;
-    }
-    for (const index of entry.stripIndices) {
-      entry.message.parts[index] = makeSentinel(entry.message.parts[index]);
-      stripped++;
+      if (isVisibleNoteReadPart(part))
+        return true;
     }
   }
-  return stripped;
+  return false;
 }
-function stripProcessedImages(messages, frozenIds, options) {
-  const { detect, watermark, messageTagNumbers } = options;
-  let stripped = 0;
-  const newlyStrippedIds = [];
-  let hasAssistantResponse = false;
-  for (let i = messages.length - 1;i >= 0; i--) {
-    const msg = messages[i];
-    if (msg.info.role === "assistant") {
-      hasAssistantResponse = true;
-      continue;
-    }
-    if (msg.info.role !== "user") {
-      continue;
-    }
-    const id = typeof msg.info.id === "string" ? msg.info.id : undefined;
-    const inFrozen = id !== undefined && frozenIds.has(id);
-    const maxTag = messageTagNumbers.get(msg) ?? 0;
-    const isNewDetection = !inFrozen && detect && hasAssistantResponse && id !== undefined && maxTag <= watermark;
-    if (!inFrozen && !isNewDetection) {
-      continue;
+function isVisibleNoteReadPart(part) {
+  if (!isRecord(part))
+    return false;
+  if (part.type === "tool" && typeof part.tool === "string" && NOTE_TOOL_NAMES.has(part.tool)) {
+    const state = part.state;
+    if (isRecord(state) && isRecord(state.input)) {
+      return state.input.action === READ_ACTION;
     }
-    let touchedThisMsg = false;
-    for (let j = 0;j < msg.parts.length; j++) {
-      const part = msg.parts[j];
-      if (!isRecord(part) || part.type !== "file") {
-        continue;
-      }
-      if (typeof part.mime !== "string" || !part.mime.startsWith("image/")) {
-        continue;
-      }
-      if (typeof part.url === "string" && part.url.startsWith("data:") && part.url.length > 200) {
-        msg.parts[j] = makeSentinel(part);
-        stripped++;
-        touchedThisMsg = true;
-      }
+    return false;
+  }
+  if (part.type === "tool_use" && typeof part.name === "string" && NOTE_TOOL_NAMES.has(part.name)) {
+    if (isRecord(part.input)) {
+      return part.input.action === READ_ACTION;
     }
-    if (touchedThisMsg && isNewDetection && id !== undefined) {
-      newlyStrippedIds.push(id);
+    return false;
+  }
+  if (part.type === "tool-invocation" && typeof part.toolName === "string" && NOTE_TOOL_NAMES.has(part.toolName)) {
+    const argsCandidate = part.args ?? part.input;
+    if (isRecord(argsCandidate)) {
+      return argsCandidate.action === READ_ACTION;
     }
+    return false;
   }
-  return { stripped, newlyStrippedIds };
+  return false;
 }
 
 // src/hooks/magic-context/supersession-reclaim.ts
@@ -32395,14 +32532,15 @@ function createExistingTagResolver(sessionId, tagger, db) {
     return cachedScopedAssignments;
   }
   return {
-    resolve(messageId2, type, currentContentId, ordinal) {
+    resolve(messageId2, type, currentContentId, ordinal, options) {
+      const accept = options?.accept ?? (() => true);
       const exactTagId = assignments.get(currentContentId);
-      if (exactTagId !== undefined) {
+      if (exactTagId !== undefined && accept(exactTagId)) {
         usedTagNumbers.add(exactTagId);
         return exactTagId;
       }
       const fallback = getScopedAssignments().get(messageId2)?.[type][ordinal];
-      if (!fallback || usedTagNumbers.has(fallback.tagNumber)) {
+      if (!fallback || usedTagNumbers.has(fallback.tagNumber) || !accept(fallback.tagNumber)) {
         return;
       }
       updateTagMessageId(db, sessionId, fallback.tagNumber, currentContentId);
@@ -32594,6 +32732,21 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
   };
   const ownerByPartKey = new Map;
   const batch = new ToolMutationBatch(messages);
+  const inertWhitespaceTagNumbers = new Set;
+  const inertWhitespaceTagsByMessage = new Map;
+  for (const tag of getInertWhitespaceAssistantTags(db, sessionId)) {
+    inertWhitespaceTagNumbers.add(tag.tagNumber);
+    tagger.bindTag(sessionId, tag.contentId, tag.tagNumber);
+    const scoped = /^(.*):p(\d+)$/.exec(tag.contentId);
+    if (!scoped)
+      continue;
+    const list = inertWhitespaceTagsByMessage.get(scoped[1]) ?? [];
+    list.push({ partIndex: Number(scoped[2]), tagNumber: tag.tagNumber });
+    inertWhitespaceTagsByMessage.set(scoped[1], list);
+  }
+  for (const list of inertWhitespaceTagsByMessage.values()) {
+    list.sort((left, right) => left.partIndex - right.partIndex);
+  }
   const assignments = tagger.getAssignments(sessionId);
   const resolver = createExistingTagResolver(sessionId, tagger, db);
   const tGetSourceContents = performance.now();
@@ -32622,6 +32775,7 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
     const messageHasTextPart = message.parts.some(isTextPart);
     let textOrdinal = 0;
     let fileOrdinal = 0;
+    let whitespaceRank = 0;
     for (let partIndex = 0;partIndex < message.parts.length; partIndex += 1) {
       const part = message.parts[partIndex];
       if (isReduceToolPart(part)) {
@@ -32677,7 +32831,47 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
         const textPart = part;
         const thinkingParts = messageThinkingParts;
         const contentId = `${messageId2}:p${partIndex}`;
-        resolver.resolve(messageId2, "message", contentId, textOrdinal);
+        const whitespaceOnlyAssistant = message.info.role === "assistant" && stripTagPrefix(textPart.text).trim().length === 0;
+        let existingTagId;
+        if (whitespaceOnlyAssistant) {
+          const persistedWhitespaceTag = getTagNumberByMessageId(db, sessionId, contentId);
+          const rankedInertTag = inertWhitespaceTagsByMessage.get(messageId2)?.[whitespaceRank];
+          const canReplayRankedTag = rankedInertTag?.partIndex === partIndex || isThinkingPart(message.parts[partIndex - 1]) || isThinkingPart(message.parts[partIndex + 1]);
+          const inertForThisPart = canReplayRankedTag ? rankedInertTag?.tagNumber : undefined;
+          whitespaceRank += 1;
+          if (inertForThisPart !== undefined) {
+            tagger.bindTag(sessionId, contentId, inertForThisPart);
+            existingTagId = inertForThisPart;
+          } else {
+            existingTagId = resolver.resolve(messageId2, "message", contentId, textOrdinal, { accept: (tagNumber) => tagNumber === persistedWhitespaceTag });
+          }
+          if (existingTagId === undefined) {
+            const persisted = getTagNumberByMessageId(db, sessionId, contentId);
+            if (persisted !== null && !getSourceContents(db, sessionId, [persisted]).has(persisted)) {
+              tagger.bindTag(sessionId, contentId, persisted);
+              existingTagId = persisted;
+            }
+          }
+          if (existingTagId === undefined) {
+            textOrdinal += 1;
+            continue;
+          }
+          const existingTag = getTagById(db, sessionId, existingTagId);
+          if (!existingTag || existingTag.type !== "message") {
+            tagger.unbindTag(sessionId, contentId);
+            textOrdinal += 1;
+            continue;
+          }
+          if (existingTag.status === "active") {
+            markWhitespaceAssistantTagInert(db, sessionId, existingTagId, contentId);
+            inertWhitespaceTagNumbers.add(existingTagId);
+          }
+        } else {
+          const resolved = resolver.resolve(messageId2, "message", contentId, textOrdinal, { accept: (tagNumber) => !inertWhitespaceTagNumbers.has(tagNumber) });
+          if (resolved === undefined && inertWhitespaceTagNumbers.has(tagger.getTag(sessionId, contentId, "message") ?? -1)) {
+            tagger.unbindTag(sessionId, contentId);
+          }
+        }
         const reasoningBytes = textOrdinal === 0 ? getReasoningByteSize(thinkingParts) : 0;
         const reasoningTokens = textOrdinal === 0 ? getReasoningTokenCount(thinkingParts) : 0;
         const _tAssignText = performance.now();
@@ -32947,11 +33141,24 @@ async function applyTodoSynthesis(args) {
   }
   return 0;
 }
+function replayRustModeBindingMismatchStrips(args) {
+  if (!modelAcceptsEmptyContent(args.resolvedProviderID))
+    return;
+  const recoveryMessageIds = new Set;
+  for (const id of getMergedReasoningStrippedIds(args.db, args.sessionId)) {
+    if (!id.startsWith(THINKING_BINDING_RECOVERY_FROZEN_PREFIX))
+      continue;
+    const messageId2 = id.slice(THINKING_BINDING_RECOVERY_FROZEN_PREFIX.length);
+    if (messageId2.length > 0)
+      recoveryMessageIds.add(messageId2);
+  }
+  stripReasoningFromAssistantIds(args.messages, args.resolvedProviderID, recoveryMessageIds);
+}
 function runRustModePostprocess(args) {
   if (!args.fullFeatureMode || args.compactionOff)
-    return;
+    return { thinkingBindingRecovery: null };
   if (args.messages.some((message) => !message || typeof message !== "object" || !isRecord(message.info))) {
-    return;
+    return { thinkingBindingRecovery: null };
   }
   reconcileMarkerRepresentation(args.messages, getPersistedCompactionMarkerState(args.db, args.sessionId), {
     db: args.db,
@@ -32967,21 +33174,80 @@ function runRustModePostprocess(args) {
       appendReminderToUserMessageById(args.messages, decision.messageId, decision.text);
     }
   }
+  const trailingBlankDecisions = new Map;
+  if (modelAcceptsEmptyContent(args.resolvedProviderID)) {
+    try {
+      for (const [id, decision] of getTrailingBlankDecisions(args.db, args.sessionId)) {
+        trailingBlankDecisions.set(id, decision);
+      }
+      const candidates = findTrailingBlankDecisionCandidates(args.messages, trailingBlankDecisions, { sourceDecisions: args.trailingBlankSourceDecisions }).filter(([id]) => id === args.trailingBlankNewestAssistantId);
+      if (candidates.length > 0) {
+        const persisted = addTrailingBlankDecisions(args.db, args.sessionId, candidates, {
+          overwriteMessageId: args.trailingBlankNewestAssistantId
+        });
+        if (persisted) {
+          const committed = getTrailingBlankDecisions(args.db, args.sessionId);
+          for (const [id] of candidates) {
+            const decision = committed.get(id);
+            if (decision)
+              trailingBlankDecisions.set(id, decision);
+          }
+        } else {
+          sessionLog(args.sessionId, "rust trailing blank decision: persistence failed; serving only frozen decisions");
+        }
+      }
+    } catch (error) {
+      sessionLog(args.sessionId, "rust trailing blank decision failed:", error);
+    }
+  }
+  const absorbingStripDecisions = new Map([...trailingBlankDecisions].filter(([, decision]) => decision === "strip"));
+  applyFrozenTrailingBlankDecisions(args.messages, absorbingStripDecisions);
   const currentUserMessageId = findLastUserMessageId(args.messages);
   const noteReadStillVisible = hasVisibleNoteReadCall(args.messages);
   const deferredNoteText = peekNoteNudgeText(args.db, args.sessionId, currentUserMessageId, args.projectPath, noteReadStillVisible);
-  if (!deferredNoteText)
-    return;
-  const instruction = `
+  if (deferredNoteText) {
+    const instruction = `
 
 <instruction name="deferred_notes">${deferredNoteText}</instruction>`;
-  const anchoredMessageId = findLastUserMessageId(args.messages);
-  const outcome = markNoteNudgeDelivered(args.db, args.sessionId, instruction, anchoredMessageId);
-  if (anchoredMessageId && outcome.ok) {
-    appendReminderToUserMessageById(args.messages, anchoredMessageId, instruction);
-  } else if (anchoredMessageId && !outcome.ok) {
-    sessionLog(args.sessionId, `rust note-nudge delivery skipped wire append: ${outcome.kind}`);
+    const anchoredMessageId = findLastUserMessageId(args.messages);
+    const outcome = markNoteNudgeDelivered(args.db, args.sessionId, instruction, anchoredMessageId);
+    if (anchoredMessageId && outcome.ok) {
+      appendReminderToUserMessageById(args.messages, anchoredMessageId, instruction);
+    } else if (anchoredMessageId && !outcome.ok) {
+      sessionLog(args.sessionId, `rust note-nudge delivery skipped wire append: ${outcome.kind}`);
+    }
+  }
+  const recoveryMessageIds = new Set;
+  let thinkingBindingRecovery = null;
+  if (modelAcceptsEmptyContent(args.resolvedProviderID)) {
+    try {
+      for (const id of getMergedReasoningStrippedIds(args.db, args.sessionId)) {
+        if (!id.startsWith(THINKING_BINDING_RECOVERY_FROZEN_PREFIX))
+          continue;
+        const messageId2 = id.slice(THINKING_BINDING_RECOVERY_FROZEN_PREFIX.length);
+        if (messageId2.length > 0)
+          recoveryMessageIds.add(messageId2);
+      }
+      const flagTarget = args.thinkingBindingRecoveryEnabledForModel ? getThinkingBindingRecoveryTarget(args.db, args.sessionId) : null;
+      if (flagTarget) {
+        const messageId2 = flagTarget === NEWEST_REASONING_BEARING_ASSISTANT ? findNewestReasoningBearingAssistantId(args.messages) : flagTarget;
+        if (messageId2 && assistantHasReasoningPart(args.messages, messageId2)) {
+          const frozenId = thinkingBindingRecoveryFrozenId(messageId2);
+          const persisted = recoveryMessageIds.has(messageId2) || addMergedReasoningStrippedIds(args.db, args.sessionId, [frozenId]);
+          if (persisted) {
+            recoveryMessageIds.add(messageId2);
+            thinkingBindingRecovery = { flagTarget, messageId: messageId2 };
+          } else {
+            sessionLog(args.sessionId, "rust thinking binding recovery: persistence failed; leaving the bound block intact");
+          }
+        }
+      }
+    } catch (error) {
+      sessionLog(args.sessionId, "rust thinking binding recovery failed:", error);
+    }
+    stripReasoningFromAssistantIds(args.messages, args.resolvedProviderID, recoveryMessageIds);
   }
+  return { thinkingBindingRecovery };
 }
 function dropMarkerSummaryTag(db, sessionId, summaryMessageId) {
   const tagNumber = getTagNumberByMessageId(db, sessionId, `${summaryMessageId}:p0`);
@@ -33105,22 +33371,13 @@ function finalizeMessageRepresentation(messages, resolvedProviderID, options) {
       clearedParts = stripClearedReasoning(targetedMessages);
     }
   }
-  let newestAssistant = options?.trailingBlankNewestAssistant;
-  if (!newestAssistant) {
-    for (let index = messages.length - 1;index >= 0; index -= 1) {
-      const message = messages[index];
-      if (message.info.role !== "assistant")
-        continue;
-      newestAssistant = message;
-      break;
-    }
-  }
-  const mergedReasoningParts = options?.skipMergedReasoningStrip ? 0 : stripReasoningFromMergedAssistants(messages, resolvedProviderID, {
+  const bindingRecoveryParts = options?.skipMergedReasoningStrip ? 0 : stripReasoningFromAssistantIds(messages, resolvedProviderID, options?.thinkingBindingRecoveryMessageIds ?? new Set);
+  const mergedReasoningParts = bindingRecoveryParts + (options?.skipMergedReasoningStrip ? 0 : stripReasoningFromMergedAssistants(messages, resolvedProviderID, {
     mutationExemptMessage: options?.reasoningMutationExemptMessage,
     frozenMessageIds: options?.mergedReasoningStrippedIds
-  });
+  }));
   if (!options?.skipTrailingWhitespaceStrip && modelAcceptsEmptyContent(resolvedProviderID)) {
-    applyFrozenTrailingBlankDecisions(messages, typeof newestAssistant?.info.id === "string" ? newestAssistant.info.id : undefined, options?.trailingBlankDecisions ?? new Map);
+    applyFrozenTrailingBlankDecisions(messages, options?.trailingBlankDecisions ?? new Map);
   }
   return { clearedParts, mergedReasoningParts };
 }
@@ -33778,10 +34035,34 @@ async function runPostTransformPhase(args) {
     }
   }
   const mergedReasoningStrippedIds = new Set;
+  const thinkingBindingRecoveryMessageIds = new Set;
+  let thinkingBindingRecovery = null;
   if (canUseEmptySentinels && !compactionOff) {
     try {
       for (const id of getMergedReasoningStrippedIds(args.db, args.sessionId)) {
         mergedReasoningStrippedIds.add(id);
+        if (id.startsWith(THINKING_BINDING_RECOVERY_FROZEN_PREFIX)) {
+          const messageId2 = id.slice(THINKING_BINDING_RECOVERY_FROZEN_PREFIX.length);
+          if (messageId2.length > 0)
+            thinkingBindingRecoveryMessageIds.add(messageId2);
+        }
+      }
+      const flagTarget = args.thinkingBindingRecoveryEnabledForModel ? getThinkingBindingRecoveryTarget(args.db, args.sessionId) : null;
+      if (flagTarget) {
+        const messageId2 = flagTarget === NEWEST_REASONING_BEARING_ASSISTANT ? findNewestReasoningBearingAssistantId(args.messages) : flagTarget;
+        if (messageId2 && assistantHasReasoningPart(args.messages, messageId2)) {
+          const frozenId = thinkingBindingRecoveryFrozenId(messageId2);
+          const persisted = mergedReasoningStrippedIds.has(frozenId) || addMergedReasoningStrippedIds(args.db, args.sessionId, [frozenId]);
+          if (persisted) {
+            mergedReasoningStrippedIds.add(frozenId);
+            thinkingBindingRecoveryMessageIds.add(messageId2);
+            thinkingBindingRecovery = { flagTarget, messageId: messageId2 };
+            bustedThisPass = true;
+          } else {
+            args.passOutcome?.record("thinking-binding-recovery-persistence-failure");
+            sessionLog(args.sessionId, "thinking binding recovery: persistence failed; leaving the bound block intact");
+          }
+        }
       }
       if (isCacheBustingPass) {
         const candidates = findMergedReasoningStripCandidateIds(args.messages, args.resolvedProviderID, { mutationExemptMessage: reasoningMutationExemptMessage });
@@ -33845,17 +34126,6 @@ async function runPostTransformPhase(args) {
       }
     }
   }
-  const tFinalRepresentation = performance.now();
-  const finalRepresentation = finalizeMessageRepresentation(args.messages, args.resolvedProviderID, {
-    prependedMessageCount,
-    reasoningMutatedMessages,
-    reasoningMutationExemptMessage,
-    trailingBlankNewestAssistant,
-    mergedReasoningStrippedIds,
-    trailingBlankDecisions,
-    skipMergedReasoningStrip: compactionOff,
-    skipTrailingWhitespaceStrip: compactionOff
-  });
   if (canUseEmptySentinels && !compactionOff) {
     const detectedCandidates = findTrailingBlankDecisionCandidates(args.messages, trailingBlankDecisions, {
       refreshMessageId: newestAssistantId,
@@ -33869,20 +34139,16 @@ async function runPostTransformPhase(args) {
         });
         if (persisted) {
           const committed = getTrailingBlankDecisions(args.db, args.sessionId);
-          const newlyFrozen = new Map;
           for (const [id] of candidates) {
             const decision = committed.get(id);
-            if (!decision)
-              continue;
-            trailingBlankDecisions.set(id, decision);
-            newlyFrozen.set(id, decision);
+            if (decision)
+              trailingBlankDecisions.set(id, decision);
           }
-          applyFrozenTrailingBlankDecisions(args.messages, newestAssistantId, newlyFrozen);
           if (isCacheBustingPass)
             bustedThisPass = true;
         } else {
           args.passOutcome?.record("trailing-blank-decision-persistence-failure");
-          sessionLog(args.sessionId, "trailing blank decision: persistence failed; leaving newly observed assistants intact");
+          sessionLog(args.sessionId, "trailing blank decision: persistence failed; serving the frozen decisions");
         }
       } catch (error) {
         args.passOutcome?.record("trailing-blank-decision-exception");
@@ -33890,6 +34156,17 @@ async function runPostTransformPhase(args) {
       }
     }
   }
+  const tFinalRepresentation = performance.now();
+  const finalRepresentation = finalizeMessageRepresentation(args.messages, args.resolvedProviderID, {
+    prependedMessageCount,
+    reasoningMutatedMessages,
+    reasoningMutationExemptMessage,
+    mergedReasoningStrippedIds,
+    thinkingBindingRecoveryMessageIds,
+    trailingBlankDecisions,
+    skipMergedReasoningStrip: compactionOff,
+    skipTrailingWhitespaceStrip: compactionOff
+  });
   sessionLog(args.sessionId, `final representation: clearedParts=${finalRepresentation.clearedParts} mergedReasoningParts=${finalRepresentation.mergedReasoningParts}`);
   logTransformTiming(args.sessionId, "finalizeMessageRepresentation", tFinalRepresentation, `clearedParts=${finalRepresentation.clearedParts} mergedReasoningParts=${finalRepresentation.mergedReasoningParts}`);
   let assertedBaseline;
@@ -33984,7 +34261,8 @@ async function runPostTransformPhase(args) {
     emergencyReclaimedTokens,
     droppedCount,
     emergency,
-    bustedThisPass
+    bustedThisPass,
+    thinkingBindingRecovery
   };
 }
 function checkM0MutationDriftAndSignal(args) {
@@ -34268,7 +34546,9 @@ function formatRustPassLog(args) {
   const measured = timings.prefixGuard + timings.ordinalResolve + timings.stateSync + timings.clone + timings.wireBuild + timings.transport + timings.apply + timings.lkgSnapshot;
   const unattributed = Math.max(0, args.elapsedMs - measured);
   const rowVersion = Number.isSafeInteger(args.rowVersion) ? args.rowVersion : 0;
-  return `rust pass: decision=${args.decision} reason=${args.reason} served_from=${args.servedFrom} in=${args.inputCount} out=${args.outputCount} applied=${args.applied} row_version=${rowVersion} elapsed=${args.elapsedMs.toFixed(1)} ms module=${args.moduleElapsedMs.toFixed(1)} ms stages=prefix_guard:${timings.prefixGuard.toFixed(1)} ordinal_resolve:${timings.ordinalResolve.toFixed(1)} state_sync:${timings.stateSync.toFixed(1)} clone:${timings.clone.toFixed(1)} wire_build:${timings.wireBuild.toFixed(1)} wire_messages:${timings.wireMessages} transport:${timings.transport.toFixed(1)} transport_pages:${timings.transportPages} transport_bytes:${timings.transportBytes} apply:${timings.apply.toFixed(1)} lkg_snapshot:${timings.lkgSnapshot.toFixed(1)} mirror_pull:${timings.mirrorPull.toFixed(1)} compartment_mirror:${timings.compartmentMirror.toFixed(1)} other:${unattributed.toFixed(1)}`;
+  const schedulerFields = args.schedulerDecision ? ` scheduler=${args.schedulerDecision}${args.schedulerDeferReason ? ` defer_reason=${args.schedulerDeferReason}` : ""}` : "";
+  const historianFields = args.historianCanonicalCause ? ` historian_no_fire=${args.historianNoFire ?? "unknown"} canonical_cause=${args.historianCanonicalCause}` : "";
+  return `rust pass: decision=${args.decision} reason=${args.reason}${schedulerFields}${historianFields} served_from=${args.servedFrom} in=${args.inputCount} out=${args.outputCount} applied=${args.applied} row_version=${rowVersion} elapsed=${args.elapsedMs.toFixed(1)} ms module=${args.moduleElapsedMs.toFixed(1)} ms stages=prefix_guard:${timings.prefixGuard.toFixed(1)} ordinal_resolve:${timings.ordinalResolve.toFixed(1)} state_sync:${timings.stateSync.toFixed(1)} clone:${timings.clone.toFixed(1)} wire_build:${timings.wireBuild.toFixed(1)} wire_messages:${timings.wireMessages} transport:${timings.transport.toFixed(1)} transport_pages:${timings.transportPages} transport_bytes:${timings.transportBytes} apply:${timings.apply.toFixed(1)} lkg_snapshot:${timings.lkgSnapshot.toFixed(1)} mirror_pull:${timings.mirrorPull.toFixed(1)} compartment_mirror:${timings.compartmentMirror.toFixed(1)} other:${unattributed.toFixed(1)}`;
 }
 function isSyntheticUserMessage(message) {
   if (!message || messageInfo2(message).role !== "user" || !Array.isArray(message.parts)) {
@@ -34816,6 +35096,7 @@ function createRustModeTransform(deps, options) {
   const states = new Map;
   const wireCaches = new Map;
   const scheduleLkgCapture = options.scheduleLkgCapture ?? ((capture) => setImmediate(capture));
+  const installNativeMessages = options.installNativeMessagesForTests ?? replaceMessagesInPlace;
   const rawFallbackEstimator = options.rawFallbackEstimatorForTests ?? estimateFinalWireInputTokens;
   const timeoutMs = Math.max(1, options.moduleTimeoutMs ?? RUST_SEND_TIMEOUT_MS);
   const logStage = (sessionId, stage, startedAt, timings, extra) => {
@@ -34903,6 +35184,12 @@ function createRustModeTransform(deps, options) {
       return false;
     }
     const replayModel = modelFromMessages(currentMessages) ?? findLastAssistantModelFromOpenCodeDb(sessionId);
+    replayRustModeBindingMismatchStrips({
+      db: deps.db,
+      sessionId,
+      messages: replay.messages,
+      resolvedProviderID: replayModel?.providerID
+    });
     const trustedReplayLimit = replayModel ? resolveTrustedContextLimit(replayModel.providerID, replayModel.modelID, {
       db: deps.db,
       sessionID: sessionId
@@ -34935,23 +35222,21 @@ function createRustModeTransform(deps, options) {
     sessionLog(sessionId, "lkg_replay_served");
     return true;
   };
-  const prepareRustCapture = (state, sessionId, input, inputSnapshots, nativeMessages, responseRowVersion) => {
+  const prepareRustCapture = (state, sessionId, inputIds, inputKeys, inputSnapshots, nativeMessages, responseRowVersion) => {
     state.lkgCaptureSequence += 1;
-    const inputIds = input.map((message) => message.info.id);
     if (inputIds.some((id) => typeof id !== "string") || new Set(inputIds).size !== inputIds.length || inputIds.length === 0 || inputSnapshots.length !== inputIds.length) {
       return null;
     }
     const jsonPrefix = JSON.stringify(nativeMessages);
     if (typeof jsonPrefix !== "string")
       return null;
-    const keys = resolveLkgModelKeys(input);
     return {
       sessionId,
       inputIds,
       inputSnapshots,
       jsonPrefix,
-      modelKey: keys.modelKey,
-      providerKey: keys.providerKey,
+      modelKey: inputKeys.modelKey,
+      providerKey: inputKeys.providerKey,
       capturedAt: Date.now(),
       rowVersion: responseRowVersion,
       captureSequence: state.lkgCaptureSequence
@@ -34996,6 +35281,8 @@ function createRustModeTransform(deps, options) {
     const passStartedAt = performance.now();
     const passObservedAtMs = Date.now();
     const state = ensureState(states, sessionId);
+    const trailingBlankSourceDecisions = snapshotTrailingBlankSourceDecisions(messages);
+    const trailingBlankNewestAssistantId = [...messages].reverse().find((message) => message.info.role === "assistant")?.info.id;
     const timings = emptyRustPassTimings();
     state.passCount += 1;
     const syntheticTurn = observeSyntheticTurn(state, messages);
@@ -35008,6 +35295,10 @@ function createRustModeTransform(deps, options) {
     let requestInputTokens = 0;
     let decision = "error";
     let materializeReason = "none";
+    let schedulerDecision;
+    let schedulerDeferReason;
+    let historianNoFire;
+    let historianCanonicalCause;
     let servedFrom = "none";
     let moduleElapsedMs = 0;
     let rowVersion = 0;
@@ -35086,6 +35377,10 @@ function createRustModeTransform(deps, options) {
       sessionLog(sessionId, formatRustPassLog({
         decision,
         reason: materializeReason,
+        schedulerDecision,
+        schedulerDeferReason,
+        historianNoFire,
+        historianCanonicalCause,
         servedFrom,
         inputCount,
         outputCount: output.messages.length,
@@ -35108,6 +35403,11 @@ function createRustModeTransform(deps, options) {
     const captureResponseTelemetry = (response) => {
       decision = typeof response.decision === "string" ? response.decision : typeof response.action === "string" ? response.action : typeof response.status === "string" ? response.status : "unknown";
       servedFrom = typeof response.served_from === "string" ? response.served_from : "unknown";
+      schedulerDecision = typeof response.scheduler_decision === "string" ? response.scheduler_decision : undefined;
+      schedulerDeferReason = typeof response.scheduler_defer_reason === "string" ? response.scheduler_defer_reason : undefined;
+      const historian = isRecord4(response.historian) ? response.historian : undefined;
+      historianNoFire = typeof historian?.no_fire === "string" ? historian.no_fire : undefined;
+      historianCanonicalCause = typeof historian?.canonical_cause === "string" ? historian.canonical_cause : undefined;
       materializeReason = typeof response.materialize_reason === "string" && response.materialize_reason.length > 0 ? response.materialize_reason : "none";
       const timings2 = isRecord4(response.timings) ? response.timings : undefined;
       const applyOnceTotal = timings2?.total;
@@ -35630,6 +35930,7 @@ function createRustModeTransform(deps, options) {
       const decisionUpper = decision.toUpperCase();
       const cacheBustingPass = response.cache_bust === true || decisionUpper === "HARD" || decisionUpper === "MIGRATE_HARD" || decisionUpper === "EXECUTE" || decisionUpper === "SOFT" || !explicitDecision;
       let appliedMessages;
+      let thinkingBindingRecovery = null;
       const applyStartedAt = performance.now();
       try {
         const moduleMessages = applyNativeMessagesVerbatim({ messages: [] }, response, previousWireCache?.nativeOutput ? {
@@ -35657,16 +35958,20 @@ function createRustModeTransform(deps, options) {
         }
         pendingWireCache.nativeOutput = appliedMessages;
         if (!replayedFrozenRepresentation) {
-          runRustModePostprocess({
+          thinkingBindingRecovery = runRustModePostprocess({
             db: deps.db,
             sessionId,
             messages: appliedMessages,
             projectPath: memoryProjectPath,
             fullFeatureMode: !sessionMeta.isSubagent,
             compactionOff: deps.compactionOff,
+            resolvedProviderID: model?.providerID,
+            thinkingBindingRecoveryEnabledForModel: isFable51ThinkingBindingModel(model?.providerID, model?.modelID),
+            trailingBlankSourceDecisions,
+            trailingBlankNewestAssistantId: typeof trailingBlankNewestAssistantId === "string" ? trailingBlankNewestAssistantId : undefined,
             tagger: deps.tagger,
             ctxReduceAvailability: reduceAvailability
-          });
+          }).thinkingBindingRecovery;
         }
         const boundaryId = response.boundary_id;
         if (typeof boundaryId === "string" && boundaryId.length > 0) {
@@ -35690,11 +35995,20 @@ function createRustModeTransform(deps, options) {
           });
         }
         logStage(sessionId, "apply", applyStartedAt, timings);
+        const lkgInputIds = messages.map((message) => message.info.id);
+        const lkgInputKeys = resolveLkgModelKeys(messages);
+        const applyReplaceStartedAt = performance.now();
+        installNativeMessages(output, appliedMessages);
+        logStage(sessionId, "apply", applyReplaceStartedAt, timings);
+        if (thinkingBindingRecovery) {
+          const cleared = clearThinkingBindingRecoveryIf(deps.db, sessionId, thinkingBindingRecovery.flagTarget);
+          sessionLog(sessionId, `rust thinking binding recovery: stripped bound reasoning from assistant ${thinkingBindingRecovery.messageId}; flag=${cleared ? "cleared" : "rearmed"}`);
+        }
         const lkgSnapshotStartedAt = performance.now();
         if (cacheBustingPass) {
           dropSlot(sessionId, "lkg_cache_bust_pending_capture");
         }
-        const capturePlan = prepareRustCapture(state, sessionId, messages, pendingWireCache.rawContentSnapshots, appliedMessages, rowVersion);
+        const capturePlan = prepareRustCapture(state, sessionId, lkgInputIds, lkgInputKeys, pendingWireCache.rawContentSnapshots, output.messages, rowVersion);
         let captureMode = "async";
         const captureFailed = (mode, error) => {
           if (states.get(sessionId) !== state || capturePlan && capturePlan.captureSequence !== state.lkgCaptureSequence) {
@@ -35731,9 +36045,6 @@ function createRustModeTransform(deps, options) {
           }
         }
         logStage(sessionId, "lkgSnapshot", lkgSnapshotStartedAt, timings, `mode=${captureMode} row_version=${rowVersion}`);
-        const applyReplaceStartedAt = performance.now();
-        replaceMessagesInPlace(output, appliedMessages);
-        logStage(sessionId, "apply", applyReplaceStartedAt, timings);
       } catch (error) {
         logStage(sessionId, "apply", applyStartedAt, timings, "failed=true");
         try {
@@ -35879,17 +36190,24 @@ function createRustModeTransform(deps, options) {
   };
   return {
     run,
-    clearSession(sessionId) {
+    async clearSession(sessionId) {
       const projectRoot = states.get(sessionId)?.memoryAuthorityRoot ?? options.projectRoot ?? null;
-      dropSlot(sessionId, "session-deleted");
-      states.delete(sessionId);
-      wireCaches.delete(sessionId);
-      clearCompartmentMirrorCursor(sessionId);
-      if (projectRoot && options.moduleClient.deleteSession) {
-        options.moduleClient.deleteSession(sessionId, projectRoot).catch((error) => {
-          sessionLog(sessionId, "rust module session deletion failed:", error);
-        }).finally(() => options.moduleClient.closeSession?.(sessionId));
-      } else {
+      const clearLocalState = () => {
+        dropSlot(sessionId, "session-deleted");
+        states.delete(sessionId);
+        wireCaches.delete(sessionId);
+        clearCompartmentMirrorCursor(sessionId);
+      };
+      clearLocalState();
+      try {
+        if (projectRoot && options.moduleClient.deleteSession) {
+          await options.moduleClient.deleteSession(sessionId, projectRoot);
+        }
+      } catch (error) {
+        sessionLog(sessionId, "rust module session deletion failed:", error);
+        throw error;
+      } finally {
+        clearLocalState();
         options.moduleClient.closeSession?.(sessionId);
       }
     },
@@ -36968,6 +37286,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       cavemanTextCompression: !reducedMode ? deps.cavemanTextCompression : undefined,
       smartDrops: deps.smartDrops === true,
       resolvedProviderID,
+      thinkingBindingRecoveryEnabledForModel: isFable51ThinkingBindingModel(modelForBudget?.providerID, modelForBudget?.modelID),
       trailingBlankSourceDecisions,
       passOutcome,
       historyRefreshSessions: deps.historyRefreshSessions,
@@ -37154,13 +37473,18 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     const elapsed = (performance.now() - startTime).toFixed(1);
     sessionLog(sessionId, `transform completed in ${elapsed}ms (${messages.length} messages, ${targets.size} targets, watermark: ${watermark})`);
     deps.maybeAutoEmbedSession?.(sessionId);
+    const bindingRecovery = postTransformResult.thinkingBindingRecovery;
+    if (bindingRecovery) {
+      const cleared = clearThinkingBindingRecoveryIf(db, sessionId, bindingRecovery.flagTarget);
+      sessionLog(sessionId, `thinking binding recovery: stripped bound reasoning from assistant ${bindingRecovery.messageId}; flag=${cleared ? "cleared" : "rearmed"}`);
+    }
   };
   return Object.assign(transform, {
     invalidateRustWireState(sessionId) {
       rustModeTransform?.invalidateWireState(sessionId);
     },
-    clearRustSession(sessionId) {
-      rustModeTransform?.clearSession(sessionId);
+    async clearRustSession(sessionId) {
+      await rustModeTransform?.clearSession(sessionId);
     }
   });
 }
@@ -37278,6 +37602,16 @@ function createEventHandler2(deps) {
         return;
       }
       try {
+        const bindingMismatch = detectThinkingBindingMismatch(errInfo.error);
+        if (bindingMismatch.isBindingMismatch) {
+          const model = findLastAssistantModelFromOpenCodeDb(errInfo.sessionID);
+          if (deps.thinkingBindingRecoveryEnabled !== false && !deps.compactionOff && isFable51ThinkingBindingModel(model?.providerID, model?.modelID)) {
+            armThinkingBindingRecovery(deps.db, errInfo.sessionID, bindingMismatch.messageId);
+            dropSlot(errInfo.sessionID, "thinking-binding-recovery-arm");
+            deps.onSessionCacheInvalidated?.(errInfo.sessionID);
+          }
+          return;
+        }
         const detection = detectOverflow(errInfo.error);
         if (!detection.isOverflow) {
           return;
@@ -37341,6 +37675,18 @@ function createEventHandler2(deps) {
         });
       }
       let messageHadOverflowError = false;
+      if (info.error !== undefined && info.error !== null) {
+        const bindingMismatch = detectThinkingBindingMismatch(info.error);
+        if (bindingMismatch.isBindingMismatch && deps.thinkingBindingRecoveryEnabled !== false && !deps.compactionOff && isFable51ThinkingBindingModel(info.providerID, info.modelID)) {
+          try {
+            armThinkingBindingRecovery(deps.db, info.sessionID, bindingMismatch.messageId);
+            dropSlot(info.sessionID, "thinking-binding-recovery-arm");
+            deps.onSessionCacheInvalidated?.(info.sessionID);
+          } catch (error) {
+            sessionLog(info.sessionID, "event message.updated thinking binding recovery persistence failed:", error);
+          }
+        }
+      }
       if (info.error !== undefined && info.error !== null) {
         const detection = detectOverflow(info.error);
         if (detection.isOverflow) {
@@ -37551,15 +37897,17 @@ function createEventHandler2(deps) {
       }
       dropSlot(sessionId, "session.deleted");
       try {
-        markSessionCleanupPending(deps.db, sessionId);
-        removeCompactionMarkerForSession(deps.db, sessionId);
-        clearSession(deps.db, sessionId);
+        const rustCleanupPending = markSessionCleanupPending(deps.db, sessionId, deps.rustSessionCleanup === true);
+        await deps.onSessionDeleted?.(sessionId);
+        if (!rustCleanupPending || deps.rustSessionCleanup === true) {
+          removeCompactionMarkerForSession(deps.db, sessionId);
+          clearSession(deps.db, sessionId, deps.rustSessionCleanup === true);
+        }
       } catch (error) {
         sessionLog(sessionId, "event session.deleted persistence failed:", error);
       }
       resetDegradedCacheCount(sessionId);
       deps.onSessionCacheInvalidated?.(sessionId);
-      deps.onSessionDeleted?.(sessionId);
       deps.contextUsageMap.delete(sessionId);
       deps.tagger.cleanup(sessionId);
       clearTransformDecisionSession(sessionId);
@@ -37590,6 +37938,14 @@ function formatEmbedFailureSummary(embedded, remaining, failure) {
       return `Embedded ${embedded} ${compartment}; ${remaining} rejected: ${failure.reason}. Fix: recertify SYNAPSE or configure embedding.fallback_provider, then run /ctx-embed start again.`;
     case "credential_required":
       return `Embedded ${embedded} ${compartment}; ${remaining} rejected: ${failure.reason}. Fix: reauthenticate SYNAPSE, then run /ctx-embed start again.`;
+    case "local_binding_missing":
+      return `Embedded ${embedded} ${compartment}; ${remaining} failed: ${failure.reason}. Fix: run \`npx @cortexkit/magic-context@latest doctor\` to verify the WASM fallback. On Intel macOS, onnxruntime-node@1.23.0 may be pinned manually for optional native speed.`;
+    case "local_fs_unavailable":
+      return `Embedded ${embedded} ${compartment}; ${remaining} failed: ${failure.reason}. Fix: update or reinstall Magic Context so its Node WASM bundle can persist the model, then run /ctx-embed start again.`;
+    case "local_download_failure":
+      return `Embedded ${embedded} ${compartment}; ${remaining} failed: ${failure.reason}. Fix: check network/proxy access to the model host.${retry}`;
+    case "local_runtime_error":
+      return `Embedded ${embedded} ${compartment}; ${remaining} failed: ${failure.reason}. Fix: run \`npx @cortexkit/magic-context@latest doctor\` for local runtime diagnostics.`;
     case "empty_result":
     case "transport_error":
       return `Embedded ${embedded} ${compartment}; ${remaining} failed: ${failure.reason}.${failure.retryable ? retry : ""}`;
@@ -38519,6 +38875,7 @@ function createMagicContextHook(deps) {
   const commitSeenLastPass = new Map;
   const variantBySession = deps.liveSessionState?.variantBySession ?? new Map;
   const liveModelBySession = deps.liveSessionState?.liveModelBySession ?? new Map;
+  const latestAssistantMessageIdBySession = deps.liveSessionState?.latestAssistantMessageIdBySession ?? new Map;
   const agentBySession = deps.liveSessionState?.agentBySession ?? new Map;
   const sessionDirectoryBySession = deps.liveSessionState?.sessionDirectoryBySession ?? new Map;
   const internalChildSessions = deps.liveSessionState?.internalChildSessions ?? new Set;
@@ -38555,6 +38912,7 @@ function createMagicContextHook(deps) {
     db,
     liveSessionState: {
       liveModelBySession,
+      latestAssistantMessageIdBySession,
       channel1StateBySession,
       variantBySession,
       agentBySession,
@@ -38713,7 +39071,7 @@ function createMagicContextHook(deps) {
     autoEmbedAttemptedBySession.add(sessionId);
     const directory = sessionDirectoryBySession.get(sessionId) ?? deps.directory;
     (async () => {
-      let completedDrainWithWork = false;
+      let drainReachedTerminal = false;
       try {
         await new Promise((resolve3) => setTimeout(resolve3, 0));
         await ensureProjectRegisteredFromOpenCodeDirectory(directory, db);
@@ -38727,25 +39085,19 @@ function createMagicContextHook(deps) {
         const remaining = coverage.session.total - coverage.session.embedded;
         if (remaining <= 0)
           return;
-        const notifyParams = getLiveNotificationParams(sessionId, liveModelBySession, variantBySession, agentBySession);
-        if (!isTuiConnected(sessionId)) {
-          const startMsg = `Embedding ${remaining} compartment${remaining === 1 ? "" : "s"} of history in the background…`;
-          await sendIgnoredMessage(deps.client, sessionId, startMsg, {
-            ...notifyParams
-          });
-        }
-        const summary = await executeEmbedHistory(sessionId);
+        const embeddedBefore = coverage.session.embedded;
+        await executeEmbedHistory(sessionId, { silent: true });
+        drainReachedTerminal = true;
         const completedCoverage = getEmbeddingCoverageStatus(db, sessionProjectIdentity, sessionId);
-        completedDrainWithWork = completedCoverage.session.total - completedCoverage.session.embedded <= 0;
-        if (!isTuiConnected(sessionId)) {
-          await sendIgnoredMessage(deps.client, sessionId, summary, {
-            ...notifyParams
-          });
+        const embeddedNow = completedCoverage.session.embedded - embeddedBefore;
+        if (embeddedNow > 0 && !isTuiConnected(sessionId)) {
+          const notifyParams = getLiveNotificationParams(sessionId, liveModelBySession, variantBySession, agentBySession);
+          await sendIgnoredMessage(deps.client, sessionId, `Embedded ${embeddedNow} compartment${embeddedNow === 1 ? "" : "s"} of history for semantic search.`, { ...notifyParams });
         }
       } catch (error) {
         log("[magic-context] auto-embed drain failed:", error);
       } finally {
-        if (!completedDrainWithWork)
+        if (!drainReachedTerminal)
           autoEmbedAttemptedBySession.delete(sessionId);
       }
     })();
@@ -39075,6 +39427,7 @@ function createMagicContextHook(deps) {
     compactionHandler: deps.compactionHandler,
     config: deps.config,
     compactionOff,
+    thinkingBindingRecoveryEnabled: deps.config.transform_mode !== "rust",
     tagger: deps.tagger,
     db,
     client: deps.client,
@@ -39090,23 +39443,27 @@ function createMagicContextHook(deps) {
     onRustWireInvalidated: (sessionId) => {
       transform.invalidateRustWireState(sessionId);
     },
-    onSessionDeleted: (sessionId) => {
+    rustSessionCleanup: rustModeModuleClient !== undefined,
+    onSessionDeleted: async (sessionId) => {
       dropSlot(sessionId, "session-deleted");
-      transform.clearRustSession(sessionId);
-      systemPromptHash.clearSession(sessionId);
-      lastHeuristicsTurnId.delete(sessionId);
-      clearToolPermissionDenied(sessionId);
-      commitSeenLastPass.delete(sessionId);
-      variantBySession.delete(sessionId);
-      liveModelBySession.delete(sessionId);
-      agentBySession.delete(sessionId);
-      sessionDirectoryBySession.delete(sessionId);
-      recompProgressBySession.delete(sessionId);
-      internalChildSessions.delete(sessionId);
-      rustMemorySyncRequestedSessions.delete(sessionId);
-      channel1StateBySession.delete(sessionId);
-      channel2DirectiveTextBySession.delete(sessionId);
-      clearEmbedSessionState(sessionId);
+      try {
+        await transform.clearRustSession(sessionId);
+      } finally {
+        systemPromptHash.clearSession(sessionId);
+        lastHeuristicsTurnId.delete(sessionId);
+        clearToolPermissionDenied(sessionId);
+        commitSeenLastPass.delete(sessionId);
+        variantBySession.delete(sessionId);
+        liveModelBySession.delete(sessionId);
+        agentBySession.delete(sessionId);
+        sessionDirectoryBySession.delete(sessionId);
+        recompProgressBySession.delete(sessionId);
+        internalChildSessions.delete(sessionId);
+        rustMemorySyncRequestedSessions.delete(sessionId);
+        channel1StateBySession.delete(sessionId);
+        channel2DirectiveTextBySession.delete(sessionId);
+        clearEmbedSessionState(sessionId);
+      }
     }
   });
   const runDreamQueueInBackground = () => {
@@ -39274,6 +39631,7 @@ function createMagicContextHook(deps) {
     contextUsageMap,
     db,
     liveModelBySession,
+    latestAssistantMessageIdBySession,
     variantBySession,
     agentBySession,
     sessionDirectoryBySession,
@@ -40173,6 +40531,48 @@ function projectIdentityForStoredPath(rawProjectPath) {
 function memoryBelongsToProject(memory, projectPath) {
   return storedPathBelongsToIdentity(memory.projectPath, projectPath);
 }
+function preflightCurateMutation(args) {
+  const { params } = args;
+  if (params.action !== "archive" && params.action !== "update") {
+    return { skip: null, successor: null };
+  }
+  const ids = params.ids;
+  const content = params.content?.trim();
+  if (!ids || ids.length === 0 || !ids.every(Number.isInteger) || params.action === "update" && (ids.length !== 1 || !content)) {
+    return { skip: null, successor: null };
+  }
+  const uniqueIds = [...new Set(ids)];
+  const memories = uniqueIds.map((id) => getMemoryById(args.db, id));
+  if (memories.some((memory) => !memory)) {
+    return { skip: null, successor: null };
+  }
+  const successor = Number.isInteger(params.superseded_by) ? getMemoryById(args.db, params.superseded_by) : null;
+  const refusals = memories.flatMap((memory) => {
+    if (!memory)
+      return [];
+    const refusal = assessCurateMutationSafety({
+      memory,
+      verdict: params.action,
+      reason: params.reason,
+      replacementContent: content,
+      successor,
+      projectIdentity: (candidate) => projectIdentityForStoredPath(candidate.projectPath)
+    });
+    return refusal ? [refusal] : [];
+  });
+  if (refusals.length === 0)
+    return { skip: null, successor };
+  let refused = 0;
+  for (const refusal of refusals) {
+    refused = recordCurateSafetyRefusal(args.sessionId, refusal);
+  }
+  const memoryIds = refusals.map((refusal) => refusal.memoryId).join(", ");
+  const reasons = [...new Set(refusals.map((refusal) => refusal.reason))].join(",");
+  return {
+    skip: `Skipped ${params.action} for memory [ID: ${memoryIds}]: curate safety refusal (${reasons}); refused=${refused}.`,
+    successor
+  };
+}
 function isPrimaryMutableMemory(memory) {
   return (memory.status === "active" || memory.status === "permanent") && memory.supersededByMemoryId === null;
 }
@@ -40199,7 +40599,10 @@ var ctxMemoryArgsShape = {
   limit: tool2.schema.number().optional().describe("Max results for list (default: 10)"),
   reason: tool2.schema.string().optional().describe("Why the memory is being archived (optional, recommended)")
 };
-var ctxMemoryArgsSchema = tool2.schema.object(ctxMemoryArgsShape).passthrough();
+var ctxMemoryArgsSchema = tool2.schema.object({
+  ...ctxMemoryArgsShape,
+  superseded_by: tool2.schema.number().optional()
+}).passthrough();
 function createCtxMemoryTool(deps) {
   const allowedActions = getAllowedActions(deps);
   return tool2({
@@ -40214,7 +40617,8 @@ function createCtxMemoryTool(deps) {
         category: { type: "enum", values: V2_MEMORY_CATEGORIES },
         ids: { type: "array", items: "number", maxItems: 100 },
         limit: "number",
-        reason: "string"
+        reason: "string",
+        superseded_by: "number"
       });
       if (toolContext.agent === SIDEKICK_AGENT) {
         return "Error: ctx_memory is not available to the sidekick agent.";
@@ -40227,6 +40631,13 @@ function createCtxMemoryTool(deps) {
         return "Error: Could not resolve project identity for memory action.";
       }
       await deps.ensureProjectRegistered?.(toolContext.directory, deps.db);
+      const curatePreflight = toolContext.agent === DREAMER_AGENT ? preflightCurateMutation({
+        db: deps.db,
+        params: args,
+        sessionId: toolContext.sessionID
+      }) : { skip: null, successor: null };
+      if (curatePreflight.skip)
+        return curatePreflight.skip;
       if (args.action !== "list") {
         const marker = getAuthorityManagedMarker(deps.db, projectPath);
         let authorityState = null;
@@ -40249,18 +40660,29 @@ function createCtxMemoryTool(deps) {
           }
           try {
             const commandId = toolCallIdFromContext(toolContext);
+            const moduleArgs = args.action === "archive" && curatePreflight.successor ? {
+              action: "merge",
+              ids: [
+                ...new Set([
+                  ...args.ids ?? [],
+                  curatePreflight.successor.id
+                ])
+              ],
+              content: curatePreflight.successor.content,
+              category: curatePreflight.successor.category
+            } : args;
             const text = moduleMemoryText(await memoryBackend({
               ...commandId ? { commandId } : {},
               sessionId: toolContext.sessionID,
               projectRoot: toolContext.directory,
               projectPath,
               memoryProject: projectPath,
-              action: args.action,
-              content: args.content,
-              category: args.category,
-              ids: args.ids,
-              reason: args.reason
-            }), args);
+              action: moduleArgs.action,
+              content: moduleArgs.content,
+              category: moduleArgs.category,
+              ids: moduleArgs.ids,
+              reason: moduleArgs.reason
+            }), moduleArgs);
             return text ?? "Error: Rust module returned an invalid ctx_memory response.";
           } catch (error) {
             if (isRustAuthorityDrainingError(error)) {
@@ -40539,11 +40961,21 @@ function createCtxMemoryTool(deps) {
         runImmediateTransaction(deps.db, () => {
           for (const target of targets) {
             archiveMemory(deps.db, target.memoryId, args.reason);
-            queueMemoryMutation(deps.db, {
-              projectPath: target.projectIdentity,
-              mutationType: "archive",
-              targetMemoryId: target.memoryId
-            });
+            if (toolContext.agent === DREAMER_AGENT && curatePreflight.successor) {
+              supersededMemory(deps.db, target.memoryId, curatePreflight.successor.id);
+              queueMemoryMutation(deps.db, {
+                projectPath: target.projectIdentity,
+                mutationType: "superseded",
+                targetMemoryId: target.memoryId,
+                supersededById: curatePreflight.successor.id
+              });
+            } else {
+              queueMemoryMutation(deps.db, {
+                projectPath: target.projectIdentity,
+                mutationType: "archive",
+                targetMemoryId: target.memoryId
+              });
+            }
           }
         });
         requestRustMemorySync(deps, toolContext.sessionID);
@@ -41578,11 +42010,16 @@ function createCtxReduceTool(deps) {
       const protectedTagIds = activeTags.map((tag) => tag.tagNumber).sort((left, right) => right - left).slice(0, deps.protectedTags);
       const protectedSet = new Set(protectedTagIds);
       const tagStatusMap = new Map(allTags.map((tag) => [tag.tagNumber, tag.status]));
+      const inertWhitespaceTagNumbers = new Set(getInertWhitespaceAssistantTags(deps.db, sessionId).map((tag) => tag.tagNumber));
+      const inertDropIds = [
+        ...new Set(dropIds.filter((id) => inertWhitespaceTagNumbers.has(id)))
+      ];
+      const inertNote = inertDropIds.length > 0 ? `Skipped: ${inertDropIds.map((id) => `§${id}§ is provider framing, nothing to reclaim`).join("; ")}.` : "";
       const pendingOps = getPendingOps(deps.db, sessionId);
       const pendingMap = new Map(pendingOps.map((op) => [op.tagId, op.operation]));
       const conflicts = [];
       for (const id of dropIds) {
-        if (tagStatusMap.get(id) === "compacted") {
+        if (tagStatusMap.get(id) === "compacted" && !inertWhitespaceTagNumbers.has(id)) {
           conflicts.push(`§${id}§ is from before compaction`);
         }
       }
@@ -41590,10 +42027,13 @@ function createCtxReduceTool(deps) {
         return `Error: Conflicting operations — ${conflicts.join("; ")}.`;
       }
       const preFilterDropCount = dropIds.length;
-      dropIds = dropIds.filter((id) => tagStatusMap.get(id) !== "dropped" && pendingMap.get(id) !== "drop");
+      dropIds = dropIds.filter((id) => !inertWhitespaceTagNumbers.has(id) && tagStatusMap.get(id) !== "dropped" && pendingMap.get(id) !== "drop");
       const skippedCount = preFilterDropCount - dropIds.length;
       if (dropIds.length === 0) {
-        return "All requested tags were already queued or processed. No new action is needed.";
+        return [
+          inertNote,
+          "All requested tags were already queued or processed. No new action is needed."
+        ].filter(Boolean).join(" ");
       }
       try {
         deps.db.transaction(() => {
@@ -41616,7 +42056,7 @@ function createCtxReduceTool(deps) {
         parts.push(`drop ${formatIds(immediateDropIds)}`);
       if (deferredDropIds.length > 0)
         parts.push(`deferred drop ${formatIds(deferredDropIds)}`);
-      return `Queued: ${parts.join(", ")}.${skippedNote}`;
+      return `Queued: ${parts.join(", ")}.${skippedNote}${inertNote ? ` ${inertNote}` : ""}`;
     }
   });
 }
@@ -42163,6 +42603,7 @@ var server = async (ctx) => {
   });
   const loadedPluginConfig = loadPluginConfigDetailed(ctx.directory);
   const pluginConfig = loadedPluginConfig.config;
+  reloadWindowOverlay(pluginConfig.models?.window_overlay_path);
   const promptSurfaceRuntime = createPromptSurfaceRuntime({
     harness: "opencode",
     directory: ctx.directory,
@@ -42227,7 +42668,9 @@ var server = async (ctx) => {
     }
   }
   const liveSessionState = createLiveSessionState();
-  const rustModeModuleClient = pluginConfig.transform_mode === "rust" ? new SubcModuleTransport(pluginConfig.subc?.connection_file) : undefined;
+  const rustModeModuleTransport = pluginConfig.transform_mode === "rust" ? new SubcModuleTransport(pluginConfig.subc?.connection_file) : undefined;
+  const rustModeModuleClient = rustModeModuleTransport;
+  const sessionCleanupModuleClient = pluginConfig.enabled ? rustModeModuleTransport ?? new SubcModuleTransport(pluginConfig.subc?.connection_file) : undefined;
   const hooks = await createSessionHooksAsync({
     ctx,
     pluginConfig,
@@ -42367,7 +42810,8 @@ var server = async (ctx) => {
             liveSessionState.dreamerProgressByProject.delete(timerProjectIdentity);
           }
         },
-        moduleClient: classifyModuleClient
+        moduleClient: classifyModuleClient,
+        sessionCleanupModuleClient
       };
       try {
         stopDreamTimerRegistration = await startDreamScheduleTimer(timerRegistration);