@cortexkit/opencode-magic-context 0.49.17 → 0.49.19

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

@@ -127,6 +127,8 @@ import {
   hasProcessLocalLkgProof,
   lkgDirtyRevision,
   rememberLkgDirtyRevision,
+  readPersistedLkgUntaggedInputIds,
+  persistLkgUntaggedInputIds,
   noteLkgRecoveryPrefix,
   readLkgRecoveryPrefix,
   noteLkgHealthyPrefix,
@@ -267,6 +269,7 @@ import {
   peekNoteNudgeText,
   markNoteNudgeDelivered,
   clearNoteNudgeTriggerAndCooldown,
+  omitIncompleteFileTokenTotals,
   RECOVERY_NO_HEAD_LIMIT,
   deriveProtectedTailTokenTarget,
   selectPerRunCap,
@@ -279,7 +282,7 @@ import {
   startCompartmentAgent,
   setRecompStarting2,
   setRecompTerminal2
-} from "./server-fw7wrk01.js";
+} from "./server-6vdzn1td.js";
 import {
   resolveHistorianModel2
 } from "./server-8cd2j99z.js";
@@ -304,7 +307,7 @@ import {
   openDatabaseAsync,
   isDatabasePersisted,
   getDatabasePersistenceError
-} from "./server-gtfhttbr.js";
+} from "./server-bmymkx73.js";
 import {
   pruneMissingProjectIdentities,
   setHomeProjectPermission,
@@ -331,12 +334,15 @@ import {
   clearCachedM0,
   expandToolPart,
   markHostUnservedRow,
+  markCoveredInstructionRow,
+  isCoveredInstructionRow,
+  takeCoveredInstructionRows,
+  cloneKeepingCoveredInstructionMarks,
   estimateTrueRawMessageTokens,
   stripSystemInjection,
   isTextPart,
   isToolPartWithOutput,
   isFilePart,
-  buildFileSourceContent,
   toolPartHasUserAnswer,
   DreamTokenBudgetExceeded,
   createDreamTokenBudget,
@@ -414,6 +420,8 @@ import {
   applyStrippedPlaceholderDelta,
   THINKING_BINDING_RECOVERY_FROZEN_PREFIX,
   thinkingBindingRecoveryFrozenId,
+  compactionOffThinkingFrozenId,
+  compactionOffFrozenThinkingIds,
   getThinkingBindingRecoveryTarget,
   clearThinkingBindingRecoveryIf,
   getMergedReasoningStrippedIds,
@@ -474,6 +482,7 @@ import {
   projectOpencodeReasoningBudgetCutoff,
   DEFAULT_KEEP_REASONING_TOKENS,
   resolveKeepReasoningTokens,
+  reasoningStepCost,
   reasoningBudgetCutoff,
   reasoningTextAndOpaque,
   opencodeReasoningBudgetCutoff,
@@ -510,7 +519,7 @@ import {
   readRawSessionMessageById2,
   readSessionChunk2,
   readRawSessionSeedTail2
-} from "./server-kh7dpa1a.js";
+} from "./server-9hx7g5jp.js";
 import {
   embedPauseBySession,
   embedRunStateBySession,
@@ -616,7 +625,7 @@ import {
   isMessageIndexReconciledThrough2,
   indexMessagesAfterOrdinal2,
   sweepOrphanedOpenCodeMessageIndexesCooperatively2
-} from "./server-3rhpvy84.js";
+} from "./server-2ar62dyx.js";
 import {
   stableStringify,
   getTemporalDecisions,
@@ -719,7 +728,7 @@ import {
   adoptNullOwnerToolTag2,
   getCandidateToolOwners2,
   pickNearestPriorOwner2
-} from "./server-zyzawhdw.js";
+} from "./server-27gq4mfz.js";
 import {
   resolveOpenCodeDbPath,
   assertOpenCodeStoreGeneration,
@@ -753,7 +762,7 @@ import {
   resolveStoredPathWorkspaceIdentity,
   storedPathBelongsToWorkspace,
   computeWorkspaceEpochFingerprint
-} from "./server-gpvay0xz.js";
+} from "./server-xq7dfjke.js";
 import {
   configureContextDatabasePragmas2
 } from "./server-fb3zxn06.js";
@@ -799,7 +808,7 @@ import {
   readGitFileChangeTimesSince,
   verificationFileExists,
   normalizeVerificationFiles
-} from "./server-my7k4eds.js";
+} from "./server-hm38q7r0.js";
 import {
   deriveTriggerBudget2,
   deriveHistorianChunkTokens2,
@@ -888,14 +897,14 @@ import {
   resolveMemoriesByIdsForSearch2,
   unifiedSearch2,
   formatSearchResults2
-} from "./server-vsw8tmm6.js";
+} from "./server-gsxjv2q2.js";
 import {
   resolvePromptContext2
 } from "./server-fmsr7v69.js";
 import"./server-kaqs6h31.js";
 import {
   renderSearchArchiveOffThread2
-} from "./server-ec4ca92p.js";
+} from "./server-45q69hkq.js";
 import {
   compareSemverCore
 } from "./server-84w6rvvf.js";
@@ -5804,6 +5813,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 +6114,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 +7039,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 +7683,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 +7702,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 +7712,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 +9197,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 +9224,6 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
             return true;
           }
         });
