@cortexkit/opencode-magic-context 0.49.17 → 0.49.18

package/dist/v2/{context-jn3zpeqh.js → context-f2xh7ba4.js}

@@ -267,6 +267,7 @@ import {
   peekNoteNudgeText,
   markNoteNudgeDelivered,
   clearNoteNudgeTriggerAndCooldown,
+  omitIncompleteFileTokenTotals,
   RECOVERY_NO_HEAD_LIMIT,
   deriveProtectedTailTokenTarget,
   selectPerRunCap,
@@ -279,7 +280,7 @@ import {
   startCompartmentAgent,
   setRecompStarting2,
   setRecompTerminal2
-} from "./server-fw7wrk01.js";
+} from "./server-bfpda1tb.js";
 import {
   resolveHistorianModel2
 } from "./server-8cd2j99z.js";
@@ -304,7 +305,7 @@ import {
   openDatabaseAsync,
   isDatabasePersisted,
   getDatabasePersistenceError
-} from "./server-gtfhttbr.js";
+} from "./server-a2eqhkxr.js";
 import {
   pruneMissingProjectIdentities,
   setHomeProjectPermission,
@@ -331,12 +332,15 @@ import {
   clearCachedM0,
   expandToolPart,
   markHostUnservedRow,
+  markCoveredInstructionRow,
+  isCoveredInstructionRow,
+  takeCoveredInstructionRows,
+  cloneKeepingCoveredInstructionMarks,
   estimateTrueRawMessageTokens,
   stripSystemInjection,
   isTextPart,
   isToolPartWithOutput,
   isFilePart,
-  buildFileSourceContent,
   toolPartHasUserAnswer,
   DreamTokenBudgetExceeded,
   createDreamTokenBudget,
@@ -474,6 +478,7 @@ import {
   projectOpencodeReasoningBudgetCutoff,
   DEFAULT_KEEP_REASONING_TOKENS,
   resolveKeepReasoningTokens,
+  reasoningStepCost,
   reasoningBudgetCutoff,
   reasoningTextAndOpaque,
   opencodeReasoningBudgetCutoff,
@@ -510,7 +515,7 @@ import {
   readRawSessionMessageById2,
   readSessionChunk2,
   readRawSessionSeedTail2
-} from "./server-kh7dpa1a.js";
+} from "./server-xhab8jx8.js";
 import {
   embedPauseBySession,
   embedRunStateBySession,
@@ -616,7 +621,7 @@ import {
   isMessageIndexReconciledThrough2,
   indexMessagesAfterOrdinal2,
   sweepOrphanedOpenCodeMessageIndexesCooperatively2
-} from "./server-3rhpvy84.js";
+} from "./server-2ehj0bw7.js";
 import {
   stableStringify,
   getTemporalDecisions,
@@ -719,7 +724,7 @@ import {
   adoptNullOwnerToolTag2,
   getCandidateToolOwners2,
   pickNearestPriorOwner2
-} from "./server-zyzawhdw.js";
+} from "./server-27gq4mfz.js";
 import {
   resolveOpenCodeDbPath,
   assertOpenCodeStoreGeneration,
@@ -888,14 +893,14 @@ import {
   resolveMemoriesByIdsForSearch2,
   unifiedSearch2,
   formatSearchResults2
-} from "./server-vsw8tmm6.js";
+} from "./server-1nyybqan.js";
 import {
   resolvePromptContext2
 } from "./server-fmsr7v69.js";
 import"./server-kaqs6h31.js";
 import {
   renderSearchArchiveOffThread2
-} from "./server-ec4ca92p.js";
+} from "./server-qv7f0hhe.js";
 import {
   compareSemverCore
 } from "./server-84w6rvvf.js";
@@ -5804,6 +5809,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",
@@ -6099,8 +6110,9 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
   const canClearReasoning = reasoningProjection?.canClearReasoning ?? modelAcceptsEmptyContent(reasoningProjection?.providerID);
   const projectedPostDropPercentage = estimateProjectedPostDropPercentage(db, sessionId, usage, preloadedActiveTags ?? getActiveTagsBySession2(db, sessionId), keepReasoningTokens, sessionMeta.clearedReasoningThroughTag, canClearReasoning, reasoningProjection?.budgetCutoff, eligiblePendingDropTagIds);
   const relativePostDropTarget = executeThresholdPercentage * POST_DROP_TARGET_RATIO;
+  const ridePermitted = reclaimRide !== undefined && (reclaimRide.permission ? reclaimRidePermitted(reclaimRide, reclaimRide.permission) : hasReclaimRide(reclaimRide));
   const rideLabel = reclaimRide ? reclaimRideLabel(reclaimRide) : "ride=none";
-  const dropsCanLand = reclaimRide !== undefined && hasReclaimRide(reclaimRide);
+  const dropsCanLand = ridePermitted;
   const forceMaterializationPercentage = escalationBands(executeThresholdPercentage).forceMaterializationPercentage;
   if (usage.percentage >= forceMaterializationPercentage) {
     if (dropsCanLand && projectedPostDropPercentage !== null && projectedPostDropPercentage <= relativePostDropTarget) {
@@ -7023,6 +7035,27 @@ function resolveHistoryBudgetTokens(historyBudgetPercentage, contextUsage, execu
   }) / 100) * historyBudgetPercentage);
 }
 
