@cortexkit/opencode-magic-context 0.49.19 → 0.49.20

package/dist/{index-jhghdnsm.js → index-67nyj0gy.js}

@@ -7,7 +7,7 @@ import {
   getTemporalDecisions,
   freezeTemporalDecisions,
   stableStringify
-} from "./index-bp5083x2.js";
+} from "./index-x9k3mqrf.js";
 import {
   protectedToolTagNumbers,
   byteSize,
@@ -73,31 +73,37 @@ import {
   adoptNullOwnerToolTag2,
   getCandidateToolOwners2,
   pickNearestPriorOwner2
-} from "./index-cf74k5ak.js";
+} from "./index-305y133n.js";
 import {
   textMentionsRecentCommit,
   hasMeaningfulUserText2,
   estimateTokens
-} from "./index-c5pytzne.js";
+} from "./index-b88dwwrh.js";
+import {
+  getMagicContextStorageDir
+} from "./index-g2q4htwp.js";
 import {
   log2,
   sessionLog2
-} from "./index-j75v2476.js";
+} from "./index-h7tgn49j.js";
 import {
   inRootAsyncContext2,
   getTagIdentityWriteGeneration2,
   getSqliteDatabasePath2,
   assertTransformWrite2,
   isTransientSqliteError2
-} from "./index-beht37jy.js";
+} from "./index-1zx2pa5d.js";
 import {
   getProjectEmbeddingSnapshot2,
   embedTextForProject2,
   embedBatchForProject2
-} from "./index-ze7mvk54.js";
+} from "./index-2yhtnfcf.js";
+import {
+  createWorkerShutdown
+} from "./index-cpjk5jd2.js";
 import {
   runSessionWarmupWorker
-} from "./index-s734jcsr.js";
+} from "./index-35qc6606.js";
 import {
   getMaxM0MutationId,
   getLastCompartmentEndMessage,
@@ -133,12 +139,12 @@ import {
   peekNoteNudgeText,
   markNoteNudgeDelivered,
   getActiveCompartmentRun
-} from "./index-rpxdjkm0.js";
+} from "./index-v7r4td4c.js";
 import {
   BoundedSessionMap,
   cleanSearchText,
   matchedSearchSnippet
-} from "./index-se4m2g6w.js";
+} from "./index-48stjd56.js";
 import {
   stripSystemInjection,
   isTextPart,
@@ -234,7 +240,7 @@ import {
   extractToolCallObservation,
   ToolMutationBatch,
   createToolDropTarget
-} from "./index-9zcsy3hh.js";
+} from "./index-x4k3f4mf.js";
 import {
   isValidLanguageCode
 } from "./index-wgypt3cs.js";
@@ -245,10 +251,10 @@ import {
   openCodeDbExists,
   withReadOnlySessionDb,
   getMessageTimesFromOpenCodeDb
-} from "./index-kq82mtg0.js";
+} from "./index-11zf2wwc.js";
 import {
   userFacingFailureCode
-} from "./index-3h4dp9wb.js";
+} from "./index-1pefp8ar.js";
 import {
   normalizeProtectedToolName,
   mergeProtectedTools
@@ -258,7 +264,7 @@ import {
 } from "./index-y8v6yerm.js";
 import {
   logSlowWriteTransaction
-} from "./index-k29z4aqh.js";
+} from "./index-t5pck3ss.js";
 
 // src/features/magic-context/tagger.ts
 var TOOL_COMPOSITE_KEY_SEP = "\x00";
@@ -1243,7 +1249,8 @@ ${trimmedBody}…
   return wrapped;
 }
 function selectAutoSearchResults(results, threshold) {
-  return results.filter((result) => (result.relevanceScore ?? result.score) >= threshold);
+  const relevance = (result) => result.relevanceScore ?? result.score;
+  return results.filter((result) => relevance(result) >= threshold).sort((left, right) => relevance(right) - relevance(left));
 }
 
 // src/hooks/magic-context/auto-search-worker-client.ts
@@ -1336,6 +1343,13 @@ function retryUnpublishedAutoSearchNoHint(db, sessionId, messageId, startedAt) {
   }
   return true;
 }
+
+class AutoSearchBusyError extends Error {
+  constructor() {
+    super("an earlier auto-search of this session is still running");
+    this.name = "AutoSearchBusyError";
+  }
+}
 async function searchAutoHint(db, sessionId, projectPath, query, options, entry = new URL(new URL(import.meta.url).pathname.endsWith(".ts") ? "./auto-search-worker.ts" : "./auto-search-worker.js", import.meta.url)) {
   return executeAutoSearchWorker(db, sessionId, projectPath, query, options, entry, "search");
 }
@@ -1344,14 +1358,19 @@ var searchWorkers = new WeakMap;
 var liveSearchWorkers = new Set;
 var MAX_IDLE_SEARCH_WORKERS = 4;
 var SEARCH_WORKER_IDLE_MS = 5 * 60000;
+var DETACHED_SEARCH_LIMIT_MS = 30000;
+var AUTO_SEARCH_WORKER_CLOSE_DEADLINE_MS = 2000;
 var workersCreated = 0;
 var workersReused = 0;
