@cortexkit/opencode-magic-context 0.46.0 → 0.47.0

package/dist/{index-qr6r7akd.js → index-w2t4ah5j.js}

@@ -24,7 +24,7 @@ import {
   SynapseEmbeddingProvider,
   computeNormalizedHash,
   getLocalEmbeddingNativeMemoryStats
-} from "./index-yasgb8ej.js";
+} from "./index-m5fe6jch.js";
 import {
   getHarness,
   harnessOwnsOpenCodeStore,
@@ -63,11 +63,8 @@ import {
   isTransientSqliteError,
   SqliteAcquisitionBusyError,
   withAsyncPrivilegedWriter
-} from "./index-fg34g6a5.js";
+} from "./index-wx8a6bw3.js";
 import {
-  isFailClosedBlockingError,
-  shouldBypassFailClosedBlock,
-  resolveAgentNameFromMessages,
   canonicalProjectDirectory,
   shouldSkipHomeProjectMemory,
   ProjectIdentityError,
@@ -82,12 +79,6 @@ import {
   storedPathBelongsToIdentity,
   beginBootQuietPeriod,
   scheduleAfterBootQuiet,
-  registerOwnRpcServerInstance,
-  rpcPortDir,
-  rpcPortFilePath,
-  parseRpcPortFile,
-  inspectProcessesAsync,
-  configureContextDatabasePragmas,
   layoutLkgPrefix,
   assembleLkgPrefix,
   V2_MEMORY_CATEGORIES,
@@ -98,7 +89,238 @@ import {
   expandWorkspaceIdentitySetWithAliases,
   resolveStoredPathWorkspaceIdentity,
   storedPathBelongsToWorkspace,
-  computeWorkspaceEpochFingerprint,
+  computeWorkspaceEpochFingerprint
+} from "./index-x3kwrmqk.js";
+import {
+  recordSessionProjectIdentity,
+  hasRecordedSessionProjectIdentity,
+  getMessageIndexSourceIdentity,
+  isMessageIndexSourceCurrent,
+  getLastIndexedOrdinal,
+  getMessageIndexReconciliationStartOrdinal,
+  isMessageIndexReconciledThrough,
+  clearIndexedMessages,
+  indexSingleMessage,
+  indexMessagesAfterOrdinal,
+  sweepOrphanedOpenCodeMessageIndexes,
+  SESSION_NOTE_CONDITION_ERROR,
+  getNoteByIdInScope,
+  getNotes,
+  addNote,
+  getSessionNotes,
+  getPendingSmartNotes,
+  getReadySmartNotes,
+  updateNote,
+  dismissNotes,
+  dismissNote,
+  markNoteReady,
+  markNoteChecked,
+  PRIMER_CANDIDATE_TTL_MS,
+  PRIMER_CANDIDATE_MAX_AGE_MS,
+  primerOccurrenceKey,
+  primerOccurrenceUtcDay,
+  updatePrimerCandidateEmbedding,
+  getPrimerCandidatesByIds,
+  getPrimerCandidatesForPromotion,
+  countPrimerCandidatesForProject,
+  getActivePrimers,
+  createPrimer,
+  updatePrimerSupport,
+  updatePrimerAnswer,
+  cosineSimilarity,
+  drainBackgroundBatches,
+  GIT_SWEEP_LEASE_RENEWAL_MS,
+  acquireGitSweepLease,
+  renewGitSweepLease,
+  markGitSweepSuccessAndRelease,
+  parkGitSweepNonIndexable,
+  releaseGitSweepLease,
+  saveEmbeddingIfHashMatches,
+  invalidateProject,
+  invalidateMemory,
+  describeShadowBackfillWriteRefusal,
+  markProjectLoadUntrusted,
+  drainProjectEmbeddingIdentityMaintenance,
+  drainStaleEmbeddingIdentitiesForProject,
+  registerProjectEmbedding,
+  registerProjectShadowEmbedding,
+  enqueueShadowEmbeddingItems,
+  registerProjectInObservationMode,
+  unregisterProjectShadowEmbedding,
+  getProjectEmbeddingSnapshot,
+  embedTextForProject,
+  embedBatchForProject,
+  embedUnembeddedMemoriesForProject,
+  embedUnembeddedMemoriesForProjectOutcome,
+  drainCommitBacklogForProject,
+  embedSessionCompartmentChunks,
+  getEmbeddingCoverageStatus,
+  computeCueContentHash,
+  hasMuralCueColumns,
+  getMuralCueState,
+  memoryNeedsCue,
+  setMuralCue,
+  recordMuralCueRejection,
+  hasMemoryShareableColumn,
+  hasMemoryClassifiedAtColumn,
+  getUnclassifiedMemoryIds,
+  insertMemory,
+  insertMemoryIdempotent,
+  getMemoryByHash,
+  getMemoriesByProject,
+  getMemoriesForList,
+  getMaxMemoryIdForProjects,
+  getMemoryById,
+  getMemoriesByIds,
+  updateMemorySeenCount,
+  setMemoryClassification,
+  supersededMemory,
+  mergeMemoryStats,
+  archiveMemory,
+  getMemoryCountsByStatus,
+  recordMemoryMapping,
+  recordMemoryVerifications,
+  getUnmappedMemoryIds,
+  clearMemoryVerifications,
+  getMemoryVerifications,
+  resolveGitTopLevel,
+  readGitHead,
+  readGitChangedFilesSince,
+  readGitFileChangeTimesSince,
+  verificationFileExists,
+  normalizeVerificationFiles
+} from "./index-fnn5pjtt.js";
+import {
+  hasTrustedAbsoluteWall,
+  applyProvenInputFloor,
+  formatWindowDerivationLine,
+  isSaneLimit,
+  getSdkWindowGeometry,
+  getSdkContextLimit,
+  getSdkOutputLimit,
+  deriveTriggerBudget2,
+  resolveKnownHistorianContextLimit2,
+  resolveHistorianProducerLimits2
+} from "./index-0c82743p.js";
+import {
+  resolveModelCalibration,
+  calibrateBuckets,
+  resolveDecisionCalibration
+} from "./index-1zx87sdm.js";
+import {
+  hasMeaningfulUserText2,
+  extractTexts2,
+  extractToolCallSummaries,
+  getTokenizerNativeMemoryStats,
+  estimateTokens,
+  estimateFixedPromptTokens,
+  normalizeText
+} from "./index-5eqk6z3s.js";
+import {
+  protectedToolTagNumbers,
+  protectedToolTokenCount,
+  peelLeadingMcTagNotation,
+  isRecord,
+  contentTagOwnerMessageId,
+  normalizeTodoStateJson,
+  computeSyntheticCallId,
+  CHANNEL1_SENTINEL,
+  toolOutputTokens,
+  decideChannel1,
+  evaluateChannel2,
+  formatChannel1Evaluation,
+  formatChannel2Evaluation,
+  reclaimableToolOutputCount,
+  buildChannel2Reminder,
+  buildChannel1Reminder,
+  queuePendingOp,
+  getPendingOps,
+  hasPendingDropOps,
+  clearPendingOps,
+  removePendingOp,
+  getTriggerTagTokenUpperBound,
+  getActiveTagTokenTotalsByMessage,
+  getReasoningTokenEstimatesByMessage,
+  updateTagStatus,
+  getInertWhitespaceAssistantTags,
+  deriveTagLoadFloor,
+  getTagsBySession,
+  getActiveTagsBySession,
+  getDroppedTagsBySession,
+  getTagsByNumbers,
+  getDroppedTagsByNumbers,
+  getMaxDroppedTagNumber,
+  getTagById,
+  expandToolPart,
+  isRawCompactionSummaryInfo,
+  extractInMemoryMessageViews,
+  buildInMemoryTailRawMessages,
+  estimateTrueRawMessageTokens,
+  toolPartHasUserAnswer,
+  DreamTokenBudgetExceeded,
+  isEditTool,
+  describeFinalWireTail,
+  estimateMessageTokens,
+  wireContentBytes,
+  createFinalWireUsageTracker,
+  estimateFinalWireInputTokens,
+  estimateAppendedWireTokens,
+  detectLatestTurnThinkingMismatch,
+  isPrefixBoundThinkingModel,
+  detectOverflow,
+  modelAcceptsEmptyContent,
+  isAnthropicFamilyRoute,
+  variantChangeBustsProviderCache,
+  setRawMessageProvider2,
+  cleanUserText2,
+  withRawSessionMessageCache2,
+  readRawSessionMessages2,
+  visitRawSessionMessages2,
+  primeTailRawMessageCache2,
+  primeInMemoryTailRawMessageCache2,
+  readRawSessionMessageOrdinalPage2,
+  getRawSessionStoredMessageCount2,
+  readRawSessionMessageIdOrdinalsForRange2,
+  readRawSessionMessagePartsById2,
+  readRawSessionMessageById2,
+  readSessionChunk2,
+  readRawSessionSeedTail2
+} from "./index-bb36vgr3.js";
+import {
+  observeTemporalDecisions,
+  getMeasuredToolDefinitionTokens
+} from "./index-5gq3b2ya.js";
+import {
+  openCodeDbExists,
+  withReadOnlySessionDb,
+  assistantAwaitingTools,
+  latestPersistedMessageForRecovery,
+  findLastAssistantModelFromOpenCodeDb
+} from "./index-6wkcswft.js";
+import {
+  CANONICAL_DREAM_TASKS,
+  DREAM_TASK_CAPABILITIES,
+  toolLoopDreamTasks,
+  formatDreamTaskBacklogs,
+  formatDreamTaskFailures,
+  processedDreamTaskItems,
+  leaseKindFor,
+  leaseKeyFor,
+  isCanonicalDreamTask,
+  compareTaskOrder,
+  buildDreamTaskRuntimeConfigs2,
+  userMemoryCollectionEnabled2
+} from "./index-mc22ayvf.js";
+import {
+  isFailClosedBlockingError,
+  shouldBypassFailClosedBlock,
+  resolveAgentNameFromMessages,
+  registerOwnRpcServerInstance,
+  rpcPortDir,
+  rpcPortFilePath,
+  parseRpcPortFile,
+  inspectProcessesAsync,
+  configureContextDatabasePragmas,
   getUnconfirmedMigrationHolders,
   getSchemaFenceRejection,
   getMigrationOnOpenRefusal,
@@ -108,7 +330,7 @@ import {
   runSqliteOptimize,
   openDatabase,
   openCurrentDatabase
-} from "./index-r5hmbx3t.js";
+} from "./index-rrrsepyw.js";
 import {
   getMagicContextBuiltinCommands,
   formatConfigParseStatusLine,
@@ -129,8 +351,6 @@ import {
   renderDreamFailure,
   dreamFailureCode,
   renderEmbeddingFailure,
-  recordSessionProjectIdentity,
-  hasRecordedSessionProjectIdentity,
   clampProducerAtomChars,
   producerInputTokenLimit,
   historianProducerReserve,
@@ -146,20 +366,13 @@ import {
   embedRunStateBySession,
   invalidateAutoEmbedSession,
   getEmbedDrainUiStatus,
+  ensureSessionMetaRow,
   getCompartments,
   getLastCompartmentEndMessage,
   getLastCompartmentEndMessageId,
-  getMessageIndexSourceIdentity,
-  isMessageIndexSourceCurrent,
-  getLastIndexedOrdinal,
-  getMessageIndexReconciliationStartOrdinal,
-  isMessageIndexReconciledThrough,
-  clearIndexedMessages,
-  indexSingleMessage,
-  indexMessagesAfterOrdinal,
-  sweepOrphanedOpenCodeMessageIndexes,
   MAX_EXECUTE_THRESHOLD,
   escalationBands,
+  decodeMergedReasoningParts,
   sessionDecisionCalibration,
   getProtectionWindowForSession,
   isRustMarkerAdmissionFenced,
@@ -176,6 +389,7 @@ import {
   resolveCompactionModeRecord,
   getCompactionModeRecord,
   setCompactionModeRecord,
+  getProtectedTailDrainBudgetSkip,
   clearPersistedReasoningWatermark,
   getEmergencyInputSample,
   clearEmergencyDropSample,
@@ -209,7 +423,10 @@ import {
   getPersistedCompactionMarkerState,
   setPersistedCompactionMarkerState,
   getStrippedPlaceholderIds,
+  getThinkingBindingRecoveryTarget,
+  armThinkingBindingRecovery,
   clearThinkingBindingRecoveryIf,
+  getMergedReasoningStrippedIds,
   getStaleReduceStrippedIds,
   getProcessedImageStrippedIds,
   getPendingCompactionMarkerState,
@@ -218,6 +435,7 @@ import {
   setSessionWorkMetrics,
   getObservedEpochFloor,
   resolveEpochFloorForPass,
+  providerResponseFailed,
   claimLkgRequestIdentity,
   noteCapturedLkgRequest,
   measuredLkgPrefix,
@@ -240,6 +458,7 @@ import {
   dropSlot,
   noteEntry,
   getLkgSlotHeapStats,
+  TOOL_SWEEP_SCOPED_MARKER,
   useScopedToolSweep,
   createPreAdoptionToolSweepResolver,
   queueMemoryMutation,
@@ -248,117 +467,31 @@ import {
   updateSessionMeta,
   retryPendingSessionCleanups,
   retryPendingRustSessionCleanupsForProject,
-  SESSION_NOTE_CONDITION_ERROR,
-  getNoteByIdInScope,
-  getNotes,
-  addNote,
-  getSessionNotes,
-  getPendingSmartNotes,
-  getReadySmartNotes,
-  updateNote,
-  dismissNotes,
-  dismissNote,
-  markNoteReady,
-  markNoteChecked,
-  PRIMER_CANDIDATE_TTL_MS,
-  PRIMER_CANDIDATE_MAX_AGE_MS,
-  primerOccurrenceKey,
-  primerOccurrenceUtcDay,
-  updatePrimerCandidateEmbedding,
-  getPrimerCandidatesByIds,
-  getPrimerCandidatesForPromotion,
-  countPrimerCandidatesForProject,
-  getActivePrimers,
-  createPrimer,
-  updatePrimerSupport,
-  updatePrimerAnswer,
   GLOBAL_USER_PROFILE_PROJECT_PATH,
   getProjectState,
   bumpProjectUserProfileVersion,
-  createChildSessionWithFence,
-  HiddenCompletionRefusal,
-  DreamerProviderOutputFailureError,
-  withDreamerModelCooldown,
-  providerOutputFailureFromInvalidManifest,
-  extractLatestAssistantText,
-  hasLengthCappedOutput,
-  parseProviderModel,
-  modelBodyField,
-  toModelEntry,
-  isPromptTimeoutError,
-  getPromptFailureDetail,
-  promptSyncWithValidatedOutputRetry,
-  normalizeSDKResponse,
-  failedInvocationStatus,
-  recordChildInvocation,
-  createPromptAsyncTransport,
-  promptSurfaceHashMaterial,
-  createPromptSurfaceRuntime,
-  createPromptSurfaceGuidanceEpochCache,
-  teardownChildSession,
-  getCompartmentEvents,
-  cosineSimilarity,
-  drainBackgroundBatches,
-  GIT_SWEEP_LEASE_RENEWAL_MS,
-  acquireGitSweepLease,
-  renewGitSweepLease,
-  markGitSweepSuccessAndRelease,
-  parkGitSweepNonIndexable,
-  releaseGitSweepLease,
-  saveEmbeddingIfHashMatches,
-  invalidateProject,
-  invalidateMemory,
-  describeShadowBackfillWriteRefusal,
-  markProjectLoadUntrusted,
-  drainProjectEmbeddingIdentityMaintenance,
-  drainStaleEmbeddingIdentitiesForProject,
-  registerProjectEmbedding,
-  registerProjectShadowEmbedding,
-  enqueueShadowEmbeddingItems,
-  registerProjectInObservationMode,
-  unregisterProjectShadowEmbedding,
-  getProjectEmbeddingSnapshot,
-  embedTextForProject,
-  embedBatchForProject,
-  embedUnembeddedMemoriesForProject,
-  embedUnembeddedMemoriesForProjectOutcome,
-  drainCommitBacklogForProject,
-  embedSessionCompartmentChunks,
-  getEmbeddingCoverageStatus,
-  computeCueContentHash,
-  hasMuralCueColumns,
-  getMuralCueState,
-  memoryNeedsCue,
-  setMuralCue,
-  recordMuralCueRejection,
-  hasMemoryShareableColumn,
-  hasMemoryClassifiedAtColumn,
-  getUnclassifiedMemoryIds,
-  insertMemory,
-  insertMemoryIdempotent,
-  getMemoryByHash,
-  getMemoriesByProject,
-  getMemoriesForList,
-  getMaxMemoryIdForProjects,
-  getMemoryById,
-  getMemoriesByIds,
-  updateMemorySeenCount,
-  setMemoryClassification,
-  supersededMemory,
-  mergeMemoryStats,
-  archiveMemory,
-  getMemoryCountsByStatus,
-  recordMemoryMapping,
-  recordMemoryVerifications,
-  getUnmappedMemoryIds,
-  clearMemoryVerifications,
-  getMemoryVerifications,
-  resolveGitTopLevel,
-  readGitHead,
-  readGitChangedFilesSince,
-  readGitFileChangeTimesSince,
-  verificationFileExists,
-  normalizeVerificationFiles,
+  createChildSessionWithFence,
+  HiddenCompletionRefusal,
+  DreamerProviderOutputFailureError,
+  withDreamerModelCooldown,
+  providerOutputFailureFromInvalidManifest,
+  extractLatestAssistantText,
+  hasLengthCappedOutput,
+  parseProviderModel,
+  modelBodyField,
+  toModelEntry,
+  isPromptTimeoutError,
+  getPromptFailureDetail,
+  promptSyncWithValidatedOutputRetry,
+  normalizeSDKResponse,
+  failedInvocationStatus,
+  recordChildInvocation,
+  createPromptAsyncTransport,
+  promptSurfaceHashMaterial,
+  createPromptSurfaceRuntime,
+  createPromptSurfaceGuidanceEpochCache,
+  teardownChildSession,
+  getCompartmentEvents,
   runTokenLog,
   formatRunTokenLog,
   resolveHiddenCompletionExecutor,
@@ -407,6 +540,8 @@ import {
   clearNoteNudgeTriggerAndCooldown,
   resetNoteNudgeCooldownOnly,
   RECOVERY_NO_HEAD_LIMIT,
+  deriveProtectedTailTokenTarget,
+  selectPerRunCap,
   resolveOpenCodeProtectedTailBoundary,
   getRawHistoryEligibility,
   hasRunnableCompartmentWindow,
@@ -414,126 +549,7 @@ import {
   snapRangeToCompartments,
   getActiveCompartmentRun,
   startCompartmentAgent
-} from "./index-p821bjdb.js";
-import {
-  hasTrustedAbsoluteWall,
-  applyProvenInputFloor,
-  formatWindowDerivationLine,
-  isSaneLimit,
-  getSdkWindowGeometry,
-  getSdkContextLimit,
-  getSdkOutputLimit,
-  deriveTriggerBudget2,
-  resolveKnownHistorianContextLimit2,
-  resolveHistorianProducerLimits2
-} from "./index-0d3g3461.js";
-import {
-  resolveModelCalibration,
-  calibrateBuckets,
-  resolveDecisionCalibration
-} from "./index-1zx87sdm.js";
-import {
-  hasMeaningfulUserText2,
-  extractTexts2,
-  extractToolCallSummaries,
-  getTokenizerNativeMemoryStats,
-  estimateTokens,
-  estimateFixedPromptTokens,
-  normalizeText
-} from "./index-5eqk6z3s.js";
-import {
-  protectedToolTagNumbers,
-  protectedToolTokenCount,
-  peelLeadingMcTagNotation,
-  isRecord,
-  contentTagOwnerMessageId,
-  normalizeTodoStateJson,
-  computeSyntheticCallId,
-  CHANNEL1_SENTINEL,
-  toolOutputTokens,
-  decideChannel1,
-  evaluateChannel2,
-  formatChannel1Evaluation,
-  formatChannel2Evaluation,
-  reclaimableToolOutputCount,
-  buildChannel2Reminder,
-  buildChannel1Reminder,
-  queuePendingOp,
-  getPendingOps,
-  hasPendingDropOps,
-  clearPendingOps,
-  removePendingOp,
-  getTriggerTagTokenUpperBound,
-  getActiveTagTokenTotalsByMessage,
-  updateTagStatus,
-  getInertWhitespaceAssistantTags,
-  deriveTagLoadFloor,
-  getTagsBySession,
-  getActiveTagsBySession,
-  getDroppedTagsBySession,
-  getTagsByNumbers,
-  getDroppedTagsByNumbers,
-  getMaxDroppedTagNumber,
-  getTagById,
-  expandToolPart,
-  isRawCompactionSummaryInfo,
-  extractInMemoryMessageViews,
-  buildInMemoryTailRawMessages,
-  estimateTrueRawMessageTokens,
-  toolPartHasUserAnswer,
-  DreamTokenBudgetExceeded,
-  isEditTool,
-  describeFinalWireTail,
-  estimateMessageTokens,
-  wireContentBytes,
-  createFinalWireUsageTracker,
-  estimateFinalWireInputTokens,
-  estimateAppendedWireTokens,
-  isPrefixBoundThinkingModel,
-  detectOverflow,
-  modelAcceptsEmptyContent,
-  isAnthropicFamilyRoute,
-  variantChangeBustsProviderCache,
-  setRawMessageProvider2,
-  cleanUserText2,
-  withRawSessionMessageCache2,
-  readRawSessionMessages2,
-  visitRawSessionMessages2,
-  primeTailRawMessageCache2,
-  primeInMemoryTailRawMessageCache2,
-  readRawSessionMessageOrdinalPage2,
-  getRawSessionStoredMessageCount2,
-  readRawSessionMessageIdOrdinalsForRange2,
-  readRawSessionMessagePartsById2,
-  readRawSessionMessageById2,
-  readSessionChunk2,
-  readRawSessionSeedTail2
-} from "./index-3h0ybwah.js";
-import {
-  observeTemporalDecisions,
-  getMeasuredToolDefinitionTokens
-} from "./index-5gq3b2ya.js";
-import {
-  openCodeDbExists,
-  withReadOnlySessionDb,
-  assistantAwaitingTools,
-  latestPersistedMessageForRecovery,
-  findLastAssistantModelFromOpenCodeDb
-} from "./index-majxda46.js";
-import {
-  CANONICAL_DREAM_TASKS,
-  DREAM_TASK_CAPABILITIES,
-  toolLoopDreamTasks,
-  formatDreamTaskBacklogs,
-  formatDreamTaskFailures,
-  processedDreamTaskItems,
-  leaseKindFor,
-  leaseKeyFor,
-  isCanonicalDreamTask,
-  compareTaskOrder,
-  buildDreamTaskRuntimeConfigs2,
-  userMemoryCollectionEnabled2
-} from "./index-mc22ayvf.js";
+} from "./index-6d9e1m08.js";
 import {
   registerNotificationSink2,
   pushNotification2,
@@ -541,12 +557,6 @@ import {
   drainNotifications2,
   isTuiConnected2
 } from "./index-x8a7jmkh.js";
-import {
-  flushIgnoredMessages2,
-  clearIgnoredMessages2,
-  observeIgnoredNotificationEvent2,
-  sendStatusNotification2
-} from "./index-7qw742ev.js";
 import {
   indexCommitsForProject,
   embedUnembeddedCommits,
@@ -554,7 +564,9 @@ import {
   parseIdShapedQuery,
   resolveMemoriesByIdsForSearch,
   unifiedSearch,
-  formatSearchResults,
+  formatSearchResults
+} from "./index-92bp57hg.js";
+import {
   findSessionId,
   findLastUserMessageId,
   clearAutoSearchForSession,
@@ -571,18 +583,26 @@ import {
   canConsumeDeferredOnThisPass,
   hasReclaimRide,
   reclaimRideLabel,
-  replayCavemanCompression,
-  DegradedPassRefusalError,
-  degradedPassError,
+  replayClearedReasoning,
+  replayStrippedInlineThinking,
+  stripClearedReasoning,
+  snapshotTrailingBlankSourceDecisions,
+  projectOpencodeReasoningBudgetCutoff,
+  resolveKeepReasoningTokens,
+  reasoningBudgetCutoff,
+  captureOpencodeReasoningBudgetStatus,
+  reasoningBudgetStatusLine,
   ENGINE_RECONNECTING_USER_MESSAGE,
   contextRefusalError,
   protectedToolRefusal,
   outgoingContextRefusal,
   EmergencyFailClosedError,
-  replayClearedReasoning,
-  replayStrippedInlineThinking,
-  stripClearedReasoning,
-  snapshotTrailingBlankSourceDecisions,
+  latestAssistantTurnStart,
+  latestAssistantTurnMessages,
+  hasActiveAnthropicThinkingTurn,
+  replayCavemanCompression,
+  DegradedPassRefusalError,
+  degradedPassError,
   applyFlushedStatuses,
   stripStructuralNoise,
   logTransformTiming,
@@ -596,11 +616,17 @@ import {
   abortSessionFailClosed2,
   evaluateEmergencyFailClosed2,
   runPostTransformPhase2
-} from "./index-k4404na5.js";
+} from "./index-cwf6s3ay.js";
+import {
+  flushIgnoredMessages2,
+  clearIgnoredMessages2,
+  observeIgnoredNotificationEvent2,
+  sendStatusNotification2
+} from "./index-adwfkpex.js";
 import {
   setRecompStarting2,
   setRecompTerminal2
-} from "./index-j7fvnjye.js";
+} from "./index-gg8j07zz.js";
 import {
   ANNOUNCEMENT_VERSION2,
   ANNOUNCEMENT_FEATURES2,
@@ -5927,7 +5953,7 @@ function getAsyncModule() {
       await beforeModuleLoad();
     const [{ default: singlefileAsyncifyVariant }, { newQuickJSAsyncWASMModuleFromVariant }] = await importPluginModule(() => Promise.all([
       import("./index-e7vx3byk.js").then((m)=>__toESM(m.default,1)),
-      import("./index-en1k8h8m.js")
+      import("./index-5prbx026.js")
     ]));
     const module = await newQuickJSAsyncWASMModuleFromVariant(singlefileAsyncifyVariant);
     return module;
@@ -8875,9 +8901,11 @@ function countCompartmentsSince(db, projectPath, since) {
 }
 function countProjectSessionsSince(db, projectPath, since) {
   const row = since === null ? db.prepare("SELECT COUNT(*) AS cnt FROM session_projects WHERE project_path = ?").get(projectPath) : db.prepare(`SELECT COUNT(*) AS cnt FROM session_projects sp
-                        JOIN schema_migrations_meta activity
+                        LEFT JOIN schema_migrations_meta activity
                           ON activity.key = 'retrospective_activity:' || sp.session_id
-                       WHERE sp.project_path = ? AND CAST(activity.value AS INTEGER) > ?`).get(projectPath, since);
+                        LEFT JOIN message_history_index history ON history.session_id = sp.session_id
+                       WHERE sp.project_path = ?
+                         AND COALESCE(CAST(activity.value AS INTEGER), history.updated_at) > ?`).get(projectPath, since);
   return row?.cnt ?? 0;
 }
 function countMappedMemories(db, projectPath) {
@@ -8952,10 +8980,11 @@ function hasActiveMemories(db, projectPath) {
   return db.prepare("SELECT 1 AS one FROM memories WHERE project_path = ? AND status IN ('active','permanent') LIMIT 1").get(projectPath) != null;
 }
 var RECENT_PROJECT_SESSIONS_SQL = `SELECT sp.session_id FROM session_projects sp
-       LEFT JOIN schema_migrations_meta activity
-         ON activity.key = 'retrospective_activity:' || sp.session_id
+        LEFT JOIN schema_migrations_meta activity
+          ON activity.key = 'retrospective_activity:' || sp.session_id
+        LEFT JOIN message_history_index history ON history.session_id = sp.session_id
       WHERE sp.project_path = ?
-        AND (sp.updated_at > ? OR CAST(activity.value AS INTEGER) > ?)`;
+        AND (sp.updated_at > ? OR COALESCE(CAST(activity.value AS INTEGER), history.updated_at) > ?)`;
 function hasRecentProjectSession(db, projectPath, since) {
   return db.prepare(`${RECENT_PROJECT_SESSIONS_SQL} LIMIT 1`).get(projectPath, since, since) != null;
 }
@@ -12289,7 +12318,9 @@ function scheduleInitialProjectRun(reg, db) {
   startupTimers.set(reg.directory, timer);
 }
 async function runProjectMaintenance(reg, origin, db) {
-  const projectMaintenanceEnabled = Boolean(reg.dreamerConfig && reg.dreamerConfig.disable !== true) || reg.memoryEnabled === true || reg.gitCommitIndexing?.enabled === true || reg.historianChildSweep !== undefined;
+  const sampled = reg.sampleDreamRun?.();
+  const current = sampled ? { ...reg, ...sampled } : reg;
+  const projectMaintenanceEnabled = Boolean(current.dreamerConfig && current.dreamerConfig.disable !== true) || reg.memoryEnabled === true || reg.gitCommitIndexing?.enabled === true || reg.historianChildSweep !== undefined;
   if (!projectMaintenanceEnabled)
     return;
   await reg.ensureRegistered(reg.directory, db);
@@ -12300,8 +12331,7 @@ async function runProjectMaintenance(reg, origin, db) {
       log(`[magic-context] proactively embedded ${embeddedCount} ${embeddedCount === 1 ? "memory" : "memories"} for project ${reg.projectIdentity}`);
     }
   }
-  const sampled = reg.sampleDreamRun?.();
-  await sweepProject(sampled ? { ...reg, ...sampled } : reg, origin, db);
+  await sweepProject(current, origin, db);
 }
 async function sweepProject(reg, origin, db, gitCommitEnabled) {
   if (!directoryStillExists(reg.directory)) {
@@ -12847,12 +12877,68 @@ function resolveModelCacheTtl(config, modelKey, configuredExplicitly = typeof co
   };
 }
 
+// src/hooks/magic-context/opencode-proven-floor.ts
+var KEY = "opencodeProvenInputFloor";
+function recordOpenCodeProvenInputFloor(db, sessionId, modelKey, tokens) {
+  db.prepare(`UPDATE session_meta SET deferred_execute_state = json_set(
+        CASE WHEN json_valid(deferred_execute_state) AND json_type(deferred_execute_state) = 'object'
+             THEN deferred_execute_state ELSE '{}' END, '$.${KEY}', json(?)) WHERE session_id = ?`).run(JSON.stringify({ modelKey, tokens, basis: "provider_usage_v1" }), sessionId);
+}
+function largestAcceptedInput(sessionId, modelKey) {
+  return withReadOnlySessionDb((db) => {
+    const rows = db.prepare(`SELECT
+            COALESCE(json_extract(data, '$.providerID'), json_extract(data, '$.model.providerID')) AS provider,
+            COALESCE(json_extract(data, '$.modelID'), json_extract(data, '$.model.id')) AS model,
+            json_extract(data, '$.finish') AS finish, json_extract(data, '$.error') AS error,
+            json_extract(data, '$.tokens.input') AS input,
+            json_extract(data, '$.tokens.cache.read') AS cacheRead,
+            json_extract(data, '$.tokens.cache.write') AS cacheWrite
+            FROM message WHERE session_id = ? AND json_valid(data)
+            AND json_extract(data, '$.role') = 'assistant'`).all(sessionId);
+    let largest = 0;
+    for (const row of rows) {
+      if (!row.provider || !row.model || piModelRefToCanonical(`${row.provider}/${row.model}`) !== piModelRefToCanonical(modelKey) || providerResponseFailed(row))
+        continue;
+      const components = [row.input ?? 0, row.cacheRead ?? 0, row.cacheWrite ?? 0];
+      if (components.every((n) => typeof n === "number" && Number.isFinite(n) && n >= 0)) {
+        largest = Math.max(largest, components.reduce((sum, n) => sum + n, 0));
+      }
+    }
+    return largest;
+  });
+}
+function resolveOpenCodeProvenInputFloor(db, sessionId, modelKey) {
+  const row = db.prepare("SELECT observed_safe_input_tokens, last_observed_model_key, deferred_execute_state FROM session_meta WHERE session_id = ?").get(sessionId);
+  const stored = row?.observed_safe_input_tokens ?? 0;
+  if (!modelKey || piModelRefToCanonical(row?.last_observed_model_key ?? "") !== piModelRefToCanonical(modelKey) || !Number.isFinite(stored) || stored <= 0)
+    return 0;
+  try {
+    const record = JSON.parse(row?.deferred_execute_state ?? "{}")[KEY];
+    if (record?.basis === "provider_usage_v1" && record.modelKey === modelKey && record.tokens === stored)
+      return stored;
+  } catch {}
+  let measured = 0;
+  try {
+    measured = largestAcceptedInput(sessionId, modelKey);
+  } catch {}
+  const repaired = Math.min(stored, measured);
+  updateSessionMeta(db, sessionId, {
+    observedSafeInputTokens: repaired,
+    cacheAlertSent: false,
+    lastUsageContextLimit: 0
+  });
+  recordOpenCodeProvenInputFloor(db, sessionId, modelKey, repaired);
+  sessionLog(sessionId, `legacy proven input floor ${stored} clamped to accepted provider usage: ${repaired}`);
+  return repaired;
+}
+
 // src/hooks/magic-context/event-resolvers.ts
 var DEFAULT_CONTEXT_LIMIT = 200000;
 function modelMatchedPersistedUsage(db, sessionID, modelKey) {
   if (!db || !sessionID || !modelKey)
     return;
   try {
+    resolveOpenCodeProvenInputFloor(db, sessionID, modelKey);
     const persisted = loadPersistedUsage(db, sessionID);
     if (persisted !== null && piModelRefToCanonical(persisted.lastObservedModelKey ?? "") === piModelRefToCanonical(modelKey)) {
       return persisted;
@@ -13964,6 +14050,29 @@ function formatThresholdClampNote(opts) {
 // src/shared/rust-mode-status.ts
 var RUST_MODE_HOST_PATHS_LINE = "Host backends → MODULE: ctx_memory, ctx_note; historian: module-side";
 
+// src/hooks/magic-context/historian-drain-gate.ts
+var loggedWindows = new WeakMap;
+function isHistorianDrainBudgetSpent(args) {
+  const target = deriveProtectedTailTokenTarget(args);
+  const state = getProtectedTailDrainBudgetSkip({
+    ...args,
+    usable: target.usable,
+    perRunCap: selectPerRunCap({ ...args, N: target.N })
+  });
+  if (!state)
+    return false;
+  let windows = loggedWindows.get(args.db);
+  if (!windows) {
+    windows = new Map;
+    loggedWindows.set(args.db, windows);
+  }
+  if (windows.get(args.sessionId) !== state.resetsAt) {
+    windows.set(args.sessionId, state.resetsAt);
+    sessionLog(args.sessionId, `historian skip: internal drain budget spent (${state.spentTokens}/${state.limitTokens} tokens); next eligible at ${new Date(state.nextEligibleAt).toISOString()}`);
+  }
+  return true;
+}
+
 // src/hooks/magic-context/compartment-trigger.ts
 var PROACTIVE_TRIGGER_OFFSET_PERCENTAGE = 2;
 var POST_DROP_TARGET_RATIO = 0.75;
@@ -14024,7 +14133,7 @@ function buildTriggerInMemoryTail(db, sessionId, messages) {
 function getProactiveCompartmentTriggerPercentage(executeThresholdPercentage) {
   return Math.max(0, executeThresholdPercentage - PROACTIVE_TRIGGER_OFFSET_PERCENTAGE);
 }
-function estimateProjectedPostDropPercentage(db, sessionId, usage, activeTags, clearReasoningAge, clearedReasoningThroughTag, canClearReasoning) {
+function estimateProjectedPostDropPercentage(db, sessionId, usage, activeTags, keepReasoningTokens, clearedReasoningThroughTag, canClearReasoning, liveBudgetCutoff) {
   const totalActiveBytes = activeTags.reduce((sum, tag) => sum + tag.byteSize + tag.reasoningByteSize, 0);
   if (totalActiveBytes === 0)
     return null;
@@ -14034,9 +14143,25 @@ function estimateProjectedPostDropPercentage(db, sessionId, usage, activeTags, c
   if (pendingDrops.length > 0) {
     droppableBytes += activeTags.filter((tag) => pendingDropTagIds.has(tag.tagNumber)).reduce((sum, tag) => sum + tag.byteSize + tag.reasoningByteSize, 0);
   }
-  const maxTag = activeTags.reduce((max, t) => Math.max(max, t.tagNumber), 0);
-  if (canClearReasoning && clearReasoningAge !== undefined && clearedReasoningThroughTag !== undefined) {
-    const reasoningAgeCutoff = maxTag - clearReasoningAge;
+  if (canClearReasoning && keepReasoningTokens !== undefined && clearedReasoningThroughTag !== undefined) {
+    const estimates = getReasoningTokenEstimatesByMessage(db, sessionId, sessionDecisionCalibration(db, sessionId).proseRatio);
+    const groups = new Map;
+    for (const tag of activeTags) {
+      const id = tag.type === "tool" ? tag.toolOwnerMessageId : tag.messageId;
+      if (!id)
+        continue;
+      const group = groups.get(id) ?? { tag: 0, cost: estimates.get(id) ?? 0 };
+      if (!estimates.has(id))
+        group.cost += tag.reasoningByteSize / 4;
+      group.tag = Math.max(group.tag, tag.tagNumber);
+      groups.set(id, group);
+    }
+    const steps = [...groups.values()].sort((a, b) => a.tag - b.tag);
+    const reasoningAgeCutoff = liveBudgetCutoff ?? reasoningBudgetCutoff(steps.map((step, index) => ({
+      ...step,
+      exempt: index === steps.length - 1,
+      alreadyRemoved: step.tag <= clearedReasoningThroughTag
+    })), keepReasoningTokens);
     for (const tag of activeTags) {
       if (tag.type !== "message")
         continue;
@@ -14106,7 +14231,7 @@ function getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThr
         usageSource: "live",
         taggerFloor
       });
-      const hasProtectedEligibleHead = boundary.offset < boundary.protectedTailStart;
+      const hasProtectedEligibleHead = boundary.offset < Math.min(boundary.protectedTailStart, boundary.eligibleEndOrdinal);
       if (!hasProtectedEligibleHead) {
         return {
           ...TAIL_INFO_DEFAULTS,
@@ -14118,7 +14243,7 @@ function getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThr
       const seed = sessionDecisionCalibration(db, sessionId);
       const sourceRatio = Math.max(seed.proseRatio, seed.toolsRatio);
       const scanBudget = Math.floor(Math.max(MIN_PROACTIVE_TAIL_TOKEN_ESTIMATE, triggerBudget * TAIL_SIZE_TRIGGER_MULTIPLIER) / sourceRatio);
-      const chunk = readSessionChunk2(sessionId, scanBudget, rawEligibility.offset, boundary.protectedTailStart);
+      const chunk = readSessionChunk2(sessionId, scanBudget, rawEligibility.offset, boundary.eligibleEndOrdinal);
       const isMeaningful = chunk.hasMore || boundary.trueRawEligibleTokens >= MIN_PROACTIVE_TAIL_TOKEN_ESTIMATE || Math.ceil(chunk.tokenEstimate * sourceRatio) >= MIN_PROACTIVE_TAIL_TOKEN_ESTIMATE || chunk.messageCount >= MIN_PROACTIVE_TAIL_MESSAGE_COUNT;
       return {
         nextStartOrdinal: rawEligibility.offset,
@@ -14140,11 +14265,19 @@ function getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThr
 function formatProjectedPostDropPercentage(value) {
   return value === null ? "none" : `${value.toFixed(1)}%`;
 }
-function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPercentage, executeThresholdPercentage, triggerBudget, clearReasoningAge, commitClusterTrigger, preloadedActiveTags, contextLimit, inMemoryTail, taggerFloorOverride, reasoningProjection, reclaimRide) {
+function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPercentage, executeThresholdPercentage, triggerBudget, keepReasoningTokens, commitClusterTrigger, preloadedActiveTags, contextLimit, inMemoryTail, taggerFloorOverride, reasoningProjection, reclaimRide) {
   if (sessionMeta.compartmentInProgress) {
     sessionLog(sessionId, `compartment trigger: skipped — historian already in progress (usage=${usage.percentage.toFixed(1)}%)`);
     return { shouldFire: false };
   }
+  if (isHistorianDrainBudgetSpent({
+    db,
+    sessionId,
+    usagePercentage: usage.percentage,
+    contextLimit: resolveBoundaryContextLimit(usage, contextLimit),
+    executeThresholdPercentage
+  }))
+    return { shouldFire: false };
   const lazyInMemoryTail = typeof inMemoryTail === "function" ? inMemoryTail : undefined;
   let resolvedInMemoryTail = typeof inMemoryTail === "function" ? undefined : inMemoryTail;
   if (resolvedInMemoryTail) {
@@ -14196,7 +14329,7 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
     return { shouldFire: false };
   }
   const canClearReasoning = reasoningProjection?.canClearReasoning ?? modelAcceptsEmptyContent(reasoningProjection?.providerID);
-  const projectedPostDropPercentage = estimateProjectedPostDropPercentage(db, sessionId, usage, preloadedActiveTags ?? getActiveTagsBySession(db, sessionId), clearReasoningAge, sessionMeta.clearedReasoningThroughTag, canClearReasoning);
+  const projectedPostDropPercentage = estimateProjectedPostDropPercentage(db, sessionId, usage, preloadedActiveTags ?? getActiveTagsBySession(db, sessionId), keepReasoningTokens, sessionMeta.clearedReasoningThroughTag, canClearReasoning, reasoningProjection?.budgetCutoff);
   const relativePostDropTarget = executeThresholdPercentage * POST_DROP_TARGET_RATIO;
   const rideLabel = reclaimRide ? reclaimRideLabel(reclaimRide) : "ride=none";
   const dropsCanLand = reclaimRide !== undefined && hasReclaimRide(reclaimRide);
@@ -14348,7 +14481,9 @@ function executeStatus(db, sessionId, executeThresholdPercentageConfig = DEFAULT
     const displayPercentage = contextUsage?.percentage ?? meta.lastContextPercentage;
     const displayContextLimit = contextLimit && contextLimit > 0 ? contextLimit : displayPercentage > 0 ? Math.round(displayInputTokens / (displayPercentage / 100)) : 0;
     const parseFailureLines = (display?.configParseFailures ?? []).map(formatConfigParseStatusLine);
+    const reasoningLine = reasoningBudgetStatusLine(sessionId);
     const lines = [
+      ...reasoningLine ? [reasoningLine, ""] : [],
       ...openCodeDbStatusLine ? [openCodeDbStatusLine, ""] : [],
       ...parseFailureLines,
       ...parseFailureLines.length > 0 ? [""] : [],
@@ -16661,7 +16796,7 @@ function registerRpcHandlers(rpcServer, args) {
     return { count: buildCompartmentCount(db, sessionId, moduleStatus) };
   });
   const buildManagedCtx = async (db) => {
-    const { deriveHistorianChunkTokens, resolveHistorianContextLimit } = await importPluginModule(() => import("./derive-budgets-7nj7r1rv.js"));
+    const { deriveHistorianChunkTokens, resolveHistorianContextLimit } = await importPluginModule(() => import("./derive-budgets-ke12jnnh.js"));
     const { resolveHistorianModel } = await importPluginModule(() => import("./model-resolution-xhfmyyvy.js"));
     const { userMemoryCollectionEnabled } = await importPluginModule(() => import("./task-config-v81k8jvk.js"));
     const DEFAULT_HISTORIAN_TIMEOUT_MS = 10 * 60 * 1000;
@@ -16697,8 +16832,8 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp } = await importPluginModule(() => import("./recomp-orchestrator-ejq7ex5d.js"));
-    const { sendIgnoredMessage } = await importPluginModule(() => import("./send-session-notification-dyw42dtr.js"));
+    const { runManagedRecomp } = await importPluginModule(() => import("./recomp-orchestrator-rervg6q4.js"));
+    const { sendIgnoredMessage } = await importPluginModule(() => import("./send-session-notification-0m68ms3n.js"));
     log(`[rpc] recomp requested for session ${sessionId}`);
     if (!args.client && !args.hiddenCompletionExecutor) {
       return {
@@ -16767,7 +16902,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedWrapup } = await importPluginModule(() => import("./wrapup-orchestrator-kw3x3myw.js"));
+    const { runManagedWrapup } = await importPluginModule(() => import("./wrapup-orchestrator-b2dztrar.js"));
     const model = liveSessionState.liveModelBySession.get(sessionId);
     const contextLimit = model ? resolveContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : 128000;
     const ctx = {
@@ -16827,18 +16962,225 @@ function registerRpcHandlers(rpcServer, args) {
       return { show: false };
     }
     return {
-      show: true,
-      version: ANNOUNCEMENT_VERSION2,
-      features: [...ANNOUNCEMENT_FEATURES2],
-      footer: ANNOUNCEMENT_FOOTER2
+      show: true,
+      version: ANNOUNCEMENT_VERSION2,
+      features: [...ANNOUNCEMENT_FEATURES2],
+      footer: ANNOUNCEMENT_FOOTER2
+    };
+  });
+  rpcServer.handle("mark-announced", async () => {
+    if (ANNOUNCEMENT_VERSION2) {
+      markAnnouncementSeen2(ANNOUNCEMENT_VERSION2);
+    }
+    return { ok: true };
+  });
+}
+
+// src/hooks/magic-context/latest-thinking-recovery.ts
+var LATEST_THINKING_RESTORE = "latest_thinking_original";
+var knownRejectedSessions = new Set;
+var lastPassTurnAnchor = new Map;
+var ACTIVE = `${LATEST_THINKING_RESTORE}:`;
+var ARMED = `${LATEST_THINKING_RESTORE}_armed:`;
+var UNRECOVERABLE = `${LATEST_THINKING_RESTORE}_unavailable`;
+var LATEST_THINKING_UNSAFE = "ANTHROPIC_LATEST_TURN_EDIT_UNSAFE: The provider rejected edits to this thinking turn and its original context cannot be safely replayed. Send a new user message or /clear to continue.";
+function armLatestThinkingRecovery(db, sessionId) {
+  knownRejectedSessions.add(sessionId);
+  ensureSessionMetaRow(db, sessionId);
+  const current = getThinkingBindingRecoveryTarget(db, sessionId);
+  const anchor = lastPassTurnAnchor.get(sessionId);
+  const next = current?.startsWith(ACTIVE) ? UNRECOVERABLE + ":" + current.slice(ACTIVE.length) : current?.startsWith(UNRECOVERABLE) || current?.startsWith(ARMED) ? current : anchor !== undefined ? ARMED + anchor : LATEST_THINKING_RESTORE;
+  db.prepare("UPDATE session_meta SET thinking_binding_recovery_target = ? WHERE session_id = ?").run(next, sessionId);
+}
+function clone(value) {
+  if (Array.isArray(value))
+    return value.map(clone);
+  if (!isRecord(value))
+    return value;
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null)
+    return value;
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, clone(item)]));
+}
+function isThinkingPart(part) {
+  return isRecord(part) && ["thinking", "reasoning", "redacted_thinking"].includes(String(part.type));
+}
+function replayableOriginal(part) {
+  if (!isThinkingPart(part) || !isRecord(part))
+    return false;
+  const metadata = isRecord(part.metadata) && isRecord(part.metadata.anthropic) ? part.metadata.anthropic : {};
+  const signature = part.signature ?? part.thinkingSignature ?? metadata.signature ?? part.data ?? metadata.redactedData;
+  return typeof signature === "string" && signature.length > 0 && part.text !== "[cleared]" && part.thinking !== "[cleared]";
+}
+function prepareLatestThinkingRecovery(args) {
+  const start = latestAssistantTurnStart(args.messages);
+  const anchor = start > 0 ? args.id(args.messages[start - 1], start - 1) : undefined;
+  if (anchor === undefined)
+    lastPassTurnAnchor.delete(args.sessionId);
+  else
+    lastPassTurnAnchor.set(args.sessionId, anchor);
+  let target;
+  try {
+    target = getThinkingBindingRecoveryTarget(args.db, args.sessionId);
+  } catch (error) {
+    if (knownRejectedSessions.has(args.sessionId))
+      throw contextRefusalError(LATEST_THINKING_UNSAFE);
+    return { restore: false, ended: false };
+  }
+  if (!target || !target.startsWith(LATEST_THINKING_RESTORE)) {
+    knownRejectedSessions.delete(args.sessionId);
+    return { restore: false, ended: false };
+  }
+  const armedAnchor = target.startsWith(ARMED) ? target.slice(ARMED.length) : undefined;
+  if (target === LATEST_THINKING_RESTORE || armedAnchor !== undefined && armedAnchor !== anchor) {
+    args.db.prepare("UPDATE session_meta SET thinking_binding_recovery_target = '' WHERE session_id = ? AND thinking_binding_recovery_target = ?").run(args.sessionId, target);
+    knownRejectedSessions.delete(args.sessionId);
+    return { restore: false, ended: false };
+  }
+  knownRejectedSessions.add(args.sessionId);
+  const savedAnchor = target.startsWith(ACTIVE) ? target.slice(ACTIVE.length) : target.startsWith(UNRECOVERABLE + ":") ? target.slice(UNRECOVERABLE.length + 1) : undefined;
+  if (savedAnchor !== undefined && savedAnchor !== anchor) {
+    args.db.prepare("UPDATE session_meta SET thinking_binding_recovery_target = '' WHERE session_id = ? AND thinking_binding_recovery_target = ?").run(args.sessionId, target);
+    knownRejectedSessions.delete(args.sessionId);
+    return { restore: false, ended: true };
+  }
+  if (target.startsWith(UNRECOVERABLE) || !anchor)
+    throw contextRefusalError(LATEST_THINKING_UNSAFE);
+  if (armedAnchor !== undefined) {
+    args.db.prepare("UPDATE session_meta SET thinking_binding_recovery_target = ? WHERE session_id = ? AND thinking_binding_recovery_target = ?").run(ACTIVE + anchor, args.sessionId, target);
+  }
+  const active = args.messages.slice(start);
+  if (!active.some((message) => args.parts(message).some(replayableOriginal)))
+    throw contextRefusalError(LATEST_THINKING_UNSAFE + " [missing-thinking-original]");
+  const ids = new Map(args.messages.map((message, index) => [args.id(message, index), index]));
+  for (const decision of getMergedReasoningStrippedIds(args.db, args.sessionId)) {
+    if (decision === "binding_mismatch_order:end" || decision === TOOL_SWEEP_SCOPED_MARKER)
+      continue;
+    const id = decodeMergedReasoningParts(decision)?.[0] ?? (decision.startsWith("binding_mismatch:") ? decision.slice("binding_mismatch:".length) : decision);
+    const index = ids.get(id);
+    if (index === undefined || index >= start && !args.parts(args.messages[index]).some(replayableOriginal))
+      throw contextRefusalError(LATEST_THINKING_UNSAFE + ` [missing-original:${id}]`);
+  }
+  return { restore: true, ended: false };
+}
+function captureOriginalTurn(messages, parts, setParts) {
+  const start = Math.max(0, latestAssistantTurnStart(messages) - 1);
+  const originals = messages.slice(start).map((message) => ({ message, parts: clone(parts(message)) }));
+  const before = messages.slice(0, start);
+  return (target = messages) => {
+    const first = target.findIndex((message) => originals.some((original) => original.message === message || isRecord(message) && isRecord(original.message) && (isRecord(message.info) && isRecord(original.message.info) && message.info.id === original.message.info.id || message.role === original.message.role && message.timestamp !== undefined && message.timestamp === original.message.timestamp)));
+    const prefix = first >= 0 ? target.slice(0, first) : target === messages ? before : target.slice();
+    for (const original of originals) {
+      setParts(original.message, clone(original.parts));
+    }
+    target.length = 0;
+    target.push(...prefix, ...originals.map((original) => original.message));
+  };
+}
+function captureLatestTurnOriginals(messages) {
+  return captureOriginalTurn(messages, (message) => message.parts, (message, parts) => {
+    message.parts = parts;
+  });
+}
+function armBindingRecoverySafely(db, sessionId) {
+  if (getThinkingBindingRecoveryTarget(db, sessionId)?.startsWith(LATEST_THINKING_RESTORE))
+    armLatestThinkingRecovery(db, sessionId);
+  else
+    armThinkingBindingRecovery(db, sessionId);
+}
+function armLatestThinkingRecoveryFromError(args) {
+  if (!detectLatestTurnThinkingMismatch(args.error))
+    return false;
+  if (!isAnthropicFamilyRoute(args.providerID, args.modelID))
+    return true;
+  armLatestThinkingRecovery(args.db, args.sessionId);
+  dropSlot(args.sessionId, "latest-thinking-recovery-arm");
+  return true;
+}
+
+// src/hooks/magic-context/lkg-replay-fit.ts
+var RAW_FALLBACK_BYTES_PER_CONTEXT_TOKEN = 4;
+function lkgReplayLimit(args) {
+  const { db, sessionId, model } = args;
+  const trusted = model ? resolveTrustedContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : undefined;
+  if (trusted !== undefined && trusted > 0)
+    return trusted;
+  const detected = getOverflowState(db, sessionId, args.modelKey).detectedContextLimit;
+  return detected > 0 ? detected : undefined;
+}
+function measureLkgReplay(args) {
+  const baseline = args.measuredInputTokens ?? 0;
+  const tailLimit = Math.max(0, args.limit - baseline);
+  const proxy = wireContentBytes(args.messages, tailLimit * RAW_FALLBACK_BYTES_PER_CONTEXT_TOKEN, RAW_FALLBACK_BYTES_PER_CONTEXT_TOKEN);
+  const skipped = { proxy, estimatorRan: false, trusted: false };
+  if (proxy === null)
+    return { fit: "unproven", tokens: null, ...skipped };
+  const proxyTokens = baseline + Math.ceil(proxy.bytes / RAW_FALLBACK_BYTES_PER_CONTEXT_TOKEN);
+  if (proxy.aborted || proxyTokens > args.limit) {
+    return { fit: "over", tokens: null, proxyTokens, ...skipped };
+  }
+  let estimate;
+  try {
+    estimate = args.estimate();
+  } catch {
+    return { fit: "unproven", tokens: null, ...skipped };
+  }
+  const seen = { proxy, estimatorRan: true, trusted: estimate.trusted };
+  const tokens = baseline + estimate.tokens;
+  if (!estimate.trusted || !Number.isFinite(tokens) || tokens <= 0 || estimate.tokens < 0) {
+    return {
+      fit: "unproven",
+      tokens: Number.isFinite(estimate.tokens) ? estimate.tokens : null,
+      ...seen
     };
+  }
+  return tokens > args.limit ? { fit: "over", tokens, proxyTokens, ...seen } : { fit: "under", tokens, ...seen };
+}
+function measureLkgReplayRequest(args) {
+  let measured;
+  try {
+    measured = args.model ? measuredLkgPrefix({
+      ...args,
+      slot: getSlot(args.sessionId),
+      modelKey: `${args.model.providerID}/${args.model.modelID}`
+    }) : undefined;
+  } catch {
+    measured = undefined;
+  }
+  const estimator = args.estimator ?? estimateFinalWireInputTokens;
+  return measureLkgReplay({
+    messages: measured?.appendedMessages ?? args.messages,
+    limit: args.limit,
+    measuredInputTokens: measured?.inputTokens,
+    estimate: () => measured ? estimateAppendedWireTokens({
+      messages: measured.appendedMessages,
+      providerID: args.model?.providerID,
+      modelID: args.model?.modelID
+    }) : estimator({
+      messages: args.messages,
+      systemPromptTokens: args.systemPromptTokens,
+      providerID: args.model?.providerID,
+      modelID: args.model?.modelID,
+      agentName: args.agentName
+    })
   });
-  rpcServer.handle("mark-announced", async () => {
-    if (ANNOUNCEMENT_VERSION2) {
-      markAnnouncementSeen2(ANNOUNCEMENT_VERSION2);
-    }
-    return { ok: true };
-  });
+}
+function lkgReplayFits(args) {
+  let limit;
+  try {
+    limit = lkgReplayLimit(args);
+  } catch {
+    return { fits: false, detail: null };
+  }
+  if (limit === undefined)
+    return { fits: false, detail: null };
+  const measure = measureLkgReplayRequest({ ...args, limit });
+  if (measure.fit === "under")
+    return { fits: true };
+  return {
+    fits: false,
+    detail: measure.fit === "over" ? `lkg_over_context_limit estimated=${measure.tokens ?? "skipped"} proxy_tokens=${measure.proxyTokens ?? "unavailable"} limit=${limit}` : `lkg_fit_untrusted estimated=${measure.tokens ?? "unavailable"} limit=${limit}`
+  };
 }
 
 // src/hooks/magic-context/storage-busy-refusal.ts
@@ -17967,10 +18309,10 @@ function createPassOutcome() {
       finalized = true;
     },
     get captureEligible() {
-      return finalized && degradations.length === 0;
+      return finalized && degradations.every((item) => item.kind !== "fatal" && item.site === "auto-search-timeout");
     },
     isCaptureEligible() {
-      return finalized && degradations.length === 0;
+      return finalized && degradations.every((item) => item.kind !== "fatal" && item.site === "auto-search-timeout");
     }
   };
 }
@@ -18559,91 +18901,6 @@ function createHistorianHostRunner(args) {
   });
 }
 
-// src/hooks/magic-context/lkg-replay-fit.ts
-var RAW_FALLBACK_BYTES_PER_CONTEXT_TOKEN = 4;
-function lkgReplayLimit(args) {
-  const { db, sessionId, model } = args;
-  const trusted = model ? resolveTrustedContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : undefined;
-  if (trusted !== undefined && trusted > 0)
-    return trusted;
-  const detected = getOverflowState(db, sessionId, args.modelKey).detectedContextLimit;
-  return detected > 0 ? detected : undefined;
-}
-function measureLkgReplay(args) {
-  const baseline = args.measuredInputTokens ?? 0;
-  const tailLimit = Math.max(0, args.limit - baseline);
-  const proxy = wireContentBytes(args.messages, tailLimit * RAW_FALLBACK_BYTES_PER_CONTEXT_TOKEN, RAW_FALLBACK_BYTES_PER_CONTEXT_TOKEN);
-  const skipped = { proxy, estimatorRan: false, trusted: false };
-  if (proxy === null)
-    return { fit: "unproven", tokens: null, ...skipped };
-  const proxyTokens = baseline + Math.ceil(proxy.bytes / RAW_FALLBACK_BYTES_PER_CONTEXT_TOKEN);
-  if (proxy.aborted || proxyTokens > args.limit) {
-    return { fit: "over", tokens: null, proxyTokens, ...skipped };
-  }
-  let estimate;
-  try {
-    estimate = args.estimate();
-  } catch {
-    return { fit: "unproven", tokens: null, ...skipped };
-  }
-  const seen = { proxy, estimatorRan: true, trusted: estimate.trusted };
-  const tokens = baseline + estimate.tokens;
-  if (!estimate.trusted || !Number.isFinite(tokens) || tokens <= 0 || estimate.tokens < 0) {
-    return {
-      fit: "unproven",
-      tokens: Number.isFinite(estimate.tokens) ? estimate.tokens : null,
-      ...seen
-    };
-  }
-  return tokens > args.limit ? { fit: "over", tokens, proxyTokens, ...seen } : { fit: "under", tokens, ...seen };
-}
-function measureLkgReplayRequest(args) {
-  let measured;
-  try {
-    measured = args.model ? measuredLkgPrefix({
-      ...args,
-      slot: getSlot(args.sessionId),
-      modelKey: `${args.model.providerID}/${args.model.modelID}`
-    }) : undefined;
-  } catch {
-    measured = undefined;
-  }
-  const estimator = args.estimator ?? estimateFinalWireInputTokens;
-  return measureLkgReplay({
-    messages: measured?.appendedMessages ?? args.messages,
-    limit: args.limit,
-    measuredInputTokens: measured?.inputTokens,
-    estimate: () => measured ? estimateAppendedWireTokens({
-      messages: measured.appendedMessages,
-      providerID: args.model?.providerID,
-      modelID: args.model?.modelID
-    }) : estimator({
-      messages: args.messages,
-      systemPromptTokens: args.systemPromptTokens,
-      providerID: args.model?.providerID,
-      modelID: args.model?.modelID,
-      agentName: args.agentName
-    })
-  });
-}
-function lkgReplayFits(args) {
-  let limit;
-  try {
-    limit = lkgReplayLimit(args);
-  } catch {
-    return { fits: false, detail: null };
-  }
-  if (limit === undefined)
-    return { fits: false, detail: null };
-  const measure = measureLkgReplayRequest({ ...args, limit });
-  if (measure.fit === "under")
-    return { fits: true };
-  return {
-    fits: false,
-    detail: measure.fit === "over" ? `lkg_over_context_limit estimated=${measure.tokens ?? "skipped"} proxy_tokens=${measure.proxyTokens ?? "unavailable"} limit=${limit}` : `lkg_fit_untrusted estimated=${measure.tokens ?? "unavailable"} limit=${limit}`
-  };
-}
-
 // src/hooks/magic-context/module-state-sync.ts
 import { createHmac, randomUUID as randomUUID4 } from "node:crypto";
 
@@ -19275,6 +19532,73 @@ function moduleRawBlockMappings(message) {
   }
   return mappings;
 }
+function moduleToolOutput(part, state, text) {
+  const attachments = state.attachments ?? part.attachments;
+  const error = state.status === "error";
+  if (!Array.isArray(attachments) || attachments.length === 0) {
+    return { kind: { type: error ? "error_text" : "text", text } };
+  }
+  const blocks = [{ kind: { type: "text", text } }];
+  for (const attachment of attachments) {
+    const child = attachment !== null && typeof attachment === "object" ? attachment : {};
+    const string = (key) => typeof child[key] === "string" ? child[key] : undefined;
+    const mime = string("mime") ?? string("mimeType");
+    const data = string("data");
+    const url = string("url");
+    let kind;
+    if (child.type === "text" && typeof child.text === "string") {
+      kind = { type: "text", text: child.text };
+    } else if (mime !== undefined && (data !== undefined || url !== undefined)) {
+      const prefix = `data:${mime};base64,`;
+      const nativeUrl = url ?? "";
+      const source = data !== undefined ? { type: "data_base64", data } : nativeUrl.startsWith(prefix) ? { type: "data_base64", data: nativeUrl.slice(prefix.length) } : { type: "url", url };
+      const filename = string("filename") ?? string("name");
+      kind = {
+        type: "media",
+        media: {
+          kind: mime.startsWith("image/") ? "image" : mime.startsWith("audio/") ? "audio" : mime.startsWith("video/") ? "video" : mime === "application/pdf" ? "document" : "file",
+          media_type: mime,
+          ...filename !== undefined ? { filename } : {},
+          source
+        }
+      };
+    } else {
+      kind = {
+        type: "opaque",
+        opaque: {
+          source: { type: "harness", harness: "opencode" },
+          kind: string("type") ?? "attachment",
+          raw: attachment
+        }
+      };
+    }
+    const rawAttachment = { ...child };
+    const sourceFields = [];
+    if (kind.type === "media") {
+      const media = kind.media;
+      const derivedUrl = media.source.type === "data_base64" ? `data:${mime};base64,${media.source.data}` : media.source.url;
+      for (const [field, derived] of [
+        ["url", derivedUrl],
+        ["data", media.source.data]
+      ]) {
+        if (child[field] !== undefined && child[field] === derived) {
+          delete rawAttachment[field];
+          sourceFields.push(field);
+        }
+      }
+    }
+    blocks.push(kind.type === "opaque" ? { kind } : {
+      kind,
+      provider_extras: {
+        opencode: {
+          rawAttachment,
+          ...sourceFields.length ? { rawAttachmentSourceFields: sourceFields } : {}
+        }
+      }
+    });
+  }
+  return { kind: { type: error ? "error_content" : "content", blocks } };
+}
 function encodeOpenCodeMessagesToCk(messages) {
   return messages.map((message, index) => {
     const raw = message !== null && typeof message === "object" ? message : {};
@@ -19345,12 +19669,7 @@ function encodeOpenCodeMessagesToCk(messages) {
               type: "tool_result",
               id: callId,
               tool_name: toolName,
-              output: {
-                kind: {
-                  type: state.status === "error" ? "error_text" : "text",
-                  text: output
-                }
-              }
+              output: moduleToolOutput(part, state, output)
             }
           });
         }
@@ -21231,7 +21550,7 @@ function buildTransformBody(args) {
     historian_model_limits: args.passInputs.historian_model_limits,
     historian_model_variants: args.passInputs.historian_model_variants,
     historian_timeout_ms: args.passInputs.historian_timeout_ms,
-    clear_reasoning_age: args.passInputs.clear_reasoning_age,
+    keep_reasoning_tokens_effective: args.passInputs.keep_reasoning_tokens_effective,
     caveman_enabled: args.passInputs.caveman_enabled === true,
     caveman_min_chars: args.passInputs.caveman_min_chars ?? 500,
     cache_ttl: args.passInputs.cache_ttl,
@@ -21751,6 +22070,15 @@ function createRustModeTransform(deps, options) {
       sessionLog(sessionId, "RUST LOOP BREAKER: suppressing host directives after three consecutive synthetic turns until a real user message arrives");
     }
     const inputCount = messages.length;
+    const inputHasActiveThinking = hasActiveAnthropicThinkingTurn(messages, "anthropic");
+    const thinkingRecovery = prepareLatestThinkingRecovery({
+      db: deps.db,
+      sessionId,
+      messages,
+      id: (message) => message?.info.id,
+      parts: (message) => message?.parts ?? []
+    });
+    const restoreLatestTurnOriginals = thinkingRecovery.restore ? captureLatestTurnOriginals(messages) : undefined;
     let requestInputTokens = 0;
     let decision = "error";
     let materializeReason = "none";
@@ -22176,7 +22504,7 @@ function createRustModeTransform(deps, options) {
         historian_model_chain: historianChain,
         historian_model_variants: resolvedHistorianModelVariants(historianModels),
         historian_timeout_ms: historianRun?.timeoutMs ?? deps.historianTimeoutMs ?? DEFAULT_HISTORIAN_TIMEOUT_MS,
-        clear_reasoning_age: deps.clearReasoningAge,
+        keep_reasoning_tokens_effective: resolveKeepReasoningTokens(deps.keepReasoningTokens, modelKey ?? undefined),
         caveman_enabled: !sessionMeta.isSubagent && deps.cavemanTextCompression?.enabled === true,
         caveman_min_chars: deps.cavemanTextCompression?.minChars ?? 500,
         cache_ttl: sessionMeta.cacheTtl,
@@ -22829,7 +23157,12 @@ function createRustModeTransform(deps, options) {
                 throw error;
             }
           }
+          const protectedThinkingMessages = latestAssistantTurnMessages(appliedMessages);
+          const activeThinkingTurn = inputHasActiveThinking && isAnthropicFamilyRoute(model?.providerID, model?.modelID);
           const postprocess = runRustModePostprocess2({
+            activeThinkingTurn,
+            protectedThinkingMessages: thinkingRecovery.restore ? protectedThinkingMessages : undefined,
+            restoreLatestTurnOriginals: () => restoreLatestTurnOriginals?.(appliedMessages),
             db: deps.db,
             sessionId,
             messages: appliedMessages,
@@ -23089,6 +23422,7 @@ function createRustModeTransform(deps, options) {
         agentName: deps.getNotificationParams?.(sessionId)?.agent,
         systemPromptHash: sessionMeta.systemPromptHash
       });
+      captureOpencodeReasoningBudgetStatus(sessionId, output.messages, resolveKeepReasoningTokens(deps.keepReasoningTokens, modelKey ?? undefined), isPrefixBoundThinkingModel(model?.providerID, model?.modelID));
       finishPass(true);
       if (state.markerAdmissionFenced) {
         setRustMarkerAdmissionFence(deps.db, sessionId, false);
@@ -23371,8 +23705,24 @@ function historianJoinFailClosedMessage(input) {
   return `historian did not complete within ${seconds} s: ${reason}`;
 }
 function runCompartmentPhase(args) {
+  if (args.historianRunnable !== false && !args.compactionOff && args.canRunCompartments && !getActiveCompartmentRun(args.sessionId) && (args.sessionMeta.compartmentInProgress || args.contextUsage.percentage >= BLOCK_UNTIL_DONE_PERCENTAGE) && isHistorianDrainBudgetSpent({
+    db: args.db,
+    sessionId: args.sessionId,
+    contextLimit: args.boundaryContextLimit,
+    executeThresholdPercentage: args.boundaryExecuteThresholdPercentage,
+    usagePercentage: args.boundaryUsage.percentage
+  })) {
+    if (args.sessionMeta.compartmentInProgress) {
+      updateSessionMeta(args.db, args.sessionId, { compartmentInProgress: false });
+    }
+    return runCompartmentPhaseImpl({
+      ...args,
+      canRunCompartments: false,
+      sessionMeta: { compartmentInProgress: false }
+    });
+  }
   const historianRunnable = args.historianRunnable !== false;
-  const willReadRawHistory = historianRunnable && !args.compactionOff && args.canRunCompartments && getActiveCompartmentRun(args.sessionId) === undefined && (args.sessionMeta.compartmentInProgress || args.contextUsage.percentage >= BLOCK_UNTIL_DONE_PERCENTAGE);
+  const willReadRawHistory = historianRunnable && !args.compactionOff && args.canRunCompartments && getActiveCompartmentRun(args.sessionId) === undefined && args.contextUsage.percentage >= BLOCK_UNTIL_DONE_PERCENTAGE;
   if (!willReadRawHistory) {
     return runCompartmentPhaseImpl(args);
   }
@@ -23498,7 +23848,7 @@ async function runCompartmentPhaseImpl(args) {
     compartmentInProgress = false;
   }
   if (historianRunnable && args.canRunCompartments && args.sessionMeta.compartmentInProgress && !getActiveCompartmentRun(args.sessionId)) {
-    if (!hasEligibleHistoryForCompartment()) {
+    if (args.contextUsage.percentage >= BLOCK_UNTIL_DONE_PERCENTAGE && !hasEligibleHistoryForCompartment()) {
       sessionLog(args.sessionId, `transform: skipping compartment start, no eligible history before protected tail (beyond ${lastObservedCompartmentEnd})`);
       updateSessionMeta(args.db, args.sessionId, { compartmentInProgress: false });
       compartmentInProgress = false;
@@ -23515,7 +23865,7 @@ async function runCompartmentPhaseImpl(args) {
         db: args.db,
         sessionId: args.sessionId,
         historianChunkTokens: args.historianChunkTokens,
-        boundarySnapshot: getBoundarySnapshotForCompartment() ?? undefined,
+        boundarySnapshot: args.preResolvedBoundarySnapshot,
         currentContextLimit: args.boundaryContextLimit,
         historyBudgetTokens: args.historyBudgetTokens,
         historianTimeoutMs: args.historianTimeoutMs,
@@ -23534,6 +23884,12 @@ async function runCompartmentPhaseImpl(args) {
         autoPromote: args.autoPromote,
         onCompartmentStatePublished: args.onCompartmentStatePublished,
         preserveInjectionCacheUntilConsumed: true
+      }, undefined, () => {
+        const snapshot = getBoundarySnapshotForCompartment();
+        if (snapshot && hasRunnableCompartmentWindow(snapshot))
+          return snapshot;
+        sessionLog(args.sessionId, `transform: skipping compartment start, no eligible history before protected tail (beyond ${lastObservedCompartmentEnd})`);
+        return null;
       });
       compartmentInProgress = true;
     }
@@ -23888,7 +24244,19 @@ function createTransform(deps) {
         sessionDirectoryFellBack = true;
       }
     }
-    const freezeM0M1 = sessionDirectoryFellBack && sessionMeta.cachedM0Bytes != null && sessionMeta.cachedM1Bytes != null && (() => {
+    const activeThinkingModel = findLastAssistantModel(messages) ?? deps.liveModelBySession?.get(sessionId);
+    const thinkingRecovery = prepareLatestThinkingRecovery({
+      db,
+      sessionId,
+      messages,
+      id: (message) => message?.info.id,
+      parts: (message) => message?.parts ?? []
+    });
+    if (thinkingRecovery.ended)
+      deps.pendingMaterializationSessions?.add(sessionId);
+    let restoreLatestTurnOriginals;
+    let activeThinkingTurn = hasActiveAnthropicThinkingTurn(messages, activeThinkingModel?.providerID, activeThinkingModel?.modelID);
+    let freezeM0M1 = activeThinkingTurn && isPrefixBoundThinkingModel(activeThinkingModel?.providerID, activeThinkingModel?.modelID) || sessionDirectoryFellBack && sessionMeta.cachedM0Bytes != null && sessionMeta.cachedM1Bytes != null && (() => {
       try {
         return hasRecordedSessionProjectIdentity(db, sessionId);
       } catch {
@@ -24018,7 +24386,10 @@ function createTransform(deps) {
       }
     }
     const resolvedProviderID = modelForBudget?.providerID;
+    activeThinkingTurn ||= hasActiveAnthropicThinkingTurn(messages, resolvedProviderID, modelForBudget?.modelID);
+    freezeM0M1 ||= activeThinkingTurn && 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, {
       db,
       sessionID: sessionId
@@ -24128,19 +24499,33 @@ function createTransform(deps) {
       if (false) {}
       return false;
     };
-    const startRecoveryRun = () => {
-      const scale = emergencyUsagePercentageEarly >= 95 ? 0.25 : 0.5;
-      let boundarySnapshot = getRunnableBoundaryForCompartment();
-      if (!boundarySnapshot || !hasRunnableCompartmentWindow(boundarySnapshot)) {
-        boundarySnapshot = getRunnableBoundaryForCompartment(scale);
-      }
-      if (false) {}
-      if (!canRunCompartments || !deps.client && !deps.hiddenCompletionExecutor || !boundarySnapshot || !hasRunnableCompartmentWindow(boundarySnapshot)) {
+    const startRecoveryRun = (onReady) => {
+      if (isHistorianDrainBudgetSpent({
+        db,
+        sessionId,
+        contextLimit: boundaryContextLimit,
+        executeThresholdPercentage: boundaryExecuteThreshold,
+        usagePercentage: boundaryUsageForProtectedTail.percentage
+      }))
         return false;
-      }
-      if (getActiveCompartmentRun(sessionId)) {
+      if (!canRunCompartments || !deps.client && !deps.hiddenCompletionExecutor || getActiveCompartmentRun(sessionId))
+        return false;
+      const prepareRecoveryBoundary = () => {
+        const scale = emergencyUsagePercentageEarly >= 95 ? 0.25 : 0.5;
+        let boundarySnapshot = getRunnableBoundaryForCompartment();
+        if (!boundarySnapshot || !hasRunnableCompartmentWindow(boundarySnapshot)) {
+          boundarySnapshot = getRunnableBoundaryForCompartment(scale);
+        }
+        if (false) {}
+        if (!boundarySnapshot || !hasRunnableCompartmentWindow(boundarySnapshot))
+          return null;
+        onReady?.();
+        return boundarySnapshot;
+      };
+      const urgent = emergencyUsagePercentageEarly >= 95;
+      const boundarySnapshot = urgent ? prepareRecoveryBoundary() : undefined;
+      if (urgent && !boundarySnapshot)
         return false;
-      }
       updateSessionMeta(db, sessionId, { compartmentInProgress: true });
       startCompartmentAgent({
         client: deps.client,
@@ -24149,7 +24534,7 @@ function createTransform(deps) {
         db,
         sessionId,
         historianChunkTokens: historianRun?.chunkTokens ?? deps.getHistorianChunkTokens?.() ?? 20000,
-        boundarySnapshot,
+        boundarySnapshot: boundarySnapshot ?? undefined,
         currentContextLimit: boundaryContextLimit,
         historyBudgetTokens,
         historianTimeoutMs: historianRun?.timeoutMs ?? deps.historianTimeoutMs,
@@ -24170,7 +24555,7 @@ function createTransform(deps) {
           deferredHistoryRefreshSessions.add(sid);
           deferredMaterializationSessions.add(sid);
         }
-      });
+      }, undefined, urgent ? undefined : prepareRecoveryBoundary);
       return true;
     };
     if (fullFeatureMode && !compactionOff && historianFailureState.failureCount > 0 && emergencyUsagePercentageEarly >= 95 && !recoveryNoHeadEscapeActive) {
@@ -24184,13 +24569,15 @@ function createTransform(deps) {
         sessionLog(sessionId, "transform: emergency recovery remains armed — no complete eligible head before protected tail");
       }
       sessionLog(sessionId, `EMERGENCY: historian recovery requested at ${emergencyPercentage}%, failures: ${historianFailureState.failureCount}`);
-    } else if (fullFeatureMode && !compactionOff && isFirstTransformPassForSession && historianFailureState.failureCount > 0 && getEligibleHistoryForCompartment() && startRecoveryRun()) {
-      sessionLog(sessionId, `transform: historian recovery triggered on session load after ${historianFailureState.failureCount} failure(s)`);
-      if (deps.client) {
-        withoutSqliteTransformPass(() => sendStatusNotification2(deps.client, sessionId, `## Historian recovery
+    } else if (fullFeatureMode && !compactionOff && isFirstTransformPassForSession && historianFailureState.failureCount > 0) {
+      startRecoveryRun(() => {
+        sessionLog(sessionId, `transform: historian recovery triggered on session load after ${historianFailureState.failureCount} failure(s)`);
+        if (deps.client) {
+          withoutSqliteTransformPass(() => sendStatusNotification2(deps.client, sessionId, `## Historian recovery
 
 Historian previously failed ${historianFailureState.failureCount} time(s), so Magic Context is retrying history comparting immediately after restart.`, notificationParams));
-      }
+        }
+      });
     }
     logTransformTiming(sessionId, "emergencyRecoveryBlock", tFirstPass);
     const memoryProjectDirectory = compartmentDirectory || process.cwd();
@@ -24218,7 +24605,10 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       const tTrigger = performance.now();
       try {
         const inMemoryTail = buildTriggerInMemoryTail(db, sessionId, extractInMemoryMessageViews(messages));
-        const triggerResult = checkCompartmentTrigger(db, sessionId, sessionMeta, boundaryUsageForProtectedTail, sessionMeta.lastContextPercentage, boundaryExecuteThreshold, deriveTriggerBudget2(boundaryContextLimit, boundaryExecuteThreshold), deps.clearReasoningAge, historianRun?.commitClusterTrigger ?? deps.commitClusterTrigger, undefined, boundaryContextLimit, inMemoryTail, taggerFloor, { providerID: resolvedProviderID }, {
+        const triggerResult = checkCompartmentTrigger(db, sessionId, sessionMeta, boundaryUsageForProtectedTail, sessionMeta.lastContextPercentage, boundaryExecuteThreshold, deriveTriggerBudget2(boundaryContextLimit, boundaryExecuteThreshold), resolveKeepReasoningTokens(deps.keepReasoningTokens, currentModelKeyForBoundary), historianRun?.commitClusterTrigger ?? deps.commitClusterTrigger, undefined, boundaryContextLimit, inMemoryTail, taggerFloor, {
+          providerID: resolvedProviderID,
+          budgetCutoff: projectOpencodeReasoningBudgetCutoff(db, sessionId, messages, resolveKeepReasoningTokens(deps.keepReasoningTokens, currentModelKeyForBoundary), sessionMeta.clearedReasoningThroughTag, sessionDecisionCalibration(db, sessionId).proseRatio)
+        }, {
           hardFold: false,
           force: contextUsageEarly.percentage >= forceMaterializationPercentage && (contextUsageEarly.percentage >= 95 || getEmergencyInputSample(db, sessionId) === 0),
           explicitFlush: deps.pendingMaterializationSessions.has(sessionId),
@@ -24289,6 +24679,8 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
           servedMessages: messages
         });
         targets = result.targets;
+        if (thinkingRecovery.restore)
+          restoreLatestTurnOriginals = captureLatestTurnOriginals(messages);
         reasoningByMessage = result.reasoningByMessage;
         messageTagNumbers = result.messageTagNumbers;
         batch = result.batch;
@@ -24549,7 +24941,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       deferredHistoryRefreshSessions,
       deferredMaterializationSessions,
       lastHeuristicsTurnId: deps.lastHeuristicsTurnId,
-      clearReasoningAge: deps.clearReasoningAge,
+      keepReasoningTokens: resolveKeepReasoningTokens(deps.keepReasoningTokens, currentModelKeyForBoundary),
       protectedTagIds,
       protectedTagNumbers,
       protectedCutoff,
@@ -24570,6 +24962,11 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       smartDrops: deps.smartDrops === true,
       protectedTools: deps.protectedTools,
       resolvedProviderID,
+      activeThinkingTurn,
+      protectedThinkingMessages: thinkingRecovery.restore ? protectedThinkingMessages : undefined,
+      restoreThinkingMessageIds: thinkingRecovery.restore ? new Set([...protectedThinkingMessages].flatMap((message) => typeof message.info.id === "string" ? [message.info.id] : [])) : undefined,
+      restoreLatestTurnOriginals,
+      resolvedModelID: modelForBudget?.modelID,
       thinkingBindingRecoveryEnabledForModel: isPrefixBoundThinkingModel(modelForBudget?.providerID, modelForBudget?.modelID),
       trailingBlankSourceDecisions,
       passOutcome,
@@ -25225,6 +25622,102 @@ function preserveUserTerminatedTail(messages, inputMessages) {
   }
   moveUserToTail(messages, userIndex >= 0 ? messages[userIndex] : inputTail, userIndex);
 }
+
+class LkgAdmissionReplay extends Error {
+}
+function tryMessagesTransformLkgReplay(args) {
+  const { output, sessionId, error, agent } = args;
+  const slotAtEntry = getSlot(sessionId);
+  let entry = args.entry;
+  if (entry === undefined && slotAtEntry) {
+    try {
+      entry = noteEntry(sessionId, output.messages);
+    } catch {
+      entry = null;
+    }
+  }
+  if (sessionId && slotAtEntry && !entry) {
+    dropSlot(sessionId, "lkg_invalidated_reshape");
+    sessionLog(sessionId, "lkg_invalidated_reshape");
+  } else if (sessionId && entry) {
+    let replayBlocked = false;
+    try {
+      const db = openDatabase();
+      const rust = args.rust;
+      if (error instanceof StorageBusyRefusalError && error.stage === "rust-mode-emergency" || rust?.emergencyFailClosed(sessionId, output.messages)) {
+        replayBlocked = true;
+        sessionLog(sessionId, "lkg_emergency_band_refused");
+      } else if (!db || isEmergencyRecoveryArmed(sessionId) || getOverflowState(db, sessionId).needsEmergencyRecovery) {
+        replayBlocked = true;
+        sessionLog(sessionId, "lkg_emergency_armed");
+      } else {
+        const inputMessages = output.messages;
+        const inputCount = inputMessages.length;
+        const keys = resolveLkgModelKeys(inputMessages);
+        const replay = replayLkg({
+          sessionId,
+          messages: inputMessages,
+          modelKey: keys.modelKey,
+          providerKey: keys.providerKey,
+          entry,
+          prepareReplay: (messages) => rust ? rust.stripPersistedReasoning(sessionId, messages, inputMessages) : replayRustModeBindingMismatchStrips2({
+            db,
+            sessionId,
+            messages,
+            resolvedProviderID: keys.providerKey ?? undefined
+          })
+        });
+        let tsFit = true;
+        if (replay.ok && !rust && keys.providerKey && keys.modelKey) {
+          const model = {
+            providerID: keys.providerKey,
+            modelID: keys.modelKey.slice(keys.providerKey.length + 1)
+          };
+          if (lkgReplayLimit({
+            db,
+            sessionId,
+            model,
+            modelKey: keys.modelKey
+          }) !== undefined) {
+            const fit = lkgReplayFits({
+              db,
+              sessionId,
+              messages: replay.messages,
+              model,
+              modelKey: keys.modelKey,
+              systemPromptTokens: getOrCreateSessionMeta(db, sessionId).systemPromptTokens,
+              agentName: agent
+            });
+            tsFit = fit.fits;
+            if (!fit.fits && fit.detail)
+              sessionLog(sessionId, fit.detail);
+          }
+        }
+        if (replay.ok && (!tsFit || args.replayFits?.(replay.messages) === false || rust && !rust.replayFits(sessionId, replay.messages, inputMessages))) {
+          replayBlocked = true;
+          sessionLog(sessionId, "lkg_replay_does_not_fit");
+        } else if (replay.ok) {
+          args.onLkgReplay?.();
+          replaceMessagesInPlace2(output, replay.messages);
+          noteExternalLkgReplay(rust, sessionId, inputCount);
+          sessionLog(sessionId, "lkg_replay_served");
+          return true;
+        } else {
+          sessionLog(sessionId, replay.reason);
+        }
+      }
+    } catch (replayError) {
+      replayBlocked = true;
+      sessionLog(sessionId, "lkg_replay_unavailable", replayError);
+    }
+    if (replayBlocked) {
+      sessionLog(sessionId, "lkg_replay_declined");
+    }
+  } else if (sessionId) {
+    sessionLog(sessionId, "lkg_miss");
+  }
+  return false;
+}
 function createMessagesTransformHandler(args) {
   const resolveRust = (sessionId) => args.rustReplayParticipant ? args.rustReplayParticipant() ?? undefined : resolveRustLkgReplayParticipant(sessionId);
   const run = async (input, output) => {
@@ -25270,15 +25763,18 @@ function createMessagesTransformHandler(args) {
       }
     }
     const magicContext = args.getMagicContext ? args.getMagicContext() : args.magicContext;
-    const slotAtEntry = sessionId ? getSlot(sessionId) : undefined;
-    const entry = slotAtEntry ? (() => {
+    const captureEntry = () => {
+      if (!sessionId || !getSlot(sessionId))
+        return null;
       try {
         return noteEntry(sessionId, output.messages);
       } catch (error) {
         sessionLog(sessionId, "lkg entry snapshot failed; replay unavailable", error);
         return null;
       }
-    })() : null;
+    };
+    let entry = captureEntry();
+    let admissionRetried = false;
     try {
       if (magicContext) {
         const admissionDb = openDatabase();
@@ -25286,6 +25782,22 @@ function createMessagesTransformHandler(args) {
           if (!args.compactionOff) {
             await withAsyncPrivilegedWriter(admissionDb, () => {
               return;
+            }, {
+              beforeRetry: (error) => {
+                admissionRetried = true;
+                entry = captureEntry();
+                if (sessionId && tryMessagesTransformLkgReplay({
+                  output,
+                  sessionId,
+                  error,
+                  entry,
+                  rust: resolveRust(sessionId),
+                  agent,
+                  replayFits: args.replayFits,
+                  onLkgReplay: args.onLkgReplay
+                }))
+                  throw new LkgAdmissionReplay;
+              }
             });
           }
         } else {
@@ -25311,9 +25823,13 @@ function createMessagesTransformHandler(args) {
           }
         }
       }
+      if (admissionRetried)
+        entry = captureEntry();
       await magicContext?.["experimental.chat.messages.transform"]?.(input, output);
       return output.messages;
     } catch (error) {
+      if (error instanceof LkgAdmissionReplay)
+        return output.messages;
       if (error instanceof RawFallbackContextLimitError || error instanceof AssistantTerminalRetryError) {
         throw error;
       }
@@ -25329,85 +25845,17 @@ function createMessagesTransformHandler(args) {
       }
       if (args.compactionOff) {
         restoreCompactionOffInput();
-      } else if (sessionId && slotAtEntry && !entry) {
-        dropSlot(sessionId, "lkg_invalidated_reshape");
-        sessionLog(sessionId, "lkg_invalidated_reshape");
-      } else if (sessionId && entry) {
-        let replayBlocked = false;
-        try {
-          const db = openDatabase();
-          const rust = resolveRust(sessionId);
-          if (error instanceof StorageBusyRefusalError && error.stage === "rust-mode-emergency" || rust?.emergencyFailClosed(sessionId, output.messages)) {
-            replayBlocked = true;
-            sessionLog(sessionId, "lkg_emergency_band_refused");
-          } else if (!db || isEmergencyRecoveryArmed(sessionId) || getOverflowState(db, sessionId).needsEmergencyRecovery) {
-            replayBlocked = true;
-            sessionLog(sessionId, "lkg_emergency_armed");
-          } else {
-            const inputMessages = output.messages;
-            const inputCount = inputMessages.length;
-            const keys = resolveLkgModelKeys(inputMessages);
-            const replay = replayLkg({
-              sessionId,
-              messages: inputMessages,
-              modelKey: keys.modelKey,
-              providerKey: keys.providerKey,
-              entry,
-              prepareReplay: (messages) => rust ? rust.stripPersistedReasoning(sessionId, messages, inputMessages) : replayRustModeBindingMismatchStrips2({
-                db,
-                sessionId,
-                messages,
-                resolvedProviderID: keys.providerKey ?? undefined
-              })
-            });
-            let tsFit = true;
-            if (replay.ok && !rust && keys.providerKey && keys.modelKey) {
-              const model = {
-                providerID: keys.providerKey,
-                modelID: keys.modelKey.slice(keys.providerKey.length + 1)
-              };
-              if (lkgReplayLimit({
-                db,
-                sessionId,
-                model,
-                modelKey: keys.modelKey
-              }) !== undefined) {
-                const fit = lkgReplayFits({
-                  db,
-                  sessionId,
-                  messages: replay.messages,
-                  model,
-                  modelKey: keys.modelKey,
-                  systemPromptTokens: getOrCreateSessionMeta(db, sessionId).systemPromptTokens,
-                  agentName: agent
-                });
-                tsFit = fit.fits;
-                if (!fit.fits && fit.detail)
-                  sessionLog(sessionId, fit.detail);
-              }
-            }
-            if (replay.ok && (!tsFit || rust && !rust.replayFits(sessionId, replay.messages, inputMessages))) {
-              replayBlocked = true;
-              sessionLog(sessionId, "lkg_replay_does_not_fit");
-            } else if (replay.ok) {
-              args.onLkgReplay?.();
-              replaceMessagesInPlace2(output, replay.messages);
-              noteExternalLkgReplay(rust, sessionId, inputCount);
-              sessionLog(sessionId, "lkg_replay_served");
-              return output.messages;
-            } else {
-              sessionLog(sessionId, replay.reason);
-            }
-          }
-        } catch (replayError) {
-          replayBlocked = true;
-          sessionLog(sessionId, "lkg_replay_unavailable", replayError);
-        }
-        if (replayBlocked) {
-          sessionLog(sessionId, "lkg_replay_declined");
-        }
-      } else if (sessionId) {
-        sessionLog(sessionId, "lkg_miss");
+      } else if (sessionId && tryMessagesTransformLkgReplay({
+        output,
+        sessionId,
+        error,
+        entry,
+        rust: resolveRust(sessionId),
+        agent,
+        replayFits: args.replayFits,
+        onLkgReplay: args.onLkgReplay
+      })) {
+        return output.messages;
       }
       if (!args.compactionOff && (error instanceof UnresolvedHistoryBoundaryError || error instanceof UnmanagedOverWindowError || error instanceof DegradedPassRefusalError)) {
         throw error;
@@ -27083,7 +27531,7 @@ function reasoningOf(part) {
 function renderPartPreview(part, expandTools) {
   if (!isRecord6(part))
     return null;
-  const expansion = expandToolPart(part, expandTools);
+  const expansion = expandToolPart(part, expandTools, true);
   if (expansion !== null)
     return `    • tool ${part.tool}: ${expansion}`;
   const text = textOf(part);
@@ -28502,4 +28950,4 @@ function createCtxSearchTools(deps) {
     [CTX_SEARCH_TOOL_NAME]: createCtxSearchTool(deps)
   };
 }
-export { createSubcCheckoutClaimGate, openCodeEventSessionId, openOpenCodeDb, DREAMER_SYSTEM_PROMPT, runSessionProjectBackfill, SMART_NOTE_COMPILER_SYSTEM_PROMPT, createLiveSessionState, getDefaultSubcConnectionFile, SubcModuleTransport, RETROSPECTIVE_MAX_USER_MESSAGE_CHARS, RETROSPECTIVE_MESSAGE_TRUNCATION_MARKER, OpenCodeRetrospectiveRawProvider, createDreamTaskExecutor, runManualDream, runDueTasksForProject, createDbLkgPersistence, startDreamScheduleTimer, ensureProjectRegisteredFromOpenCodeDirectory, resolveContextWindowGeometry, resolveContextLimit, resolveExecuteThresholdDetail, resolveModelKey, resolveSessionId, createScheduler, describeStorageUnavailability, scheduleClearAndReindex, resolveSessionCacheTtl, runEmbedHistoryDrain, pauseEmbedHistoryDrain, formatEmbedStatusText, getSessionProperties, getSessionCreatedInfo, getMessageUpdatedAssistantInfo, getMessageUpdatedInfo, getSessionErrorInfo, getMessageRemovedInfo, summarizeManualDream, createMagicContextCommandHandler, getLiveNotificationParams, createChatMessageHook, createEventHook, createCommandExecuteBeforeHook, createToolExecuteAfterHook, recordHiddenVariantWarning, buildStatusDetail, isDebugRpcEnabled, registerRpcHandlers, clearTransformDecisionSession, scheduleOpenCodeTransformDecisionWrite, maybeDeliverChannel2, STORAGE_BUSY_MESSAGE, StorageBusyRefusalError, UnmanagedOverWindowError, UnresolvedHistoryBoundaryError, clearMessageTokensCache, createTransform, createSubcModuleClient, createModuleToolBackends, createRustRefusalRecovery, createSystemPromptHashHandler, createMessagesTransformHandler, primaryOnlyToolIds, subagentToolRefusal, guardSubagentTools, hideSubagentTools, createCtxExpandTools, CTX_MEMORY_LIST_TOOL_NAME, CTX_MEMORY_ACTIONS, createCtxMemoryTools, createCtxMemoryListTools, createCtxNoteTools, createCtxReduceTools, createCtxSearchTools, parameterDescriptionsFor, applyJsonSchemaParameterDescriptions, MagicContextRpcServer };
+export { createSubcCheckoutClaimGate, openCodeEventSessionId, openOpenCodeDb, DREAMER_SYSTEM_PROMPT, runSessionProjectBackfill, SMART_NOTE_COMPILER_SYSTEM_PROMPT, createLiveSessionState, getDefaultSubcConnectionFile, SubcModuleTransport, RETROSPECTIVE_MAX_USER_MESSAGE_CHARS, RETROSPECTIVE_MESSAGE_TRUNCATION_MARKER, OpenCodeRetrospectiveRawProvider, createDreamTaskExecutor, runManualDream, runDueTasksForProject, createDbLkgPersistence, startDreamScheduleTimer, ensureProjectRegisteredFromOpenCodeDirectory, recordOpenCodeProvenInputFloor, resolveOpenCodeProvenInputFloor, resolveContextWindowGeometry, resolveContextLimit, resolveExecuteThresholdDetail, resolveModelKey, resolveSessionId, createScheduler, describeStorageUnavailability, scheduleClearAndReindex, resolveSessionCacheTtl, runEmbedHistoryDrain, pauseEmbedHistoryDrain, formatEmbedStatusText, getSessionProperties, getSessionCreatedInfo, getMessageUpdatedAssistantInfo, getMessageUpdatedInfo, getSessionErrorInfo, getMessageRemovedInfo, summarizeManualDream, createMagicContextCommandHandler, getLiveNotificationParams, createChatMessageHook, createEventHook, createCommandExecuteBeforeHook, createToolExecuteAfterHook, recordHiddenVariantWarning, buildStatusDetail, isDebugRpcEnabled, registerRpcHandlers, clearTransformDecisionSession, scheduleOpenCodeTransformDecisionWrite, maybeDeliverChannel2, armLatestThinkingRecovery, armBindingRecoverySafely, armLatestThinkingRecoveryFromError, lkgReplayLimit, measureLkgReplay, STORAGE_BUSY_MESSAGE, StorageBusyRefusalError, UnmanagedOverWindowError, UnresolvedHistoryBoundaryError, clearMessageTokensCache, createTransform, createSubcModuleClient, createModuleToolBackends, createRustRefusalRecovery, createSystemPromptHashHandler, tryMessagesTransformLkgReplay, createMessagesTransformHandler, primaryOnlyToolIds, subagentToolRefusal, guardSubagentTools, hideSubagentTools, createCtxExpandTools, CTX_MEMORY_LIST_TOOL_NAME, CTX_MEMORY_ACTIONS, createCtxMemoryTools, createCtxMemoryListTools, createCtxNoteTools, createCtxReduceTools, createCtxSearchTools, parameterDescriptionsFor, applyJsonSchemaParameterDescriptions, MagicContextRpcServer };