@cortexkit/opencode-magic-context 0.48.0 → 0.49.0

package/dist/{index-f0h6xwqm.js → index-1g30axtz.js}

@@ -1,6 +1,12 @@
 import {
   getHarness2
 } from "./index-pavzsdc6.js";
+import {
+  tagIdentityRevisionKey,
+  getTemporalDecisions,
+  freezeTemporalDecisions,
+  stableStringify
+} from "./index-1bt88epp.js";
 import {
   protectedToolTagNumbers,
   stripWellFormedLeadingTagPrefix,
@@ -64,42 +70,36 @@ import {
   adoptNullOwnerToolTag2,
   getCandidateToolOwners2,
   pickNearestPriorOwner2
-} from "./index-k9nnwad5.js";
+} from "./index-nydv6g8r.js";
 import {
   textMentionsRecentCommit,
   hasMeaningfulUserText2,
   estimateTokens
-} from "./index-1qb0z7wa.js";
+} from "./index-qx53vezw.js";
 import {
   log2,
   sessionLog2
-} from "./index-8j7gqj40.js";
+} from "./index-nsjyysj0.js";
 import {
   getTagIdentityWriteGeneration2,
   getSqliteDatabasePath2,
   assertTransformWrite2,
   isTransientSqliteError2
 } from "./index-kb9nn0a0.js";
-import {
-  getTemporalDecisions,
-  freezeTemporalDecisions,
-  stableStringify
-} from "./index-db7zwa3v.js";
 import {
   isValidLanguageCode,
   resolveModelConfigValue
-} from "./index-bhvjj0ys.js";
+} from "./index-kq57tdf0.js";
 import {
   getProjectEmbeddingSnapshot2,
   embedTextForProject2,
   embedBatchForProject2
-} from "./index-c43kr12f.js";
+} from "./index-kp5qe690.js";
 import {
   isEmbeddingHostBusy2
 } from "./index-qt1qqasc.js";
 import {
   BoundedSessionMap,
-  renderUserFacingFailure,
   getMaxM0MutationId,
   escalationBands,
   MERGED_REASONING_PARTS_PREFIX,
@@ -120,7 +120,7 @@ import {
   getAutoSearchHintDecisions,
   appendAutoSearchHintDecision,
   pruneNoteNudgeAnchors,
-  pruneAutoSearchHintDecisions,
+  flushAutoSearchHintDecisionRetirement,
   getPersistedTodoPermissionDenied,
   setPersistedTodoPermissionDenied,
   getPersistedTodoSyntheticAnchor,
@@ -146,6 +146,9 @@ import {
   setPendingCompactionMarkerState,
   replacePendingCompactionMarkerStateIf,
   clearPendingCompactionMarkerStateIf,
+  rememberUnpublishedAutoSearchNoHint,
+  getUnpublishedAutoSearchNoHint,
+  forgetUnpublishedAutoSearchNoHint,
   registerAutoSearchWork,
   cancelAutoSearchWork,
   updateSessionMeta,
@@ -170,15 +173,15 @@ import {
   peekNoteNudgeText,
   markNoteNudgeDelivered,
   getActiveCompartmentRun
-} from "./index-692jzy0p.js";
+} from "./index-2jcbj7r1.js";
 import {
   runSessionWarmupWorker
-} from "./index-dhwzyd54.js";
+} from "./index-h5zfkjyk.js";
 import {
   openCodeDbExists,
   withReadOnlySessionDb,
   getMessageTimesFromOpenCodeDb
-} from "./index-ty64eqcn.js";
+} from "./index-9qjqq45k.js";
 import {
   stripSystemInjection,
   isTextPart,
@@ -203,7 +206,10 @@ import {
   extractToolCallObservation,
   ToolMutationBatch,
   createToolDropTarget
-} from "./index-bdckkfw6.js";
+} from "./index-2jgwttpt.js";
+import {
+  renderUserFacingFailure
+} from "./index-kmpvemph.js";
 import {
   getErrorMessage
 } from "./index-y8v6yerm.js";
@@ -213,7 +219,7 @@ import {
 } from "./index-d9vfe7xq.js";
 import {
   logSlowWriteTransaction
-} from "./index-2y0s2hep.js";
+} from "./index-4mjhqadz.js";
 
 // src/features/magic-context/tagger.ts
 var TOOL_COMPOSITE_KEY_SEP = "\x00";
@@ -221,7 +227,9 @@ function makeToolCompositeKey(ownerMsgId, callId) {
   return `${ownerMsgId}${TOOL_COMPOSITE_KEY_SEP}${callId}`;
 }
 var GET_COUNTER_SQL = `SELECT counter FROM session_meta WHERE session_id = ?`;
-var GET_TAGS_VERSION_SQL = `SELECT tags_version FROM session_meta WHERE session_id = ?`;
+var GET_TAGS_VERSION_SQL = `SELECT
+    (SELECT tags_version FROM session_meta WHERE session_id = ?) AS tags_version,
+    (SELECT value FROM schema_migrations_meta WHERE key = ?) AS identity_revision`;
 var GET_ASSIGNMENTS_SQL = "SELECT message_id, tag_number, type, tool_owner_message_id, byte_size, token_count, input_byte_size, input_token_count FROM tags WHERE session_id = ? ORDER BY tag_number ASC";
 var GET_ASSIGNMENTS_SCOPED_SQL = "SELECT message_id, tag_number, type, tool_owner_message_id, byte_size, token_count, input_byte_size, input_token_count FROM tags WHERE session_id = ? AND tag_number >= ? ORDER BY tag_number ASC";
 var probeTagsVersionStatements = new WeakMap;