+// src/features/magic-context/storage-host-instruction-retention.ts
+var NAMESPACE = "hostInstructionRetention";
+var enabled = true;
+function hostInstructionRetentionEnabled() {
+  return enabled;
+}
+function isHostInstructionRetentionOn(db, sessionId) {
+  const lane = readReplayEnvelope(db, sessionId)[NAMESPACE];
+  return typeof lane === "object" && lane !== null && lane.on === true;
+}
+function markHostInstructionRetention(db, sessionId) {
+  return updateReplayDocument(db, sessionId, (doc) => {
+    const lane = doc[NAMESPACE];
+    if (typeof lane === "object" && lane !== null && lane.on === true)
+      return false;
+    doc.version = 2;
+    doc[NAMESPACE] = { on: true };
+    return true;
+  });
+}
+
 // src/hooks/magic-context/pending-drop-eligibility.ts
 function pendingDropVeto(tagNumber, target, protectedTagIds) {
   if (protectedTagIds.has(tagNumber))
@@ -7646,7 +7679,7 @@ function foldExecutesThisPass(foldDue, materialized) {
 }
 
 // src/features/magic-context/storage-caveman-rules.ts
-var NAMESPACE = "caveman";
+var NAMESPACE2 = "caveman";
 var CURRENT_RULES_VERSION = 2;
 var ORIGINAL_RULES = {
   currentRules: false,
@@ -7665,7 +7698,7 @@ function parseState(lane) {
 }
 function getCavemanReplayState(db, sessionId) {
   try {
-    return parseState(readReplayEnvelope(db, sessionId)[NAMESPACE]);
+    return parseState(readReplayEnvelope(db, sessionId)[NAMESPACE2]);
   } catch (error) {
     if (error instanceof ReplayDocumentError)
       return ORIGINAL_RULES;
@@ -7675,11 +7708,11 @@ function getCavemanReplayState(db, sessionId) {
 function recordCavemanCurrentRules(db, sessionId, englishWordRules, legacyReasoningTags) {
   const tags = [...new Set(legacyReasoningTags)].sort((a, b) => a - b);
   const persisted = updateReplayDocument(db, sessionId, (doc) => {
-    const current = parseState(doc[NAMESPACE]);
+    const current = parseState(doc[NAMESPACE2]);
     if (current.currentRules && current.englishWordRules === englishWordRules)
       return false;
     doc.version = 2;
-    doc[NAMESPACE] = {
+    doc[NAMESPACE2] = {
       rules: CURRENT_RULES_VERSION,
       legacyReasoningTags: current.currentRules ? [...current.legacyReasoningTags].sort((a, b) => a - b) : tags,
       ...englishWordRules ? {} : { englishWordRules: false }
@@ -9160,25 +9193,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();
-            if (options.refreshSourceContents)
-              replaceSourceContent(db, sessionId, tagId, sourceContent);
-            else
-              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,
@@ -9200,7 +9220,6 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
             return true;
           }
         });
-        fileOrdinal += 1;
       }
     }
     if (message.info.role === "assistant" && !messageHasTextPart) {
@@ -9964,7 +9983,7 @@ async function runPostTransformPhase(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;
@@ -9994,7 +10013,7 @@ async function runPostTransformPhase(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;
@@ -10016,7 +10035,7 @@ async function runPostTransformPhase(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({
@@ -10153,7 +10172,7 @@ async function runPostTransformPhase(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);
@@ -10164,16 +10183,34 @@ async function runPostTransformPhase(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);
   }
@@ -10644,6 +10681,26 @@ async function runPostTransformPhase(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);
@@ -11166,7 +11223,7 @@ async function runPostTransformPhase(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 = freezeReasoningOnBustingPass({
@@ -11183,7 +11240,11 @@ async function runPostTransformPhase(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");
     }
   }
@@ -11342,7 +11403,8 @@ async function runPostTransformPhase(args) {
     prefixTrimStatus: deliveredPrefix?.prefixTrimStatus ?? null,
     thinkingBindingRecovery,
     proactiveThinkingStrip,
-    thinkingReleasedForFit
+    thinkingReleasedForFit,
+    openTurnSignedThinkingKept: args.thinkingBindingRecoveryEnabledForModel === true && activeThinkingTurn && !rewritingSignedPrefix
   };
 }
 function checkM0MutationDriftAndSignal(args) {
@@ -11981,7 +12043,9 @@ var PASS_DEGRADATION_EFFECTS = {
   "trailing-blank-decision-exception": "changes-request",
   "proactive-thinking-strip-persistence-failure": "changes-request",
   "reasoning-removal-read-failure": "changes-request",
-  "reasoning-removal-persistence-failure": "changes-request"
+  "reasoning-removal-persistence-failure": "changes-request",
+  "host-instruction-retention-read-failure": "changes-request",
+  "host-instruction-retention-persistence-failure": "changes-request"
 };
 function degradationChangesRequest(site) {
   return PASS_DEGRADATION_EFFECTS[site] === "changes-request";
@@ -14711,6 +14775,24 @@ function contextUsagePassSnapshot(sessionMeta) {
     } : null
   };
 }
+function savedProviderReadingForPass(input) {
+  const persisted = input.persisted;
+  if (!persisted)
+    return null;
+  const { percentage, inputTokens } = persisted.usage;
+  if (!Number.isFinite(percentage) || percentage <= 0 || !Number.isFinite(inputTokens) || inputTokens <= 0) {
+    return null;
+  }
+  if (!(input.lastResponseTime > 0) || input.cacheExpired)
+    return null;
+  if (persisted.lastObservedModelKey === null || input.currentModelKey === undefined || input.currentModelKey.length === 0 || piModelRefToCanonical(persisted.lastObservedModelKey) !== piModelRefToCanonical(input.currentModelKey)) {
+    return null;
+  }
+  if (typeof input.contextLimit !== "number" || !(input.contextLimit > 0) || persisted.lastUsageContextLimit !== input.contextLimit) {
+    return null;
+  }
+  return { percentage, inputTokens };
+}
 function resolveUnknownUsageFromWireEstimate(input) {
   if (input.usage.inputTokens > 0 || !input.pricedPass)
     return input.usage;
@@ -17918,6 +18000,101 @@ function createRustModeTransform(deps, options) {
   return adapter;
 }
 
+// src/hooks/magic-context/signed-thinking-hold.ts
+var HEAVY_REASONING_TOKENS = 1500;
+var HEAVY_REASONING_WINDOW_STEPS = 15;
+var HOLD_CAP_POINTS = 10;
+var REASONING_TYPES = new Set(["reasoning", "thinking"]);
+function role2(message) {
+  if (!isRecord(message))
+    return;
+  return isRecord(message.info) ? message.info.role : message.role;
+}
+function parts(message) {
+  if (!isRecord(message))
+    return [];
+  if (Array.isArray(message.parts))
+    return message.parts;
+  return Array.isArray(message.content) ? message.content : [];
+}
+function recordedReasoningTokens(message) {
+  if (!isRecord(message))
+    return;
+  const info = isRecord(message.info) ? message.info : undefined;
+  const candidates = [];
+  if (info && isRecord(info.tokens))
+    candidates.push(info.tokens.reasoning);
+  if (isRecord(message.usage)) {
+    candidates.push(message.usage.reasoning, message.usage.reasoningTokens);
+  }
+  for (const value of candidates) {
+    if (typeof value === "number" && Number.isFinite(value) && value > 0)
+      return value;
+  }
+  return;
+}
+function stepReasoningTokens(message, estimateTextTokens) {
+  let text = "";
+  let opaque = false;
+  for (const part of parts(message)) {
+    if (!isRecord(part))
+      continue;
+    const type = String(part.type ?? part.kind);
+    if (type === "redacted_thinking" || part.redacted === true) {
+      opaque = true;
+      continue;
+    }
+    if (!REASONING_TYPES.has(type))
+      continue;
+    const body = typeof part.thinking === "string" ? part.thinking : typeof part.text === "string" ? part.text : "";
+    if (body.length > 0)
+      text += body;
+    else
+      opaque = true;
+  }
+  if (!text && !opaque)
+    return 0;
+  return reasoningStepCost(recordedReasoningTokens(message), text ? estimateTextTokens(text) : 0, opaque);
+}
+function decideSignedThinkingHold(args) {
+  const capPercentage = args.executeThresholdPercentage + HOLD_CAP_POINTS;
+  let heavyStepsBack = null;
+  let heavyStepTokens = 0;
+  const start = latestAssistantTurnStart(args.messages);
+  let stepsBack = 0;
+  for (let index = args.messages.length - 1;index >= start; index--) {
+    const message = args.messages[index];
+    if (role2(message) !== "assistant" || parts(message).length === 0)
+      continue;
+    stepsBack++;
+    if (stepsBack > HEAVY_REASONING_WINDOW_STEPS)
+      break;
+    const tokens = stepReasoningTokens(message, args.estimateTextTokens);
+    if (tokens > HEAVY_REASONING_TOKENS) {
+      heavyStepsBack = stepsBack;
+      heavyStepTokens = tokens;
+      break;
+    }
+  }
+  if (heavyStepsBack === null)
+    return {
+      held: false,
+      reason: "no_recent_heavy_reasoning",
+      heavyStepsBack,
+      heavyStepTokens,
+      capPercentage
+    };
+  if (!(args.usagePercentage < capPercentage))
+    return { held: false, reason: "above_cap", heavyStepsBack, heavyStepTokens, capPercentage };
+  return {
+    held: true,
+    reason: "heavy_reasoning",
+    heavyStepsBack,
+    heavyStepTokens,
+    capPercentage
+  };
+}
+
 // src/hooks/magic-context/temporal-served-projection.ts
 function readLkgTemporalDecisions(db, sessionId, runtime) {
   const slot = getInMemorySlot(sessionId) ?? loadPersistedLkgSlot(db, sessionId);
@@ -18141,7 +18318,7 @@ async function runCompartmentPhaseImpl(args) {
     justAwaitedPublication = activeRun.published;
     published = published || activeRun.published;
     const historyReprepareShouldBust = activeRun.published && args.deferredHistoryRefreshSessions.has(args.sessionId);
-    pendingCompartmentInjection = prepareCompartmentInjection(args.db, args.resolvedSessionId, args.messages, historyReprepareShouldBust, args.projectPath, args.injectionBudgetTokens, args.experimentalTemporalAwareness);
+    pendingCompartmentInjection = prepareCompartmentInjection(args.db, args.resolvedSessionId, args.messages, historyReprepareShouldBust, args.coveredInstructions, args.projectPath, args.injectionBudgetTokens, args.experimentalTemporalAwareness);
     if (historyReprepareShouldBust) {
       rebuiltHistoryThisPass = true;
     }
@@ -18432,7 +18609,8 @@ function createTransform(deps) {
     const startTime = performance.now();
     const historianRun = deps.resolveHistorianRun?.();
     const messages = output.messages;
-    const originalForThinkingFit = messages.some((message) => message.parts.some((part) => isRecord(part) && ["reasoning", "thinking", "redacted_thinking"].includes(String(part.type)))) ? structuredClone(messages) : null;
+    const originalForThinkingFit = messages.some((message) => message.parts.some((part) => isRecord(part) && ["reasoning", "thinking", "redacted_thinking"].includes(String(part.type)))) ? cloneKeepingCoveredInstructionMarks(messages) : null;
+    const coveredHostInstructions = takeCoveredInstructionRows(messages);
     const passOutcome = createPassOutcome();
     const tSessionId = performance.now();
     const sessionId = findSessionId(messages);
@@ -18630,8 +18808,8 @@ function createTransform(deps) {
         return true;
       }
     })();
-    let activeThinkingPrefixHold = activeThinkingTurn && isPrefixBoundThinkingModel(activeThinkingModel?.providerID, activeThinkingModel?.modelID);
-    let freezeM0M1 = unresolvedDirectoryHold || activeThinkingPrefixHold;
+    let activeThinkingPrefixHold = false;
+    let freezeM0M1 = unresolvedDirectoryHold;
     const compartmentDirectory = sessionDirectory;
     const historianRunnable = deps.historianRunnable !== false;
     const canRunCompartments = fullFeatureMode && !compactionOff && historianRunnable && (deps.client !== undefined || deps.hiddenCompletionExecutor !== undefined) && compartmentDirectory.length > 0;
@@ -18759,13 +18937,7 @@ function createTransform(deps) {
     }
     const resolvedProviderID = modelForBudget?.providerID;
     activeThinkingTurn ||= hasActiveAnthropicThinkingTurn(messages, resolvedProviderID, modelForBudget?.modelID);
-    activeThinkingPrefixHold ||= activeThinkingTurn && isPrefixBoundThinkingModel(resolvedProviderID, modelForBudget?.modelID);
-    freezeM0M1 ||= activeThinkingPrefixHold;
-    if (freezeM0M1 && prefixHoldLogTurnIds.get(sessionId) !== currentTurnId) {
-      prefixHoldLogTurnIds.set(sessionId, currentTurnId);
-      const reason = activeThinkingPrefixHold ? "active thinking turn (prefix-bound model)" : "session directory unresolved";
-      sessionLog2(sessionId, `m[0]/m[1] frozen: ${reason}; replaying the frozen prefix and deferring any rebuild`);
-    }
+    const signedThinkingPrefixBound = activeThinkingTurn && (isPrefixBoundThinkingModel(activeThinkingModel?.providerID, activeThinkingModel?.modelID) || isPrefixBoundThinkingModel(resolvedProviderID, modelForBudget?.modelID));
     const canUseEmptySentinels = modelAcceptsEmptyContent(resolvedProviderID);
     const protectedThinkingMessages = activeThinkingTurn || isAnthropicFamilyRoute(resolvedProviderID, modelForBudget?.modelID) ? latestAssistantTurnMessages(messages) : new Set;
     const resolvedContextLimit = modelForBudget ? resolveTrustedContextLimit(modelForBudget.providerID, modelForBudget.modelID, {
@@ -18819,6 +18991,29 @@ function createTransform(deps) {
     const effectiveExecuteThresholdPercentage = executeThresholdDetail.percentage;
     sessionLog2(sessionId, `transform threshold: model=${currentModelKeyForBoundary ?? "unknown"} matchedModel=${executeThresholdDetail.matchedKey ?? "scalar"} mode=${executeThresholdDetail.mode} threshold=${effectiveExecuteThresholdPercentage}% proactiveFloor=${getProactiveCompartmentTriggerPercentage(effectiveExecuteThresholdPercentage)}%`);
     const { forceMaterializationPercentage } = escalationBands(effectiveExecuteThresholdPercentage);
+    let holdProseRatio;
+    const signedThinkingHold = signedThinkingPrefixBound ? decideSignedThinkingHold({
+      messages,
+      usagePercentage: contextUsageEarly.percentage,
+      executeThresholdPercentage: effectiveExecuteThresholdPercentage,
+      estimateTextTokens: (text) => {
+        holdProseRatio ??= sessionDecisionCalibration(db, sessionId).proseRatio;
+        return estimateTokens(text) * holdProseRatio;
+      }
+    }) : null;
+    activeThinkingPrefixHold = signedThinkingPrefixBound && (compactionOff || signedThinkingHold?.held === true);
+    freezeM0M1 ||= activeThinkingPrefixHold;
+    const prefixHoldLogKey = signedThinkingHold ? `${currentTurnId}:${signedThinkingHold.reason}:${signedThinkingHold.heavyStepsBack ?? "none"}` : freezeM0M1 ? `${currentTurnId}:directory` : null;
+    if (prefixHoldLogKey !== null && prefixHoldLogTurnIds.get(sessionId) !== prefixHoldLogKey) {
+      prefixHoldLogTurnIds.set(sessionId, prefixHoldLogKey);
+      if (signedThinkingHold) {
+        sessionLog2(sessionId, `signed thinking hold: held=${signedThinkingHold.held} reason=${signedThinkingHold.reason} heavyStepsBack=${signedThinkingHold.heavyStepsBack ?? "none"} heavyStepTokens=${signedThinkingHold.heavyStepTokens} usage=${contextUsageEarly.percentage.toFixed(1)}% cap=${signedThinkingHold.capPercentage}%`);
+      }
+      if (freezeM0M1) {
+        const reason = activeThinkingPrefixHold ? compactionOff ? "active thinking turn in compaction-off mode (prefix-bound model)" : "recent heavy reasoning in the active thinking turn (prefix-bound model)" : "session directory unresolved";
+        sessionLog2(sessionId, `m[0]/m[1] frozen: ${reason}; replaying the frozen prefix and deferring any rebuild`);
+      }
+    }
     const persistedUsageFreshForBoundary = persistedUsageBeforeResets && Date.now() - persistedUsageBeforeResets.updatedAt <= 10 * 60 * 1000 && (persistedUsageBeforeResets.lastObservedModelKey === null || currentModelKeyForBoundary === undefined || piModelRefToCanonical(persistedUsageBeforeResets.lastObservedModelKey) === piModelRefToCanonical(currentModelKeyForBoundary)) && (resolvedContextLimit === undefined || persistedUsageBeforeResets.lastUsageContextLimit === 0 || persistedUsageBeforeResets.lastUsageContextLimit === resolvedContextLimit) ? persistedUsageBeforeResets.usage : null;
     const boundaryUsageForProtectedTail = persistedUsageFreshForBoundary ?? contextUsageEarly;
     const boundaryUsageSource = persistedUsageFreshForBoundary ? "persisted" : "live";
@@ -19005,8 +19200,14 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         }, {
           hardFold: false,
           force: contextUsageEarly.percentage >= forceMaterializationPercentage && (contextUsageEarly.percentage >= 95 || getEmergencyInputSample(db, sessionId) === 0),
-          explicitFlush: deps.pendingMaterializationSessions.has(sessionId),
-          publishedHistory: isCacheBusting
+          explicitFlush: hasPendingMaterializationOrigin(deps.pendingMaterializationSessions, sessionId, "user_flush"),
+          publishedHistory: isCacheBusting,
+          permission: {
+            signedThinkingHold: activeThinkingPrefixHold,
+            firstRender: false,
+            idleExpiry: false,
+            emergency: contextUsageEarly.percentage >= forceMaterializationPercentage
+          }
         }, pendingDropEligibility.read(sessionId, dropProjectionKey()));
         if (triggerResult.shouldFire) {
           sessionLog2(sessionId, `compartment trigger: firing (reason=${triggerResult.reason})`);
@@ -19026,7 +19227,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     const messagesBeforeInitialPrepare = isCacheBusting && deferredHistoryWasPendingAtPassStart ? [...messages] : null;
     if (fullFeatureMode && !compactionOff) {
       const tInj = performance.now();
-      pendingCompartmentInjection = prepareCompartmentInjection(db, sessionId, messages, isCacheBusting, projectIdentity, deps.memoryConfig?.injectionBudgetTokens, deps.experimentalTemporalAwareness);
+      pendingCompartmentInjection = prepareCompartmentInjection(db, sessionId, messages, isCacheBusting, coveredHostInstructions, projectIdentity, deps.memoryConfig?.injectionBudgetTokens, deps.experimentalTemporalAwareness);
       if (messagesBeforeInitialPrepare) {
         const skippedVisibleMessages = pendingCompartmentInjection?.skippedVisibleMessages ?? 0;
         trimmedMessagesAtCompactionBoundary = messagesBeforeInitialPrepare.slice(0, skippedVisibleMessages);
@@ -19200,6 +19401,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       fallbackModels: historianRun?.fallbackModels ?? deps.fallbackModels,
       compartmentDirectory,
       messages,
+      coveredInstructions: coveredHostInstructions,
       pendingCompartmentInjection,
       fallbackModelId,
       projectPath: projectIdentity,
@@ -19271,30 +19473,53 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       bustReason: calibrationBustReason,
       onAdopt: (message) => sessionLog2(sessionId, message)
     });
+    let contextUsageFromEstimate = false;
     if (contextUsage.inputTokens <= 0 && protectionCacheBustingPass) {
+      const overflowRecoveryPass = usagePercentageSynthetic || emergencyRecoveryArmed;
+      const savedProviderReading = overflowRecoveryPass ? null : savedProviderReadingForPass({
+        persisted: persistedUsageBeforeResets,
+        currentModelKey: currentModelKeyForBoundary ?? (hardModelKey || undefined),
+        contextLimit: resolvedContextLimit,
+        lastResponseTime: sessionMeta.lastResponseTime,
+        cacheExpired: hardCacheExpired
+      });
+      let pressureEstimate;
       try {
-        const pressureEstimate = estimateFinalWireInputTokens({
+        pressureEstimate = estimateFinalWireInputTokens({
           messages,
           systemPromptTokens: sessionMeta.systemPromptTokens,
           providerID: modelForBudget?.providerID,
           modelID: modelForBudget?.modelID,
           agentName: notificationParams.agent
         });
+      } catch (error) {
+        sessionLog2(sessionId, `transform: wire-estimate pressure fallback unavailable: ${getErrorMessage(error)}`);
+      }
+      const usableHard = windowGeometry?.usableHard;
+      const countPercentage = pressureEstimate?.pressureTokens !== undefined && Number.isFinite(pressureEstimate.pressureTokens) && typeof usableHard === "number" && usableHard > 0 ? pressureEstimate.pressureTokens / usableHard * 100 : 0;
+      const grewPastSavedReading = savedProviderReading !== null && countPercentage >= 95 && countPercentage > savedProviderReading.percentage;
+      if (savedProviderReading && !grewPastSavedReading) {
+        contextUsage = {
+          inputTokens: savedProviderReading.inputTokens,
+          percentage: Math.max(contextUsage.percentage, savedProviderReading.percentage)
+        };
+        sessionLog2(sessionId, `transform: unknown provider usage; using saved provider reading for priced pass inputTokens=${contextUsage.inputTokens} percentage=${contextUsage.percentage.toFixed(1)} countPercentage=${countPercentage.toFixed(1)}`);
+      } else if (pressureEstimate) {
+        const percentageBeforeEstimate = contextUsage.percentage;
         contextUsage = resolveUnknownUsageFromWireEstimate({
           usage: contextUsage,
           pricedPass: true,
-          wireEstimateTokens: pressureEstimate.tokens,
+          wireEstimateTokens: overflowRecoveryPass ? pressureEstimate.tokens : pressureEstimate.pressureTokens,
           wireEstimateTrusted: pressureEstimate.trusted,
           providerProvenInputTokens: providerProvenInputForRecovery,
           providerProvenLimitTokens: providerProvenLimitForRecovery,
-          usableHardLimit: windowGeometry?.usableHard
+          usableHardLimit: usableHard
         });
         if (contextUsage.inputTokens > 0) {
           const usedProviderInput = !pressureEstimate.trusted && providerProvenLimitForRecovery !== undefined && providerProvenInputForRecovery !== undefined && contextUsage.inputTokens >= providerProvenInputForRecovery;
-          sessionLog2(sessionId, `transform: unknown provider usage; using ${usedProviderInput ? "provider-proven input" : "wire estimate"} for priced pass inputTokens=${contextUsage.inputTokens} percentage=${contextUsage.percentage.toFixed(1)} trusted=${pressureEstimate.trusted} wireTokens=${pressureEstimate.tokens}`);
+          contextUsageFromEstimate = !overflowRecoveryPass && !usedProviderInput && !usagePercentageSynthetic && contextUsage.percentage > percentageBeforeEstimate;
+          sessionLog2(sessionId, `transform: unknown provider usage; using ${usedProviderInput ? "provider-proven input" : "wire estimate"} for priced pass inputTokens=${contextUsage.inputTokens} percentage=${contextUsage.percentage.toFixed(1)} trusted=${pressureEstimate.trusted} wireTokens=${pressureEstimate.tokens} pressureTokens=${pressureEstimate.pressureTokens}${grewPastSavedReading ? ` grewPastSavedReading=${savedProviderReading?.percentage.toFixed(1)}` : ""}`);
         }
-      } catch (error) {
-        sessionLog2(sessionId, `transform: wire-estimate pressure fallback unavailable: ${getErrorMessage(error)}`);
       }
     }
     const protectionUsableSoft = windowGeometry?.usableSoft ?? boundaryContextLimit;
@@ -19335,6 +19560,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       activeAgent,
       batch,
       contextUsage,
+      contextUsageFromEstimate,
       usableWindow: resolvedContextLimit ?? 0,
       schedulerDecision,
       schedulerDeferReason,
@@ -19380,6 +19606,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       emergencyCeilingTokens,
       pendingCompartmentInjection,
       prefixTrimSourceOrder,
+      coveredHostInstructions,
       hiddenMessagesAtCompactionSeam,
       trimmedMessagesAtCompactionBoundary,
       didMutateFromFlushedStatuses,
@@ -19580,7 +19807,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     if (!finalWireEstimate) {
       sessionLog2(sessionId, `transform: final-wire telemetry estimate=unavailable trusted=false conversation=unknown tools=unknown system=unknown toolDefinitions=unknown tail=${finalWireTail}`);
     }
-    finishSystemDateRefresh(deps.historyRefreshSessions, dateRequest, postTransformResult.bustedThisPass && !activeThinkingPrefixHold || postTransformResult.thinkingReleasedForFit === true);
+    finishSystemDateRefresh(deps.historyRefreshSessions, dateRequest, postTransformResult.bustedThisPass && !activeThinkingPrefixHold && postTransformResult.openTurnSignedThinkingKept !== true || postTransformResult.thinkingReleasedForFit === true);
     if (activeThinkingPrefixHold && !postTransformResult.thinkingReleasedForFit && sessionMeta.cachedM0Bytes != null && sessionMeta.cachedM1Bytes != null) {
       recordHeldHeadForRequest(sessionId, currentLkgRequestIdentity(sessionId), (ownsHistory) => deferDeliveredSystemRefresh(deps, sessionId, ownsHistory));
     }
@@ -19681,7 +19908,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     });
     if (uncachedMessageIds.length > 0) {
       try {
-        storedByMessage = getActiveTagTokenTotalsByMessage2(db, sessionId, uncachedMessageIds);
+        storedByMessage = omitIncompleteFileTokenTotals(db, sessionId, messages.flatMap((message) => message.info.id ? [{ id: message.info.id, parts: message.parts }] : []), getActiveTagTokenTotalsByMessage2(db, sessionId, uncachedMessageIds));
       } catch {
         storedByMessage = new Map;
       }
@@ -22999,7 +23226,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp } = await importPluginModule(() => import("./recomp-orchestrator-cmqnfpp3.js"));
+    const { runManagedRecomp } = await importPluginModule(() => import("./recomp-orchestrator-4vfxej9t.js"));
     const { sendIgnoredMessage } = await importPluginModule(() => import("./send-session-notification-3pxn658x.js"));
     log2(`[rpc] recomp requested for session ${sessionId}`);
     if (!args.client && !args.hiddenCompletionExecutor) {
@@ -23084,7 +23311,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedWrapup } = await importPluginModule(() => import("./wrapup-orchestrator-xs8redz9.js"));
+    const { runManagedWrapup } = await importPluginModule(() => import("./wrapup-orchestrator-psqz7yh0.js"));
     const model = liveSessionState.liveModelBySession.get(sessionId);
     const contextLimit = model ? resolveContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : 128000;
     const ctx = {
@@ -24706,6 +24933,8 @@ function adaptPayload(draft, admittedIDs = new Set, messageTimes = new Map) {
       parts
     };
     originals.set(mapped, message);
+    if (isCoveredInstructionRow(message))
+      markCoveredInstructionRow(mapped.info);
     if (typeof message.id !== "string")
       bridgesByCarrier.set(mapped, byCallID);
     messages.push(mapped);
@@ -51796,6 +52025,11 @@ async function applyV2SystemPrompt(systemPrompt, draft) {
     text
   })));
 }
+function coveredInstructionRows(reader, sessionID, throughSeq, model) {
+  if (throughSeq < 0)
+    return [];
+  return reader.instructionRowsThrough(sessionID, throughSeq).flatMap((row) => restoreRow(row, model)).map((message) => markCoveredInstructionRow(message));
+}
 async function registerContext(context) {
   const directory = context.location.directory;
   const config = loadPluginConfigDetailed(directory).config;
@@ -52791,7 +53025,7 @@ async function registerContext(context) {
             asset: hostMediaAsset,
             unavailable: (detail) => sessionLog2(draft.sessionID, `v2 restore: attachment replaced by a note row=${detail.rowID} name=${JSON.stringify(detail.name ?? null)} mediaType=${detail.mediaType} reason=${JSON.stringify(detail.reason)}`)
           } : undefined));
-          draft.messages.splice(0, draft.messages.length, ...restored, ...draft.messages.filter((message) => message !== incoming));
+          draft.messages.splice(0, draft.messages.length, ...rustModeModuleClient ? [] : coveredInstructionRows(reader, draft.sessionID, Math.min(boundary, cut.seq), draft.model), ...restored, ...draft.messages.filter((message) => message !== incoming));
         }
         if (config.temporal_awareness === true)
           messageTimes = reader.messageTimes(draft.sessionID, draft.messages.flatMap((message) => message.id ? [message.id] : []));