-        fileOrdinal += 1;
       }
     }
     if (message.info.role === "assistant" && !messageHasTextPart) {
@@ -9385,7 +9408,10 @@ function freezeReasoningOnBustingPass(args) {
     return { strip: null, persistenceFailed: false };
   let persisted = false;
   try {
-    persisted = addMergedReasoningStrippedIds(args.db, args.sessionId, messageIds.map(thinkingBindingRecoveryFrozenId));
+    persisted = addMergedReasoningStrippedIds(args.db, args.sessionId, [
+      ...messageIds.map(thinkingBindingRecoveryFrozenId),
+      ...args.compactionOff ? messageIds.map(compactionOffThinkingFrozenId) : []
+    ]);
   } catch (error) {
     sessionLog2(args.sessionId, "proactive thinking strip: persistence threw:", error);
   }
@@ -9895,7 +9921,7 @@ function finalizeMessageRepresentation(messages, resolvedProviderID, options) {
       clearedParts = stripClearedReasoning(targetedMessages.filter((message) => !restoredMessages.has(message)));
     }
   }
-  const bindingRecoveryParts = options?.skipMergedReasoningStrip ? 0 : stripReasoningFromAssistantIds(messages, resolvedProviderID, options?.frozenThinkingBindingMessageIds ?? new Set, restoredMessages);
+  const bindingRecoveryParts = stripReasoningFromAssistantIds(messages, resolvedProviderID, options?.frozenThinkingBindingMessageIds ?? new Set, restoredMessages);
   const mergedReasoningParts = bindingRecoveryParts + (options?.skipMergedReasoningStrip ? 0 : stripReasoningFromMergedAssistants(messages, resolvedProviderID, {
     mutationExemptMessage: options?.reasoningMutationExemptMessage,
     frozenMessageIds: options?.mergedReasoningStrippedIds,
@@ -9964,7 +9990,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;
@@ -9972,8 +9998,9 @@ async function runPostTransformPhase(args) {
   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)));
+  const frozenThinking = new Set(args.activeThinkingTurn || compactionOff ? getMergedReasoningStrippedIds(args.db, args.sessionId) : []);
+  const compactionOffFrozenThinking = compactionOff ? compactionOffFrozenThinkingIds(frozenThinking) : new Set;
+  const bindingThinking = compactionOff ? new Set(compactionOffFrozenThinking) : new Set([...frozenThinking].filter((id) => id.startsWith(THINKING_BINDING_RECOVERY_FROZEN_PREFIX)).map((id) => id.slice(THINKING_BINDING_RECOVERY_FROZEN_PREFIX.length)));
   const retainedThinking = args.activeThinkingTurn ? retainedActiveThinkingParts({
     messages: args.messages,
     providerID: args.resolvedProviderID,
@@ -9994,19 +10021,24 @@ 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;
-  const releaseThinkingForRewrite = (forFit = false) => {
+  const releaseThinkingForRewrite = (forFit = false, stripInCompactionOff = false) => {
+    const stripOffWire = compactionOff && stripInCompactionOff;
     const stripped = freezeReasoningOnBustingPass({
       db: args.db,
       sessionId: args.sessionId,
       messages: args.messages,
-      alreadyFrozen: bindingThinking
+      alreadyFrozen: bindingThinking,
+      compactionOff: stripOffWire
     });
     if (stripped.persistenceFailed)
       throw new Error("Cannot persist signed thinking omission before prefix rewrite");
+    if (stripOffWire)
+      for (const id of stripped.strip?.messageIds ?? [])
+        compactionOffFrozenThinking.add(id);
     retainedThinking.clear();
     protectedThinkingMessages.clear();
     activeThinkingTurn = false;
@@ -10016,7 +10048,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({
@@ -10104,7 +10136,7 @@ async function runPostTransformPhase(args) {
       });
       preparedPrefix = foldResult;
       if (activeThinkingPrefixHold && firstRenderBust && committedFoldBustsServedPrefix) {
-        releaseThinkingForRewrite();
+        releaseThinkingForRewrite(false, true);
       }
       prefixPreflightFailed = foldResult.materializationContentionRetryExhausted === true;
       foldExecutedThisPass = foldExecutesThisPass(foldDueDecision.value || softRefreshOpportunity, foldResult.m0RematerializedThisPass);
@@ -10153,7 +10185,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 +10196,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 +10694,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);
@@ -10984,7 +11054,10 @@ async function runPostTransformPhase(args) {
   const mergedReasoningStrippedIds = new Set(replaySnapshot?.mergedReasoningStrippedIds ?? []);
   const frozenThinkingBindingMessageIds = new Set;
   let thinkingBindingRecovery = null;
-  if (!compactionOff) {
+  if (compactionOff) {
+    for (const id of compactionOffFrozenThinking)
+      frozenThinkingBindingMessageIds.add(id);
+  } else {
     try {
       for (const id of mergedReasoningStrippedIds) {
         if (id.startsWith(THINKING_BINDING_RECOVERY_FROZEN_PREFIX)) {
@@ -11166,7 +11239,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 +11256,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 +11419,8 @@ async function runPostTransformPhase(args) {
     prefixTrimStatus: deliveredPrefix?.prefixTrimStatus ?? null,
     thinkingBindingRecovery,
     proactiveThinkingStrip,
-    thinkingReleasedForFit
+    thinkingReleasedForFit,
+    openTurnSignedThinkingKept: args.thinkingBindingRecoveryEnabledForModel === true && activeThinkingTurn && !rewritingSignedPrefix
   };
 }
 function checkM0MutationDriftAndSignal(args) {
@@ -11512,6 +11590,7 @@ function beginSystemDateRequest(history, sessionId, stage, turnId, identity) {
       systemDone: false,
       messagesSeen: false,
       permitted: undefined,
+      signedThinkingKept: undefined,
       ambiguous: identity === undefined && (turnId === undefined || sameTurn)
     };
     const blocked = [...requests.values()].filter((candidate) => !candidate.explicit && candidate.ambiguous && !(candidate.systemSeen && candidate.messagesSeen) && candidate.turnId === turnId).length;
@@ -11534,6 +11613,10 @@ function systemDateRefreshPermission(history, request) {
   const current = state(history, request);
   return current?.ambiguous ? undefined : current?.permitted;
 }
+function systemDateSignedThinkingKept(history, request) {
+  const current = state(history, request);
+  return current?.ambiguous ? undefined : current?.signedThinkingKept;
+}
 function waitForSystemDateRefresh(history, request, apply) {
   const current = state(history, request);
   if (!current)
@@ -11548,7 +11631,7 @@ function retire(history, current) {
   if (unpairable) {
     const apply = current.waiting;
     current.waiting = undefined;
-    apply?.(false);
+    apply?.(false, undefined);
   }
   const channel = channels.get(history);
   const requests = channel?.get(current.sessionId);
@@ -11556,14 +11639,15 @@ function retire(history, current) {
   if (requests?.size === 0)
     channel?.delete(current.sessionId);
 }
-function finishSystemDateRefresh(history, request, permitted) {
+function finishSystemDateRefresh(history, request, permitted, signedThinkingKept) {
   const current = state(history, request);
   if (!current)
     return;
   current.permitted = current.ambiguous ? false : permitted;
+  current.signedThinkingKept = current.ambiguous ? undefined : signedThinkingKept;
   const apply = current.waiting;
   current.waiting = undefined;
-  apply?.(current.permitted);
+  apply?.(current.permitted, current.signedThinkingKept);
   retire(history, current);
 }
 function finishSystemDateHook(history, request) {
@@ -11675,11 +11759,14 @@ function createSystemPromptHashHandler(deps) {
     const stableCandidateHash = systemPromptFingerprint(stableCandidate, promptSurface.preset);
     const contentOrPresetChanged = hasPersistedHash && stableCandidateHash !== previousHash;
     const rewritePermission = systemDateRefreshPermission(deps.historyRefreshSessions, dateRequest);
+    const signedThinkingKept = systemDateSignedThinkingKept(deps.historyRefreshSessions, dateRequest);
+    const idleDateMayAdvance = idleCacheExpired && signedThinkingKept !== true;
+    const prefixBoundModel = isPrefixBoundThinkingModel(liveModel?.providerID, liveModel?.modelID);
     let deferredDateRefresh = false;
-    if (currentDate && stickyDate && currentDate !== stickyDate && isCacheBusting && !idleCacheExpired && !contentOrPresetChanged && !requestMessagesFinal) {
+    if (currentDate && stickyDate && currentDate !== stickyDate && (idleCacheExpired ? prefixBoundModel : isCacheBusting) && !contentOrPresetChanged && !requestMessagesFinal) {
       const liveElements = [...output.system];
-      deferredDateRefresh = waitForSystemDateRefresh(deps.historyRefreshSessions, dateRequest, (permitted) => {
-        if (!permitted) {
+      deferredDateRefresh = waitForSystemDateRefresh(deps.historyRefreshSessions, dateRequest, (permitted, keptSignedThinking) => {
+        if (!permitted && !(idleCacheExpired && keptSignedThinking !== true)) {
           deps.systemPromptRefreshSessions.add(sessionId);
           return;
         }
@@ -11703,7 +11790,7 @@ function createSystemPromptHashHandler(deps) {
         }
       });
     }
-    const dateMayAdvance = idleCacheExpired || contentOrPresetChanged || isCacheBusting && !deferredDateRefresh && (dateRequest ? rewritePermission === true : rewritePermission !== false);
+    const dateMayAdvance = idleDateMayAdvance && !deferredDateRefresh || contentOrPresetChanged || isCacheBusting && !deferredDateRefresh && (dateRequest ? rewritePermission === true : rewritePermission !== false);
     if (currentDate && !stickyDate) {
       stickyDateBySession.set(sessionId, currentDate);
     } else if (currentDate && stickyDate && currentDate !== stickyDate) {
@@ -11981,7 +12068,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 +14800,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 +18025,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 +18343,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 +18634,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);
@@ -18448,6 +18651,11 @@ function createTransform(deps) {
     const tLkgEntry = performance.now();
     const lkgInput = deps.transformMode === "rust" ? [] : projectEntry(sessionId, messages);
     const recovery = deps.compactionOff || deps.transformMode === "rust" ? {} : readLkgRecoveryPrefix(sessionId, lkgInput, messages, deps.db);
+    const persistedUntaggedInputIds = deps.compactionOff || deps.transformMode === "rust" ? [] : readPersistedLkgUntaggedInputIds(deps.db, sessionId);
+    const untaggedReplayIds = new Set([
+      ...recovery.prefix?.untaggedInputIds ?? [],
+      ...persistedUntaggedInputIds
+    ]);
     logTransformTiming(sessionId, "lkg.entryProjection", tLkgEntry, deps.transformMode === "rust" || !entryReuse ? undefined : `reused=${entryReuse.reused} retained=${entryReuse.retained} retainedBytes=${entryReuse.retainedBytes}`);
     const resolvedSessionId = sessionId;
     const runNotificationParams = (sid) => {
@@ -18630,8 +18838,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 +18967,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 +19021,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 +19230,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 +19257,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);
@@ -19058,10 +19289,11 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     let taggingSucceeded = false;
     let recoveryBatch = null;
     let recoveryNormalized = false;
-    const normalizeRecoveryTail = recovery.prefix ? () => {
+    const untaggedReplayTailServed = !!recovery.prefix || untaggedReplayIds.size > 0 && messages.some((message) => untaggedReplayIds.has(message.info.id ?? ""));
+    const normalizeRecoveryTail = untaggedReplayTailServed ? () => {
       if (recoveryNormalized)
         return;
-      const tail = messages.filter((message) => recovery.prefix?.untaggedInputIds.has(message.info.id ?? ""));
+      const tail = messages.filter((message) => untaggedReplayIds.has(message.info.id ?? ""));
       const tagged = tagMessages(sessionId, tail, deps.tagger, db, {
         skipPrefixInjection: !ctxReduceCallable,
         servedMessages: messages,
@@ -19087,7 +19319,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         const messagesForTagging = messagesBeforeInitialPrepare && hiddenMessagesAtCompactionSeam.length > 0 ? messagesBeforeInitialPrepare : messages;
         const canAdoptScopedToolSweep = isCacheBusting || canConsumeDeferredEarly;
         const scopedToolSweep = useScopedToolSweep(db, sessionId, canAdoptScopedToolSweep) ? true : createPreAdoptionToolSweepResolver(db, sessionId);
-        const result = tagMessages(sessionId, recovery.prefix ? messagesForTagging.filter((message) => !recovery.prefix?.untaggedInputIds.has(message.info.id ?? "")) : messagesForTagging, deps.tagger, db, {
+        const result = tagMessages(sessionId, untaggedReplayIds.size > 0 ? messagesForTagging.filter((message) => !untaggedReplayIds.has(message.info.id ?? "")) : messagesForTagging, deps.tagger, db, {
           skipPrefixInjection,
           scopedToolSweep,
           servedMessages: messages,
@@ -19200,6 +19432,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 +19504,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 +19591,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       activeAgent,
       batch,
       contextUsage,
+      contextUsageFromEstimate,
       usableWindow: resolvedContextLimit ?? 0,
       schedulerDecision,
       schedulerDeferReason,
@@ -19380,6 +19637,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       emergencyCeilingTokens,
       pendingCompartmentInjection,
       prefixTrimSourceOrder,
+      coveredHostInstructions,
       hiddenMessagesAtCompactionSeam,
       trimmedMessagesAtCompactionBoundary,
       didMutateFromFlushedStatuses,
@@ -19419,7 +19677,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       postTransformResult.bustedThisPass = true;
     passOutcome.markFinalized();
     const finalWireTail = describeFinalWireTail(messages);
-    const signedFitPreviouslyRefused = !compactionOff && getMergedReasoningStrippedIds(db, sessionId).has(SIGNED_FIT_REFUSED_MARKER);
+    const signedFitPreviouslyRefused = !compactionOff && activeThinkingPrefixHold && getMergedReasoningStrippedIds(db, sessionId).has(SIGNED_FIT_REFUSED_MARKER);
     let finalWireEstimate;
     if (postTransformResult.bustedThisPass) {
       try {
@@ -19580,7 +19838,12 @@ 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);
+    if (!compactionOff) {
+      const stillUntagged = untaggedReplayTailServed && !recoveryNormalized ? [...untaggedReplayIds] : [];
+      if (JSON.stringify([...new Set(stillUntagged)].sort()) !== JSON.stringify([...new Set(persistedUntaggedInputIds)].sort()) && !persistLkgUntaggedInputIds(db, sessionId, stillUntagged))
+        throw new Error("Cannot persist the last-good untagged-message record");
+    }
+    finishSystemDateRefresh(deps.historyRefreshSessions, dateRequest, postTransformResult.bustedThisPass && !activeThinkingPrefixHold && postTransformResult.openTurnSignedThinkingKept !== true || postTransformResult.thinkingReleasedForFit === true, postTransformResult.openTurnSignedThinkingKept === true);
     if (activeThinkingPrefixHold && !postTransformResult.thinkingReleasedForFit && sessionMeta.cachedM0Bytes != null && sessionMeta.cachedM1Bytes != null) {
       recordHeldHeadForRequest(sessionId, currentLkgRequestIdentity(sessionId), (ownsHistory) => deferDeliveredSystemRefresh(deps, sessionId, ownsHistory));
     }
@@ -19681,7 +19944,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;
       }
@@ -20128,7 +20391,8 @@ function tryMessagesTransformLkgReplay(args) {
             sessionId,
             entry,
             messages: replay.messages,
-            ...keys
+            ...keys,
+            db
           }))
             return false;
           retirePendingSystemPromptDelivery(sessionId);
@@ -22999,7 +23263,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-f6m9jr7p.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 +23348,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-embdz8gj.js"));
     const model = liveSessionState.liveModelBySession.get(sessionId);
     const contextLimit = model ? resolveContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : 128000;
     const ctx = {
@@ -24706,6 +24970,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);
@@ -27770,6 +28036,7 @@ async function applyCuesThroughModule(args, chunk, manifestText, signal) {
 }
 
 // src/features/magic-context/dreamer/hidden-single-shot.ts
+var DREAMER_FIRST_OUTPUT_TIMEOUT_MS = 90000;
 async function runHiddenSingleShotPrompt(args) {
   const system = withContentLanguageDirective(args.system, args.language);
   const opening = args.executor.open({
@@ -27811,6 +28078,7 @@ async function runHiddenSingleShotPrompt(args) {
     }, {
       transport: Object.assign((request) => args.executor.attempt(handle, request), { childSessionId: handle.childSessionId }),
       timeoutMs: args.timeoutMs,
+      ...args.firstOutputTimeoutMs !== undefined ? { firstOutputTimeoutMs: args.firstOutputTimeoutMs } : {},
       ...args.signal ? { signal: args.signal } : {},
       fallbackModels: args.fallbackModels,
       callContext: args.callContext,
@@ -28664,6 +28932,7 @@ async function classifyOneChunk(args, chunk, anchors, sliceMs, signal) {
       }, {
         transport: Object.assign((request) => executor.attempt(opened, request), { childSessionId: opened.childSessionId }),
         timeoutMs: sliceMs,
+        firstOutputTimeoutMs: args.firstOutputTimeoutMs ?? DREAMER_FIRST_OUTPUT_TIMEOUT_MS,
         signal,
         fallbackModels: args.fallbackModels,
         callContext: "dreamer:classify-memories",
@@ -31138,6 +31407,7 @@ async function mapOneBatch(args, batch, sliceMs, signal) {
         model: args.model,
         fallbackModels: args.fallbackModels,
         timeoutMs: sliceMs,
+        firstOutputTimeoutMs: args.firstOutputTimeoutMs ?? DREAMER_FIRST_OUTPUT_TIMEOUT_MS,
         signal,
         onOpened: () => {
           stage = "prompt";
@@ -31192,6 +31462,7 @@ async function mapOneBatch(args, batch, sliceMs, signal) {
         onBudgetUpdate
       }),
       timeoutMs: sliceMs,
+      firstOutputTimeoutMs: args.firstOutputTimeoutMs ?? DREAMER_FIRST_OUTPUT_TIMEOUT_MS,
       signal,
       fallbackModels: args.fallbackModels,
       callContext: "dreamer:map-memories",
@@ -33269,6 +33540,7 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
         fallbackModels: args.fallbackModels,
         language: args.language,
         timeoutMs: sliceMs,
+        firstOutputTimeoutMs: args.firstOutputTimeoutMs ?? DREAMER_FIRST_OUTPUT_TIMEOUT_MS,
         signal: batchSignal,
         onFailureOutput: (completion) => {
           failedCompletion = completion;
@@ -33326,6 +33598,7 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
         onBudgetUpdate
       }),
       timeoutMs: sliceMs,
+      firstOutputTimeoutMs: args.firstOutputTimeoutMs ?? DREAMER_FIRST_OUTPUT_TIMEOUT_MS,
       signal: batchSignal,
       fallbackModels: args.fallbackModels,
       callContext: "dreamer:verify",
@@ -49405,6 +49678,7 @@ function renderItemByTag(db, sessionId, number, textIndexDomain = "part") {
 }
 
 // src/tools/ctx-expand/tools.ts
+var CTX_EXPAND_RUST_TAG_REFUSAL = "Tag lookup isn't available on this session: its §N§ tags are numbered by the Rust transform engine and ctx_expand cannot resolve those numbers, so no content was returned. Expand by message instead: ctx_expand(message=<ordinal>) or ctx_expand(start=<ordinal>, end=<ordinal>), using ordinals from a <session-history> heading or a ctx_search hit.";
 var ctxExpandArgsShape = {
   tag: tool.schema.union([tool.schema.number(), tool.schema.string()]).optional().describe("Tag number from a §N§ tag or a [dropped §N§] placeholder, not a message ordinal. Returns that one item in full. Use alone."),
   start: tool.schema.number().optional().describe("First message ordinal of the range (a <session-history> heading's start, or a ctx_search hit), not a tag number."),
@@ -49427,9 +49701,12 @@ function createCtxExpandTool(deps) {
         message: "number"
       });
       const sessionId = toolContext.sessionID;
+      const mode = resolveCtxExpandMode(args, "positive");
+      if (mode.kind === "tag" && deps.transformMode === "rust") {
+        return CTX_EXPAND_RUST_TAG_REFUSAL;
+      }
       if (!await prepareRawSessionOrdinals2(sessionId))
         return "Session ordinals are warming in the background. Retry ctx_expand shortly; no approximate ordinal was served.";
-      const mode = resolveCtxExpandMode(args, "positive");
       if (mode.kind === "error") {
         return mode.message;
       }
@@ -51316,7 +51593,11 @@ async function registerTools(context, db, config, rustToolBackends, isInternalCh
       getProtectionWindow: (sessionID) => getProtectionWindowForSession(db, sessionID, getObservedEpochFloor(db, sessionID)),
       ...rustToolBackends ? { rustToolBackends } : {}
     }) : {},
-    ...createCtxExpandTools({ db, expandTools: config.historian?.expand_tools }),
+    ...createCtxExpandTools({
+      db,
+      expandTools: config.historian?.expand_tools,
+      transformMode: config.transform_mode
+    }),
     ...createCtxNoteTools({
       ...project,
       dreamerEnabled: isDreamerRunnable(config),
@@ -51796,6 +52077,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 +53077,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] : []));