@@ -342,10 +350,16 @@ function createTagger() {
       const memCounter = heapHolder.counters.get(sessionId) ?? 0;
       const dbMax = getMaxTagNumberBySession2(db, sessionId);
       const next = Math.max(memCounter, dbMax) + 1;
+      const loaded = heapHolder.loadSignatures.get(sessionId);
+      let ownedInitialIdentity;
       try {
         db.transaction(() => {
+          const admitted = loaded?.db === db && loaded.identityRevision === null ? probeSignature(sessionId, db) : null;
+          const initializesOwnedEpoch = admitted !== null && loaded !== undefined && admitted.identityRevision === null && admitted.tagsVersion === loaded.tagsVersion;
           getUpsertCounterStatement(db).run(sessionId, next, getHarness2());
           insertTag2(db, sessionId, messageId, type, byteSize, next, reasoningByteSize, toolName, inputByteSize, toolOwnerMessageId, entryFingerprint, tokenCounts);
+          if (initializesOwnedEpoch)
+            ownedInitialIdentity = probeSignature(sessionId, db).identityRevision;
         }).immediate();
       } catch (error) {
         if (!isUniqueConstraintError(error)) {
@@ -366,6 +380,8 @@ function createTagger() {
       const signature = heapHolder.loadSignatures.get(sessionId);
       if (signature?.db === db) {
         signature.tagsVersion += 1;
+        if (signature === loaded && ownedInitialIdentity !== undefined)
+          signature.identityRevision = ownedInitialIdentity;
       }
       if (type === "tool") {
         getSessionToolAccounting(sessionId).set(next, {
@@ -468,15 +484,16 @@ function createTagger() {
     return heapHolder.counters.get(sessionId) ?? 0;
   }
   function probeSignature(sessionId, db) {
-    const row = getProbeTagsVersionStatement(db).get(sessionId);
+    const row = getProbeTagsVersionStatement(db).get(sessionId, tagIdentityRevisionKey(sessionId));
     return {
-      tagsVersion: row?.tags_version ?? 0
+      tagsVersion: row?.tags_version ?? 0,
+      identityRevision: row?.identity_revision ?? null
     };
   }
   function initFromDb(sessionId, db, floor = 0) {
     const probe = probeSignature(sessionId, db);
     const cached = heapHolder.loadSignatures.get(sessionId);
-    if (cached !== undefined && cached.db === db && cached.tagsVersion === probe.tagsVersion && cached.floor === floor) {
+    if (cached !== undefined && cached.db === db && cached.tagsVersion === probe.tagsVersion && cached.identityRevision === probe.identityRevision && cached.floor === floor) {
       return;
     }
     const row = db.prepare(GET_COUNTER_SQL).get(sessionId);
@@ -509,6 +526,7 @@ function createTagger() {
     heapHolder.loadSignatures.set(sessionId, {
       db,
       tagsVersion: probe.tagsVersion,
+      identityRevision: probe.identityRevision,
       floor
     });
   }
@@ -516,6 +534,10 @@ function createTagger() {
     const signature = heapHolder.loadSignatures.get(sessionId);
     return signature?.db === db ? signature.tagsVersion : undefined;
   }
+  function getLoadedTagIdentityRevision(sessionId, db) {
+    const signature = heapHolder.loadSignatures.get(sessionId);
+    return signature?.db === db ? signature.identityRevision : undefined;
+  }
   function cleanup(sessionId) {
     heapHolder.counters.delete(sessionId);
     heapHolder.assignments.delete(sessionId);
@@ -558,6 +580,7 @@ function createTagger() {
     getCounter,
     initFromDb,
     getLoadedTagsVersion,
+    getLoadedTagIdentityRevision,
     cleanup,
     getHeapStats
   };
@@ -606,6 +629,8 @@ function persistAutoSearchSkip(db, sessionId, messageId, reason = "timeout") {
     ok = outcome.ok && outcome.decision.decision === "no-hint";
   } catch {}
   assertTransformWrite2();
+  if (!ok)
+    rememberUnpublishedAutoSearchNoHint(sessionId, messageId, reason);
   const persistence = Promise.resolve(ok);
   messages.set(messageId, persistence);
   return persistence;
@@ -1237,7 +1262,36 @@ function queueAutoSearchRegistration(db, projectPath, register) {
 function persistAutoSearchDecision(db, sessionId, decision, startedAt) {
   if (performance.now() - startedAt >= AUTO_SEARCH_TIMEOUT_MS)
     return null;
-  return appendAutoSearchHintDecision(db, sessionId, decision);
+  let outcome;
+  try {
+    outcome = appendAutoSearchHintDecision(db, sessionId, decision);
+  } catch (error) {
+    assertTransformWrite2();
+    rememberUnpublishedAutoSearchNoHint(sessionId, decision.messageId, decision.decision === "no-hint" ? decision.reason : "error");
+    if (!isTransientSqliteError2(error))
+      throw error;
+    log2(`[auto-search] decision save hit a busy store for session ${sessionId}; serving without a hint and retrying the save on a later pass: ${error instanceof Error ? error.message : String(error)}`);
+    return { ok: false, kind: "storage-busy" };
+  }
+  if (!outcome.ok) {
+    assertTransformWrite2();
+    rememberUnpublishedAutoSearchNoHint(sessionId, decision.messageId, decision.decision === "no-hint" ? decision.reason : "error");
+  } else if (outcome.decision.decision === "no-hint") {
+    forgetUnpublishedAutoSearchNoHint(sessionId, decision.messageId);
+  }
+  return outcome;
+}
+function retryUnpublishedAutoSearchNoHint(db, sessionId, messageId, startedAt) {
+  const reason = getUnpublishedAutoSearchNoHint(sessionId, messageId);
+  if (reason === undefined)
+    return false;
+  try {
+    persistAutoSearchDecision(db, sessionId, { messageId, decision: "no-hint", reason }, startedAt);
+  } catch (error) {
+    assertTransformWrite2();
+    log2(`[auto-search] frozen omission save still failed for session ${sessionId}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return true;
 }
 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");
@@ -1625,6 +1679,9 @@ async function runAutoSearchHint(args) {
   return coalesceAutoSearchTurn(db, sessionId, userMsgId, async (lifecycleSignal) => {
     if (lifecycleSignal.aborted)
       return AUTO_SEARCH_OK;
+    if (retryUnpublishedAutoSearchNoHint(db, sessionId, userMsgId, startedAt)) {
+      return AUTO_SEARCH_OK;
+    }
     if (wasAutoSearchSkipped(db, sessionId, userMsgId))
       return AUTO_SEARCH_OK;
     const existing = getAutoSearchHintDecisions(db, sessionId);
@@ -1655,7 +1712,10 @@ async function runAutoSearchHint(args) {
         return { ok: false, kind: "timeout" };
       }
       if (!outcome.ok)
-        return { ok: false, kind: "cas-exhaustion" };
+        return {
+          ok: false,
+          kind: outcome.kind === "storage-busy" ? "storage-busy" : "cas-exhaustion"
+        };
       if (outcome.kind === "already-present" && outcome.decision.decision === "hint") {
         appendReminderToUserMessageById(messages, userMsgId, outcome.decision.text);
       }
@@ -1699,8 +1759,11 @@ async function runAutoSearchHint(args) {
         });
       }, startedAt);
     } catch (error) {
-      log2(`[auto-search] unified search failed for session ${sessionId} (will retry next pass): ${error instanceof Error ? error.message : String(error)}`);
-      return { ok: false, kind: "search-failure" };
+      if (lifecycleSignal.aborted)
+        return AUTO_SEARCH_OK;
+      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;
     }
     if (lifecycleSignal.aborted)
       return AUTO_SEARCH_OK;
@@ -1735,6 +1798,8 @@ ${hintText}`;
         return { ok: false, kind: "timeout" };
       }
       if (!outcome.ok) {
+        if (outcome.kind === "storage-busy")
+          return { ok: false, kind: "storage-busy" };
         sessionLog2(sessionId, `auto-search: CAS exhausted for ${userMsgId}; skipping wire append`);
         return { ok: false, kind: "cas-exhaustion" };
       }
@@ -1748,6 +1813,8 @@ ${hintText}`;
         queueAutoSearchBackfill(db, sessionId, options.projectPath, rawPrompt);
     }
   }, () => {
+    if (getUnpublishedAutoSearchNoHint(sessionId, userMsgId) !== undefined)
+      return;
     if (wasAutoSearchSkipped(db, sessionId, userMsgId))
       return;
     const decision = getAutoSearchHintDecisions(db, sessionId).find((entry) => entry.messageId === userMsgId);
@@ -3001,11 +3068,15 @@ function opencodeReasoningBudgetStatus(messages, budget, prefixBound, proseRatio
 
 // src/hooks/magic-context/emergency-fail-closed.ts
 var ENGINE_RECONNECTING_USER_MESSAGE = "Magic Context's engine is reconnecting. Send your message again in a few seconds.";
+var ENGINE_BUSY_USER_MESSAGE = "Magic Context is still applying the previous context update for this session. Send your message again in a moment.";
 var PROTECTED_TOOL_RESULTS_OVER_LIMIT = "The tool results kept by protected_tools are larger than this model's context window, so this turn was not sent. Lower the protected_tools counts.";
 var PROTECTED_TOOL_RESULTS_OVER_LIMIT_CODE = "protected_tool_results_over_limit";
+var SIGNED_TURN_OVER_LIMIT = "This turn's context is larger than the model's context window even after all of its thinking and reclaimable tool output were removed, so it was not sent. Send a new message or start a new session to continue.";
+var SIGNED_TURN_OVER_LIMIT_CODE = "signed_turn_over_limit";
+var SIGNED_THINKING_RESET_FENCE_FAILED = "Magic Context could not record a thinking reset for this session, so this turn was not sent. Send your message again.";
 function contextRefusalError(message) {
   return new EmergencyFailClosedError(message, {
-    code: message === PROTECTED_TOOL_RESULTS_OVER_LIMIT ? PROTECTED_TOOL_RESULTS_OVER_LIMIT_CODE : undefined
+    code: message === PROTECTED_TOOL_RESULTS_OVER_LIMIT ? PROTECTED_TOOL_RESULTS_OVER_LIMIT_CODE : message === SIGNED_TURN_OVER_LIMIT ? SIGNED_TURN_OVER_LIMIT_CODE : undefined
   });
 }
 function protectedToolRefusal(error) {
@@ -3015,6 +3086,8 @@ function protectedToolRefusal(error) {
     const current = error;
     if (current.code === PROTECTED_TOOL_RESULTS_OVER_LIMIT_CODE)
       return contextRefusalError(PROTECTED_TOOL_RESULTS_OVER_LIMIT);
+    if (current.code === SIGNED_TURN_OVER_LIMIT_CODE)
+      return contextRefusalError(SIGNED_TURN_OVER_LIMIT);
     error = current.cause;
   }
   return;
@@ -3024,6 +3097,11 @@ function outgoingContextRefusal(estimate, limit, protectedToolTokens = 0) {
     return;
   return PROTECTED_TOOL_RESULTS_OVER_LIMIT;
 }
+function signedTurnContextRefusal(estimate, limit) {
+  if (estimate?.refusalGrade !== true || typeof estimate.refusalTokens !== "number" || !Number.isFinite(estimate.refusalTokens) || !limit || !Number.isFinite(limit) || limit <= 0 || estimate.refusalTokens <= limit)
+    return;
+  return SIGNED_TURN_OVER_LIMIT;
+}
 
 class EmergencyFailClosedError extends Error {
   code;
@@ -4343,6 +4421,39 @@ function postprocessReplaySnapshot(db, sessionId) {
   };
 }
 
+// src/hooks/magic-context/strict-thinking-prefix.ts
+function servedPrefixMatches(args) {
+  const heads = args.messages?.slice(0, 2);
+  if (!heads || heads.length !== 2 || args.m0Text == null || args.m1Text == null)
+    return false;
+  const text = (message) => {
+    if (!isRecord(message))
+      return;
+    if (typeof message.content === "string")
+      return message.content;
+    const parts = Array.isArray(message.parts) ? message.parts : message.content;
+    if (!Array.isArray(parts))
+      return;
+    return parts.filter(isRecord).filter((part) => part.type === "text").map((part) => String(part.text ?? "")).join("");
+  };
+  if (text(heads[0]) !== args.m0Text || text(heads[1]) !== args.m1Text)
+    return false;
+  const head = heads[0];
+  if (!isRecord(head))
+    return false;
+  const parts = Array.isArray(head.parts) ? head.parts : head.content;
+  if (!Array.isArray(parts))
+    return !args.muralDataUrl;
+  const images = parts.filter(isRecord).filter((part) => part.type === "image" || part.type === "file");
+  if (!args.muralDataUrl)
+    return images.length === 0;
+  if (images.length !== 1)
+    return false;
+  const image = images[0];
+  const url = typeof image.url === "string" ? image.url : typeof image.data === "string" && typeof image.mimeType === "string" ? `data:${image.mimeType};base64,${image.data}` : undefined;
+  return url === args.muralDataUrl;
+}
+
 // src/hooks/magic-context/supersession-reclaim.ts
 var SUPERSESSION_RECENT_MESSAGE_WINDOW = 20;
 function recentSupersessionOwnerMessageIds(db, sessionId) {
@@ -4655,6 +4766,7 @@ function getCachedInertWhitespaceAssistantTags(db, sessionId, tagger, messages)
   const messageIds = messages.flatMap((message) => typeof message.info.id === "string" ? [message.info.id] : []);
   const ownersKey = JSON.stringify(messageIds);
   const tagsVersion = tagger.getLoadedTagsVersion?.(sessionId, db);
+  const identityRevision = tagger.getLoadedTagIdentityRevision?.(sessionId, db);
   if (tagsVersion === undefined)
     return getInertWhitespaceAssistantTags2(db, sessionId, messageIds);
   let bySession = inertWhitespaceCache.get(db);
@@ -4663,10 +4775,10 @@ function getCachedInertWhitespaceAssistantTags(db, sessionId, tagger, messages)
     inertWhitespaceCache.set(db, bySession);
   }
   const cached = bySession.get(sessionId);
-  if (cached?.tagsVersion === tagsVersion && cached.ownersKey === ownersKey)
+  if (cached?.tagsVersion === tagsVersion && cached.identityRevision === identityRevision && cached.ownersKey === ownersKey)
     return cached.tags;
   const tags = getInertWhitespaceAssistantTags2(db, sessionId, messageIds);
-  bySession.set(sessionId, { tagsVersion, ownersKey, tags });
+  bySession.set(sessionId, { tagsVersion, identityRevision, ownersKey, tags });
   return tags;
 }
 function makeToolOwnerCacheKey(sessionId, callId) {
@@ -5509,6 +5621,8 @@ function applyRustModeThinkingStrips(args, hostEditBeforeNewestThinking) {
   const recoveryMessageIds = new Set;
   let thinkingBindingRecovery = null;
   let proactiveThinkingStrip = null;
+  const signedThinkingReset = args.cacheBustingPass === true && args.moduleSignedThinkingReset === true;
+  const stripProtection = signedThinkingReset ? undefined : args.protectedThinkingMessages;
   {
     try {
       for (const id of getMergedReasoningStrippedIds(args.db, args.sessionId)) {
@@ -5535,26 +5649,31 @@ function applyRustModeThinkingStrips(args, hostEditBeforeNewestThinking) {
     } catch (error) {
       sessionLog2(args.sessionId, "rust thinking binding recovery failed:", error);
     }
-    stripReasoningFromAssistantIds(args.messages, args.resolvedProviderID, recoveryMessageIds, args.protectedThinkingMessages);
-    const moduleBustStrips = !args.activeThinkingTurn && args.cacheBustingPass === true && (args.moduleReasoningTrimOnly !== true || hostEditBeforeNewestThinking);
-    const stripFrom = args.thinkingBindingRecoveryEnabledForModel === true ? proactiveStripStartIndex({ ...args, cacheBustingPass: moduleBustStrips }) : null;
+    stripReasoningFromAssistantIds(args.messages, args.resolvedProviderID, recoveryMessageIds, stripProtection);
+    const moduleBustStrips = signedThinkingReset || !args.activeThinkingTurn && args.cacheBustingPass === true && (args.moduleReasoningTrimOnly !== true || hostEditBeforeNewestThinking);
+    const stripFrom = args.thinkingBindingRecoveryEnabledForModel === true || signedThinkingReset ? proactiveStripStartIndex({ ...args, cacheBustingPass: moduleBustStrips }) : null;
     if (stripFrom !== null) {
+      const stripped = args.messages.slice(stripFrom);
       const outcome = freezeReasoningOnBustingPass2({
         db: args.db,
         sessionId: args.sessionId,
-        messages: args.messages.slice(stripFrom),
-        protectedMessages: args.protectedThinkingMessages,
+        messages: stripped,
+        protectedMessages: stripProtection,
         alreadyFrozen: recoveryMessageIds
       });
       if (outcome.strip) {
         proactiveThinkingStrip = outcome.strip;
         for (const id of outcome.strip.messageIds)
           recoveryMessageIds.add(id);
-        stripReasoningFromAssistantIds(args.messages, args.resolvedProviderID, new Set(outcome.strip.messageIds), args.protectedThinkingMessages);
+      }
+      const removed = signedThinkingReset ? new Set(findReasoningBearingAssistantIds(stripped)) : new Set(outcome.strip?.messageIds ?? []);
+      if (removed.size > 0) {
+        stripReasoningFromAssistantIds(args.messages, args.resolvedProviderID, removed, stripProtection);
       }
     }
   }
-  args.restoreLatestTurnOriginals?.();
+  if (!signedThinkingReset)
+    args.restoreLatestTurnOriginals?.();
   return { thinkingBindingRecovery, proactiveThinkingStrip };
 }
 function runRustModePostprocess2(args) {
@@ -5597,7 +5716,7 @@ function runRustModePostprocess2(args) {
     appendReminderToUserMessageById(args.messages, anchor.messageId, anchor.text);
   }
   for (const decision of getAutoSearchHintDecisions(args.db, args.sessionId)) {
-    if (decision.decision === "hint") {
+    if (decision.decision === "hint" && getUnpublishedAutoSearchNoHint(args.sessionId, decision.messageId) === undefined) {
       appendReminderToUserMessageById(args.messages, decision.messageId, decision.text);
     }
   }
@@ -5860,7 +5979,7 @@ async function runPostTransformPhase2(args) {
   const reasoningMutationExemptMessage = findLatestAssistantReasoningMutationExemptMessage(args.messages);
   const pendingMaterializationAtPassStart = args.pendingMaterializationSessions.has(args.sessionId);
   const deferredMaterializationAtPassStart = args.deferredMaterializationSessions.has(args.sessionId);
-  const isExplicitFlush = pendingMaterializationAtPassStart;
+  let isExplicitFlush = pendingMaterializationAtPassStart;
   const deferredMaterializationWasPending = deferredMaterializationAtPassStart;
   const alreadyRanThisTurn = args.currentTurnId !== null && args.lastHeuristicsTurnId.get(args.sessionId) === args.currentTurnId;
   const forceMaterialization = args.fullFeatureMode && !compactionOff && args.contextUsage.percentage >= args.forceMaterializationPercentage;
@@ -5877,8 +5996,8 @@ async function runPostTransformPhase2(args) {
   }
   const activeCompartmentRun = args.canRunCompartments ? getActiveCompartmentRun(args.sessionId) : undefined;
   const compartmentRunning = args.canRunCompartments && !args.awaitedCompartmentRun && activeCompartmentRun !== undefined;
-  const deferredMaterialize = args.canConsumeDeferredLate && deferredMaterializationWasPending;
-  const materializationRequested = isExplicitFlush || deferredMaterialize;
+  let deferredMaterialize = args.canConsumeDeferredLate && deferredMaterializationWasPending;
+  let materializationRequested = isExplicitFlush || deferredMaterialize;
   const m0M1EnabledForFold = args.m0M1 !== undefined && (!!args.m0M1.projectPath || !!args.m0M1.projectDirectory) && (args.fullFeatureMode || compactionOff);
   const frozenThinking = new Set(args.activeThinkingTurn ? getMergedReasoningStrippedIds(args.db, args.sessionId) : []);
   const bindingThinking = new Set([...frozenThinking].filter((id) => id.startsWith(THINKING_BINDING_RECOVERY_FROZEN_PREFIX)).map((id) => id.slice(THINKING_BINDING_RECOVERY_FROZEN_PREFIX.length)));
@@ -5890,9 +6009,9 @@ async function runPostTransformPhase2(args) {
     bindingIds: bindingThinking,
     removedIds: getReasoningRemovalState(args.db, args.sessionId).messageIds
   }) : new Set;
-  const activeThinkingTurn = retainedThinking.size > 0;
+  let activeThinkingTurn = retainedThinking.size > 0;
   const protectedThinkingMessages = new Set(args.messages.filter((message) => message.parts.some((part) => retainedThinking.has(part))));
-  const newTargets = protectNewTagMutations(args.messages, args.targets, retainedThinking, args.thinkingBindingRecoveryEnabledForModel === true);
+  let newTargets = protectNewTagMutations(args.messages, args.targets, retainedThinking, args.thinkingBindingRecoveryEnabledForModel === true);
   let maxReasoningTag = 0;
   for (const tag of args.messageTagNumbers.values())
     maxReasoningTag = Math.max(maxReasoningTag, tag);
@@ -5902,7 +6021,28 @@ async function runPostTransformPhase2(args) {
     if (tag && tag > 0)
       safeReasoningCutoff = Math.min(safeReasoningCutoff, tag - 1);
   }
-  const freezeM0M1 = args.freezeM0M1 === true || activeThinkingTurn && args.thinkingBindingRecoveryEnabledForModel === true;
+  let activeThinkingPrefixHold = args.activeThinkingPrefixHold === true || activeThinkingTurn && args.thinkingBindingRecoveryEnabledForModel === true;
+  let freezeM0M1 = args.freezeM0M1 === true || activeThinkingPrefixHold;
+  let rewritingSignedPrefix = false;
+  let thinkingReleasedForFit = false;
+  const releaseThinkingForRewrite = (forFit = false) => {
+    const stripped = freezeReasoningOnBustingPass2({
+      db: args.db,
+      sessionId: args.sessionId,
+      messages: args.messages,
+      alreadyFrozen: bindingThinking
+    });
+    if (stripped.persistenceFailed)
+      throw new Error("Cannot persist signed thinking omission before prefix rewrite");
+    retainedThinking.clear();
+    protectedThinkingMessages.clear();
+    activeThinkingTurn = false;
+    activeThinkingPrefixHold = false;
+    freezeM0M1 = args.directoryPrefixHold === true;
+    newTargets = args.targets;
+    rewritingSignedPrefix = true;
+    thinkingReleasedForFit ||= forFit;
+  };
   const foldDueDecision = m0M1EnabledForFold && args.m0M1 && !freezeM0M1 ? mustMaterialize({
     db: args.db,
     sessionId: args.sessionId,
@@ -5922,6 +6062,7 @@ async function runPostTransformPhase2(args) {
   const cachedPrefixBeforePreflight = shouldCaptureCachedPrefix ? prepareCachedM0M1Replay(args.db, args.sessionId) : undefined;
   const completeCachedPrefixAvailable = args.sessionMeta.cachedM0Bytes != null && args.sessionMeta.cachedM1Bytes != null || cachedPrefixBeforePreflight !== undefined || m0M1EnabledForFold && !shouldCaptureCachedPrefix && hasCompleteCachedM0M1(args.db, args.sessionId);
   const firstRenderBust = m0M1EnabledForFold && !completeCachedPrefixAvailable;
+  const servedBeforeFirstRender = firstRenderBust ? args.readLastServedMessages?.() : null;
   let foldExecutedThisPass = false;
   let foldBustsServedPrefixThisPass = false;
   let publishedM1RefreshedThisPass = false;
@@ -5939,7 +6080,7 @@ async function runPostTransformPhase2(args) {
     m1Bytes: args.sessionMeta.cachedM1Bytes ?? null,
     muralDataUrl: args.sessionMeta.cachedM0MuralDataUrl ?? null
   };
-  if ((foldDueDecision.value || softRefreshOpportunity) && m0M1EnabledForFold && args.m0M1) {
+  if ((foldDueDecision.value || softRefreshOpportunity || firstRenderBust && activeThinkingPrefixHold) && m0M1EnabledForFold && args.m0M1) {
     let committedFoldBustsServedPrefix;
     try {
       const previousM1 = args.sessionMeta.cachedM1Bytes?.toString("utf8");
@@ -5964,7 +6105,12 @@ async function runPostTransformPhase2(args) {
         onFoldPrepare: () => {
           const conversions = prepareLegacyToolSkeletonConversions(args.db, args.sessionId, args.targets);
           return (db, rendered) => {
-            const bustsPrefix = foldBustsServedPrefix(foldDueDecision.reason, servedPrefixBeforeFold, rendered);
+            const bustsPrefix = activeThinkingPrefixHold ? !servedPrefixMatches({
+              messages: servedBeforeFirstRender,
+              m0Text: rendered.m0Bytes.toString(),
+              m1Text: rendered.m1Bytes.toString(),
+              muralDataUrl: rendered.muralDataUrl
+            }) : foldBustsServedPrefix(foldDueDecision.reason, servedPrefixBeforeFold, rendered);
             if (bustsPrefix) {
               if (!conversions.isCurrent(db)) {
                 throw new MaterializeContentionError({
@@ -5981,6 +6127,9 @@ async function runPostTransformPhase2(args) {
         }
       });
       preparedPrefix = foldResult;
+      if (activeThinkingPrefixHold && firstRenderBust && committedFoldBustsServedPrefix) {
+        releaseThinkingForRewrite();
+      }
       prefixPreflightFailed = foldResult.materializationContentionRetryExhausted === true;
       foldExecutedThisPass = foldExecutesThisPass(foldDueDecision.value || softRefreshOpportunity, foldResult.m0RematerializedThisPass);
       foldBustsServedPrefixThisPass = foldExecutedThisPass && (committedFoldBustsServedPrefix ?? true);
@@ -6016,6 +6165,15 @@ async function runPostTransformPhase2(args) {
   }
   logTransformTiming(args.sessionId, "pp.prefixPreflight", tPostprocessSetup, `foldExecuted=${foldExecutedThisPass} m1Refreshed=${publishedM1RefreshedThisPass}`);
   const tPassDecisions = performance.now();
+  const frontToolCandidates = args.tags.filter((tag) => tag.type === "tool" && tag.status === "active" && args.targets.get(tag.tagNumber)?.canDrop?.());
+  if (activeThinkingPrefixHold && (args.forceSignedRebuildForFit || args.contextUsage.percentage >= 95 && frontToolCandidates.length > 0 && frontToolCandidates.every((tag) => newTargets.get(tag.tagNumber)?.thinkingRewriteProtected === true))) {
+    releaseThinkingForRewrite(true);
+  }
+  if (activeThinkingPrefixHold) {
+    isExplicitFlush = false;
+    deferredMaterialize = false;
+    materializationRequested = false;
+  }
   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;
@@ -6025,7 +6183,8 @@ async function runPostTransformPhase2(args) {
     const depth = getPendingOpsCount(args.db, args.sessionId);
     return depth === null ? "not loaded (deferred pass)" : String(depth);
   };
-  const idleExpiryRebuild = !freezeM0M1 && args.m0M1?.hardSignals?.cacheExpired === true;
+  const heldIdleExpiryRebuild = activeThinkingPrefixHold && args.m0M1?.hardSignals?.cacheExpired === true;
+  const idleExpiryRebuild = (!freezeM0M1 || activeThinkingPrefixHold) && args.m0M1?.hardSignals?.cacheExpired === true;
   const rideSignals = {
     subagentExecute: !args.fullFeatureMode && args.schedulerDecision === "execute",
     hardFold: foldBustsServedPrefixThisPass || firstRenderBust || idleExpiryRebuild,
@@ -6033,15 +6192,16 @@ async function runPostTransformPhase2(args) {
     explicitFlush: isExplicitFlush || deferredMaterialize && !prefixPreflightFailed,
     publishedHistory: publishedM1RefreshedThisPass || !m0M1EnabledForFold && (args.pendingCompartmentInjection?.compartmentCount ?? 0) > 0 && (args.historyRebuiltThisPass || args.rebuiltHistoryFromInitialPrepare || args.canConsumeDeferredLate && args.deferredHistoryWasPendingAtPassStart)
   };
-  const publishedWorkDrainAllowed = !compactionOff && hasReclaimRide(rideSignals);
+  const publishedWorkDrainAllowed = !compactionOff && (!activeThinkingPrefixHold || firstRenderBust || idleExpiryRebuild || emergencyDropEligible) && hasReclaimRide(rideSignals);
   const shouldApplyPendingOps = publishedWorkDrainAllowed;
-  const shouldRunHeuristics = !compactionOff && hasReclaimRide(rideSignals) && (rideSignals.publishedHistory || materializationRequested || forceMaterialization || foldBustsServedPrefixThisPass || firstRenderBust || emergencyDropEligible || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
+  const shouldRunHeuristics = publishedWorkDrainAllowed && (rideSignals.publishedHistory || materializationRequested || forceMaterialization || foldBustsServedPrefixThisPass || firstRenderBust || heldIdleExpiryRebuild || emergencyDropEligible || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
   const isCacheBustingPass = publishedWorkDrainAllowed;
+  const canEditWholePrefix = isCacheBustingPass && !activeThinkingPrefixHold;
   const previousTemporalDecisions = args.temporalCandidates && !compactionOff ? new Map([
     ...args.temporalObservedDecisions ?? [],
     ...getTemporalDecisions(args.db, args.sessionId, args.temporalReplayIds ?? args.temporalCandidates.keys())
   ]) : undefined;
-  const temporalDecisions = args.temporalCandidates && !compactionOff ? isCacheBustingPass ? new Map([
+  const temporalDecisions = args.temporalCandidates && !compactionOff ? canEditWholePrefix ? new Map([
     ...previousTemporalDecisions ?? [],
     ...freezeTemporalDecisions(args.db, args.sessionId, args.temporalCandidates)
   ]) : previousTemporalDecisions : undefined;
@@ -6199,7 +6359,7 @@ async function runPostTransformPhase2(args) {
         wordRules: args.cavemanTextCompression.wordRules
       } : undefined;
       const heuristicTags = shouldApplyPendingOps ? getActiveTagsBySession2(args.db, args.sessionId) : args.tags;
-      const emergencyRewriteAlreadyPriced = pendingOpsDidMutate || foldBustsServedPrefixThisPass || args.historyRebuiltThisPass || args.compartmentInjectionRebuiltFromDb || args.rebuiltHistoryFromInitialPrepare;
+      const emergencyRewriteAlreadyPriced = pendingOpsDidMutate || foldBustsServedPrefixThisPass || firstRenderBust || heldIdleExpiryRebuild || args.historyRebuiltThisPass || args.compartmentInjectionRebuiltFromDb || args.rebuiltHistoryFromInitialPrepare;
       if (emergencyDropEligible && emergencyRewriteAlreadyPriced && getEmergencyInputSample(args.db, args.sessionId) > 0) {
         clearEmergencyDropSample(args.db, args.sessionId);
       }
@@ -6260,7 +6420,7 @@ async function runPostTransformPhase2(args) {
         }
       }
       const reasoningEstimates = tryGetReasoningTokenEstimatesByMessage2(args.db, args.sessionId, sessionDecisionCalibration(args.db, args.sessionId).proseRatio);
-      const budgetCutoff = routineCleanupApplied && reasoningEstimates ? Math.min(safeReasoningCutoff, opencodeReasoningBudgetCutoff({
+      const budgetCutoff = routineCleanupApplied && !activeThinkingPrefixHold && reasoningEstimates ? Math.min(safeReasoningCutoff, opencodeReasoningBudgetCutoff({
         messages: args.messages,
         messageTagNumbers: args.messageTagNumbers,
         budget: args.keepReasoningTokens ?? DEFAULT_KEEP_REASONING_TOKENS,
@@ -6282,7 +6442,7 @@ async function runPostTransformPhase2(args) {
         replayStrippedInlineThinking(args.messages, args.messageTagNumbers, persistedInlineWatermark);
       }
       let removedReasoningMessages = 0;
-      if (routineCleanupApplied && reasoningRemovalSelectable && reasoningRemovalReadable) {
+      if (routineCleanupApplied && !prefixBoundModel && reasoningRemovalSelectable && reasoningRemovalReadable) {
         const newIds = selectReasoningRemovals({
           messages: args.messages,
           messageTagNumbers: args.messageTagNumbers,
@@ -6399,7 +6559,7 @@ async function runPostTransformPhase2(args) {
       logTransformTiming(args.sessionId, "toolReclaim.select", tReclaimSelect, `targets=${autoReclaimTargetCount}`);
       if (syntheticPendingOps.length > 0) {
         const tReclaimApply = performance.now();
-        autoReclaimDidMutate = applyPendingOperations(args.sessionId, args.db, args.targets, args.protectedTagIds, undefined, [], syntheticPendingOps, editMarkerTagIds, (reduction) => droppedTokenReductions.push(reduction));
+        autoReclaimDidMutate = applyPendingOperations(args.sessionId, args.db, newTargets, args.protectedTagIds, undefined, [], syntheticPendingOps, editMarkerTagIds, (reduction) => droppedTokenReductions.push(reduction));
         logTransformTiming(args.sessionId, "toolReclaim.apply", tReclaimApply);
         if (autoReclaimDidMutate) {
           droppedCount += syntheticPendingOps.length;
@@ -6452,7 +6612,7 @@ async function runPostTransformPhase2(args) {
       const t8 = performance.now();
       const frozenStaleReduceIds = replaySnapshot.staleReduceStrippedIds;
       const staleReduceResult = dropStaleReduceCalls(args.messages, frozenStaleReduceIds, {
-        detect: isCacheBustingPass,
+        detect: canEditWholePrefix,
         protectedCount: args.protectedCount,
         protectedCallIds: new Set(args.tags.filter((tag) => protectedToolTags.has(tag.tagNumber)).map((tag) => tag.messageId)),
         onFirstApplication: recordFirstApplicationAt
@@ -6471,7 +6631,7 @@ async function runPostTransformPhase2(args) {
       const tImg = performance.now();
       const frozenImageIds = replaySnapshot.processedImageStrippedIds;
       const imageResult = stripProcessedImages(args.messages, frozenImageIds, {
-        detect: isCacheBustingPass && args.watermark > 0,
+        detect: canEditWholePrefix && args.watermark > 0,
         watermark: args.watermark,
         messageTagNumbers: args.messageTagNumbers,
         onFirstApplication: recordFirstApplicationAt
@@ -6715,7 +6875,7 @@ async function runPostTransformPhase2(args) {
       messages: args.messages,
       fullFeatureMode: args.fullFeatureMode,
       compactionOff,
-      isCacheBustingPass,
+      isCacheBustingPass: canEditWholePrefix,
       sessionMeta: args.sessionMeta,
       todowriteAvailability: args.todowriteAvailability,
       client: args.client,
@@ -6782,7 +6942,7 @@ async function runPostTransformPhase2(args) {
     autoSearchHintAppendedThisPass = autoSearchCompletedThisPass && countAutoSearchHints(args.db, args.sessionId) !== autoSearchHintsBefore;
     logTransformTiming(args.sessionId, "pp.autoSearchHint", tAutoSearch);
   }
-  if (args.fullFeatureMode && isCacheBustingPass) {
+  if (args.fullFeatureMode && canEditWholePrefix) {
     const visibleIds = new Set;
     for (const message of args.messages) {
       if (typeof message.info?.id === "string") {
@@ -6790,15 +6950,15 @@ async function runPostTransformPhase2(args) {
       }
     }
     const prunedAnchors = pruneNoteNudgeAnchors(args.db, args.sessionId, visibleIds);
-    const prunedDecisions = pruneAutoSearchHintDecisions(args.db, args.sessionId, visibleIds);
-    if (prunedAnchors > 0 || prunedDecisions > 0) {
-      sessionLog2(args.sessionId, `sticky-injection GC: pruned ${prunedAnchors} note-nudge anchor(s), ${prunedDecisions} auto-search decision(s)`);
+    flushAutoSearchHintDecisionRetirement(args.db, args.sessionId, visibleIds);
+    if (prunedAnchors > 0) {
+      sessionLog2(args.sessionId, `sticky-injection GC: pruned ${prunedAnchors} note-nudge anchor(s)`);
     }
   }
   const materializeReason = m0MaterializeReason ?? (explicitMaterializedSuccessfully ? "explicit_flush" : null);
   const materialized = m0RematerializedThisPass || explicitMaterializedSuccessfully || deferredMaterializedSuccessfully;
   let bustedThisPass = firstApplicationEdits.any || firstRenderBust || pendingOpsDidMutate || heuristicOrReasoningDidMutate || autoReclaimDidMutateThisPass || convertedToolSkeletonsDidMutate || m0RematerializedThisPass || m0M1InjectedThisPass && historyWasConsumedThisPass || historyWasConsumedThisPass;
-  const proactiveThinkingStripPermitted = isCacheBustingPass;
+  const proactiveThinkingStripPermitted = isCacheBustingPass && !activeThinkingPrefixHold;
   const tFrozenDecisions = performance.now();
   if (reasoningMutationTargetUnknown) {
     const reasoningCandidates = args.reasoningByMessage.size > 0 ? args.reasoningByMessage.keys() : args.messages;
@@ -6849,7 +7009,7 @@ async function runPostTransformPhase2(args) {
           sessionLog2(args.sessionId, "thinking binding recovery: persistence failed; leaving the bound blocks intact");
         }
       }
-      if (canUseEmptySentinels && isCacheBustingPass) {
+      if (canUseEmptySentinels && canEditWholePrefix) {
         const candidates = findMergedReasoningStripDecisions(args.messages, args.resolvedProviderID, mergedReasoningStrippedIds, {
           mutationExemptMessage: reasoningMutationExemptMessage,
           protectedMessages: protectedThinkingMessages
@@ -6895,7 +7055,7 @@ async function runPostTransformPhase2(args) {
       recordFirstApplicationAt(message, partIndex);
     }
   };
-  if (isCacheBustingPass && trailingBlankDecisions.size > 0) {
+  if (canEditWholePrefix && trailingBlankDecisions.size > 0) {
     const visibleMessageIds = new Set(args.messages.flatMap((message) => typeof message.info.id === "string" ? [message.info.id] : []));
     const poisonedKeepIds = [];
     for (const [id, decision] of trailingBlankDecisions) {
@@ -7000,7 +7160,7 @@ async function runPostTransformPhase2(args) {
       }
     }
   }
-  const prefixEditBesidesReasoningTrim = firstRenderBust || 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 || firstApplicationEdits.beforeNewerThinking;
   let proactiveThinkingStrip = null;
   if (!compactionOff && args.thinkingBindingRecoveryEnabledForModel === true && proactiveThinkingStripPermitted && prefixEditBesidesReasoningTrim) {
     const outcome = freezeReasoningOnBustingPass2({
@@ -7047,8 +7207,9 @@ async function runPostTransformPhase2(args) {
   const removedReasoningParts = reasoningRemovalEnabled ? removeReasoningParts(args.messages, removedReasoningIds, args.resolvedProviderID) : 0;
   const reasoningStatusRatio = sessionDecisionCalibration(args.db, args.sessionId).proseRatio;
   captureOpencodeReasoningBudgetStatus(args.sessionId, args.messages, args.keepReasoningTokens ?? DEFAULT_KEEP_REASONING_TOKENS, prefixBoundModel, reasoningStatusRatio);
-  args.restoreLatestTurnOriginals?.();
-  if (args.restoreLatestTurnOriginals) {
+  if (!rewritingSignedPrefix)
+    args.restoreLatestTurnOriginals?.();
+  if (!rewritingSignedPrefix && args.restoreLatestTurnOriginals) {
     refreshReasoningRemovalUnion();
     if (replayCommittedVisibleDrops()) {
       finalizeMessageRepresentation2(args.messages, args.resolvedProviderID, finalizeOptions);
@@ -7172,7 +7333,8 @@ async function runPostTransformPhase2(args) {
     bustedThisPass,
     prefixTrimStatus: deliveredPrefix?.prefixTrimStatus ?? null,
     thinkingBindingRecovery,
-    proactiveThinkingStrip
+    proactiveThinkingStrip,
+    thinkingReleasedForFit
   };
 }
 function checkM0MutationDriftAndSignal2(args) {
@@ -7187,4 +7349,4 @@ function checkM0MutationDriftAndSignal2(args) {
   return false;
 }
 
-export { createTagger, cavemanWordRulesForLanguage, searchMessageHistoryOffThread, findSessionId, findLastUserMessageId, clearAutoSearchForSession, setCtxReduceRegisteredGlobally, resolveCtxReduceAvailabilityFromMessages, resolveCtxReduceAvailability, primeCtxReduceSpawnPermission, ctxReduceSpawnPermissionReadNeeded, spawnAgentFromMessages, spawnAgentFromOpenCodeDb, todowritePermissionDenied, cachedToolPermissionDenied, clearToolPermissionDenied, resolveTodowriteAvailabilityFromMessages, resolveTodowriteAvailability, canConsumeDeferredOnThisPass, hasReclaimRide, reclaimRideLabel, replayClearedReasoning, replayStrippedInlineThinking, stripClearedReasoning, snapshotTrailingBlankSourceDecisions, projectOpencodeReasoningBudgetCutoff, resolveKeepReasoningTokens, reasoningBudgetCutoff, captureOpencodeReasoningBudgetStatus, reasoningBudgetStatusLine, ENGINE_RECONNECTING_USER_MESSAGE, contextRefusalError, protectedToolRefusal, outgoingContextRefusal, EmergencyFailClosedError, latestAssistantTurnStart, latestAssistantTurnMessages, hasActiveAnthropicThinkingTurn, replayCavemanCompression, DegradedPassRefusalError, degradedPassError, 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 { createTagger, cavemanWordRulesForLanguage, searchMessageHistoryOffThread, findSessionId, findLastUserMessageId, clearAutoSearchForSession, setCtxReduceRegisteredGlobally, resolveCtxReduceAvailabilityFromMessages, resolveCtxReduceAvailability, primeCtxReduceSpawnPermission, ctxReduceSpawnPermissionReadNeeded, spawnAgentFromMessages, spawnAgentFromOpenCodeDb, todowritePermissionDenied, cachedToolPermissionDenied, clearToolPermissionDenied, resolveTodowriteAvailabilityFromMessages, resolveTodowriteAvailability, canConsumeDeferredOnThisPass, hasReclaimRide, reclaimRideLabel, replayClearedReasoning, replayStrippedInlineThinking, stripClearedReasoning, findReasoningBearingAssistantIds, snapshotTrailingBlankSourceDecisions, projectOpencodeReasoningBudgetCutoff, resolveKeepReasoningTokens, reasoningBudgetCutoff, 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, 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 };