@cortexkit/opencode-magic-context 0.49.16 → 0.49.18

package/dist/{index-kn4t1haw.js → index-e4xv8890.js}

@@ -34,10 +34,12 @@ import {
   getPendingOps,
   getPendingOpsCount,
   removePendingOp,
+  updateTagByteSize2,
   getRecentTagOwnerMessageIds2,
   AGE_RECLAIM_MIN_TOKENS2,
   getOldestActiveUnprotectedToolTags2,
   getActiveToolTagsForAgeReclaim2,
+  updateTagTokenCount2,
   tryGetReasoningTokenEstimatesByMessage2,
   cachedTagOwnerRatios2,
   tagOwnerWarmupState2,
@@ -71,12 +73,12 @@ import {
   adoptNullOwnerToolTag2,
   getCandidateToolOwners2,
   pickNearestPriorOwner2
-} from "./index-nd7m2a5a.js";
+} from "./index-cf74k5ak.js";
 import {
   textMentionsRecentCommit,
   hasMeaningfulUserText2,
   estimateTokens
-} from "./index-hqkczed7.js";
+} from "./index-c5pytzne.js";
 import {
   log2,
   sessionLog2
@@ -87,27 +89,61 @@ import {
   getSqliteDatabasePath2,
   assertTransformWrite2,
   isTransientSqliteError2
-} from "./index-wafzvyhg.js";
-import {
-  isValidLanguageCode
-} from "./index-wgypt3cs.js";
-import {
-  runSessionWarmupWorker
-} from "./index-7pa32z07.js";
+} from "./index-beht37jy.js";
 import {
   getProjectEmbeddingSnapshot2,
   embedTextForProject2,
   embedBatchForProject2
-} from "./index-qrahzcqv.js";
+} from "./index-ze7mvk54.js";
 import {
-  isEmbeddingHostBusy2
-} from "./index-qt1qqasc.js";
+  runSessionWarmupWorker
+} from "./index-s734jcsr.js";
+import {
+  getMaxM0MutationId,
+  getLastCompartmentEndMessage,
+  rememberUnpublishedAutoSearchNoHint,
+  getUnpublishedAutoSearchNoHint,
+  forgetUnpublishedAutoSearchNoHint,
+  registerAutoSearchWork,
+  cancelAutoSearchWork,
+  updateSessionMeta,
+  advanceToolReclaimWatermark,
+  requestPendingMaterialization,
+  pendingMaterializationOrigin,
+  hasPendingMaterializationOrigin,
+  clearPendingMaterialization,
+  saveSourceContent,
+  replaceSourceContent,
+  getSourceContents,
+  compareOpenCodeMessagesByCanonicalOrder,
+  prepareCompactionMarkerCandidates,
+  MARKER_SUMMARY_TEXT,
+  applyDeferredCompactionMarker,
+  injectTemporalMarkers,
+  clearInjectionCache,
+  getVisibleMemoryIds,
+  renderCompartmentInjection,
+  MaterializeContentionError,
+  mustMaterialize,
+  hydrateCachedM0Mural,
+  prepareCachedM0M1Replay,
+  hasCompleteCachedM0M1,
+  injectM0M1,
+  observeNoteNudgeServe,
+  peekNoteNudgeText,
+  markNoteNudgeDelivered,
+  getActiveCompartmentRun
+} from "./index-s1ex9y6p.js";
+import {
+  BoundedSessionMap,
+  cleanSearchText,
+  matchedSearchSnippet
+} from "./index-x4njr8df.js";
 import {
   stripSystemInjection,
   isTextPart,
   isToolPartWithOutput,
   isFilePart,
-  buildFileSourceContent,
   toolPartHasUserAnswer,
   isEditTool,
   escalationBands,
@@ -196,53 +232,21 @@ import {
   extractToolCallObservation,
   ToolMutationBatch,
   createToolDropTarget
-} from "./index-j6zw70pf.js";
+} from "./index-rmwykbbb.js";
 import {
-  getMaxM0MutationId,
-  rememberUnpublishedAutoSearchNoHint,
-  getUnpublishedAutoSearchNoHint,
-  forgetUnpublishedAutoSearchNoHint,
-  registerAutoSearchWork,
-  cancelAutoSearchWork,
-  updateSessionMeta,
-  advanceToolReclaimWatermark,
-  requestPendingMaterialization,
-  pendingMaterializationOrigin,
-  hasPendingMaterializationOrigin,
-  clearPendingMaterialization,
-  saveSourceContent,
-  replaceSourceContent,
-  getSourceContents,
-  compareOpenCodeMessagesByCanonicalOrder,
-  prepareCompactionMarkerCandidates,
-  MARKER_SUMMARY_TEXT,
-  applyDeferredCompactionMarker,
-  injectTemporalMarkers,
-  clearInjectionCache,
-  getVisibleMemoryIds,
-  renderCompartmentInjection,
-  MaterializeContentionError,
-  mustMaterialize,
-  hydrateCachedM0Mural,
-  prepareCachedM0M1Replay,
-  hasCompleteCachedM0M1,
-  injectM0M1,
-  observeNoteNudgeServe,
-  peekNoteNudgeText,
-  markNoteNudgeDelivered,
-  getActiveCompartmentRun
-} from "./index-ayym1x7f.js";
+  isValidLanguageCode
+} from "./index-wgypt3cs.js";
+import {
+  isEmbeddingHostBusy2
+} from "./index-qt1qqasc.js";
 import {
   openCodeDbExists,
   withReadOnlySessionDb,
   getMessageTimesFromOpenCodeDb
-} from "./index-mtw9e71a.js";
-import {
-  BoundedSessionMap
-} from "./index-p4vde22c.js";
+} from "./index-kq82mtg0.js";
 import {
   userFacingFailureCode
-} from "./index-wv9n2zcq.js";
+} from "./index-v8awdgvd.js";
 import {
   normalizeProtectedToolName,
   mergeProtectedTools
@@ -620,7 +624,8 @@ function createTagger() {
 }
 
 // src/hooks/magic-context/auto-search-deadline.ts
-var AUTO_SEARCH_TIMEOUT_MS = 3000;
+var AUTO_SEARCH_TIMEOUT_MS = 1000;
+var AUTO_SEARCH_VECTOR_TIMEOUT_MS = 200;
 var operationDeadlines = new WeakMap;
 function autoSearchDeadlineUnixMs(signal) {
   const deadline = signal && operationDeadlines.get(signal);
@@ -1176,32 +1181,32 @@ function formatAge(committedAtMs) {
   const years = Math.floor(days / 365);
   return years === 1 ? "1y ago" : `${years}y ago`;
 }
-function renderFragment(result, charCap, wordRules) {
+function renderFragment(result, charCap, wordRules, query) {
   switch (result.source) {
     case "memory": {
-      const compressed = cavemanCompress(result.content, "ultra", CURRENT_CAVEMAN_RULES, wordRules);
+      const compressed = cavemanCompress(cleanSearchText(result.content), "ultra", CURRENT_CAVEMAN_RULES, wordRules);
       return truncate(compressed, charCap);
     }
     case "git_commit": {
-      const subject = result.content.split(/\r?\n/)[0] ?? result.content;
+      const subject = cleanSearchText(result.content.split(/\r?\n/)[0] ?? result.content);
       const body = truncate(subject, Math.max(10, charCap - 20));
       return `commit ${result.shortSha} ${formatAge(result.committedAtMs)}: ${body}`;
     }
     case "message": {
-      const compressed = cavemanCompress(result.content, "ultra", CURRENT_CAVEMAN_RULES, wordRules);
+      const compressed = cavemanCompress(query ? matchedSearchSnippet(result.content, query, charCap) : cleanSearchText(result.content), "ultra", CURRENT_CAVEMAN_RULES, wordRules);
       return truncate(compressed, charCap);
     }
     case "compartment": {
-      const source = result.snippet ?? result.title;
+      const source = cleanSearchText(result.title);
       const compressed = cavemanCompress(source, "ultra", CURRENT_CAVEMAN_RULES, wordRules);
       return truncate(compressed, charCap);
     }
     case "primer": {
-      const compressed = cavemanCompress(result.content, "ultra", CURRENT_CAVEMAN_RULES, wordRules);
+      const compressed = cavemanCompress(cleanSearchText(result.content), "ultra", CURRENT_CAVEMAN_RULES, wordRules);
       return truncate(compressed, charCap);
     }
     case "note": {
-      const compressed = cavemanCompress(result.content, "ultra", CURRENT_CAVEMAN_RULES, wordRules);
+      const compressed = cavemanCompress(cleanSearchText(result.content), "ultra", CURRENT_CAVEMAN_RULES, wordRules);
       return truncate(compressed, charCap);
     }
   }
@@ -1212,7 +1217,7 @@ function buildAutoSearchHint(results, options = {}) {
   const picks = results.slice(0, maxFragments);
   const lines = [];
   for (const result of picks) {
-    const fragment = renderFragment(result, fragmentCharCap, options.wordRules ?? "english");
+    const fragment = renderFragment(result, fragmentCharCap, options.wordRules ?? "english", options.query ?? "");
     if (fragment.length === 0)
       continue;
     lines.push(`- ${fragment}`);
@@ -1235,6 +1240,9 @@ ${trimmedBody}…
   }
   return wrapped;
 }
+function selectAutoSearchResults(results, threshold) {
+  return results.filter((result) => (result.relevanceScore ?? result.score) >= threshold);
+}
 
 // src/hooks/magic-context/auto-search-worker-client.ts
 import { Worker } from "node:worker_threads";
@@ -1330,6 +1338,63 @@ async function searchAutoHint(db, sessionId, projectPath, query, options, entry
   return executeAutoSearchWorker(db, sessionId, projectPath, query, options, entry, "search");
 }
 var pendingBackfills = new WeakMap;
+var searchWorkers = new WeakMap;
+var liveSearchWorkers = new Set;
+var MAX_IDLE_SEARCH_WORKERS = 4;
+var SEARCH_WORKER_IDLE_MS = 5 * 60000;
+var workersCreated = 0;
+var workersReused = 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) {
+      const current = slot;
+      await new Promise((resolve) => {
+        const done = () => {
+          signal.removeEventListener("abort", done);
+          resolve();
+        };
+        signal.addEventListener("abort", done, { once: true });
+        current.busy?.then(done);
+        if (signal.aborted)
+          done();
+      });
+      continue;
+    }
+    const fresh = !slot;
+    if (!slot) {
+      const worker = inRootAsyncContext2(() => new Worker(entry, { workerData: { ...input, persistent: true } }));
+      slot = {
+        worker,
+        dispose() {
+          clearTimeout(this.idleTimer);
+          if (pool.get(key) === this)
+            pool.delete(key);
+          liveSearchWorkers.delete(this);
+          worker.terminate();
+          worker.unref();
+        }
+      };
+      workersCreated++;
+      pool.set(key, slot);
+      liveSearchWorkers.add(slot);
+      const current = slot;
+      worker.on("error", () => current.dispose());
+      worker.on("exit", () => current.dispose());
+    } else
+      workersReused++;
+    clearTimeout(slot.idleTimer);
+    const current = slot;
+    current.busy = new Promise((resolve) => {
+      current.release = resolve;
+    });
+    current.worker.ref();
+    return { slot: current, fresh };
+  }
+  return null;
+}
 function queueAutoSearchBackfill(db, sessionId, projectPath, query) {
   if (isEmbeddingHostBusy2())
     return Promise.resolve();
@@ -1394,6 +1459,7 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     query,
     options: {
       ...serializable,
+      autoHint: true,
       backfillMemoryEmbeddings: false,
       countRetrievals: false,
       measurementDisabled: true
@@ -1403,8 +1469,20 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     snapshot,
     deadlineUnixMs: autoSearchDeadlineUnixMs(deadlineSignal)
   };
+  let lease;
+  try {
+    lease = await acquireSearchWorker(db, `${input.harness}\x00${projectPath}\x00${job}\x00${entry.href}`, entry, input, signal);
+  } catch (error) {
+    lifecycle.done();
+    throw error;
+  }
+  if (!lease) {
+    lifecycle.done();
+    return [];
+  }
+  const { slot, fresh } = lease;
+  const worker = slot.worker;
   return new Promise((resolve, reject) => {
-    const worker = inRootAsyncContext2(() => new Worker(entry, { workerData: input }));
     let settled = false;
     const finish = (results, error) => {
       if (settled)
@@ -1413,7 +1491,25 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
       signal?.removeEventListener("abort", abort);
       lifecycle.signal.removeEventListener("abort", abort);
       lifecycle.done();
-      worker.terminate();
+      worker.off("message", onMessage);
+      worker.off("error", onError);
+      worker.off("exit", onExit);
+      if (error || signal.aborted || entry.href !== defaultAutoSearchWorkerEntry().href)
+        slot.dispose();
+      else {
+        slot.idleTimer = setTimeout(() => slot.dispose(), SEARCH_WORKER_IDLE_MS);
+        slot.idleTimer.unref?.();
+      }
+      const release = slot.release;
+      slot.busy = undefined;
+      slot.release = undefined;
+      release?.();
+      const reusable = liveSearchWorkers.delete(slot);
+      if (reusable)
+        liveSearchWorkers.add(slot);
+      const idle = [...liveSearchWorkers].filter((candidate) => !candidate.busy);
+      for (const prior of idle.slice(0, Math.max(0, idle.length - MAX_IDLE_SEARCH_WORKERS)))
+        prior.dispose();
       worker.unref();
       if (error)
         reject(error);
@@ -1423,9 +1519,9 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     const abort = () => finish([]);
     signal?.addEventListener("abort", abort, { once: true });
     lifecycle.signal.addEventListener("abort", abort, { once: true });
-    worker.on("error", (error) => finish([], error));
-    worker.on("exit", (code) => finish([], new Error(`auto-search worker exited (${code})`)));
-    worker.on("message", async (reply) => {
+    const onError = (error) => finish([], error);
+    const onExit = (code) => finish([], new Error(`auto-search worker exited (${code})`));
+    const onMessage = async (reply) => {
       if (settled)
         return;
       if (reply.kind === "result") {
@@ -1444,7 +1540,7 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
       const response = { id: reply.id };
       try {
         if (reply.kind === "query")
-          response.result = await (job === "backfill" ? embedTextForProject2(projectPath, reply.text, signal, "query") : embedQuery?.(reply.text, signal)) ?? null;
+          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);
@@ -1459,13 +1555,46 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
         response.error = error instanceof Error ? error.message : String(error);
       }
       response.embeddingHostBusy = isEmbeddingHostBusy2();
-      if (!settled && !signal?.aborted)
-        worker.postMessage(response);
-    });
+      if (!settled && !signal?.aborted) {
+        try {
+          worker.postMessage(response);
+        } catch (error) {
+          finish([], error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+    };
+    worker.on("error", onError);
+    worker.on("exit", onExit);
+    worker.on("message", onMessage);
     if (signal?.aborted)
       abort();
+    else if (!fresh) {
+      try {
+        worker.postMessage({ kind: "run", input });
+      } catch (error) {
+        finish([], error instanceof Error ? error : new Error(String(error)));
+      }
+    }
   });
 }
+async function boundedHintEmbedding(embed, text, signal) {
+  const controller = new AbortController;
+  const combined = AbortSignal.any([signal, controller.signal]);
+  let timer;
+  try {
+    return await Promise.race([
+      Promise.resolve().then(() => embed?.(text, combined) ?? null),
+      new Promise((resolve) => {
+        timer = setTimeout(() => {
+          resolve(null);
+          controller.abort();
+        }, AUTO_SEARCH_VECTOR_TIMEOUT_MS);
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
 function defaultAutoSearchWorkerEntry() {
   return new URL(new URL(import.meta.url).pathname.endsWith(".ts") ? "./auto-search-worker.ts" : "./auto-search-worker.js", import.meta.url);
 }
@@ -1773,6 +1902,8 @@ async function runAutoSearchHint(args) {
         const gitCommitsEnabled = embeddingSnapshot?.gitCommitEnabled ?? options.gitCommitsEnabled ?? false;
         const searchOptions = {
           limit: 10,
+          maxMessageOrdinal: Math.max(0, getLastCompartmentEndMessage(db, sessionId)),
+          excludeMessageId: userMsgId,
           memoryEnabled,
           embeddingEnabled,
           gitCommitsEnabled,
@@ -1810,11 +1941,15 @@ async function runAutoSearchHint(args) {
       if (results.length === 0) {
         return writeNoHintAndReconcile("empty");
       }
-      if (results[0].score < options.scoreThreshold) {
-        sessionLog2(sessionId, `auto-search: top score ${results[0].score.toFixed(3)} below threshold ${options.scoreThreshold}`);
+      results = selectAutoSearchResults(results, options.scoreThreshold);
+      if (results.length === 0) {
+        sessionLog2(sessionId, `auto-search: no fragment meets relevance threshold ${options.scoreThreshold}`);
         return writeNoHintAndReconcile("below-threshold");
       }
-      const hintText = buildAutoSearchHint(results, { wordRules: options.wordRules });
+      const hintText = buildAutoSearchHint(results, {
+        wordRules: options.wordRules,
+        query: rawPrompt
+      });
       if (!hintText) {
         return writeNoHintAndReconcile("empty");
       }
@@ -2157,6 +2292,12 @@ function canConsumeDeferredOnThisPass(args) {
 function hasReclaimRide(signals) {
   return signals.hardFold || signals.force || signals.explicitFlush || signals.publishedHistory || signals.subagentExecute === true;
 }
+function prefixMutationPermitted(gate) {
+  return !gate.signedThinkingHold || gate.firstRender || gate.idleExpiry || gate.emergency;
+}
+function reclaimRidePermitted(signals, gate) {
+  return prefixMutationPermitted(gate) && hasReclaimRide(signals);
+}
 var RECLAIM_RIDE_NAMES = [
   "hardFold",
   "force",
@@ -2852,33 +2993,70 @@ function createPendingDropEligibilityCache() {
   };
 }
 
+// src/features/magic-context/storage-host-instruction-retention.ts
+var NAMESPACE2 = "hostInstructionRetention";
+var enabled = true;
+function hostInstructionRetentionEnabled() {
+  return enabled;
+}
+function isHostInstructionRetentionOn(db, sessionId) {
+  const lane = readReplayEnvelope(db, sessionId)[NAMESPACE2];
+  return typeof lane === "object" && lane !== null && lane.on === true;
+}
+function markHostInstructionRetention(db, sessionId) {
+  return updateReplayDocument(db, sessionId, (doc) => {
+    const lane = doc[NAMESPACE2];
+    if (typeof lane === "object" && lane !== null && lane.on === true)
+      return false;
+    doc.version = 2;
+    doc[NAMESPACE2] = { on: true };
+    return true;
+  });
+}
+
 // src/hooks/magic-context/apply-operations.ts
 var RECENT_TOOL_SKELETON_WINDOW = 20;
 function buildReplacementContent(tagId) {
   return `[dropped §${tagId}§]`;
 }
 function applyNewToolDrop(target, options) {
-  if (options.persist && (target?.prepareDrop?.() ?? target?.canDrop?.()) === false) {
+  const plan = planNewToolDrop(target, options, !!options.persist);
+  if (!plan)
     return { result: "incomplete", mode: "full" };
+  options.persist?.(plan.mode);
+  return plan.apply();
+}
+function planNewToolDrop(target, options, prepare, plannedRemovals) {
+  if (prepare && (target?.prepareDrop?.() ?? target?.canDrop?.()) === false) {
+    return;
   }
   if (!target) {
-    options.persist?.("full");
-    return { result: "absent", mode: "full" };
+    return { mode: "full", apply: () => ({ result: "absent", mode: "full" }) };
   }
-  if (options.inWindow && hasSmallToolInput(target) || options.keepSkeleton === true || target.cannotRemove?.() === true || target.wouldStrandConversationEnd?.() === true) {
+  if (options.inWindow && hasSmallToolInput(target) || options.keepSkeleton === true || target.cannotRemove?.() === true || target.wouldStrandConversationEnd?.(plannedRemovals) === true) {
     const strip = target.hasAttachments?.() === true;
-    options.persist?.(strip ? "skeleton_stripped" : "skeleton_real");
+    const mode = strip ? "skeleton_stripped" : "skeleton_real";
     return {
-      result: (strip ? target.skeletonStripped?.() : target.skeletonReal?.()) ?? "absent",
-      mode: strip ? "skeleton_stripped" : "skeleton_real"
+      mode,
+      apply: () => ({
+        result: (strip ? target.skeletonStripped?.() : target.skeletonReal?.()) ?? "absent",
+        mode
+      })
     };
   }
-  options.persist?.("full");
-  const result = target.drop?.() ?? "absent";
-  if (result === "truncated" && target.hasAttachments?.() === true) {
-    return { result: target.skeletonStripped?.() ?? "absent", mode: "skeleton_stripped" };
-  }
-  return { result, mode: result === "truncated" ? "skeleton_real" : "full" };
+  return {
+    mode: "full",
+    apply: () => {
+      const result = target.drop?.() ?? "absent";
+      if (result === "truncated" && target.hasAttachments?.() === true) {
+        return {
+          result: target.skeletonStripped?.() ?? "absent",
+          mode: "skeleton_stripped"
+        };
+      }
+      return { result, mode: result === "truncated" ? "skeleton_real" : "full" };
+    }
+  };
 }
 function applyPersistedToolDrop(db, sessionId, tagNumber, target, options, afterWrite) {
   return applyNewToolDrop(target, {
@@ -2972,6 +3150,7 @@ function renderConvertedToolSkeletons(targets, converted) {
   }
   return didMutate;
 }
+var PENDING_OPERATION_CHUNK_SIZE = 64;
 function applyPendingOperations(sessionId, db, targets, protectedTagIds, preloadedTags, preloadedPendingOps, syntheticPendingOps = [], editMarkerTagIds = new Set, onTagReduced, onBatchComplete, onEligibilitySnapshot) {
   let didMutateMessage = false;
   let diagnostics;
@@ -2981,153 +3160,184 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
     diagnostics.reasons[reason] = (diagnostics.reasons[reason] ?? 0) + 1;
   };
   let admitted = false;
-  try {
-    db.transaction(() => {
-      admitted = true;
-    }).immediate();
-    {
-      const pendingOps = preloadedPendingOps ?? getPendingOps(db, sessionId);
-      onEligibilitySnapshot?.(capturePendingDropEligibility(targets, protectedTagIds));
-      const tags = preloadedTags ?? getTagsByNumbers2(db, sessionId, [
-        ...new Set([
-          ...pendingOps.map((op) => op.tagId),
-          ...syntheticPendingOps.map((op) => op.tagId)
-        ])
-      ]);
-      const tagById = new Map(tags.map((tag) => [tag.tagNumber, tag]));
-      const tagStatusById = new Map(tags.map((tag) => [tag.tagNumber, tag.status]));
-      const tagTypeById = new Map(tags.map((tag) => [tag.tagNumber, tag.type]));
-      const opsToApply = [
-        ...pendingOps.map((op) => ({ op, synthetic: false })),
-        ...syntheticPendingOps.map((op) => ({ op, synthetic: true }))
-      ];
-      diagnostics = {
-        source: pendingOps.length > 0 && syntheticPendingOps.length > 0 ? "mixed" : syntheticPendingOps.length > 0 ? "synthetic" : "pending",
-        total: opsToApply.length,
-        mutated: 0,
-        persistedWithoutMutation: 0,
-        reasons: {}
-      };
-      const skeletonWindow = new Set(preloadedTags ? tags.filter((tag) => tag.type === "tool").map((tag) => tag.tagNumber).sort((left, right) => right - left).slice(0, RECENT_TOOL_SKELETON_WINDOW) : getNewestToolTagNumbers2(db, sessionId, RECENT_TOOL_SKELETON_WINDOW));
-      for (const { op: pendingOp, synthetic } of opsToApply) {
-        let operationMutated = false;
-        const tagStatus = tagStatusById.get(pendingOp.tagId);
-        if (tagStatus === "compacted" || tagStatus === "dropped") {
-          reject("already_reduced");
-          if (!synthetic)
-            removePendingOp(db, sessionId, pendingOp.tagId);
-          continue;
-        }
-        const target = targets.get(pendingOp.tagId);
-        const veto = pendingDropVeto(pendingOp.tagId, target, protectedTagIds);
-        if (veto) {
-          reject(veto);
-          continue;
-        }
-        const isToolTag = tagTypeById.get(pendingOp.tagId) === "tool";
-        if (synthetic) {
-          if (!isToolTag) {
-            reject("synthetic_non_tool");
-            continue;
-          }
-          if (target?.canDrop?.() !== true) {
-            reject("synthetic_target_not_droppable");
-            continue;
-          }
+  let startedAt = 0;
+  const mutations = [];
+  let drainChunk;
+  let hasMore = false;
+  do {
+    admitted = false;
+    startedAt = 0;
+    try {
+      db.transaction(() => {
+        admitted = true;
+        startedAt = performance.now();
+        if (drainChunk) {
+          drainChunk();
+          return;
         }
-        const persistDrop = (mode) => {
-          let startedAt = 0;
-          try {
-            db.transaction(() => {
-              startedAt = performance.now();
-              markTagDropped2(db, sessionId, pendingOp.tagId, mode);
+        const pendingOps = preloadedPendingOps ?? getPendingOps(db, sessionId);
+        onEligibilitySnapshot?.(capturePendingDropEligibility(targets, protectedTagIds));
+        const tags = preloadedTags ?? getTagsByNumbers2(db, sessionId, [
+          ...new Set([
+            ...pendingOps.map((op) => op.tagId),
+            ...syntheticPendingOps.map((op) => op.tagId)
+          ])
+        ]);
+        const tagById = new Map(tags.map((tag) => [tag.tagNumber, tag]));
+        const tagStatusById = new Map(tags.map((tag) => [tag.tagNumber, tag.status]));
+        const tagTypeById = new Map(tags.map((tag) => [tag.tagNumber, tag.type]));
+        const opsToApply = [
+          ...pendingOps.map((op) => ({ op, synthetic: false })),
+          ...syntheticPendingOps.map((op) => ({ op, synthetic: true }))
+        ];
+        diagnostics = {
+          source: pendingOps.length > 0 && syntheticPendingOps.length > 0 ? "mixed" : syntheticPendingOps.length > 0 ? "synthetic" : "pending",
+          total: opsToApply.length,
+          mutated: 0,
+          persistedWithoutMutation: 0,
+          reasons: {}
+        };
+        const skeletonWindow = new Set(preloadedTags ? tags.filter((tag) => tag.type === "tool").map((tag) => tag.tagNumber).sort((left, right) => right - left).slice(0, RECENT_TOOL_SKELETON_WINDOW) : getNewestToolTagNumbers2(db, sessionId, RECENT_TOOL_SKELETON_WINDOW));
+        const plannedRemovals = new Set;
+        const removedTagIds = new Set;
+        const record = (mutated) => {
+          if (!diagnostics)
+            return;
+          if (mutated) {
+            didMutateMessage = true;
+            diagnostics.mutated += 1;
+          } else
+            diagnostics.persistedWithoutMutation += 1;
+        };
+        let cursor = 0;
+        drainChunk = () => {
+          const chunk = opsToApply.slice(cursor, cursor + PENDING_OPERATION_CHUNK_SIZE);
+          cursor += chunk.length;
+          hasMore = cursor < opsToApply.length;
+          for (const { op: pendingOp, synthetic } of chunk) {
+            const tagStatus = tagStatusById.get(pendingOp.tagId);
+            if (tagStatus === "compacted" || tagStatus === "dropped") {
+              reject("already_reduced");
               if (!synthetic)
                 removePendingOp(db, sessionId, pendingOp.tagId);
-            }).immediate();
-          } finally {
-            if (startedAt)
-              logSlowWriteTransaction("apply_pending_operation", startedAt);
-          }
-        };
-        let shouldPersistDrop = false;
-        if (isToolTag) {
-          if (editMarkerTagIds.has(pendingOp.tagId)) {
-            const strip = target?.hasAttachments?.() === true;
-            if (target?.canDrop?.() === false || target?.prepareDrop?.() === false || !target) {
-              reject("edit_marker_incomplete");
               continue;
             }
-            persistDrop(strip ? "edit_marker_stripped" : "edit_marker");
-            const markResult = (strip ? target?.editMarkerStripped?.() : target?.editMarker?.()) ?? "absent";
-            if (markResult === "incomplete" || markResult === "absent") {
-              reject(`edit_marker_${markResult}`);
+            if (removedTagIds.has(pendingOp.tagId)) {
+              reject("drop_incomplete");
               continue;
             }
-            didMutateMessage = true;
-            operationMutated = true;
-            onTagReduced?.({ tagNumber: pendingOp.tagId, mode: "edit_marker" });
-            shouldPersistDrop = true;
-          } else {
-            const { result: dropResult, mode: appliedMode } = applyNewToolDrop(target, {
-              inWindow: skeletonWindow.has(pendingOp.tagId),
-              persist: persistDrop
-            });
-            if (dropResult === "incomplete" || synthetic && dropResult !== "removed" && dropResult !== "truncated") {
-              reject(`drop_${dropResult}`);
+            const target = targets.get(pendingOp.tagId);
+            const veto = pendingDropVeto(pendingOp.tagId, target, protectedTagIds);
+            if (veto) {
+              reject(veto);
               continue;
             }
-            if (dropResult === "removed" || dropResult === "truncated") {
-              didMutateMessage = true;
-              operationMutated = true;
-              onTagReduced?.({
-                tagNumber: pendingOp.tagId,
-                mode: appliedMode === "full" ? "full" : "truncated"
+            const isToolTag = tagTypeById.get(pendingOp.tagId) === "tool";
+            if (synthetic) {
+              if (!isToolTag) {
+                reject("synthetic_non_tool");
+                continue;
+              }
+              if (target?.canDrop?.() !== true) {
+                reject("synthetic_target_not_droppable");
+                continue;
+              }
+            }
+            const persistDrop = (mode) => {
+              markTagDropped2(db, sessionId, pendingOp.tagId, mode);
+              if (!synthetic)
+                removePendingOp(db, sessionId, pendingOp.tagId);
+            };
+            if (isToolTag) {
+              if (editMarkerTagIds.has(pendingOp.tagId)) {
+                const strip = target?.hasAttachments?.() === true;
+                if (target?.canDrop?.() === false || target?.prepareDrop?.() === false || !target) {
+                  reject("edit_marker_incomplete");
+                  continue;
+                }
+                persistDrop(strip ? "edit_marker_stripped" : "edit_marker");
+                mutations.push(() => {
+                  const markResult = (strip ? target?.editMarkerStripped?.() : target?.editMarker?.()) ?? "absent";
+                  if (markResult === "incomplete" || markResult === "absent") {
+                    reject(`edit_marker_${markResult}`);
+                    return;
+                  }
+                  record(true);
+                  onTagReduced?.({
+                    tagNumber: pendingOp.tagId,
+                    mode: "edit_marker"
+                  });
+                });
+              } else {
+                const plan = planNewToolDrop(target, { inWindow: skeletonWindow.has(pendingOp.tagId) }, true, plannedRemovals);
+                if (!plan) {
+                  reject("drop_incomplete");
+                  continue;
+                }
+                persistDrop(plan.mode);
+                if (plan.mode === "full" && target?.drop) {
+                  target.notePlannedRemoval?.(plannedRemovals);
+                  removedTagIds.add(pendingOp.tagId);
+                }
+                mutations.push(() => {
+                  const { result: dropResult, mode: appliedMode } = plan.apply();
+                  if (dropResult === "incomplete" || synthetic && dropResult !== "removed" && dropResult !== "truncated") {
+                    reject(`drop_${dropResult}`);
+                    return;
+                  }
+                  if (dropResult === "removed" || dropResult === "truncated") {
+                    record(true);
+                    onTagReduced?.({
+                      tagNumber: pendingOp.tagId,
+                      mode: appliedMode === "full" ? "full" : "truncated"
+                    });
+                  } else {
+                    reject(`drop_${dropResult}`);
+                    record(false);
+                  }
+                });
+              }
+            } else if (target) {
+              const replacement = buildReplacementContent(pendingOp.tagId);
+              persistDrop();
+              mutations.push(() => {
+                const priorContent = target.getContent?.();
+                const changed = target.setContent(replacement);
+                record(changed);
+                if (changed) {
+                  const originalCharacters = typeof priorContent === "string" ? priorContent.length : tagById.get(pendingOp.tagId)?.byteSize ?? replacement.length;
+                  onTagReduced?.({
+                    tagNumber: pendingOp.tagId,
+                    mode: "partial",
+                    removedCharacters: Math.max(0, originalCharacters - replacement.length)
+                  });
+                } else {
+                  reject("content_unchanged");
+                }
               });
-            } else {
-              reject(`drop_${dropResult}`);
+            } else if (!synthetic) {
+              reject("target_absent");
+              persistDrop();
+              mutations.push(() => record(false));
             }
-            shouldPersistDrop = true;
           }
-        } else if (target) {
-          const replacement = buildReplacementContent(pendingOp.tagId);
-          const priorContent = target.getContent?.();
-          persistDrop();
-          const changed = target.setContent(replacement);
-          if (changed) {
-            didMutateMessage = true;
-            operationMutated = true;
-            const originalCharacters = typeof priorContent === "string" ? priorContent.length : tagById.get(pendingOp.tagId)?.byteSize ?? replacement.length;
-            onTagReduced?.({
-              tagNumber: pendingOp.tagId,
-              mode: "partial",
-              removedCharacters: Math.max(0, originalCharacters - replacement.length)
-            });
-          } else {
-            reject("content_unchanged");
-          }
-          shouldPersistDrop = true;
-        } else if (!synthetic) {
-          reject("target_absent");
-          persistDrop();
-          shouldPersistDrop = true;
-        }
-        if (!shouldPersistDrop) {
-          reject("not_persisted");
-          continue;
-        }
-        if (operationMutated)
-          diagnostics.mutated += 1;
-        else
-          diagnostics.persistedWithoutMutation += 1;
+        };
+        drainChunk();
+      }).immediate();
+    } catch (error) {
+      if (!admitted && /database (?:table )?is locked|sqlite_(busy|locked)/i.test(String(error))) {
+        sessionLog2(sessionId, "pending operations write admission busy; retaining remaining operations for retry");
+        hasMore = false;
+      } else {
+        throw error;
       }
+    } finally {
+      if (startedAt)
+        logSlowWriteTransaction("apply_pending_operations", startedAt);
     }
-  } catch (error) {
-    if (!admitted && /database (?:table )?is locked|sqlite_(busy|locked)/i.test(String(error))) {
-      sessionLog2(sessionId, "pending operations write admission busy; retaining prior bytes for retry");
-      return false;
-    }
-    throw error;
-  }
+    for (const mutate of mutations.splice(0))
+      mutate();
+  } while (hasMore);
   if (diagnostics) {
     onBatchComplete?.(diagnostics);
     if (diagnostics.total > 0 && diagnostics.mutated === 0) {
@@ -4170,10 +4380,41 @@ function createExistingTagResolver(sessionId, tagger, db) {
 }
 
 // src/hooks/magic-context/transform-stage-logger.ts
-function logTransformTiming(sessionId, stage, startMs, extra) {
-  const elapsed = (performance.now() - startMs).toFixed(1);
+import { AsyncLocalStorage } from "node:async_hooks";
+var SLOW_STAGE_MS = 100;
+var passes = new AsyncLocalStorage;
+async function withTransformTimingSummary(run) {
+  const pass = {
+    stages: [],
+    slow: [],
+    closed: false,
+    sessionId: undefined
+  };
+  return passes.run(pass, async () => {
+    try {
+      return await run();
+    } finally {
+      pass.closed = true;
+      if (pass.sessionId)
+        sessionLog2(pass.sessionId, `transform stages: ${pass.stages.join(" ")} slow>=${SLOW_STAGE_MS}ms=[${pass.slow.join(",")}]`);
+    }
+  });
+}
+function logTransformElapsed(sessionId, stage, elapsedMs, extra) {
+  const elapsed = elapsedMs.toFixed(1);
   const suffix = extra ? ` ${extra}` : "";
-  sessionLog2(sessionId, `transform stage: stage=${stage} elapsed=${elapsed}ms${suffix}`);
+  const pass = passes.getStore();
+  if (pass && !pass.closed) {
+    pass.sessionId = sessionId;
+    pass.stages.push(`${stage}=${elapsed}ms${extra ? `(${extra})` : ""}`);
+    if (elapsedMs >= SLOW_STAGE_MS)
+      pass.slow.push(stage);
+  }
+  if (elapsedMs >= SLOW_STAGE_MS)
+    sessionLog2(sessionId, `transform stage: stage=${stage} elapsed=${elapsed}ms${suffix}`);
+}
+function logTransformTiming(sessionId, stage, startMs, extra) {
+  logTransformElapsed(sessionId, stage, performance.now() - startMs, extra);
 }
 
 // src/hooks/magic-context/tag-messages.ts
@@ -4539,13 +4780,18 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
         }));
         accAssignTag += performance.now() - _tAssignText;
         const persistedSource = sourceContents.get(tagId);
-        if (persistedSource !== undefined) {
+        if (persistedSource !== undefined && !options.refreshSourceContents) {
           textPart.text = options.normalizeRestoredAssistantText && message.info.role === "assistant" ? options.normalizeRestoredAssistantText(persistedSource) : persistedSource;
         } else {
           const sourceContent = stripTagPrefix(textPart.text);
-          if (sourceContent.trim().length > 0) {
+          if (sourceContent.trim().length > 0 || options.refreshSourceContents) {
             const _tSaveText = performance.now();
-            saveSourceContent(db, sessionId, tagId, sourceContent);
+            if (options.refreshSourceContents) {
+              replaceSourceContent(db, sessionId, tagId, sourceContent);
+              updateTagByteSize2(db, sessionId, tagId, byteSize(sourceContent));
+              updateTagTokenCount2(db, sessionId, tagId, estimateTextTagTokenCount(sourceContent));
+            } else
+              saveSourceContent(db, sessionId, tagId, sourceContent);
             accSaveSource += performance.now() - _tSaveText;
           }
         }
@@ -4626,22 +4872,12 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
         const filePart = part;
         const messageParts = message.parts;
         const contentId = `${messageId}:file${partIndex}`;
-        const existingTagId = resolver.resolve(messageId, "file", contentId, fileOrdinal);
-        const _tAssignFile = performance.now();
-        const tagId = existingTagId ?? tagger.assignTag(sessionId, contentId, "file", byteSize(filePart.url), db, 0, null, 0, null, () => ({
-          tokenCount: estimateTextTagTokenCount(filePart.url),
-          inputTokenCount: null,
-          reasoningTokenCount: null
-        }));
-        accAssignTag += performance.now() - _tAssignFile;
-        if (existingTagId === undefined) {
-          const sourceContent = buildFileSourceContent(message.parts);
-          if (sourceContent) {
-            const _tSaveFile = performance.now();
-            saveSourceContent(db, sessionId, tagId, sourceContent);
-            accSaveSource += performance.now() - _tSaveFile;
-          }
-        }
+        const existingTagId = resolver.resolve(messageId, "file", contentId, fileOrdinal) ?? getTagNumberByMessageId2(db, sessionId, contentId) ?? undefined;
+        fileOrdinal += 1;
+        if (existingTagId === undefined)
+          continue;
+        const tagId = existingTagId;
+        tagger.bindTag(sessionId, contentId, tagId);
         messageTagNumbers.set(message, Math.max(messageTagNumbers.get(message) ?? 0, tagId));
         targets.set(tagId, {
           message,
@@ -4663,7 +4899,6 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
             return true;
           }
         });
-        fileOrdinal += 1;
       }
     }
     if (message.info.role === "assistant" && !messageHasTextPart) {
@@ -5431,7 +5666,7 @@ async function runPostTransformPhase2(args) {
     routinePressureAppliedBySession.set(args.sessionId, true);
   }
   const routinePressureAlreadyApplied = args.fullFeatureMode && executePressureEligible && routinePressureAppliedBySession.get(args.sessionId) === true;
-  if (args.contextUsage.percentage > 0 && args.contextUsage.percentage < args.forceMaterializationPercentage - 5 && getEmergencyInputSample(args.db, args.sessionId) > 0) {
+  if (args.contextUsageFromEstimate !== true && args.contextUsage.percentage > 0 && args.contextUsage.percentage < args.forceMaterializationPercentage - 5 && getEmergencyInputSample(args.db, args.sessionId) > 0) {
     clearEmergencyDropSample(args.db, args.sessionId);
   }
   const activeCompartmentRun = args.canRunCompartments ? getActiveCompartmentRun(args.sessionId) : undefined;
@@ -5461,7 +5696,7 @@ async function runPostTransformPhase2(args) {
     if (tag && tag > 0)
       safeReasoningCutoff = Math.min(safeReasoningCutoff, tag - 1);
   }
-  let activeThinkingPrefixHold = args.activeThinkingPrefixHold === true || activeThinkingTurn && args.thinkingBindingRecoveryEnabledForModel === true;
+  let activeThinkingPrefixHold = args.activeThinkingPrefixHold === true;
   let freezeM0M1 = args.freezeM0M1 === true || activeThinkingPrefixHold;
   let rewritingSignedPrefix = false;
   let thinkingReleasedForFit = false;
@@ -5483,7 +5718,7 @@ async function runPostTransformPhase2(args) {
     rewritingSignedPrefix = true;
     thinkingReleasedForFit ||= forFit;
   };
-  if (activeThinkingPrefixHold && args.forceSignedRebuildForFit) {
+  if (args.forceSignedRebuildForFit && (activeThinkingPrefixHold || activeThinkingTurn && args.thinkingBindingRecoveryEnabledForModel === true)) {
     releaseThinkingForRewrite(true);
   }
   const foldDueDecision = m0M1EnabledForFold && args.m0M1 && !freezeM0M1 ? mustMaterialize({
@@ -5620,7 +5855,7 @@ async function runPostTransformPhase2(args) {
   const shouldReadPendingOps = !compactionOff && (materializationRequested || publishedM1RefreshedThisPass || args.schedulerDecision === "execute" || forceMaterialization || foldExecutedThisPass || firstRenderBust || compartmentRunning);
   const pendingOps = shouldReadPendingOps ? getPendingOps(args.db, args.sessionId) : [];
   const hasPendingUserOps = pendingOps.length > 0;
-  if (args.schedulerDecision === "execute" && pendingOps.some((op) => newTargets.get(op.tagId)?.thinkingDropProtected))
+  if (args.schedulerDecision === "execute" && args.thinkingBindingRecoveryEnabledForModel !== true && pendingOps.some((op) => newTargets.get(op.tagId)?.thinkingDropProtected))
     requestPendingMaterialization(args.pendingMaterializationSessions, args.sessionId, "thinking_hold");
   const formatPendingOpsDepth = () => {
     const depth = getPendingOpsCount(args.db, args.sessionId);
@@ -5631,16 +5866,34 @@ async function runPostTransformPhase2(args) {
   const rideSignals = {
     subagentExecute: !args.fullFeatureMode && args.schedulerDecision === "execute",
     hardFold: rewritingSignedPrefix || foldBustsServedPrefixThisPass || firstRenderBust || idleExpiryRebuild,
-    force: emergencyDropEligible && (args.contextUsage.percentage >= 95 || getEmergencyInputSample(args.db, args.sessionId) === 0),
+    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 publishedWorkDrainAllowed = !compactionOff && (!activeThinkingPrefixHold || firstRenderBust || idleExpiryRebuild || emergencyDropEligible) && hasReclaimRide(rideSignals);
+  const publishedWorkDrainAllowed = !compactionOff && reclaimRidePermitted(rideSignals, {
+    signedThinkingHold: activeThinkingPrefixHold,
+    firstRender: firstRenderBust,
+    idleExpiry: idleExpiryRebuild,
+    emergency: emergencyDropEligible
+  });
   const shouldApplyPendingOps = publishedWorkDrainAllowed;
   const shouldRunHeuristics = publishedWorkDrainAllowed && (rideSignals.publishedHistory || materializationRequested || forceMaterialization || foldBustsServedPrefixThisPass || firstRenderBust || heldIdleExpiryRebuild || emergencyDropEligible || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
   const isCacheBustingPass = publishedWorkDrainAllowed;
-  if (args.normalizeRecoveryTail && isCacheBustingPass) {
+  let unheldSignedTurnBust = false;
+  if (isCacheBustingPass && !activeThinkingPrefixHold && activeThinkingTurn && args.thinkingBindingRecoveryEnabledForModel === true) {
+    if (foldBustsServedPrefixThisPass || firstRenderBust || publishedM1RefreshedThisPass)
+      releaseThinkingForRewrite();
+    else {
+      unheldSignedTurnBust = true;
+      retainedThinking.clear();
+      protectedThinkingMessages.clear();
+      newTargets = args.targets;
+    }
+  }
+  let recoveryTailNormalizedThisPass = false;
+  if (args.normalizeRecoveryTail && isCacheBustingPass && !activeThinkingPrefixHold) {
     args.normalizeRecoveryTail();
+    recoveryTailNormalizedThisPass = true;
     args.tags = getTagsBySession2(args.db, args.sessionId);
     newTargets = protectNewTagMutations(args.messages, args.targets, retainedThinking, args.thinkingBindingRecoveryEnabledForModel === true);
   }
@@ -6111,6 +6364,26 @@ async function runPostTransformPhase2(args) {
     }
   }
   const m0M1Enabled = m0M1EnabledForFold;
+  if (m0M1Enabled && args.m0M1 && !compactionOff && args.opencode2) {
+    const covered = args.coveredHostInstructions ?? [];
+    if (covered.length > 0 || canEditWholePrefix) {
+      let retain = false;
+      if (hostInstructionRetentionEnabled()) {
+        try {
+          retain = isHostInstructionRetentionOn(args.db, args.sessionId);
+        } catch (error) {
+          failPass("host-instruction-retention-read-failure", error);
+        }
+        if (!retain && canEditWholePrefix) {
+          if (!markHostInstructionRetention(args.db, args.sessionId))
+            failPass("host-instruction-retention-persistence-failure");
+          retain = true;
+        }
+      }
+      if (retain && covered.length > 0)
+        args.messages.unshift(...covered);
+    }
+  }
   if (m0M1Enabled && args.m0M1) {
     if (freezeM0M1 && !preparedPrefix) {
       preparedPrefix = prepareCachedM0M1Replay(args.db, args.sessionId);
@@ -6633,7 +6906,7 @@ async function runPostTransformPhase2(args) {
       }
     }
   }
-  const prefixEditBesidesReasoningTrim = firstRenderBust || heldIdleExpiryRebuild || materializationRequested || explicitMaterializedSuccessfully || deferredMaterializedSuccessfully || foldBustsServedPrefixThisPass || publishedM1RefreshedThisPass || m0RematerializedThisPass || m0M1InjectedThisPass && historyWasConsumedThisPass || historyWasConsumedThisPass || pendingOpsDidMutate || heuristicOrReasoningEditBesidesTrim || emergency || autoReclaimDidMutateThisPass || convertedToolSkeletonsDidMutate || deferredClearedMarkerRetires || noteNudgeAppendedThisPass || todoAnchorMovedThisPass || autoSearchHintAppendedThisPass || dropModeSwitchesThisPass || firstApplicationEdits.beforeNewerThinking;
+  const prefixEditBesidesReasoningTrim = firstRenderBust || heldIdleExpiryRebuild || materializationRequested || explicitMaterializedSuccessfully || deferredMaterializedSuccessfully || foldBustsServedPrefixThisPass || publishedM1RefreshedThisPass || m0RematerializedThisPass || m0M1InjectedThisPass && historyWasConsumedThisPass || historyWasConsumedThisPass || pendingOpsDidMutate || heuristicOrReasoningEditBesidesTrim || emergency || autoReclaimDidMutateThisPass || convertedToolSkeletonsDidMutate || deferredClearedMarkerRetires || noteNudgeAppendedThisPass || todoAnchorMovedThisPass || autoSearchHintAppendedThisPass || dropModeSwitchesThisPass || recoveryTailNormalizedThisPass || firstApplicationEdits.beforeNewerThinking;
   let proactiveThinkingStrip = null;
   if (!compactionOff && args.thinkingBindingRecoveryEnabledForModel === true && proactiveThinkingStripPermitted && prefixEditBesidesReasoningTrim) {
     const outcome = freezeReasoningOnBustingPass2({
@@ -6650,7 +6923,11 @@ async function runPostTransformPhase2(args) {
         mergedReasoningStrippedIds.add(thinkingBindingRecoveryFrozenId(messageId));
       }
       bustedThisPass = true;
+      if (unheldSignedTurnBust)
+        rewritingSignedPrefix = true;
     } else if (outcome.persistenceFailed) {
+      if (unheldSignedTurnBust)
+        throw new Error("Cannot persist signed thinking omission after a mid-turn edit");
       failPass("proactive-thinking-strip-persistence-failure");
     }
   }
@@ -6809,7 +7086,8 @@ async function runPostTransformPhase2(args) {
     prefixTrimStatus: deliveredPrefix?.prefixTrimStatus ?? null,
     thinkingBindingRecovery,
     proactiveThinkingStrip,
-    thinkingReleasedForFit
+    thinkingReleasedForFit,
+    openTurnSignedThinkingKept: args.thinkingBindingRecoveryEnabledForModel === true && activeThinkingTurn && !rewritingSignedPrefix
   };
 }
 function checkM0MutationDriftAndSignal2(args) {
@@ -6824,4 +7102,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, 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, 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, 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 };