+var searchesSkippedBusy = 0;
 async function acquireSearchWorker(db, key, entry, input, signal) {
   const pool = searchWorkers.get(db) ?? new Map;
   searchWorkers.set(db, pool);
   while (!signal.aborted) {
     let slot = pool.get(key);
     if (slot?.busy) {
+      if (input.job === "search" && (slot.detached || slot.busySessionId === input.sessionId))
+        return "busy";
       const current = slot;
       await new Promise((resolve) => {
         const done = () => {
@@ -1360,6 +1379,8 @@ async function acquireSearchWorker(db, key, entry, input, signal) {
         };
         signal.addEventListener("abort", done, { once: true });
         current.busy?.then(done);
+        if (!current.detached)
+          current.detachedSignal?.then(done);
         if (signal.aborted)
           done();
       });
@@ -1368,14 +1389,16 @@ async function acquireSearchWorker(db, key, entry, input, signal) {
     const fresh = !slot;
     if (!slot) {
       const worker = inRootAsyncContext2(() => new Worker(entry, { workerData: { ...input, persistent: true } }));
+      const shutdown = createWorkerShutdown(worker, "auto-search", AUTO_SEARCH_WORKER_CLOSE_DEADLINE_MS);
       slot = {
         worker,
         dispose() {
+          this.disposed = true;
           clearTimeout(this.idleTimer);
           if (pool.get(key) === this)
             pool.delete(key);
           liveSearchWorkers.delete(this);
-          worker.terminate();
+          shutdown.close();
           worker.unref();
         }
       };
@@ -1389,9 +1412,14 @@ async function acquireSearchWorker(db, key, entry, input, signal) {
       workersReused++;
     clearTimeout(slot.idleTimer);
     const current = slot;
+    current.busySessionId = input.sessionId;
+    current.detached = false;
     current.busy = new Promise((resolve) => {
       current.release = resolve;
     });
+    current.detachedSignal = new Promise((resolve) => {
+      current.markDetached = resolve;
+    });
     current.worker.ref();
     return { slot: current, fresh };
   }
@@ -1400,6 +1428,9 @@ async function acquireSearchWorker(db, key, entry, input, signal) {
 function queueAutoSearchBackfill(db, sessionId, projectPath, query) {
   if (isEmbeddingHostBusy2())
     return Promise.resolve();
+  const snapshot = getProjectEmbeddingSnapshot2(projectPath);
+  if (!snapshot?.enabled || !snapshot.features.memoryEnabled)
+    return Promise.resolve();
   const key = `${sessionId}\x00${projectPath}`;
   const pending = pendingBackfills.get(db) ?? new Map;
   pendingBackfills.set(db, pending);
@@ -1447,6 +1478,7 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     signal: deadlineSignal,
     readMessages: _readMessages,
     searchMessageHistory: _searchMessageHistory,
+    stepTimings: _stepTimings,
     ...serializable
   } = options;
   const lifecycle = registerAutoSearchWork(sessionId);
@@ -1482,30 +1514,55 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     lifecycle.done();
     return [];
   }
+  if (lease === "busy") {
+    lifecycle.done();
+    searchesSkippedBusy++;
+    throw new AutoSearchBusyError;
+  }
   const { slot, fresh } = lease;
   const worker = slot.worker;
+  const detachable = job === "search" && entry.href === defaultAutoSearchWorkerEntry().href;
+  const startedAt = performance.now();
+  let detachedAt;
+  let ownerVectorMs;
+  let abandonTimer;
   return new Promise((resolve, reject) => {
     let settled = false;
-    const finish = (results, error) => {
+    let released = false;
+    const settle = (results, error) => {
       if (settled)
         return;
       settled = true;
+      if (error)
+        reject(error);
+      else
+        resolve(results);
+    };
+    const release = (dispose) => {
+      if (released)
+        return;
+      released = true;
+      clearTimeout(abandonTimer);
       signal?.removeEventListener("abort", abort);
       lifecycle.signal.removeEventListener("abort", abort);
       lifecycle.done();
       worker.off("message", onMessage);
       worker.off("error", onError);
       worker.off("exit", onExit);
-      if (error || signal.aborted || entry.href !== defaultAutoSearchWorkerEntry().href)
+      if (dispose || !detachable)
         slot.dispose();
-      else {
+      else if (!slot.disposed) {
         slot.idleTimer = setTimeout(() => slot.dispose(), SEARCH_WORKER_IDLE_MS);
         slot.idleTimer.unref?.();
       }
-      const release = slot.release;
+      const free = slot.release;
       slot.busy = undefined;
       slot.release = undefined;
-      release?.();
+      slot.busySessionId = undefined;
+      slot.detached = false;
+      slot.detachedSignal = undefined;
+      slot.markDetached = undefined;
+      free?.();
       const reusable = liveSearchWorkers.delete(slot);
       if (reusable)
         liveSearchWorkers.add(slot);
@@ -1513,51 +1570,82 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
       for (const prior of idle.slice(0, Math.max(0, idle.length - MAX_IDLE_SEARCH_WORKERS)))
         prior.dispose();
       worker.unref();
-      if (error)
-        reject(error);
-      else
-        resolve(results);
     };
-    const abort = () => finish([]);
+    const finish = (results, error) => {
+      settle(results, error);
+      release(Boolean(error) || signal.aborted);
+    };
+    const abort = () => {
+      if (lifecycle.signal.aborted || !detachable) {
+        finish([]);
+        return;
+      }
+      if (settled)
+        return;
+      detachedAt = performance.now();
+      slot.detached = true;
+      slot.markDetached?.();
+      settle([]);
+      abandonTimer = setTimeout(() => {
+        log2(`[auto-search] session ${sessionId}: search still running ${DETACHED_SEARCH_LIMIT_MS} ms after its deadline; disposing its worker (owner vector wait ${formatMs(ownerVectorMs)})`);
+        release(true);
+      }, DETACHED_SEARCH_LIMIT_MS);
+      abandonTimer.unref?.();
+    };
     signal?.addEventListener("abort", abort, { once: true });
     lifecycle.signal.addEventListener("abort", abort, { once: true });
     const onError = (error) => finish([], error);
     const onExit = (code) => finish([], new Error(`auto-search worker exited (${code})`));
     const onMessage = async (reply) => {
-      if (settled)
+      if (released)
         return;
-      if (reply.kind === "result") {
+      if (reply.kind === "result" || reply.kind === "error") {
+        if (detachedAt !== undefined) {
+          logLateSearch(sessionId, performance.now() - detachedAt, detachedAt - startedAt, ownerVectorMs, reply.kind === "result" ? reply.timings : undefined, reply.kind === "error");
+          release(reply.kind === "error");
+          return;
+        }
+        if (reply.kind === "error") {
+          finish([], new Error(reply.error));
+          return;
+        }
         if (snapshot && getProjectEmbeddingSnapshot2(projectPath)?.generation !== snapshot.generation)
           finish([]);
         else
           finish(reply.results);
         return;
       }
-      if (reply.kind === "error") {
-        finish([], new Error(reply.error));
-        return;
-      }
       if (reply.kind === "messages" || reply.kind === "accepted")
         return;
       const response = { id: reply.id };
-      try {
+      if (!signal.aborted) {
+        const requestedAt = performance.now();
+        try {
+          if (reply.kind === "query")
+            response.result = await (job === "backfill" ? embedTextForProject2(projectPath, reply.text, signal, "query") : boundedHintEmbedding(embedQuery, reply.text, signal)) ?? null;
+          else {
+            const passage = await embedBatchForProject2(projectPath, reply.texts, signal, reply.purpose);
+            const current = getProjectEmbeddingSnapshot2(projectPath);
+            response.passage = passage && current ? {
+              ...passage,
+              providerIdentity: current.providerIdentity,
+              runtimeFingerprint: current.runtimeFingerprint,
+              dimensions: passage.vectors.find((vector) => vector !== null)?.length ?? null
+            } : null;
+          }
+        } catch (error) {
+          response.error = error instanceof Error ? error.message : String(error);
+        }
         if (reply.kind === "query")
-          response.result = await (job === "backfill" ? embedTextForProject2(projectPath, reply.text, signal, "query") : boundedHintEmbedding(embedQuery, reply.text, signal)) ?? null;
-        else {
-          const passage = await embedBatchForProject2(projectPath, reply.texts, signal, reply.purpose);
-          const current = getProjectEmbeddingSnapshot2(projectPath);
-          response.passage = passage && current ? {
-            ...passage,
-            providerIdentity: current.providerIdentity,
-            runtimeFingerprint: current.runtimeFingerprint,
-            dimensions: passage.vectors.find((vector) => vector !== null)?.length ?? null
-          } : null;
+          ownerVectorMs = performance.now() - requestedAt;
+        if (signal.aborted) {
+          response.result = undefined;
+          response.passage = undefined;
+          response.error = undefined;
         }
-      } catch (error) {
-        response.error = error instanceof Error ? error.message : String(error);
       }
       response.embeddingHostBusy = isEmbeddingHostBusy2();
-      if (!settled && !signal?.aborted) {
+      if (!released) {
         try {
           worker.postMessage(response);
         } catch (error) {
@@ -1579,6 +1667,15 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     }
   });
 }
+function formatMs(value) {
+  return value === undefined ? "n/a" : `${Math.round(value)} ms`;
+}
+function logLateSearch(sessionId, lateMs, waitedMs, ownerVectorMs, timings, failed) {
+  const steps = timings?.steps;
+  const warm = timings?.lastPoolWarm;
+  const pool = warm ? `last pool refresh ${warm.outcome} in ${formatMs(warm.totalMs)} (probe ${formatMs(warm.probeMs)}, read ${formatMs(warm.readMs)}, decode ${formatMs(warm.decodeMs)}, ${warm.probedRows} rows probed, ${warm.decodedRows} decoded)` : "no pool refresh yet";
+  log2(`[auto-search] session ${sessionId}: deadline passed after ${formatMs(waitedMs)}; the search ${failed ? "failed" : "finished"} ${formatMs(lateMs)} later. Steps: message FTS ${formatMs(steps?.messageMs)}, vector wait ${formatMs(steps?.vectorWaitMs)} (owner embedding ${formatMs(ownerVectorMs)}), chunk lane ${formatMs(steps?.chunkMs)} (pool ${steps?.chunkPool ?? "n/a"}), other lanes ${formatMs(steps?.otherLanesMs)}, job ${formatMs(timings?.jobMs)}; ${pool}`);
+}
 async function boundedHintEmbedding(embed, text, signal) {
   const controller = new AbortController;
   const combined = AbortSignal.any([signal, controller.signal]);
@@ -1602,6 +1699,7 @@ function defaultAutoSearchWorkerEntry() {
 }
 var MESSAGE_WORKER_ACCEPT_TIMEOUT_MS = 400;
 var MESSAGE_WORKER_RESULT_TIMEOUT_MS = 30000;
+var MESSAGE_SEARCH_WORKER_CLOSE_DEADLINE_MS = 2000;
 var messageSearchWorkerFallbacks = new Map;
 function searchMessageHistoryOffThread(db, request, entry = defaultAutoSearchWorkerEntry(), deadlines = {}) {
   const fallback = (reason, detail) => {
@@ -1629,6 +1727,7 @@ function searchMessageHistoryOffThread(db, request, entry = defaultAutoSearchWor
   return new Promise((resolve) => {
     let settled = false;
     let worker;
+    let shutdown;
     let deadline;
     const finish = (outcome, reason, detail) => {
       if (settled)
@@ -1637,7 +1736,7 @@ function searchMessageHistoryOffThread(db, request, entry = defaultAutoSearchWor
       clearTimeout(deadline);
       if (reason)
         fallback(reason, detail);
-      worker?.terminate();
+      shutdown?.close();
       worker?.unref();
       resolve(outcome);
     };
@@ -1648,6 +1747,7 @@ function searchMessageHistoryOffThread(db, request, entry = defaultAutoSearchWor
     };
     try {
       worker = inRootAsyncContext2(() => new Worker(entry, { workerData: input }));
+      shutdown = createWorkerShutdown(worker, "message-search", MESSAGE_SEARCH_WORKER_CLOSE_DEADLINE_MS);
     } catch (error) {
       finish(null, "start-failed", error);
       return;
@@ -1916,7 +2016,8 @@ async function runAutoSearchHint(args) {
           },
           isEmbeddingRuntimeEnabled: () => embeddingEnabled === true,
           visibleMemoryIds: options.visibleMemoryIds ?? null,
-          sources: ["memory", "message", "git_commit"]
+          sources: ["memory", "message", "git_commit"],
+          chunkPoolWarmOnly: true
         };
         return searchAutoHint(db, sessionId, options.projectPath, rawPrompt, {
           ...searchOptions,
@@ -1927,6 +2028,11 @@ async function runAutoSearchHint(args) {
     } catch (error) {
       if (lifecycleSignal.aborted)
         return AUTO_SEARCH_OK;
+      if (error instanceof AutoSearchBusyError) {
+        sessionLog2(sessionId, "auto-search: an earlier search of this session is still running, skipping hint for this turn");
+        persistAutoSearchSkip(db, sessionId, userMsgId);
+        return { ok: false, kind: "timeout" };
+      }
       log2(`[auto-search] unified search failed for session ${sessionId} (no-hint frozen for this turn): ${error instanceof Error ? error.message : String(error)}`);
       const outcome = await writeNoHintAndReconcile("error");
       return outcome.ok ? { ok: false, kind: "search-failure" } : outcome;
@@ -1976,7 +2082,7 @@ ${hintText}`;
       if (outcome.decision.decision === "hint") {
         appendReminderToUserMessageById(messages, userMsgId, outcome.decision.text);
       }
-      sessionLog2(sessionId, `auto-search: attached hint to ${userMsgId} (${results.length} fragments, top score ${results[0].score.toFixed(3)})`);
+      sessionLog2(sessionId, `auto-search: attached hint to ${userMsgId} (${results.length} fragments, top relevance ${(results[0].relevanceScore ?? results[0].score).toFixed(3)})`);
       return AUTO_SEARCH_OK;
     } finally {
       if (!lifecycleSignal.aborted && results !== null)
@@ -2285,6 +2391,22 @@ function resolveTodowriteAvailability(sessionId) {
   return resolveToolAvailability(sessionId, TODOWRITE_TOOL);
 }
 
+// src/hooks/magic-context/diagnostic-log-state.ts
+var states = new BoundedSessionMap(1000);
+var scope = (sessionId) => `${getMagicContextStorageDir()}\x00${getHarness2()}\x00${sessionId}`;
+function diagnosticStateChanged(sessionId, category, state) {
+  const key = scope(sessionId);
+  const previous = states.get(key) ?? new Map;
+  if (previous.get(category) === state)
+    return false;
+  previous.set(category, state);
+  states.set(key, previous);
+  return true;
+}
+function clearDiagnosticLogState(sessionId) {
+  states.delete(scope(sessionId));
+}
+
 // src/hooks/magic-context/cache-busting-signals.ts
 function canConsumeDeferredOnThisPass(args) {
   if (args.justAwaitedPublication)
@@ -2292,7 +2414,7 @@ function canConsumeDeferredOnThisPass(args) {
   return args.schedulerDecision === "execute" || args.contextPercentage >= (args.forceMaterializationPercentage ?? escalationBands(65).forceMaterializationPercentage);
 }
 function hasReclaimRide(signals) {
-  return signals.hardFold || signals.force || signals.explicitFlush || signals.publishedHistory || signals.subagentExecute === true;
+  return signals.hardFold || signals.force || signals.explicitFlush || signals.publishedHistory || signals.subagentExecute === true || signals.executeReclaim === true;
 }
 function prefixMutationPermitted(gate) {
   return !gate.signedThinkingHold || gate.firstRender || gate.idleExpiry || gate.emergency;
@@ -2305,13 +2427,233 @@ var RECLAIM_RIDE_NAMES = [
   "force",
   "explicitFlush",
   "publishedHistory",
-  "subagentExecute"
+  "subagentExecute",
+  "executeReclaim"
 ];
 function reclaimRideLabel(signals) {
   const active = RECLAIM_RIDE_NAMES.filter((name) => signals[name]);
   return `ride=${active.length > 0 ? active.join("+") : "none"}`;
 }
 
+// src/hooks/magic-context/pending-drop-eligibility.ts
+function pendingDropVeto(tagNumber, target, protectedTagIds) {
+  if (protectedTagIds.has(tagNumber))
+    return "protected";
+  if (target?.thinkingDropProtected)
+    return "active_thinking";
+  return null;
+}
+function capturePendingDropEligibility(targets, protectedTagIds) {
+  const eligible = new Set;
+  for (const [number, target] of targets) {
+    if (pendingDropVeto(number, target, protectedTagIds))
+      continue;
+    if (target.drop) {
+      if (target.canDrop?.() === true)
+        eligible.add(number);
+    } else {
+      const content = target.getContent?.();
+      const replacement = `[dropped §${number}§]`;
+      if (typeof content === "string" && content.length > replacement.length && target.canSetContent?.(replacement) !== false)
+        eligible.add(number);
+    }
+  }
+  return eligible;
+}
+function pendingDropEligibilityKey(db, sessionId, input, protectionInputs) {
+  const digests = input.map((message) => message.contentDigest?.() ?? null);
+  if (digests.some((digest) => digest === null))
+    return null;
+  const revision = db.prepare("SELECT value FROM schema_migrations_meta WHERE key = ?").get(tagRevisionKey(sessionId));
+  if (!revision?.value)
+    return null;
+  return JSON.stringify([
+    input.map((message, index) => [
+      message.id,
+      message.role,
+      message.synthetic,
+      digests[index]
+    ]),
+    revision.value,
+    readEpochFloorSnapshot(db, sessionId),
+    sessionDecisionCalibration(db, sessionId).toolsRatio,
+    loadProtectedTailMeta(db, sessionId),
+    [...getMergedReasoningStrippedIds(db, sessionId)].sort(),
+    [...getReasoningRemovalState(db, sessionId).messageIds].sort(),
+    protectionInputs
+  ]);
+}
+function createPendingDropEligibilityCache() {
+  const sessions = new Map;
+  return {
+    read(sessionId, key) {
+      const previous = sessions.get(sessionId);
+      if (key === null || previous?.key !== key) {
+        sessions.delete(sessionId);
+        return;
+      }
+      return previous.eligible;
+    },
+    record(sessionId, key, eligible) {
+      sessions.delete(sessionId);
+      if (key === null)
+        return;
+      const oldest = sessions.keys().next().value;
+      if (sessions.size >= 64 && oldest !== undefined)
+        sessions.delete(oldest);
+      sessions.set(sessionId, { key, eligible: new Set(eligible) });
+    }
+  };
+}
+
+// src/hooks/magic-context/postprocess-read-cache.ts
+var connections = new WeakMap;
+function snapshot(db, sessionId) {
+  const transaction = db;
+  try {
+    if (transaction.inTransaction || transaction.isTransaction) {
+      connections.delete(db);
+      return { version: -1, changes: -1 };
+    }
+  } catch {
+    connections.delete(db);
+    return { version: -1, changes: -1 };
+  }
+  let connection = connections.get(db);
+  if (!connection) {
+    connection = {
+      stamp: db.prepare("SELECT total_changes() AS changes, data_version AS version FROM pragma_data_version"),
+      sessions: new BoundedSessionMap(100)
+    };
+    connections.set(db, connection);
+  }
+  const stamp = connection.stamp.get();
+  const previous = connection.sessions.get(sessionId);
+  if (previous?.version === stamp.version && previous.changes === stamp.changes) {
+    return previous;
+  }
+  const value = { ...stamp };
+  connection.sessions.set(sessionId, value);
+  return value;
+}
+function postprocessTailTags(db, sessionId) {
+  const state = snapshot(db, sessionId);
+  return state.tags ??= getTailHygieneTags2(db, sessionId);
+}
+function postprocessOldestTags(db, sessionId, protectedNumbers) {
+  const state = snapshot(db, sessionId);
+  const hints = state.hints;
+  if (hints && hints.protectedNumbers.size === protectedNumbers.size && [...protectedNumbers].every((number) => hints.protectedNumbers.has(number))) {
+    return hints.value;
+  }
+  const value = getOldestActiveUnprotectedToolTags2(db, sessionId, protectedNumbers);
+  state.hints = { protectedNumbers: new Set(protectedNumbers), value };
+  return value;
+}
+function postprocessReplaySnapshot(db, sessionId) {
+  const state = snapshot(db, sessionId);
+  const replay = state.replay ??= loadPostprocessReplaySnapshot(db, sessionId);
+  return {
+    ...replay,
+    staleReduceStrippedIds: new Set(replay.staleReduceStrippedIds),
+    processedImageStrippedIds: new Set(replay.processedImageStrippedIds),
+    processedImageMarkers: new Map(replay.processedImageMarkers),
+    strippedPlaceholderIds: new Set(replay.strippedPlaceholderIds),
+    hiddenSeamPlaceholderIds: new Set(replay.hiddenSeamPlaceholderIds),
+    mergedReasoningStrippedIds: new Set(replay.mergedReasoningStrippedIds),
+    trailingBlankDecisions: new Map(replay.trailingBlankDecisions),
+    noteNudgeAnchors: structuredClone(replay.noteNudgeAnchors),
+    autoSearchHintDecisions: structuredClone(replay.autoSearchHintDecisions),
+    todoSyntheticAnchor: structuredClone(replay.todoSyntheticAnchor),
+    pendingCompactionMarker: structuredClone(replay.pendingCompactionMarker),
+    compactionMarker: structuredClone(replay.compactionMarker)
+  };
+}
+
+// src/hooks/magic-context/execute-reclaim.ts
+var NAMESPACE = "executeReclaim";
+var failedWrites = new WeakMap;
+function readExecuteReclaimState(db, sessionId) {
+  return parseState(postprocessReplaySnapshot(db, sessionId).executeReclaim);
+}
+function parseState(lane) {
+  const value = lane;
+  return {
+    heldPasses: typeof value?.heldPasses === "number" ? Math.max(0, value.heldPasses) : 0,
+    floorOrdinal: typeof value?.floorOrdinal === "number" ? value.floorOrdinal : null,
+    floorPromptId: typeof value?.floorPromptId === "string" ? value.floorPromptId : null
+  };
+}
+function writeExecuteReclaimState(db, sessionId, patch) {
+  if (failedWrites.get(db)?.has(sessionId))
+    return false;
+  try {
+    const current = readExecuteReclaimState(db, sessionId);
+    if (JSON.stringify(current) === JSON.stringify({ ...current, ...patch }))
+      return true;
+    if (!updateReplayDocument(db, sessionId, (doc) => {
+      const previous = parseState(doc[NAMESPACE]);
+      const state = { ...previous, ...patch };
+      if (JSON.stringify(previous) === JSON.stringify(state))
+        return false;
+      doc.version = 2;
+      doc[NAMESPACE] = state;
+      return true;
+    }))
+      throw new Error("Could not persist execute reclaim state");
+    return true;
+  } catch (error) {
+    let failed = failedWrites.get(db);
+    if (!failed)
+      failedWrites.set(db, failed = new Set);
+    failed.add(sessionId);
+    sessionLog2(sessionId, `execute reclaim state persistence failed; retaining existing policy: ${String(error)}`);
+    return false;
+  }
+}
+function clearExecuteReclaimState(db, sessionId) {
+  writeExecuteReclaimState(db, sessionId, {
+    heldPasses: 0,
+    floorOrdinal: null,
+    floorPromptId: null
+  });
+}
+function maintainExecuteFloorMark(db, sessionId, promptId, belowExecute) {
+  failedWrites.get(db)?.delete(sessionId);
+  const state = readExecuteReclaimState(db, sessionId);
+  if (state.floorOrdinal !== null && (belowExecute || promptId !== null && promptId !== state.floorPromptId)) {
+    writeExecuteReclaimState(db, sessionId, { floorOrdinal: null, floorPromptId: null });
+  }
+}
+function estimateExecuteReclaimTokens(args) {
+  const eligible = capturePendingDropEligibility(args.targets, args.protectedTagIds);
+  const queued = new Set(args.pendingOps.filter((op) => op.operation === "drop").map((op) => op.tagId));
+  const candidates = args.tags.filter((tag) => tag.status === "active" && queued.has(tag.tagNumber) && eligible.has(tag.tagNumber));
+  const preparationTargets = new Map;
+  for (const tag of candidates) {
+    const target = args.targets.get(tag.tagNumber);
+    if (target?.prepareDrop)
+      preparationTargets.set(tag.tagNumber, target);
+  }
+  const prepared = preparationTargets.size === 0 ? new Set : args.probePreparation?.(preparationTargets) ?? new Set([...preparationTargets].filter(([, target]) => target.prepareDrop?.() !== false).map(([number]) => number));
+  const seed = sessionDecisionCalibration(args.db, args.sessionId);
+  return candidates.reduce((total, tag) => {
+    if (preparationTargets.has(tag.tagNumber) && !prepared.has(tag.tagNumber))
+      return total;
+    const ratio = tag.type === "tool" ? seed.toolsRatio : seed.proseRatio;
+    return total + Math.max(0, (tag.tokenCount ?? Math.ceil(tag.byteSize / 4)) * ratio);
+  }, 0);
+}
+function originateExecuteReclaim(args) {
+  if (failedWrites.get(args.db)?.has(args.sessionId))
+    return false;
+  const state = readExecuteReclaimState(args.db, args.sessionId);
+  const heldPasses = args.primaryExecute && args.reclaimableTokens > 0 && !args.alreadyBusting ? state.heldPasses + 1 : 0;
+  if (!writeExecuteReclaimState(args.db, args.sessionId, { heldPasses }))
+    return false;
+  return args.primaryExecute && !args.alreadyBusting && !args.summaryCanCome && args.reclaimableTokens > 0 && (args.usableWindow > 0 && args.reclaimableTokens >= args.usableWindow * 0.02 || heldPasses >= 3);
+}
+
 // src/hooks/magic-context/reasoning-budget-status.ts
 var sources = new Map;
 function captureOpencodeReasoningBudgetStatus(sessionId, messages, budget, prefixBound, proseRatio = 1) {
@@ -2594,6 +2936,9 @@ function latestAssistantTurnStart(messages) {
 function latestAssistantTurnMessages(messages) {
   return new Set(messages.slice(latestAssistantTurnStart(messages)));
 }
+function isAnthropicThinkingPart(part, familyRoute) {
+  return isRecord(part) && THINKING_TYPES.has(String(part.type ?? part.kind)) && (familyRoute || isRecord(part.metadata) && isRecord(part.metadata.anthropic));
+}
 function hasActiveAnthropicThinkingTurn(messages, provider, model) {
   const familyRoute = isAnthropicFamilyRoute(provider, model);
   for (const message of messages.slice(latestAssistantTurnStart(messages))) {
@@ -2602,7 +2947,7 @@ function hasActiveAnthropicThinkingTurn(messages, provider, model) {
     const parts = content(message);
     if (!Array.isArray(parts))
       continue;
-    if (parts.some((part) => isRecord(part) && THINKING_TYPES.has(String(part.type ?? part.kind)) && (familyRoute || isRecord(part.metadata) && isRecord(part.metadata.anthropic))))
+    if (parts.some((part) => isAnthropicThinkingPart(part, familyRoute)))
       return true;
   }
   return false;
@@ -2678,14 +3023,14 @@ function retainedActiveThinkingParts(args) {
 }
 
 // src/features/magic-context/storage-caveman-rules.ts
-var NAMESPACE = "caveman";
+var NAMESPACE2 = "caveman";
 var CURRENT_RULES_VERSION = 2;
 var ORIGINAL_RULES = {
   currentRules: false,
   englishWordRules: true,
   legacyReasoningTags: new Set
 };
-function parseState(lane) {
+function parseState2(lane) {
   if (!isRecord(lane) || lane.rules !== CURRENT_RULES_VERSION)
     return ORIGINAL_RULES;
   const tags = Array.isArray(lane.legacyReasoningTags) ? lane.legacyReasoningTags : [];
@@ -2697,7 +3042,7 @@ function parseState(lane) {
 }
 function getCavemanReplayState(db, sessionId) {
   try {
-    return parseState(readReplayEnvelope(db, sessionId)[NAMESPACE]);
+    return parseState2(readReplayEnvelope(db, sessionId)[NAMESPACE2]);
   } catch (error) {
     if (error instanceof ReplayDocumentError)
       return ORIGINAL_RULES;
@@ -2707,11 +3052,11 @@ function getCavemanReplayState(db, sessionId) {
 function recordCavemanCurrentRules(db, sessionId, englishWordRules, legacyReasoningTags) {
   const tags = [...new Set(legacyReasoningTags)].sort((a, b) => a - b);
   const persisted = updateReplayDocument(db, sessionId, (doc) => {
-    const current = parseState(doc[NAMESPACE]);
+    const current = parseState2(doc[NAMESPACE2]);
     if (current.currentRules && current.englishWordRules === englishWordRules)
       return false;
     doc.version = 2;
-    doc[NAMESPACE] = {
+    doc[NAMESPACE2] = {
       rules: CURRENT_RULES_VERSION,
       legacyReasoningTags: current.currentRules ? [...current.legacyReasoningTags].sort((a, b) => a - b) : tags,
       ...englishWordRules ? {} : { englishWordRules: false }
@@ -2925,93 +3270,23 @@ function degradedPassError(site, error) {
   return new DegradedPassRefusalError(site, { cause: error });
 }
 
-// src/hooks/magic-context/pending-drop-eligibility.ts
-function pendingDropVeto(tagNumber, target, protectedTagIds) {
-  if (protectedTagIds.has(tagNumber))
-    return "protected";
-  if (target?.thinkingDropProtected)
-    return "active_thinking";
-  return null;
-}
-function capturePendingDropEligibility(targets, protectedTagIds) {
-  const eligible = new Set;
-  for (const [number, target] of targets) {
-    if (pendingDropVeto(number, target, protectedTagIds))
-      continue;
-    if (target.drop) {
-      if (target.canDrop?.() === true)
-        eligible.add(number);
-    } else {
-      const content = target.getContent?.();
-      if (typeof content === "string" && content.length > `[dropped §${number}§]`.length)
-        eligible.add(number);
-    }
-  }
-  return eligible;
-}
-function pendingDropEligibilityKey(db, sessionId, input, protectionInputs) {
-  const digests = input.map((message) => message.contentDigest?.() ?? null);
-  if (digests.some((digest) => digest === null))
-    return null;
-  const revision = db.prepare("SELECT value FROM schema_migrations_meta WHERE key = ?").get(tagRevisionKey(sessionId));
-  if (!revision?.value)
-    return null;
-  return JSON.stringify([
-    input.map((message, index) => [
-      message.id,
-      message.role,
-      message.synthetic,
-      digests[index]
-    ]),
-    revision.value,
-    readEpochFloorSnapshot(db, sessionId),
-    sessionDecisionCalibration(db, sessionId).toolsRatio,
-    loadProtectedTailMeta(db, sessionId),
-    [...getMergedReasoningStrippedIds(db, sessionId)].sort(),
-    [...getReasoningRemovalState(db, sessionId).messageIds].sort(),
-    protectionInputs
-  ]);
-}
-function createPendingDropEligibilityCache() {
-  const sessions = new Map;
-  return {
-    read(sessionId, key) {
-      const previous = sessions.get(sessionId);
-      if (key === null || previous?.key !== key) {
-        sessions.delete(sessionId);
-        return;
-      }
-      return previous.eligible;
-    },
-    record(sessionId, key, eligible) {
-      sessions.delete(sessionId);
-      if (key === null)
-        return;
-      const oldest = sessions.keys().next().value;
-      if (sessions.size >= 64 && oldest !== undefined)
-        sessions.delete(oldest);
-      sessions.set(sessionId, { key, eligible: new Set(eligible) });
-    }
-  };
-}
-
 // src/features/magic-context/storage-host-instruction-retention.ts
-var NAMESPACE2 = "hostInstructionRetention";
+var NAMESPACE3 = "hostInstructionRetention";
 var enabled = true;
 function hostInstructionRetentionEnabled() {
   return enabled;
 }
 function isHostInstructionRetentionOn(db, sessionId) {
-  const lane = readReplayEnvelope(db, sessionId)[NAMESPACE2];
+  const lane = readReplayEnvelope(db, sessionId)[NAMESPACE3];
   return typeof lane === "object" && lane !== null && lane.on === true;
 }
 function markHostInstructionRetention(db, sessionId) {
   return updateReplayDocument(db, sessionId, (doc) => {
-    const lane = doc[NAMESPACE2];
+    const lane = doc[NAMESPACE3];
     if (typeof lane === "object" && lane !== null && lane.on === true)
       return false;
     doc.version = 2;
-    doc[NAMESPACE2] = { on: true };
+    doc[NAMESPACE3] = { on: true };
     return true;
   });
 }
@@ -3301,12 +3576,16 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
               }
             } else if (target) {
               const replacement = buildReplacementContent(pendingOp.tagId);
+              if (target.canSetContent?.(replacement) === false) {
+                reject("content_unchanged");
+                continue;
+              }
               persistDrop();
               mutations.push(() => {
                 const priorContent = target.getContent?.();
                 const changed = target.setContent(replacement);
-                record(changed);
                 if (changed) {
+                  record(true);
                   const originalCharacters = typeof priorContent === "string" ? priorContent.length : tagById.get(pendingOp.tagId)?.byteSize ?? replacement.length;
                   onTagReduced?.({
                     tagNumber: pendingOp.tagId,
@@ -3877,70 +4156,6 @@ function isVisibleNoteReadPart(part) {
   return false;
 }
 
-// src/hooks/magic-context/postprocess-read-cache.ts
-var connections = new WeakMap;
-function snapshot(db, sessionId) {
-  const transaction = db;
-  try {
-    if (transaction.inTransaction || transaction.isTransaction) {
-      connections.delete(db);
-      return { version: -1, changes: -1 };
-    }
-  } catch {
-    connections.delete(db);
-    return { version: -1, changes: -1 };
-  }
-  let connection = connections.get(db);
-  if (!connection) {
-    connection = {
-      stamp: db.prepare("SELECT total_changes() AS changes, data_version AS version FROM pragma_data_version"),
-      sessions: new BoundedSessionMap(100)
-    };
-    connections.set(db, connection);
-  }
-  const stamp = connection.stamp.get();
-  const previous = connection.sessions.get(sessionId);
-  if (previous?.version === stamp.version && previous.changes === stamp.changes) {
-    return previous;
-  }
-  const value = { ...stamp };
-  connection.sessions.set(sessionId, value);
-  return value;
-}
-function postprocessTailTags(db, sessionId) {
-  const state = snapshot(db, sessionId);
-  return state.tags ??= getTailHygieneTags2(db, sessionId);
-}
-function postprocessOldestTags(db, sessionId, protectedNumbers) {
-  const state = snapshot(db, sessionId);
-  const hints = state.hints;
-  if (hints && hints.protectedNumbers.size === protectedNumbers.size && [...protectedNumbers].every((number) => hints.protectedNumbers.has(number))) {
-    return hints.value;
-  }
-  const value = getOldestActiveUnprotectedToolTags2(db, sessionId, protectedNumbers);
-  state.hints = { protectedNumbers: new Set(protectedNumbers), value };
-  return value;
-}
-function postprocessReplaySnapshot(db, sessionId) {
-  const state = snapshot(db, sessionId);
-  const replay = state.replay ??= loadPostprocessReplaySnapshot(db, sessionId);
-  return {
-    ...replay,
-    staleReduceStrippedIds: new Set(replay.staleReduceStrippedIds),
-    processedImageStrippedIds: new Set(replay.processedImageStrippedIds),
-    processedImageMarkers: new Map(replay.processedImageMarkers),
-    strippedPlaceholderIds: new Set(replay.strippedPlaceholderIds),
-    hiddenSeamPlaceholderIds: new Set(replay.hiddenSeamPlaceholderIds),
-    mergedReasoningStrippedIds: new Set(replay.mergedReasoningStrippedIds),
-    trailingBlankDecisions: new Map(replay.trailingBlankDecisions),
-    noteNudgeAnchors: structuredClone(replay.noteNudgeAnchors),
-    autoSearchHintDecisions: structuredClone(replay.autoSearchHintDecisions),
-    todoSyntheticAnchor: structuredClone(replay.todoSyntheticAnchor),
-    pendingCompactionMarker: structuredClone(replay.pendingCompactionMarker),
-    compactionMarker: structuredClone(replay.compactionMarker)
-  };
-}
-
 // src/hooks/magic-context/strict-thinking-prefix.ts
 function servedPrefixMatches(args) {
   const heads = args.messages?.slice(0, 2);
@@ -4812,6 +5027,10 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
           dropReasoningParts: thinkingParts,
           mutationParts: [{ message, part: textPart }],
           textPrefix: skipPrefixInjection ? "" : prependTag(tagId, ""),
+          canSetContent: (content) => {
+            const partialEnd = messageId ? getPartialEnds().get(messageId) : undefined;
+            return textPart.text !== content && (partialEnd === undefined || partIndex <= partialEnd);
+          },
           setContent: (content, options) => {
             if (textPart.text === content)
               return false;
@@ -5118,6 +5337,25 @@ function proactiveStripStartIndex(args) {
     return divergence;
   return divergence ?? lastServed.messages.length;
 }
+function servesThinkingBlock2(messages, providerID, modelID) {
+  const familyRoute = isAnthropicFamilyRoute(providerID, modelID);
+  for (const message of messages) {
+    if (message.info.role !== "assistant")
+      continue;
+    for (const part of message.parts) {
+      if (!isAnthropicThinkingPart(part, familyRoute) || part.ignored === true)
+        continue;
+      if (part.type === "redacted_thinking")
+        return true;
+      if (typeof part.text === "string" && part.text !== "")
+        return true;
+      const records = isRecord(part.metadata) ? Object.values(part.metadata) : [];
+      if (records.some((record) => isRecord(record) && record.redactedData !== undefined))
+        return true;
+    }
+  }
+  return false;
+}
 function isPartDroppedBeforeWire(part, providerID) {
   if (!modelAcceptsEmptyContent(providerID) || !isRecord(part))
     return false;
@@ -5720,6 +5958,8 @@ async function runPostTransformPhase2(args) {
     if (stripOffWire)
       for (const id of stripped.strip?.messageIds ?? [])
         compactionOffFrozenThinking.add(id);
+    for (const id of stripped.strip?.messageIds ?? [])
+      bindingThinking.add(id);
     retainedThinking.clear();
     protectedThinkingMessages.clear();
     activeThinkingTurn = false;
@@ -5732,6 +5972,10 @@ async function runPostTransformPhase2(args) {
   if (args.forceSignedRebuildForFit && (activeThinkingPrefixHold || activeThinkingTurn && args.thinkingBindingRecoveryEnabledForModel === true)) {
     releaseThinkingForRewrite(true);
   }
+  if (args.compactionModeTransition === true && args.thinkingBindingRecoveryEnabledForModel === true) {
+    sessionLog2(args.sessionId, "compaction mode switch: stripping signed thinking");
+    releaseThinkingForRewrite(false, true);
+  }
   const foldDueDecision = m0M1EnabledForFold && args.m0M1 && !freezeM0M1 ? mustMaterialize({
     db: args.db,
     sessionId: args.sessionId,
@@ -5771,6 +6015,7 @@ async function runPostTransformPhase2(args) {
   };
   if ((foldDueDecision.value || softRefreshOpportunity || firstRenderBust && activeThinkingPrefixHold) && m0M1EnabledForFold && args.m0M1) {
     let committedFoldBustsServedPrefix;
+    let committedFoldChangesHead;
     try {
       const previousM1 = args.sessionMeta.cachedM1Bytes?.toString("utf8");
       const foldResult = injectM0M1({
@@ -5800,6 +6045,12 @@ async function runPostTransformPhase2(args) {
               m1Text: rendered.m1Bytes.toString(),
               muralDataUrl: rendered.muralDataUrl
             }) : foldBustsServedPrefix(foldDueDecision.reason, servedPrefixBeforeFold, rendered);
+            committedFoldChangesHead = firstRenderBust ? !servedPrefixMatches({
+              messages: servedBeforeFirstRender,
+              m0Text: rendered.m0Bytes.toString(),
+              m1Text: rendered.m1Bytes.toString(),
+              muralDataUrl: rendered.muralDataUrl
+            }) : foldChangesServedPrefix(servedPrefixBeforeFold, rendered);
             if (bustsPrefix) {
               if (!conversions.isCurrent(db)) {
                 throw new MaterializeContentionError({
@@ -5818,6 +6069,9 @@ async function runPostTransformPhase2(args) {
       preparedPrefix = foldResult;
       if (activeThinkingPrefixHold && firstRenderBust && committedFoldBustsServedPrefix) {
         releaseThinkingForRewrite(false, true);
+      } else if (compactionOff && !activeThinkingPrefixHold && args.thinkingBindingRecoveryEnabledForModel === true && committedFoldChangesHead) {
+        sessionLog2(args.sessionId, "compaction-off fold changed the head: stripping signed thinking");
+        releaseThinkingForRewrite(false, true);
       }
       prefixPreflightFailed = foldResult.materializationContentionRetryExhausted === true;
       foldExecutedThisPass = foldExecutesThisPass(foldDueDecision.value || softRefreshOpportunity, foldResult.m0RematerializedThisPass);
@@ -5875,12 +6129,30 @@ async function runPostTransformPhase2(args) {
   const heldIdleExpiryRebuild = activeThinkingPrefixHold && args.m0M1?.hardSignals?.cacheExpired === true;
   const idleExpiryRebuild = (!freezeM0M1 || activeThinkingPrefixHold) && args.m0M1?.hardSignals?.cacheExpired === true;
   const rideSignals = {
+    executeReclaim: false,
     subagentExecute: !args.fullFeatureMode && args.schedulerDecision === "execute",
     hardFold: rewritingSignedPrefix || foldBustsServedPrefixThisPass || firstRenderBust || idleExpiryRebuild,
     force: emergencyDropEligible && (args.contextUsage.percentage >= 95 || args.contextUsageFromEstimate !== true && getEmergencyInputSample(args.db, args.sessionId) === 0),
     explicitFlush: isExplicitFlush && hasPendingMaterializationOrigin(args.pendingMaterializationSessions, args.sessionId, "user_flush"),
     publishedHistory: !prefixPreflightFailed && (publishedM1RefreshedThisPass || !m0M1EnabledForFold && (args.pendingCompartmentInjection?.compartmentCount ?? 0) > 0 && legacyPublishedHeadChanged(args))
   };
+  const protectedToolTags = protectedToolTagNumbers(args.tags, args.protectedTools);
+  rideSignals.executeReclaim = !compactionOff && originateExecuteReclaim({
+    db: args.db,
+    sessionId: args.sessionId,
+    primaryExecute: args.fullFeatureMode && args.schedulerDecision === "execute" && args.contextUsage.percentage < args.forceMaterializationPercentage,
+    alreadyBusting: Object.values(rideSignals).some(Boolean) || args.historyRebuiltThisPass,
+    summaryCanCome: compartmentRunning || args.sessionMeta.compartmentInProgress || (prefixPreflightFailed || freezeM0M1 || activeThinkingPrefixHold) && (args.deferredHistoryRefreshSessions.has(args.sessionId) || args.deferredMaterializationSessions.has(args.sessionId) || args.historyRefreshSessions?.has(args.sessionId) === true) || readExecuteReclaimState(args.db, args.sessionId).floorOrdinal !== null,
+    reclaimableTokens: estimateExecuteReclaimTokens({
+      db: args.db,
+      sessionId: args.sessionId,
+      pendingOps,
+      tags: args.tags,
+      targets: newTargets,
+      protectedTagIds: new Set([...args.protectedTagIds, ...protectedToolTags])
+    }),
+    usableWindow: args.usableWindow
+  });
   const publishedWorkDrainAllowed = !compactionOff && reclaimRidePermitted(rideSignals, {
     signedThinkingHold: activeThinkingPrefixHold,
     firstRender: firstRenderBust,
@@ -5888,7 +6160,7 @@ async function runPostTransformPhase2(args) {
     emergency: emergencyDropEligible
   });
   const shouldApplyPendingOps = publishedWorkDrainAllowed;
-  const shouldRunHeuristics = publishedWorkDrainAllowed && (rideSignals.publishedHistory || materializationRequested || forceMaterialization || foldBustsServedPrefixThisPass || firstRenderBust || heldIdleExpiryRebuild || emergencyDropEligible || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
+  const shouldRunHeuristics = publishedWorkDrainAllowed && (rideSignals.publishedHistory || rideSignals.executeReclaim || materializationRequested || forceMaterialization || foldBustsServedPrefixThisPass || firstRenderBust || heldIdleExpiryRebuild || emergencyDropEligible || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
   const isCacheBustingPass = publishedWorkDrainAllowed;
   let unheldSignedTurnBust = false;
   if (isCacheBustingPass && !activeThinkingPrefixHold && activeThinkingTurn && args.thinkingBindingRecoveryEnabledForModel === true) {
@@ -5980,17 +6252,28 @@ async function runPostTransformPhase2(args) {
       throw new EmergencyFailClosedError("Magic Context could not read its saved reasoning-removal state for this session", { cause: error });
     }
   }
+  const heuristicsLogChanged = diagnosticStateChanged(args.sessionId, "heuristics", JSON.stringify([
+    args.currentTurnId,
+    shouldRunHeuristics,
+    shouldRunHeuristics ? null : args.schedulerDeferReason
+  ]));
+  const pendingLogChanged = diagnosticStateChanged(args.sessionId, "pending-ops", JSON.stringify([
+    args.currentTurnId,
+    shouldApplyPendingOps,
+    shouldApplyPendingOps ? null : args.schedulerDeferReason,
+    shouldApplyPendingOps ? null : (getPendingOpsCount(args.db, args.sessionId) ?? 0) > 0
+  ]));
   if (shouldRunHeuristics) {
     const subagentRerun = !args.fullFeatureMode && alreadyRanThisTurn && args.schedulerDecision === "execute" && !isExplicitFlush && !forceMaterialization;
     const reason = isExplicitFlush ? `pending_materialization origin=${pendingOrigin}` : deferredMaterialize ? "deferred_materialization" : forceMaterialization ? `force_materialization (${args.contextUsage.percentage.toFixed(1)}% >= ${args.forceMaterializationPercentage}%)` : foldBustsServedPrefixThisPass && args.schedulerDecision !== "execute" ? `m0_hard_fold (drain folded into executed m[0] bust, scheduler=${args.schedulerDecision})` : subagentRerun ? `${reclaimRideLabel(rideSignals)} subagent_rerun (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})` : `${reclaimRideLabel(rideSignals)} (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})`;
     sessionLog2(args.sessionId, `heuristics WILL RUN — reason=${reason}, context=${args.contextUsage.percentage.toFixed(1)}%, turn=${args.currentTurnId}`);
-  } else if (args.schedulerDeferReason !== undefined && args.schedulerDeferReason !== null) {
+  } else if (heuristicsLogChanged && args.schedulerDeferReason !== undefined && args.schedulerDeferReason !== null) {
     sessionLog2(args.sessionId, `heuristics WILL NOT RUN — reason=${args.schedulerDeferReason}`);
   }
   if (alreadyRanThisTurn && args.schedulerDecision === "execute" && !materializationRequested && args.fullFeatureMode) {
     sessionLog2(args.sessionId, `transform: skipping heuristics (already ran for turn ${args.currentTurnId})`);
   }
-  if (!shouldApplyPendingOps && args.schedulerDeferReason !== undefined && args.schedulerDeferReason !== null) {
+  if (!shouldApplyPendingOps && pendingLogChanged && args.schedulerDeferReason !== undefined && args.schedulerDeferReason !== null) {
     sessionLog2(args.sessionId, `pending ops WILL NOT APPLY — reason=${args.schedulerDeferReason} pendingOps=${formatPendingOpsDepth()} context=${args.contextUsage.percentage.toFixed(1)}%`);
   }
   if (hasPendingUserOps && !shouldApplyPendingOps) {
@@ -5999,7 +6282,6 @@ async function runPostTransformPhase2(args) {
   let explicitMaterializedSuccessfully = false;
   let deferredMaterializedSuccessfully = false;
   let pendingOpsDidMutate = false;
-  const protectedToolTags = protectedToolTagNumbers(args.tags, args.protectedTools);
   const firstApplicationEdits = { any: false, beforeNewerThinking: false };
   const recordFirstApplicationWireEdit = (beforeNewerThinking) => {
     firstApplicationEdits.any = true;
@@ -7080,6 +7362,8 @@ async function runPostTransformPhase2(args) {
     });
   }
   logTransformTiming(args.sessionId, "pp.tailGuard", tTailGuard);
+  if (bustedThisPass)
+    clearExecuteReclaimState(args.db, args.sessionId);
   return {
     explicitMaterializedSuccessfully,
     deferredMaterializedSuccessfully,
@@ -7100,8 +7384,7 @@ async function runPostTransformPhase2(args) {
     prefixTrimStatus: deliveredPrefix?.prefixTrimStatus ?? null,
     thinkingBindingRecovery,
     proactiveThinkingStrip,
-    thinkingReleasedForFit,
-    openTurnSignedThinkingKept: args.thinkingBindingRecoveryEnabledForModel === true && activeThinkingTurn && !rewritingSignedPrefix
+    thinkingReleasedForFit
   };
 }
 function checkM0MutationDriftAndSignal2(args) {
@@ -7116,4 +7399,4 @@ function checkM0MutationDriftAndSignal2(args) {
   return false;
 }
 
-export { makeToolCompositeKey, createTagger, cavemanWordRulesForLanguage, searchMessageHistoryOffThread, findSessionId, findLastUserMessageId, clearAutoSearchForSession, setCtxReduceRegisteredGlobally, resolveCtxReduceAvailabilityFromMessages, resolveCtxReduceAvailability, primeCtxReduceSpawnPermission, ctxReduceSpawnPermissionReadNeeded, spawnAgentFromMessages, spawnAgentFromOpenCodeDb, todowritePermissionDenied, cachedToolPermissionDenied, clearToolPermissionDenied, resolveTodowriteAvailabilityFromMessages, resolveTodowriteAvailability, canConsumeDeferredOnThisPass, hasReclaimRide, reclaimRidePermitted, reclaimRideLabel, captureOpencodeReasoningBudgetStatus, reasoningBudgetStatusLine, ENGINE_RECONNECTING_USER_MESSAGE, ENGINE_BUSY_USER_MESSAGE, SIGNED_THINKING_RESET_FENCE_FAILED, contextRefusalError, protectedToolRefusal, outgoingContextRefusal, signedTurnContextRefusal, EmergencyFailClosedError, latestAssistantTurnStart, latestAssistantTurnMessages, hasActiveAnthropicThinkingTurn, replayCavemanCompression, DegradedPassRefusalError, degradedPassError, pendingDropEligibilityKey, createPendingDropEligibilityCache, applyFlushedStatuses, prewarmTagOwners, waitForTagOwners, stripStructuralNoise, withTransformTimingSummary, logTransformTiming, hasRecentAssistantCommit, tagMessages, resetDegradedCacheCount2, isSyntheticHeadMessage2, applyTodoSynthesis2, freezeReasoningOnBustingPass2, firstServedDivergenceIndex2, rustModeServedKeyAfterPersistedStrips2, replayRustModeBindingMismatchStrips2, RUST_MARKER_LOCK_SKIP_LOG2, applyRustModeDeferredCompactionMarker2, clearRustModeBoundaryRecord2, runRustModePostprocess2, reconcileMarkerRepresentation2, clearPendingCompactionMarkerAfterSuccessfulDrain2, defaultCompactionMarkerStrategy2, abortSessionFailClosed2, evaluateEmergencyFailClosed2, finalizeMessageRepresentation2, runPostTransformPhase2, checkM0MutationDriftAndSignal2 };
+export { makeToolCompositeKey, createTagger, cavemanWordRulesForLanguage, searchMessageHistoryOffThread, findSessionId, findLastUserMessageId, clearAutoSearchForSession, setCtxReduceRegisteredGlobally, resolveCtxReduceAvailabilityFromMessages, resolveCtxReduceAvailability, primeCtxReduceSpawnPermission, ctxReduceSpawnPermissionReadNeeded, spawnAgentFromMessages, spawnAgentFromOpenCodeDb, todowritePermissionDenied, cachedToolPermissionDenied, clearToolPermissionDenied, resolveTodowriteAvailabilityFromMessages, resolveTodowriteAvailability, diagnosticStateChanged, clearDiagnosticLogState, canConsumeDeferredOnThisPass, hasReclaimRide, reclaimRidePermitted, reclaimRideLabel, pendingDropEligibilityKey, createPendingDropEligibilityCache, readExecuteReclaimState, writeExecuteReclaimState, maintainExecuteFloorMark, captureOpencodeReasoningBudgetStatus, reasoningBudgetStatusLine, ENGINE_RECONNECTING_USER_MESSAGE, ENGINE_BUSY_USER_MESSAGE, SIGNED_THINKING_RESET_FENCE_FAILED, contextRefusalError, protectedToolRefusal, outgoingContextRefusal, signedTurnContextRefusal, EmergencyFailClosedError, latestAssistantTurnStart, latestAssistantTurnMessages, hasActiveAnthropicThinkingTurn, replayCavemanCompression, DegradedPassRefusalError, degradedPassError, applyFlushedStatuses, prewarmTagOwners, waitForTagOwners, stripStructuralNoise, withTransformTimingSummary, logTransformTiming, hasRecentAssistantCommit, tagMessages, resetDegradedCacheCount2, isSyntheticHeadMessage2, applyTodoSynthesis2, freezeReasoningOnBustingPass2, servesThinkingBlock2, firstServedDivergenceIndex2, rustModeServedKeyAfterPersistedStrips2, replayRustModeBindingMismatchStrips2, RUST_MARKER_LOCK_SKIP_LOG2, applyRustModeDeferredCompactionMarker2, clearRustModeBoundaryRecord2, runRustModePostprocess2, reconcileMarkerRepresentation2, clearPendingCompactionMarkerAfterSuccessfulDrain2, defaultCompactionMarkerStrategy2, abortSessionFailClosed2, evaluateEmergencyFailClosed2, finalizeMessageRepresentation2, runPostTransformPhase2, checkM0MutationDriftAndSignal2 };